util/fs/tsfs.c

Go to the documentation of this file.

#include <dma.h>
#include <util.h>
#include <assert.h>
#include <malloc.h>
#include <stdint.h>
#include <string.h>
#include <byteorder.h>
#include <status_codes.h>

#include <board/physmem.h>

#include <fs/tsfs.h>

#ifdef CONFIG_FS_TSFS_USE_HUGEMEM
# include <hugemem.h>
#endif

#ifdef CONFIG_FS_TSFS_USE_HUGEMEM
static void tsfs_read_filetable_page_done(struct tsfs *tsfs);
#endif

static void tsfs_buf_list_done(struct block_device *bdev,
                struct block_request *breq, struct slist *buf_list)
{
        /* Intentionally empty. */
}

static void tsfs_read_page_done(struct block_device *bdev,
                struct block_request *breq)
{
        struct tsfs *tsfs = breq->context;

        block_free_request(bdev, breq);
        tsfs->current_breq = NULL;

        tsfs->page_read_callback(tsfs);
}


static void tsfs_read_page(struct tsfs *tsfs, block_addr_t lba,
                void (*callback_func)(struct tsfs *tsfs))
{
        struct block_device *bdev = tsfs->bdev;

        // Busy reading another file?
        assert(!tsfs->current_breq);

        tsfs->page_read_callback    = callback_func;
        tsfs->current_breq          = block_alloc_request(bdev);
        tsfs->lba_in_buf            = lba;

        // Prepare to read one block of data from the block device.
        block_prepare_req(bdev, tsfs->current_breq, lba, 1, BLK_OP_READ);

        tsfs->current_breq->req_done = tsfs_read_page_done;
        tsfs->current_breq->buf_list_done = tsfs_buf_list_done;
        tsfs->current_breq->context = tsfs;

        buffer_init_rx(&tsfs->buffer, tsfs->buffer_data, TSFS_BLOCKSIZE);
        blk_req_add_buffer(tsfs->current_breq, &tsfs->buffer);

        block_submit_req(bdev, tsfs->current_breq);
}

static void tsfs_parse_filetable_from_buffer(struct tsfs *tsfs,
                uint_fast8_t offset_filetable, uint_fast8_t offset_block,
                uint_fast8_t nr_entries)
{
        struct tsfs_filetable_entry     ft_entry;
        uint_fast8_t                    size;
        uint_fast8_t                    i;

        size = sizeof(struct tsfs_filetable_entry);

        for (i = 0; i < nr_entries; i++) {
#ifdef CONFIG_FS_TSFS_USE_HUGEMEM
                uint16_t        mem_table_offset;
#endif
                uint_fast16_t   mem_block_offset = (offset_block + i) * size;

                memcpy(&ft_entry, tsfs->buffer_data + mem_block_offset, size);

                ft_entry.file_offset = be32_to_cpu(ft_entry.file_offset);
                ft_entry.file_size = be32_to_cpu(ft_entry.file_size);

#ifdef CONFIG_FS_TSFS_USE_HUGEMEM
                mem_table_offset = (offset_filetable + i) * size;
                hugemem_write_block((hugemem_ptr_t)((phys_addr_t)
                                        tsfs->filetable_address
                                        + mem_table_offset), &ft_entry, size);
#else
                memcpy(&tsfs->filetable[offset_filetable + i], &ft_entry, size);
#endif
        }

#ifdef CONFIG_FS_TSFS_USE_HUGEMEM
        tsfs->filetable_entries_read += nr_entries;

        if (tsfs->filetable_entries_read < tsfs->header.nr_files) {
                // More entries to read, queue reading of another page.
                block_addr_t next_lba = tsfs->lba_in_buf + 1;
                tsfs_read_page(tsfs, next_lba, tsfs_read_filetable_page_done);
        } else {
#endif
                /* Done reading filetable. flag system as ready and schedule
                 * task if required.
                 */
                tsfs->status = STATUS_OK;

                if (tsfs->current_read_request.task) {
                        workqueue_add_task(&main_workqueue,
                                        tsfs->current_read_request.task);
                }
#ifdef CONFIG_FS_TSFS_USE_HUGEMEM
        }
#endif
}

#ifdef CONFIG_FS_TSFS_USE_HUGEMEM
static void tsfs_read_filetable_page_done(struct tsfs *tsfs)
{
        uint_fast8_t    offset_filetable = tsfs->filetable_entries_read;

        tsfs_parse_filetable_from_buffer(tsfs, offset_filetable, 0,
                        TSFS_FILETABLE_ENTRIES_PER_BLOCK);
}
#endif

static void tsfs_read_header_done(struct tsfs *tsfs)
{
        memcpy(&tsfs->header, tsfs->buffer_data, sizeof(tsfs->header));

        tsfs->header.id             = be16_to_cpu(tsfs->header.id);
        tsfs->header.volume_size    = be32_to_cpu(tsfs->header.volume_size);
        tsfs->header.nr_files       = be32_to_cpu(tsfs->header.nr_files);

        if (tsfs->header.nr_files > TSFS_MAX_FILES)
                tsfs->header.nr_files = TSFS_MAX_FILES;

        if (tsfs->header.id == TSFS_ID) {
                uint8_t entries_to_read = TSFS_FILETABLE_ENTRIES_PER_BLOCK;

                // substract one because of TSFS header structure
                entries_to_read -= 1;

                uint8_t nr_to_read = min_u(tsfs->header.nr_files, entries_to_read );

                tsfs_parse_filetable_from_buffer(tsfs, 0, 1, nr_to_read);
        } else {
                tsfs->status = ERR_BAD_FORMAT;

                if (tsfs->current_read_request.task) {
                        workqueue_add_task(&main_workqueue,
                                        tsfs->current_read_request.task);
                }
        }
}

static void read_header(struct tsfs *tsfs)
{
        tsfs_read_page(tsfs, 0, tsfs_read_header_done);
}

status_t tsfs_init(struct tsfs *tsfs, struct block_device *bdev,
                struct workqueue_task *init_done_task)
{
        tsfs->buffer_data = malloc(TSFS_BLOCKSIZE);
        if (!tsfs->buffer_data)
                return ERR_NO_MEMORY;

        tsfs->bdev      = bdev;
        tsfs->status    = ERR_BUSY;

        tsfs->current_read_request.task = init_done_task;
#ifdef CONFIG_FS_TSFS_USE_HUGEMEM
        tsfs->filetable_address =
                (hugemem_ptr_t)physmem_alloc(&board_extram_pool,
                                sizeof(struct tsfs_filetable_entry) *
                                TSFS_MAX_FILES, CPU_DMA_ALIGN);

        assert(tsfs->filetable_address != PHYSMEM_ALLOC_ERR);
#endif
        read_header(tsfs);

        return STATUS_OK;
}

static void tsfs_read_buffer_ready(struct tsfs *tsfs)
{
        uint16_t        copy_start;
        uint16_t        copy_len;
        void            *buffer;

        // Figure out where in block buffer to read from and to.
        copy_start  = tsfs->current_read_request.cursor % TSFS_BLOCKSIZE;
        copy_len    = min_u(TSFS_BLOCKSIZE - copy_start,
                        tsfs->current_read_request.remaining_bytes);

        buffer = tsfs->buffer_data + copy_start;

        memcpy(tsfs->current_read_request.buffer, buffer, copy_len);

        //update metadata with remaining bytes to be read, and buffer postition
        tsfs->current_read_request.buffer=
                (uint8_t *)tsfs->current_read_request.buffer+ copy_len;
        tsfs->current_read_request.cursor += copy_len;
        tsfs->current_read_request.remaining_bytes -= copy_len;

        if (tsfs->current_read_request.remaining_bytes > 0) {
                // More entries to read, queue reading of another page.
                block_addr_t next_lba =
                        tsfs->current_read_request.cursor
                        >> ilog2(TSFS_BLOCKSIZE);
                tsfs_read_page(tsfs, next_lba, tsfs_read_buffer_ready);
        } else {
                /* Done reading, flag that the file system is ready and
                 * schedule user task.
                 */
                tsfs->status = STATUS_OK;
                workqueue_add_task(&main_workqueue,
                                tsfs->current_read_request.task);
        }
}

status_t tsfs_read(struct tsfs *tsfs, struct tsfs_file *file,
                void *buffer, uint32_t length, struct workqueue_task *task)
{
        block_addr_t block_nr;

        if (tsfs->status != STATUS_OK)
                return ERR_BUSY;

        // check and limit range of length of data to be read.
        if (file->cursor + length > file->end)
                length = file->end - file->cursor;
        if (!length)
                return ERR_INVALID_ARG;

        tsfs->status = ERR_BUSY;

        tsfs->current_read_request.task = task;
        tsfs->current_read_request.buffer = buffer;
        tsfs->current_read_request.cursor = file->cursor;
        tsfs->current_read_request.remaining_bytes = length;

        // Check which block we are reading from.
        block_nr = file->cursor >> ilog2(TSFS_BLOCKSIZE);

        if (tsfs->lba_in_buf == block_nr) {
                // Block already in buffer, perform first read directly.
                tsfs_read_buffer_ready(tsfs);
        } else {
                // Schedule a block read to buffer.
                tsfs_read_page(tsfs, block_nr, tsfs_read_buffer_ready);
        }

        // Move file cursor.
        file->cursor += length;

        return STATUS_OK;
}

static void tsfs_get_filetable_entry(struct tsfs *tsfs, uint8_t file_index,
                struct tsfs_filetable_entry *ft_entry)
{
        uint8_t size = sizeof(struct tsfs_filetable_entry);

#ifdef CONFIG_FS_TSFS_USE_HUGEMEM
        hugemem_read_block(ft_entry,
                        (hugemem_ptr_t)((phys_addr_t)tsfs->filetable_address
                                + (size * file_index)), size);
#else
        memcpy(ft_entry, &tsfs->filetable[file_index], size);
#endif
}

static uint32_t tsfs_locate_file_in_table(struct tsfs *tsfs,
                const char *filename)
{
        struct tsfs_filetable_entry     ft_entry;
        uint32_t                        file_index = 0;
        char                            name_buffer[TSFS_FILENAME_LEN];

        while (file_index < tsfs->header.nr_files) {
                tsfs_get_filetable_entry(tsfs, file_index, &ft_entry);

                memcpy(name_buffer, ft_entry.filename, TSFS_FILENAME_LEN);

                if (strncmp(name_buffer, filename, TSFS_FILENAME_LEN) == 0)
                        return file_index;

                file_index++;
        }

        return file_index;
}

status_t tsfs_open(struct tsfs *tsfs, const char *filename,
                struct tsfs_file *filehandle)
{
        struct tsfs_filetable_entry     entry;
        uint32_t                        file_index;

        file_index = tsfs_locate_file_in_table(tsfs, filename);

        /* If returned file_index (starts at index 0) is greater or equal to
         * number of files, then the file was not found.
         */
        if (file_index >= tsfs->header.nr_files)
                return ERR_INVALID_ARG;

        tsfs_get_filetable_entry(tsfs, file_index, &entry);

        filehandle->start   = entry.file_offset;
        filehandle->cursor  = entry.file_offset;
        filehandle->end     = entry.file_offset + entry.file_size;

        return STATUS_OK;
}

status_t tsfs_seek(struct tsfs_file* file, int32_t offset,
                enum tsfs_seek_origin origin)
{
        switch(origin) {
        case SEEK_SET:
                file->cursor = file->start + offset;
                break;

        case SEEK_CUR:
                file->cursor += offset;
                break;

        case SEEK_END:
                file->cursor = file->end + offset;
                break;

        default:
                unhandled_case(origin);
                break;
        }

        return STATUS_OK;
}

void tsfs_get_filename(struct tsfs *tsfs, uint_fast8_t file_index,
                uint8_t *buffer)
{
        struct tsfs_filetable_entry     entry;
        tsfs_get_filetable_entry(tsfs, file_index, &entry);
        memcpy(buffer, entry.filename, TSFS_FILENAME_LEN);
}

---