Changeset 155f792 in mainline


Ignore:
Timestamp:
2011-03-20T11:30:25Z (13 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6adba0a8
Parents:
930baca
Message:

Use a generic minixfs inode in core to avoid code duplication

Location:
uspace/srv/fs/minixfs
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/minixfs/mfs.h

    r930baca r155f792  
    8282};
    8383
     84/*Generic MinixFS inode*/
     85struct mfs_ino_info {
     86        uint16_t        i_mode;
     87        uint16_t        i_nlinks;
     88        int16_t         i_uid;
     89        uint16_t        i_gid;
     90        int32_t         i_size;
     91        int32_t         i_atime;
     92        int32_t         i_mtime;
     93        int32_t         i_ctime;
     94        /*Block numbers for direct zones*/
     95        uint32_t        i_dzone[V2_NR_DIRECT_ZONES];
     96        /*Block numbers for indirect zones*/
     97        uint32_t        i_izone[V2_NR_INDIRECT_ZONES];
     98};
     99
    84100struct mfs_instance {
    85101        link_t link;
    … …  
    90106/*MinixFS node in core*/
    91107struct mfs_node {
    92         union {
    93                 struct mfs_inode *ino;
    94                 struct mfs2_inode *ino2;
    95         };
    96 
     108        struct mfs_ino_info *ino_i;
    97109        struct mfs_instance *instance;
    98110};
    … …  
    115127/*mfs_inode.c*/
    116128extern
    117 struct mfs_inode *mfs_read_inode_raw(const struct mfs_instance *instance,
     129struct mfs_ino_info *mfs_read_inode_raw(const struct mfs_instance *instance,
    118130                                        uint16_t inum);
    119131extern
    120 struct mfs2_inode *mfs2_read_inode_raw(const struct mfs_instance *instance,
     132struct mfs_ino_info *mfs2_read_inode_raw(const struct mfs_instance *instance,
    121133                                        uint32_t inum);
    122134

  • uspace/srv/fs/minixfs/mfs_inode.c

    r930baca r155f792  
    11#include <stdlib.h>
    22#include <assert.h>
     3#include <errno.h>
    34#include <mem.h>
    45#include "mfs.h"
    56#include "mfs_utils.h"
    67
    7 struct mfs_inode *mfs_read_inode_raw(const struct mfs_instance *instance,
     8struct mfs_ino_info *mfs_read_inode_raw(const struct mfs_instance *instance,
    89                                        uint16_t inum)
    910{
    10         struct mfs_inode *ino;
     11        struct mfs_inode *ino = NULL;
     12        struct mfs_ino_info *ino_i = NULL;
    1113        struct mfs_sb_info *sbi;
    1214        block_t *b;
    … …  
    1618        const size_t ino_size = sizeof(struct mfs_inode);
    1719
     20        ino_i = (struct mfs_ino_info *) malloc(sizeof(struct mfs_ino_info));
    1821        ino = (struct mfs_inode *) malloc(ino_size);
    1922
    20         if (!ino)
    21                 return NULL;
     23        if (!ino || !ino_i)
     24                goto out_err;
    2225
    2326        sbi = instance->sbi;
    … …  
    2629        const int itable_off = 2 + sbi->ibmap_blocks + sbi->zbmap_blocks;
    2730
    28         block_get(&b, instance->handle, itable_off + inum / V1_INODES_PER_BLOCK,
    29                         BLOCK_FLAGS_NONE);
     31        if (block_get(&b, instance->handle, itable_off + inum / V1_INODES_PER_BLOCK,
     32                        BLOCK_FLAGS_NONE) != EOK)
     33                goto out_err;
    3034
    3135        memcpy(ino, ((uint8_t *) b->data) + ino_off * ino_size, ino_size);
    3236
    33         ino->i_mode = conv16(sbi->native, ino->i_mode);
    34         ino->i_uid = conv16(sbi->native, ino->i_uid);
    35         ino->i_size = conv32(sbi->native, ino->i_size);
    36         ino->i_mtime = conv32(sbi->native, ino->i_mtime);
     37        ino_i->i_mode = conv16(sbi->native, ino->i_mode);
     38        ino_i->i_uid = conv16(sbi->native, ino->i_uid);
     39        ino_i->i_size = conv32(sbi->native, ino->i_size);
     40        ino_i->i_mtime = conv32(sbi->native, ino->i_mtime);
    3741
    3842        for (i = 0; i < V1_NR_DIRECT_ZONES; ++i)
    39                 ino->i_dzone[i] = conv16(sbi->native, ino->i_dzone[i]);
     43                ino_i->i_dzone[i] = conv16(sbi->native, ino->i_dzone[i]);
    4044
    4145        for (i = 0; i < V1_NR_INDIRECT_ZONES; ++i)
    42                 ino->i_izone[i] = conv16(sbi->native, ino->i_izone[i]);
     46                ino_i->i_izone[i] = conv16(sbi->native, ino->i_izone[i]);
    4347
    4448        block_put(b);
    4549
    46         return ino;
     50        free(ino);
     51        return ino_i;
     52
     53out_err:
     54        if (ino)
     55                free(ino);
     56        if (ino_i)
     57                free(ino_i);
     58        return NULL;
    4759}
    4860
    49 struct mfs2_inode *mfs2_read_inode_raw(const struct mfs_instance *instance,
     61struct mfs_ino_info *mfs2_read_inode_raw(const struct mfs_instance *instance,
    5062                                        uint32_t inum)
    5163{
    52         struct mfs2_inode *ino;
     64        struct mfs2_inode *ino = NULL;
     65        struct mfs_ino_info *ino_i = NULL;
    5366        struct mfs_sb_info *sbi;
    5467        block_t *b;
    … …  
    5871
    5972        ino = (struct mfs2_inode *) malloc(ino_size);
     73        ino_i = (struct mfs_ino_info *) malloc(sizeof(struct mfs_ino_info));
    6074
    61         if (!ino)
    62                 return NULL;
     75        if (!ino || !ino_i)
     76                goto out_err;
    6377
    6478        sbi = instance->sbi;
    … …  
    6882        const int ino_off = inum % V3_INODES_PER_BLOCK(sbi->block_size);
    6983
    70         block_get(&b, instance->handle,
     84        if (block_get(&b, instance->handle,
    7185                itable_off + inum / V3_INODES_PER_BLOCK(sbi->block_size),
    72                 BLOCK_FLAGS_NONE);
     86                        BLOCK_FLAGS_NONE) != EOK)
     87                goto out_err;
    7388
    7489        memcpy(ino, ((uint8_t *)b->data) + ino_off * ino_size, ino_size);
    7590
    76         ino->i_mode = conv16(sbi->native, ino->i_mode);
    77         ino->i_nlinks = conv16(sbi->native, ino->i_nlinks);
    78         ino->i_uid = conv16(sbi->native, ino->i_uid);
    79         ino->i_gid = conv16(sbi->native, ino->i_gid);
    80         ino->i_size = conv32(sbi->native, ino->i_size);
    81         ino->i_atime = conv32(sbi->native, ino->i_atime);
    82         ino->i_mtime = conv32(sbi->native, ino->i_mtime);
    83         ino->i_ctime = conv32(sbi->native, ino->i_ctime);
     91        ino_i->i_mode = conv16(sbi->native, ino->i_mode);
     92        ino_i->i_nlinks = conv16(sbi->native, ino->i_nlinks);
     93        ino_i->i_uid = conv16(sbi->native, ino->i_uid);
     94        ino_i->i_gid = conv16(sbi->native, ino->i_gid);
     95        ino_i->i_size = conv32(sbi->native, ino->i_size);
     96        ino_i->i_atime = conv32(sbi->native, ino->i_atime);
     97        ino_i->i_mtime = conv32(sbi->native, ino->i_mtime);
     98        ino_i->i_ctime = conv32(sbi->native, ino->i_ctime);
    8499
    85100        for (i = 0; i < V2_NR_DIRECT_ZONES; ++i)
    86                 ino->i_dzone[i] = conv32(sbi->native, ino->i_dzone[i]);
     101                ino_i->i_dzone[i] = conv32(sbi->native, ino->i_dzone[i]);
    87102
    88103        for (i = 0; i < V2_NR_INDIRECT_ZONES; ++i)
    89                 ino->i_izone[i] = conv32(sbi->native, ino->i_izone[i]);
     104                ino_i->i_izone[i] = conv32(sbi->native, ino->i_izone[i]);
    90105
    91106        block_put(b);
    92107
    93         return ino;
     108        free(ino);
     109        return ino_i;
     110
     111out_err:
     112        if (ino)
     113                free(ino);
     114        if (ino_i)
     115                free(ino_i);
     116        return NULL;
    94117}
    95118

  • uspace/srv/fs/minixfs/mfs_ops.c

    r930baca r155f792  
    212212aoff64_t mfs_size_get(fs_node_t *node)
    213213{
    214         aoff64_t size;
    215 
    216214        mfsdebug("request for inode size\n");
    217215        assert(node);
    … …  
    219217        const struct mfs_node *mnode = node->data;
    220218        assert(mnode);
    221 
    222         const struct mfs_instance *inst = mnode->instance;
    223         assert(inst);
    224 
    225         const struct mfs_sb_info *sbi = inst->sbi;
    226         assert(sbi);
    227 
    228         if (sbi->fs_version == MFS_VERSION_V1) {
    229                 struct mfs_inode *ino;
    230                 ino = mnode->ino;
    231                 size = ino->i_size;
    232         } else {
    233                 struct mfs2_inode *ino2;
    234                 ino2 = mnode->ino2;
    235                 size = ino2->i_size;
    236         }
    237 
    238         return size;
     219        assert(mnode->ino_i);
     220
     221        return mnode->ino_i->i_size;
    239222}
    240223
    … …  
    282265        }
    283266
     267        struct mfs_ino_info *ino_i;
     268
    284269        if (sbi->fs_version == MFS_VERSION_V1) {
    285270                /*Read MFS V1 inode*/
    286                 struct mfs_inode *ino;
    287 
    288                 ino = mfs_read_inode_raw(inst, index);
    289                 mnode->ino = ino;
     271                ino_i = mfs_read_inode_raw(inst, index);
    290272        } else {
    291273                /*Read MFS V2/V3 inode*/
    292                 struct mfs2_inode *ino2;
    293 
    294                 ino2 = mfs2_read_inode_raw(inst, index);
    295                 mnode->ino2 = ino2;
    296         }
     274                ino_i = mfs2_read_inode_raw(inst, index);
     275        }
     276
     277        if (!ino_i)
     278                return -1;
     279
     280        mnode->ino_i = ino_i;
    297281
    298282        mnode->instance = inst;
    … …  
    313297{
    314298        const struct mfs_node *node = fsnode->data;
    315         const struct mfs_sb_info *sbi = node->instance->sbi;
    316 
    317         if (sbi->fs_version == MFS_VERSION_V1)
    318                 return S_ISDIR(node->ino->i_mode);
    319         else
    320                 return S_ISDIR(node->ino2->i_mode);
     299        return S_ISDIR(node->ino_i->i_mode);
    321300}
    322301
    … …  
    324303{
    325304        struct mfs_node *node = fsnode->data;
    326         struct mfs_sb_info *sbi = node->instance->sbi;
    327 
    328         if (sbi->fs_version == MFS_VERSION_V1)
    329                 return S_ISREG(node->ino->i_mode);
    330         else
    331                 return S_ISREG(node->ino2->i_mode);
     305        return S_ISREG(node->ino_i->i_mode);
    332306}
    333307

  • uspace/srv/fs/minixfs/mfs_read.c

    r930baca r155f792  
    44#include "mfs_utils.h"
    55
    6 static int read_map_v1(uint16_t *b, const struct mfs_node *mnode, int rblock);
    7 static int read_map_v2(uint32_t *b, const struct mfs_node *mnode, int rblock);
     6static int read_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock);
    87
    98/*Given the position in the file expressed in
    … …  
    2221        assert(sbi);
    2322
    24         const mfs_version_t fs_version = sbi->fs_version;
    2523        const int block_size = sbi->block_size;
    2624
    … …  
    2826        int rblock = pos / block_size;
    2927
    30         if (fs_version == MFS_VERSION_V1) {
    31                 if (mnode->ino->i_size < (int32_t) pos)
    32                         return -1;
    33 
    34                 uint16_t b16 = 0;
    35                 r = read_map_v1(&b16, mnode, rblock);
    36                 *b = b16;
    37         } else {
    38                 if (mnode->ino2->i_size < (int32_t) pos)
    39                         return -1;
    40 
    41                 r = read_map_v2(b, mnode, rblock);
    42         }
    43 
    44         return r;
    45 }
    46 
    47 static int read_map_v1(uint16_t *b, const struct mfs_node *mnode, int rblock)
    48 {
    49         const int ptrs_per_block = MFS_BLOCKSIZE / sizeof(uint16_t);
    50         block_t *bi1, *bi2;
    51         const struct mfs_inode *ino = mnode->ino;
    52         int r;
    53 
    54         assert(ino);
    55         assert(mnode->instance);
    56 
    57         if (rblock < V1_NR_DIRECT_ZONES) {
    58                 *b = ino->i_dzone[rblock];
     28        if (mnode->ino_i->i_size < (int32_t) pos) {
    5929                r = EOK;
     30                *b = 0;
    6031                goto out;
    6132        }
    6233
    63         rblock -= V1_NR_DIRECT_ZONES - 1;
    64 
    65         /*Check if the wanted block is in the single indirect zone*/
    66         if (rblock < ptrs_per_block) {
    67                 if (ino->i_izone[0] == 0) {
    68                         r = -1;
    69                         goto out;
    70                 }
    71 
    72                 r = read_ind_block(bi1, mnode->instance, ino->i_izone[0]);
    73 
    74                 if (r != EOK)
    75                         goto out;
    76 
    77                 *b = ((uint16_t *) bi1->data)[rblock];
    78                 goto out_block;
    79         }
    80 
    81         rblock -= ptrs_per_block - 1;
    82 
    83         /*The wanted block is in the double indirect zone*/
    84         uint16_t di_block = rblock / ptrs_per_block;
    85 
    86         /*read the first indirect zone*/
    87         if (ino->i_izone[1] == 0) {
    88                 r = -1;
    89                 goto out;
    90         }
    91 
    92         r = read_ind_block(bi1, mnode->instance, ino->i_izone[1]);
    93 
    94         if (r != EOK)
    95                 goto out;
    96 
    97         /*read the dobule indirect zone*/
    98         r = read_ind_block(bi2, mnode->instance,
    99                         ((uint16_t *) bi1->data)[di_block]);
    100 
    101         if (r != EOK)
    102                 goto out_block;
    103 
    104         *b = ((uint16_t *) bi2->data)[rblock % ptrs_per_block];
    105         block_put(bi2);
    106 
    107 out_block:
    108         block_put(bi1);
     34        r = read_map_ondisk(b, mnode, rblock);
    10935out:
    11036        return r;
    11137}
    11238
    113 static int read_map_v2(uint32_t *b, const struct mfs_node *mnode, int rblock)
     39static int read_map_ondisk(uint32_t *b, const struct mfs_node *mnode, int rblock)
    11440{
    11541        block_t *bi1, *bi2;
    116         int r;
     42        int r, nr_direct, nr_indirect;
     43        int ptrs_per_block;
    11744
    11845        assert(mnode);
    119         const struct mfs2_inode *ino2 = mnode->ino2;
     46        const struct mfs_ino_info *ino_i = mnode->ino_i;
    12047
    121         assert(ino2);
     48        assert(ino_i);
    12249        assert(mnode->instance);
    12350
    … …  
    12552        assert(sbi);
    12653
    127         const int ptrs_per_block = sbi->block_size / sizeof(uint32_t);
     54        const int fs_version = sbi->fs_version;
    12855
    129         if (rblock < V2_NR_DIRECT_ZONES) {
    130                 *b = ino2->i_dzone[rblock];
     56        if (fs_version == MFS_VERSION_V1) {
     57                nr_direct = V1_NR_DIRECT_ZONES;
     58                nr_indirect = V1_NR_INDIRECT_ZONES;
     59                ptrs_per_block = MFS_BLOCKSIZE / sizeof(uint16_t);
     60        } else {
     61                nr_direct = V2_NR_DIRECT_ZONES;
     62                nr_indirect = V2_NR_INDIRECT_ZONES;
     63                ptrs_per_block = sbi->block_size / sizeof(uint32_t);
     64        }
     65
     66        if (rblock < nr_direct) {
     67                *b = ino_i->i_dzone[rblock];
    13168                r = EOK;
    13269                goto out;
    13370        }
    134         rblock -= V2_NR_DIRECT_ZONES - 1;
     71        rblock -= nr_direct - 1;
    13572
    13673        /*Check if the wanted block is in the single indirect zone*/
    13774        if (rblock < ptrs_per_block) {
    138                 if (ino2->i_izone[0] == 0) {
     75                if (ino_i->i_izone[0] == 0) {
    13976                        r = -1;
    14077                        goto out;
    14178                }
    14279
    143                 r = read_ind_block(bi2, mnode->instance, ino2->i_izone[0]);
     80                r = read_ind_block(bi2, mnode->instance, ino_i->i_izone[0]);
    14481
    14582                if (r != EOK)
    14683                        goto out;
    14784
    148                 *b = ((uint32_t *) bi1->data)[rblock];
     85                *b = fs_version == MFS_VERSION_V1 ?
     86                                ((uint16_t *) bi1->data)[rblock] :
     87                                ((uint32_t *) bi1->data)[rblock];
    14988                goto out_block;
    15089        }
    … …  
    15695
    15796        /*read the first indirect zone*/
    158         if (ino2->i_izone[1] == 0) {
     97        if (ino_i->i_izone[1] == 0) {
    15998                r = -1;
    16099                goto out;
    161100        }
    162101
    163         r = read_ind_block(bi1, mnode->instance, ino2->i_izone[1]);
     102        r = read_ind_block(bi1, mnode->instance, ino_i->i_izone[1]);
    164103
    165104        if (r != EOK)
    … …  
    167106
    168107        /*read the second indirect zone*/
    169         r = read_ind_block(bi2, mnode->instance,
     108        if (fs_version == MFS_VERSION_V1) {
     109                r = read_ind_block(bi2, mnode->instance,
     110                        ((uint16_t *) bi1->data)[di_block]);
     111
     112                if (r != EOK)
     113                        goto out_block;
     114
     115                *b = ((uint16_t *) bi2->data)[rblock % ptrs_per_block];
     116        } else {
     117                r = read_ind_block(bi2, mnode->instance,
    170118                        ((uint32_t *) bi1->data)[di_block]);
    171119
    172         if (r != EOK)
    173                 goto out_block;
     120                if (r != EOK)
     121                        goto out_block;
    174122
    175         *b = ((uint32_t *) bi2->data)[rblock % ptrs_per_block];
     123                *b = ((uint32_t *) bi2->data)[rblock % ptrs_per_block];
     124        }
    176125        block_put(bi2);
    177126
Note: See TracChangeset for help on using the changeset viewer.