core: some cleanups

The blksize filed in inode structure removed, since we can simply get it
by BLOCK_SIZE(fs) macro.

Signed-off-by: Liu Aleaxander <Aleaxander@gmail.com>

6 files changed, 53 insertions, 58 deletions

diff --git a/core/fs.c b/core/fs.c
index 0d45c191..7248edab 100644
--- a/core/fs.c
+++ b/core/fs.c
@@ -171,7 +171,7 @@ void searchdir(com32sys_t *regs)
 	if (inode->mode == I_SYMLINK) {
 	    if (!this_fs->fs_ops->follow_symlink || 
 		--symlink_count == 0               ||      /* limit check */
-		inode->size >= (uint32_t)inode->blksize)
+		inode->size >= BLOCK_SIZE(this_fs))
 		goto err;
 	    name = this_fs->fs_ops->follow_symlink(inode, name);
 	    free_inode(inode);
diff --git a/core/fs/ext2/ext2.c b/core/fs/ext2/ext2.c
index e4374b66..b8ca5c38 100644
--- a/core/fs/ext2/ext2.c
+++ b/core/fs/ext2/ext2.c
@@ -67,9 +67,10 @@ static sector_t linsector(struct fs_info *fs,
 			  struct inode *inode, 
 			  uint32_t lin_sector)
 {
-    block_t block = bmap(fs, inode, lin_sector >> fs->blk_bits);
+    int blk_bits = fs->block_shift - fs->sector_shift;
+    block_t block = bmap(fs, inode, lin_sector >> blk_bits);
     
-    return (block << fs->blk_bits) + (lin_sector & ((1 << fs->blk_bits) - 1));
+    return (block << blk_bits) + (lin_sector & ((1 << blk_bits) - 1));
 }
 
 
@@ -85,13 +86,13 @@ static void getlinsec_ext(struct fs_info *fs, char *buf,
 			  sector_t sector, int sector_cnt)
 {
     int ext_cnt = 0;
-    int sec_per_block = 1 << fs->blk_bits;
+    int sec_per_block = 1 << (fs->block_shift - fs->sector_shift);
     struct disk *disk = fs->fs_dev->disk;
     
     if (sector < sec_per_block) {
         ext_cnt = sec_per_block - sector;
-        memset(buf, 0, ext_cnt << SECTOR_SHIFT);
-        buf += ext_cnt << SECTOR_SHIFT;
+        memset(buf, 0, ext_cnt << fs->sector_shift);
+        buf += ext_cnt << fs->sector_shift;
     }
     
     sector += ext_cnt;
@@ -111,18 +112,18 @@ static void getlinsec_ext(struct fs_info *fs, char *buf,
 static uint32_t ext2_getfssec(struct file *file, char *buf,
 			      int sectors, bool *have_more)
 {
-    int sector_left, next_sector, sector_idx;
-    int frag_start, con_sec_cnt;
-    int bytes_read = sectors << SECTOR_SHIFT;
     struct inode *inode = file->inode;
     struct fs_info *fs = file->fs;
+    int sector_left, next_sector, sector_idx;
+    int frag_start, con_sec_cnt;
+    int bytes_read = sectors << fs->sector_shift; 
     uint32_t bytesleft = inode->size - file->offset;
     
-    sector_left = (bytesleft + SECTOR_SIZE - 1) >> SECTOR_SHIFT;
+    sector_left = (bytesleft + SECTOR_SIZE(fs) - 1) >> fs->sector_shift;
     if (sectors > sector_left)
         sectors = sector_left;
     
-    sector_idx = file->offset >> SECTOR_SHIFT;
+    sector_idx = file->offset >> fs->sector_shift;
     while (sectors) {
         /*
          * get the frament
@@ -150,7 +151,7 @@ static uint32_t ext2_getfssec(struct file *file, char *buf,
                frag_start, frag_start + con_sec_cnt -1);
 #endif        
         getlinsec_ext(fs, buf, frag_start, con_sec_cnt);
-        buf += con_sec_cnt << SECTOR_SHIFT;
+        buf += con_sec_cnt << fs->sector_shift;
     } while(sectors);
     
     if (bytes_read >= bytesleft) { 
@@ -209,7 +210,7 @@ ext2_find_entry(struct fs_info *fs, struct inode *inode, char *dname)
 	i += de->d_rec_len;
 	if (i >= (int)inode->size)
 	    break;
-	if ((char *)de >= (char *)cs->data + inode->blksize) {
+	if ((char *)de >= (char *)cs->data + BLOCK_SIZE(fs)) {
 	    if (!(block = bmap(fs, inode, index++)))
 		break;
 	    cs = get_cache_block(fs->fs_dev, block);
@@ -268,7 +269,6 @@ static void fill_inode(struct inode *inode, struct ext2_inode *e_inode)
     inode->dtime   = e_inode->i_dtime;
     inode->blocks  = e_inode->i_blocks;
     inode->flags   = e_inode->i_flags;
-    inode->blksize = 1 << (SECTOR_SHIFT + this_fs->blk_bits);
     inode->file_acl = e_inode->i_file_acl;
     
     inode->data = malloc(EXT2_N_BLOCKS * sizeof(uint32_t *));
@@ -302,8 +302,7 @@ static struct inode *ext2_iget_current()
 {
     extern int CurrentDir;
     
-    if (CurrentDir)
-	return ext2_iget_by_inr(CurrentDir);
+    return ext2_iget_by_inr(CurrentDir);
 }
 
 static struct inode *ext2_iget(char *dname, struct inode *parent)
@@ -320,13 +319,13 @@ static struct inode *ext2_iget(char *dname, struct inode *parent)
 
 static char * ext2_follow_symlink(struct inode *inode, const char *name_left)
 {
-    int sec_per_block = 1 << this_fs->blk_bits;
+    int sec_per_block = 1 << (this_fs->block_shift - this_fs->sector_shift);
     int fast_symlink;
     char *symlink_buf;
     char *p;
     struct cache_struct *cs;
     
-    symlink_buf = malloc(inode->blksize);
+    symlink_buf = malloc(BLOCK_SIZE(this_fs));
     if (!symlink_buf) {
 	malloc_error("symlink buffer");
 	return NULL;
@@ -342,7 +341,7 @@ static char * ext2_follow_symlink(struct inode *inode, const char *name_left)
     
     if (*name_left)
 	*p++ = '/';
-    if (strecpy(p, name_left, symlink_buf + inode->blksize)) {
+    if (strecpy(p, name_left, symlink_buf + BLOCK_SIZE(this_fs))) {
 	free(symlink_buf);
 	return NULL;
     }
@@ -379,8 +378,7 @@ static int ext2_fs_init(struct fs_info *fs)
     struct disk *disk = fs->fs_dev->disk;
     struct ext2_sb_info *sbi;
     struct ext2_super_block sb;
-    int block_size;
-    int block_shift;
+    int blk_bits;
     int db_count;
     int i;
     int desc_block;
@@ -401,16 +399,15 @@ static int ext2_fs_init(struct fs_info *fs)
 	return 0;
     }
 
-    block_shift  = sb.s_log_block_size + 10;
-    block_size = 1 << block_shift;
-    fs->blk_bits = block_shift - SECTOR_SHIFT;
-        
+    fs->sector_shift = disk->sector_shift;
+    fs->block_shift  = sb.s_log_block_size + 10;
+    
     sbi->s_inodes_per_group = sb.s_inodes_per_group;
     sbi->s_blocks_per_group = sb.s_blocks_per_group;
-    sbi->s_inodes_per_block = block_size / sb.s_inode_size;
+    sbi->s_inodes_per_block = BLOCK_SIZE(fs) / sb.s_inode_size;
     if (sb.s_desc_size < sizeof(struct ext2_group_desc))
 	sb.s_desc_size = sizeof(struct ext2_group_desc);
-    sbi->s_desc_per_block   = block_size / sb.s_desc_size;
+    sbi->s_desc_per_block   = BLOCK_SIZE(fs) / sb.s_desc_size;
     sbi->s_groups_count     = (sb.s_blocks_count - sb.s_first_data_block 
 			       + EXT2_BLOCKS_PER_GROUP(fs) - 1) 
 	                      / EXT2_BLOCKS_PER_GROUP(fs);
@@ -420,13 +417,14 @@ static int ext2_fs_init(struct fs_info *fs)
     
     /* read the descpritors */
     desc_block = sb.s_first_data_block + 1;
-    desc_buffer = malloc(db_count * block_size);
+    desc_buffer = malloc(db_count * BLOCK_SIZE(fs));
     if (!desc_buffer) {
 	malloc_error("desc_buffer");
 	return -1;
-    }
-    disk->rdwr_sectors(disk, desc_buffer, desc_block << fs->blk_bits, 
-		       db_count << fs->blk_bits, 0);
+    }    
+    blk_bits = fs->block_shift - fs->sector_shift;
+    disk->rdwr_sectors(disk, desc_buffer, desc_block << blk_bits, 
+		       db_count << blk_bits, 0);
     sbi->s_group_desc = malloc(sizeof(struct ext2_group_desc *) 
 			       * sbi->s_groups_count);
     if (!sbi->s_group_desc) {
@@ -438,7 +436,7 @@ static int ext2_fs_init(struct fs_info *fs)
 	desc_buffer += sb.s_desc_size;
     }
     
-    return block_shift;
+    return fs->block_shift;
 }
 
 const struct fs_ops ext2_fs_ops = {
diff --git a/core/fs/fat/fat.c b/core/fs/fat/fat.c
index 7ed714b9..843c90c8 100644
--- a/core/fs/fat/fat.c
+++ b/core/fs/fat/fat.c
@@ -23,8 +23,6 @@ static struct inode * new_fat_inode(void)
     if (!inode->data) 
 	malloc_error("inode->data");
     
-    inode->blksize = 1 << SECTOR_SHIFT;
-    
     return inode;
 }
 
@@ -225,12 +223,12 @@ static void __getfssec(struct fs_info *fs, char *buf,
 static uint32_t vfat_getfssec(struct file *file, char *buf, int sectors,
 			      bool *have_more)
 {
+    struct fs_info *fs = file->fs;
     uint32_t bytes_left = file->inode->size - file->offset;
-    uint32_t bytes_read = sectors << SECTOR_SHIFT;
+    uint32_t bytes_read = sectors << fs->sector_shift;
     int sector_left;
-    struct fs_info *fs = file->fs;
-    
-    sector_left = (bytes_left + SECTOR_SIZE - 1) >> SECTOR_SHIFT;
+        
+    sector_left = (bytes_left + SECTOR_SIZE(fs) - 1) >> fs->sector_shift;
     if (sectors > sector_left)
         sectors = sector_left;
     
@@ -420,7 +418,7 @@ static struct inode *vfat_find_entry(char *dname, struct inode *dir)
     while (1) {
 	cs = get_cache_block(this_fs->fs_dev, dir_sector);
 	de = (struct fat_dir_entry *)cs->data;
-	entries = 1 << (SECTOR_SHIFT - 5);
+	entries = 1 << (this_fs->sector_shift - 5);
 	
 	while(entries--) {
 	    if (de->name[0] == 0)
@@ -519,7 +517,7 @@ static struct inode *vfat_iget_root(void)
     struct inode *inode = new_fat_inode();
     int root_size = FAT_SB(this_fs)->root_size;
     
-    inode->size = root_size << SECTOR_SHIFT;
+    inode->size = root_size << this_fs->sector_shift;
     *inode->data = FAT_SB(this_fs)->root;
     inode->mode = I_DIR;
     
@@ -550,10 +548,10 @@ static int vfat_load_config(void)
     static const char syslinux_cfg1[] = "/boot/syslinux/syslinux.cfg";
     static const char syslinux_cfg2[] = "/syslinux/syslinux.cfg";
     static const char syslinux_cfg3[] = "/syslinux.cfg";
-    static const char config_name[] = "syslinux.cfg";    
     const char * const syslinux_cfg[] =
 	{ syslinux_cfg1, syslinux_cfg2, syslinux_cfg3 };
     com32sys_t regs;
+    char *p;
     int i = 0;
 
     /* 
@@ -575,7 +573,11 @@ static int vfat_load_config(void)
         return 1;  /* no config file */
     }
     
-    strcpy(ConfigName, config_name);
+    strcpy(ConfigName, "syslinux.cfg");
+    strcpy(CurrentDirName, syslinux_cfg[i]);
+    p = strrchr(CurrentDirName, '/');
+    *p = '\0';
+    
     return 0;
 }
  
@@ -595,6 +597,7 @@ static int vfat_fs_init(struct fs_info *fs)
     uint32_t clust_num;
     sector_t total_sectors;
     
+    fs->sector_shift = fs->block_shift = disk->sector_shift;
     disk->rdwr_sectors(disk, &fat, 0, 1, 0);
     
     sbi = malloc(sizeof(*sbi));
@@ -612,9 +615,9 @@ static int vfat_fs_init(struct fs_info *fs)
     sbi->data      = sbi->root + sbi->root_size;
     
     sbi->clust_shift      = bsr(fat.bxSecPerClust);
-    sbi->clust_byte_shift = sbi->clust_shift + SECTOR_SHIFT;
+    sbi->clust_byte_shift = sbi->clust_shift + fs->sector_shift;
     sbi->clust_mask       = fat.bxSecPerClust - 1;
-    sbi->clust_size       = fat.bxSecPerClust << SECTOR_SHIFT;
+    sbi->clust_size       = fat.bxSecPerClust << fs->sector_shift;
     
     clust_num = (total_sectors - sbi->data) >> sbi->clust_shift;
     if (clust_num < 4085)
@@ -624,9 +627,8 @@ static int vfat_fs_init(struct fs_info *fs)
     else
 	sbi->fat_type = FAT32;
     
-    fs->blk_bits = 0;    
     /* for SYSLINUX, the cache is based on sector size */
-    return SECTOR_SHIFT;
+    return fs->sector_shift;
 }
         
 const struct fs_ops vfat_fs_ops = {
diff --git a/core/fs/iso9660/iso9660.c b/core/fs/iso9660/iso9660.c
index 47e676c9..001d33f8 100644
--- a/core/fs/iso9660/iso9660.c
+++ b/core/fs/iso9660/iso9660.c
@@ -22,8 +22,6 @@ static struct inode *new_iso_inode(void)
 		free(inode);
 		return NULL;
 	}
-
-	inode->blksize = BLOCK_SIZE(this_fs);
 	
 	return inode;
 }
@@ -214,11 +212,11 @@ static struct iso_dir_entry *iso_find_entry(char *dname, struct inode *inode)
 	offset += de_len;
 	
 	/* Make sure we have a full directory entry */
-	if (offset >= inode->blksize) {
-	    int slop = de_len + inode->blksize - offset;
+	if (offset >= BLOCK_SIZE(this_fs)) {
+	    int slop = de_len + BLOCK_SIZE(this_fs) - offset;
 	    
 	    memcpy(&tmpde, de, slop);
-	    offset &= inode->blksize - 1;
+	    offset &= BLOCK_SIZE(this_fs) - 1;
 	    if (offset) {
 		if (++i > inode->blocks)
 		    return NULL;
@@ -303,7 +301,7 @@ static struct inode *iso_iget(char *dname, struct inode *parent)
 /* Load the config file, return 1 if failed, or 0 */
 static int iso_load_config(void)
 {
-    const char *config_name[] = {
+    const char *config_file[] = {
 	"/boot/isolinux/isolinux.cfg", 
 	"/isolinux/isolinux.cfg"
     };
@@ -313,7 +311,7 @@ static int iso_load_config(void)
     
     for (; i < 2; i++) {
 	    memset(&regs, 0, sizeof regs);
-	    strcpy(ConfigName, config_name[i]);
+	    strcpy(ConfigName, config_file[i]);
 	    regs.edi.w[0] = OFFS_WRT(ConfigName, 0);
 	    call16(core_open, &regs, &regs);
 	    if (!(regs.eflags.l & EFLAGS_ZF))
@@ -325,7 +323,7 @@ static int iso_load_config(void)
     }
     
     strcpy(ConfigName, "isolinux.cfg");
-    strcpy(CurrentDirName, config_name[i]);
+    strcpy(CurrentDirName, config_file[i]);
     p = strrchr(CurrentDirName, '/');
     *p = '\0';
     
diff --git a/core/include/disk.h b/core/include/disk.h
index 91f7a57a..55d24fbc 100644
--- a/core/include/disk.h
+++ b/core/include/disk.h
@@ -6,7 +6,6 @@
 #include <stdbool.h>
 
 #define SECTOR_SHIFT     9
-#define SECTOR_SIZE      (1 << SECTOR_SHIFT)
 
 typedef uint64_t sector_t;
 typedef uint64_t block_t;
diff --git a/core/include/fs.h b/core/include/fs.h
index e6a0a45b..04eb21f8 100644
--- a/core/include/fs.h
+++ b/core/include/fs.h
@@ -21,12 +21,12 @@
 #define FILENAME_MAX     (1 << FILENAME_MAX_LG2)
 
 #define BLOCK_SIZE(fs)   (1 << fs->block_shift)
+#define SECTOR_SIZE(fs)  (1 << fs->sector_shift)
 
 struct fs_info {
     const struct fs_ops *fs_ops;
     struct device *fs_dev;
     void *fs_info;             /* The fs-specific information */
-    int blk_bits;              /* block_size = 1 << (blk_bits + SECTOR_SHIFT) */
     int sector_shift;
     int block_shift;
 };
@@ -85,8 +85,6 @@ struct inode {
     int          blocks; /* How many blocks the file take */
     uint32_t *   data;   /* The block address array where the file stored */
     uint32_t     flags;
-    int          blkbits;
-    int          blksize;
     uint32_t     file_acl;
 };