# HG changeset patch # User Michael Spacefalcon # Date 1388992322 0 # Node ID 517dd86b45b1221409a0ab31643c8f9343e378aa # Parent bdfdea886beabf8ca7eae2a903640f664e1560c6 gsm-fw/services/ffs: fsck.c compiles diff -r bdfdea886bea -r 517dd86b45b1 gsm-fw/services/ffs/Makefile --- a/gsm-fw/services/ffs/Makefile Mon Jan 06 04:43:21 2014 +0000 +++ b/gsm-fw/services/ffs/Makefile Mon Jan 06 07:12:02 2014 +0000 @@ -2,7 +2,7 @@ CFLAGS= -O2 -fno-builtin -mthumb-interwork -mthumb LD= arm-elf-ld -OBJS= cfgffs.o core.o drv.o ffs_env.o ffstrace.o task.o +OBJS= cfgffs.o core.o drv.o ffs_env.o ffstrace.o fsck.o task.o HDRS= core.h drv.h ffs.h ffs_api.h ffs_env.h ffs_pool_size.h ffstrace.h \ intctl.h ramffs.h task.h tmffs.h diff -r bdfdea886bea -r 517dd86b45b1 gsm-fw/services/ffs/fsck.c --- a/gsm-fw/services/ffs/fsck.c Mon Jan 06 04:43:21 2014 +0000 +++ b/gsm-fw/services/ffs/fsck.c Mon Jan 06 07:12:02 2014 +0000 @@ -8,17 +8,13 @@ * ******************************************************************************/ -#ifndef TARGET -#include "ffs.cfg" -#endif - #include #include -#include "ffs/ffs.h" -#include "ffs/board/core.h" -#include "ffs/board/drv.h" -#include "ffs/board/ffstrace.h" +#include "ffs.h" +#include "core.h" +#include "drv.h" +#include "ffstrace.h" /****************************************************************************** * Functions @@ -89,14 +85,14 @@ break; } - // Init all file_descriptors to zero - memset(fs.fd, 0, sizeof(struct file_descriptor_s) * fs.fd_max); + // Init all file_descriptors to zero + memset(fs.fd, 0, sizeof(struct file_descriptor_s) * fs.fd_max); // If blocks_fsck() found a block that needs cleaning, we do it, now // that all the file system has been initialized. if (b > 0) { block_clean(b - 1); - block_free(b - 1); + block_free(b - 1); } statistics_init(); @@ -124,20 +120,20 @@ { uint8 opt, digit; uint32 n; - int numdatablocks; + int numdatablocks; tw(tr(TR_BEGIN, TrFsck, "fsparams_init('%s') {\n", p)); - // Compiled default values + // Compiled default values fs.filename_max = FFS_FILENAME_MAX; - fs.path_depth_max = FFS_PATH_DEPTH_MAX; + fs.path_depth_max = FFS_PATH_DEPTH_MAX; fs.fd_max = FFS_FD_MAX; - fs.journal_size = FFS_JOURNAL_SIZE_IN256THS; - fs.flags = 0; + fs.journal_size = FFS_JOURNAL_SIZE_IN256THS; + fs.flags = 0; fs.testflags = 0; - + // Flag that it not has been changed by an input arg. - fs.block_files_max = 0; + fs.block_files_max = 0; // The default lost bytes percentage of a block before it is reclaimed // is approx. 90%. @@ -148,19 +144,19 @@ fs.blocks_free_min = (dev.numblocks > 2 ? 1 : 0); // Don't count free and inodes blocks - numdatablocks = dev.numblocks - fs.blocks_free_min - 1; + numdatablocks = dev.numblocks - fs.blocks_free_min - 1; - // Abselute max number of inodes. + // Abselute max number of inodes. fs.inodes_max = dev.blocksize / sizeof(struct inode_s); if (fs.inodes_max > FFS_INODES_MAX) - fs.inodes_max = FFS_INODES_MAX; + fs.inodes_max = FFS_INODES_MAX; - // MUST be true: objects_max <= inodes_max - block_files_max, this is do - // to the fact that we always need to have block_files_max number of - // inodes left when we run a data reclaim. + // MUST be true: objects_max <= inodes_max - block_files_max, this is do + // to the fact that we always need to have block_files_max number of + // inodes left when we run a data reclaim. fs.objects_max = fs.inodes_max / 2; - // Find a suitable chunk_size + // Find a suitable chunk_size if (dev.numblocks*dev.blocksize > 1024*1024) fs.chunk_size_max = 8192; else @@ -168,7 +164,7 @@ ? (dev.blocksize / 8) : 2048); fs.fd_buf_size = fs.chunk_size_max; - + fs.journal_size = fs.journal_size * dev.blocksize / 256; if (fs.journal_size < FFS_JOURNAL_SIZE_MIN) fs.journal_size = FFS_JOURNAL_SIZE_MIN; @@ -183,7 +179,7 @@ // reserved_space. if (fs.block_files_max > fs.objects_max / 2) fs.block_files_max = fs.objects_max / 2 - 4; - + // Are we able to reach objects_max? If not then lower the number if (fs.objects_max > numdatablocks * fs.block_files_max) fs.objects_max = numdatablocks * fs.block_files_max + 10; @@ -192,7 +188,7 @@ // needed to have a reasonable performance. fs.reserved_space = dev.blocksize / 2 + numdatablocks * dev.blocksize / 16 + RESERVED_LOW; - + // skip to first char following second slash in name n = 0; while (*p) { @@ -239,14 +235,14 @@ // Now recompute a few parameters based on adjusted values. - // No journal file thuse no reserved space. - if (fs.journal_size == 0) { - fs.block_files_max = fs.objects_max / 2; - fs.reserved_space = 0; - fs.block_files_reserved = 0; - } + // No journal file thuse no reserved space. + if (fs.journal_size == 0) { + fs.block_files_max = fs.objects_max / 2; + fs.reserved_space = 0; + fs.block_files_reserved = 0; + } - else { + else { // If journal size is less than minimum must it have been changed by an // input arg, recalculate. if (fs.journal_size < FFS_JOURNAL_SIZE_MIN) @@ -255,28 +251,28 @@ if (fs.reserved_space < RESERVED_LOW) fs.reserved_space = fs.reserved_space * dev.blocksize / 256; - // Only one reserved is needed however we want a margin and set it to two - fs.block_files_reserved = 2; + // Only one reserved is needed however we want a margin and set it to 2 + fs.block_files_reserved = 2; } - - // Don't count free blocks, inode block, reserved space, block headers - // and the size of one filename. - fs.filesize_max = numdatablocks * dev.blocksize - fs.reserved_space - - numdatablocks * BHEADER_SIZE - FFS_FILENAME_MAX; - - // Furthermore don't count the overhead from each chunk (alignment) - fs.filesize_max -= ((fs.filesize_max / fs.chunk_size_max) * dev.atomsize + + // Don't count free blocks, inode block, reserved space, block headers + // and the size of one filename. + fs.filesize_max = numdatablocks * dev.blocksize - fs.reserved_space - + numdatablocks * BHEADER_SIZE - FFS_FILENAME_MAX; + + // Furthermore don't count the overhead from each chunk (alignment) + fs.filesize_max -= ((fs.filesize_max / fs.chunk_size_max) * dev.atomsize + dev.atomsize); - + // NOTEME: chunk_size_min is never used - fs.chunk_size_min = numdatablocks / fs.objects_max; - + fs.chunk_size_min = numdatablocks / fs.objects_max; + tw(tr(TR_FUNC, TrFsck, "dev.numblocks = %d\n", dev.numblocks)); tw(tr(TR_FUNC, TrFsck, "fs.blocks_free_min = %d\n", fs.blocks_free_min)); tw(tr(TR_FUNC, TrFsck, "fs.inodes_max = %d\n", fs.inodes_max)); tw(tr(TR_FUNC, TrFsck, "fs.objects_max = %d\n", fs.objects_max)); tw(tr(TR_FUNC, TrFsck, "fs.block_files_max = %d\n", fs.block_files_max)); - tw(tr(TR_FUNC, TrFsck, "fs.block_files_reserved = %d\n", fs.block_files_reserved)); + tw(tr(TR_FUNC, TrFsck, "fs.block_files_reserved = %d\n", fs.block_files_reserved)); tw(tr(TR_FUNC, TrFsck, "fs.chunk_size_max = %d\n", fs.chunk_size_max)); tw(tr(TR_FUNC, TrFsck, "fs.filename_max = %d\n", fs.filename_max)); tw(tr(TR_FUNC, TrFsck, "fs.lost_threshold = %d\n", fs.lost_threshold)); @@ -341,7 +337,7 @@ uint32 *p, *q; tlw(led_toggle(LED_BLOCKS_FSCK)); - + // We search backwards through block to find the last used byte and // thus the total number of used bytes. Note that this code depends // on the fact that an erased flash location is 0xFF! @@ -384,7 +380,7 @@ // block is found or another error occurs, we return the error code. bref_t blocks_fsck(void) { - bref_t b, b_to_clean, b_inode_lost; + bref_t b, b_to_clean, b_inode_lost; int age_valid; age_t age_min, age_max, age_dist, age_dist_min, age_dist_max; struct block_header_s *bhp; @@ -399,7 +395,7 @@ fs.format = 0; fs.inodes = -1; fs.newinodes = -1; - b_inode_lost = -1; + b_inode_lost = -1; b_to_clean = EFFS_OK; for (b = 0; b < dev.numblocks; b++) @@ -571,7 +567,7 @@ ttw(ttr(TTrInit, "fs.inodes, newinodes = %d, %d" NL, fs.inodes, fs.newinodes)); tw(tr(TR_FUNC, TrFsck, "age min, max = %d, %d\n", age_min, age_max)); - + // If any blocks were in the EMPTY state, now is the time to bring them // into the FREE state. Note that we must only do this *after* // fs.age_max has been initialized. @@ -584,32 +580,31 @@ } } - if (fs.inodes >= 0) { + if (fs.inodes >= 0) { // The 'old' inode block is still valid thus we keep it. - if (fs.newinodes >= 0) + if (fs.newinodes >= 0) // The copying of inodes to the new block was not finished thus // we free the block - block_free(fs.newinodes); - inodes_set(fs.inodes); - } - else { - // Copying must have been finished - if (fs.newinodes >= 0 && b_inode_lost >= 0) { + block_free(fs.newinodes); + inodes_set(fs.inodes); + } + else { + // Copying must have been finished + if (fs.newinodes >= 0 && b_inode_lost >= 0) { // The inode reclaim did finish but currently there is no valid // inode block thus the operation must be finished by committing // the new block as the valid inode block. - fs.inodes = b_inode_lost; - block_commit(); - - } - else { + fs.inodes = b_inode_lost; + block_commit(); + } + else { // No old or new Inode block! - tw(tr(TR_END, TrFsck, "} %d\n", EFFS_NOFORMAT)); - ttw(ttr(TTrInitLow, "} %d" NL, EFFS_NOFORMAT)); - return EFFS_NOFORMAT; - } + tw(tr(TR_END, TrFsck, "} %d\n", EFFS_NOFORMAT)); + ttw(ttr(TTrInitLow, "} %d" NL, EFFS_NOFORMAT)); + return EFFS_NOFORMAT; } - + } + if ((fs.format >> 8) != (FFS_FORMAT_VERSION >> 8)) { tw(tr(TR_END, TrFsck, "} %d\n", EFFS_BADFORMAT)); ttw(ttr(TTrInitLow, "} %d" NL, EFFS_BADFORMAT)); @@ -1085,7 +1080,7 @@ // Unless we are currently relocating the journal file itself, check if // journal file is near full and relocate it if it is. if (fs.journal_pos >= fs.journal_size - FFS_JOURNAL_MARGIN * - sizeof(struct journal_s) && fs.journal.oldi != fs.ijournal) { + sizeof(struct journal_s) && fs.journal.oldi != fs.ijournal) { tw(tr(TR_FUNC, TrJournal, "Journal file (near) full!\n")); journal_create(fs.ijournal); } @@ -1214,13 +1209,13 @@ if (fs.journal_depth > 1) { tw(tr(TR_FUNC, TrAll, "FATAL: journal_push() to depth %d\n", fs.journal_depth)); - return -1; - } + return -1; + } tw(tr(TR_FUNC, TrJournal, "journal_push() to depth %d\n", fs.journal_depth)); - - return EFFS_OK; + + return EFFS_OK; } // Recall "old" journal into current journal @@ -1233,11 +1228,11 @@ if (fs.journal_depth < 0) { tw(tr(TR_FUNC, TrAll, "FATAL: journal_pop() to depth %d\n", fs.journal_depth)); - return -1; + return -1; } memcpy(&fs.journal, &fs.ojournal, sizeof(struct journal_s)); - return EFFS_OK; + return EFFS_OK; } // Initialize the journalling system. Create journal file if it not already @@ -1441,7 +1436,7 @@ // zero and set the magic. This function is called from ffs_init(). void statistics_init(void) { - memset(&stats, 0, sizeof(struct ffs_stats_s)); + memset(&stats, 0, sizeof(struct ffs_stats_s)); } void statistics_update_drec(int valid, int lost, int candidate) @@ -1472,4 +1467,3 @@ stats.irec.valid += valid; stats.irec.lost += lost; } -