Changeset 8ab1adff in mainline


Ignore:
Timestamp:
2011-04-06T19:50:13Z (13 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f9329cf
Parents:
c922bc7
Message:

Add functions to read and write indirect zones, it simplifies the rw_map_ondisk() function

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rc922bc7 r8ab1adff  
    4242
    4343static int
    44 reset_block_content(struct mfs_instance *inst, uint32_t block);
    45 
    46 static int
    47 alloc_zone_and_clear(struct mfs_instance *inst, uint32_t *block);
     44reset_zone_content(struct mfs_instance *inst, uint32_t zone);
     45
     46static int
     47alloc_zone_and_clear(struct mfs_instance *inst, uint32_t *zone);
     48
     49static int
     50read_ind_zone(struct mfs_instance *inst, uint32_t zone, uint32_t **ind_zone);
     51
     52static int
     53write_ind_zone(struct mfs_instance *inst, uint32_t zone, uint32_t *ind_zone);
    4854
    4955
    … …  
    110116        int r, nr_direct;
    111117        int ptrs_per_block;
    112         block_t *bi1;
    113         block_t *bi2;
     118        uint32_t *ind_zone, *ind2_zone;
    114119
    115120        assert(mnode);
    … …  
    148153                if (ino_i->i_izone[0] == 0) {
    149154                        if (write_mode) {
    150                                 uint32_t block;
    151                                 r = alloc_zone_and_clear(inst, &block);
     155                                uint32_t zone;
     156                                r = alloc_zone_and_clear(inst, &zone);
    152157                                if (r != EOK)
    153158                                        return r;
    154159
    155                                 ino_i->i_izone[0] = block;
     160                                ino_i->i_izone[0] = zone;
    156161                                ino_i->dirty = true;
    157162                        } else
    … …  
    159164                }
    160165
    161                 r = block_get(&bi1, inst->handle, ino_i->i_izone[0],
    162                                 BLOCK_FLAGS_NONE);
     166                r = read_ind_zone(inst, ino_i->i_izone[0], &ind_zone);
    163167                if (r != EOK)
    164168                        return r;
    165169
    166                 if (fs_version == MFS_VERSION_V1) {
    167                         uint16_t *tmp = &(((uint16_t *) bi1->data)[rblock]);
    168                         *b = conv16(sbi->native, *tmp);
    169                         if (write_mode) {
    170                                 *tmp = conv16(sbi->native, w_block);
    171                                 bi1->dirty = true;
    172                         }
    173                 } else {
    174                         uint32_t *tmp = &(((uint32_t *) bi1->data)[rblock]);
    175                         *b = conv32(sbi->native, *tmp);
    176                         if (write_mode) {
    177                                 *tmp = conv32(sbi->native, w_block);
    178                                 bi1->dirty = true;
    179                         }
     170                *b = ind_zone[rblock];
     171                if (write_mode) {
     172                        ind_zone[rblock] = w_block;
     173                        write_ind_zone(inst, ino_i->i_izone[0], ind_zone);
    180174                }
    181175
    182                 goto out_put_1;
     176                goto out_free_ind1;
    183177        }
    184178
    … …  
    190184        if (ino_i->i_izone[1] == 0) {
    191185                if (write_mode) {
    192                         uint32_t block;
    193                         r = alloc_zone_and_clear(inst, &block);
     186                        uint32_t zone;
     187                        r = alloc_zone_and_clear(inst, &zone);
    194188                        if (r != EOK)
    195189                                return r;
    196190
    197                         ino_i->i_izone[1] = block;
     191                        ino_i->i_izone[1] = zone;
    198192                        ino_i->dirty = true;
    199193                } else
    … …  
    201195        }
    202196
    203         r = block_get(&bi1, inst->handle, ino_i->i_izone[1],
    204                         BLOCK_FLAGS_NONE);
     197        r = read_ind_zone(inst, ino_i->i_izone[1], &ind_zone);
    205198        if (r != EOK)
    206199                return r;
    … …  
    210203         *zone pointer in the chain.
    211204         */
    212         uint32_t ind2_block = rblock / ptrs_per_block;
     205        uint32_t ind2_off = rblock / ptrs_per_block;
    213206
    214207        /*read the second indirect zone of the chain*/
    215         if (fs_version == MFS_VERSION_V1) {
    216                 uint16_t *pt16 = bi1->data;
    217                 uint16_t blk = conv16(sbi->native, pt16[ind2_block]);
    218 
    219                 if (blk == 0) {
    220                         if (write_mode) {
    221                                 uint32_t block;
    222                                 r = alloc_zone_and_clear(inst, &block);
    223                                 if (r != EOK)
    224                                         return r;
    225 
    226                                 blk = block;
    227                                 pt16[ind2_block] = conv16(sbi->native, blk);
    228                                 bi1->dirty = true;
    229                         } else
    230                                 return -1;
     208        if (ind_zone[ind2_off] == 0) {
     209                if (write_mode) {
     210                        uint32_t zone;
     211                        r = alloc_zone_and_clear(inst, &zone);
     212                        if(r != EOK)
     213                                goto out_free_ind1;
     214                        ind_zone[ind2_off] = zone;
     215                        write_ind_zone(inst, ino_i->i_izone[1], ind_zone);
     216                } else {
     217                        r = -1;
     218                        goto out_free_ind1;
    231219                }
    232        
    233                 r = block_get(&bi2, inst->handle, blk, BLOCK_FLAGS_NONE);
    234 
    235                 if (r != EOK)
    236                         goto out_put_1;
    237 
    238                 pt16 = bi2->data;
    239                 pt16 += ind2_block % ptrs_per_block;
    240                 *b = conv16(sbi->native, *pt16);
    241                 if (write_mode) {
    242                         *pt16 = conv16(sbi->native, w_block);
    243                         bi2->dirty = true;
    244                 }
    245         } else {
    246                 uint32_t *pt32 = bi1->data;
    247                 uint32_t blk = conv32(sbi->native, pt32[ind2_block]);
    248 
    249                 if (blk == 0) {
    250                         if (write_mode) {
    251                                 uint32_t block;
    252                                 r = alloc_zone_and_clear(inst, &block);
    253                                 if (r != EOK)
    254                                         return r;
    255 
    256                                 blk = block;
    257                                 pt32[ind2_block] = conv32(sbi->native, blk);
    258                                 bi1->dirty = true;
    259                         } else
    260                                 return -1;
    261                 }
    262        
    263                 r = block_get(&bi2, inst->handle, blk, BLOCK_FLAGS_NONE);
    264 
    265                 if (r != EOK)
    266                         goto out_put_1;
    267 
    268                 pt32 = bi2->data;
    269                 pt32 += ind2_block % ptrs_per_block;
    270                 *b = conv32(sbi->native, *pt32);
    271                 if (write_mode) {
    272                         *pt32 = conv32(sbi->native, w_block);
    273                         bi2->dirty = true;
    274                 }
    275         }
     220        }
     221
     222        r = read_ind_zone(inst, ind_zone[ind2_off], &ind2_zone);
     223        if (r != EOK)
     224                goto out_free_ind1;
     225
     226        *b = ind2_zone[ind2_off % ptrs_per_block];
     227        if (write_mode) {
     228                ind2_zone[ind2_off % ptrs_per_block] = w_block;
     229                write_ind_zone(inst, ind_zone[ind2_off], ind2_zone);
     230        }
     231
    276232        r = EOK;
    277233
    278         block_put(bi2);
    279 out_put_1:
    280         block_put(bi1);
     234        free(ind2_zone);
     235out_free_ind1:
     236        free(ind_zone);
    281237        return r;
    282238}
    … …  
    284240
    285241static int
    286 reset_block_content(struct mfs_instance *inst, uint32_t block)
     242reset_zone_content(struct mfs_instance *inst, uint32_t zone)
    287243{
    288244        block_t *b;
    289245        int r;
    290246
    291         r = block_get(&b, inst->handle, block, BLOCK_FLAGS_NOREAD);
     247        r = block_get(&b, inst->handle, zone, BLOCK_FLAGS_NOREAD);
    292248        if (r != EOK)
    293249                return r;
    … …  
    301257
    302258static int
    303 alloc_zone_and_clear(struct mfs_instance *inst, uint32_t *block)
    304 {
    305         int r;
    306 
    307         r = mfs_alloc_bit(inst, block, BMAP_ZONE);
     259alloc_zone_and_clear(struct mfs_instance *inst, uint32_t *zone)
     260{
     261        int r;
     262
     263        r = mfs_alloc_bit(inst, zone, BMAP_ZONE);
    308264        if (r != EOK)
    309265                goto out;
    310266
    311         r = reset_block_content(inst, *block);
     267        r = reset_zone_content(inst, *zone);
    312268out:
    313269        return r;
    314270}
     271
     272static int
     273read_ind_zone(struct mfs_instance *inst, uint32_t zone, uint32_t **ind_zone)
     274{
     275        struct mfs_sb_info *sbi = inst->sbi;
     276        int r;
     277        unsigned i;
     278        block_t *b;
     279
     280        *ind_zone = malloc(sbi->block_size);
     281        if (*ind_zone == NULL)
     282                return ENOMEM;
     283
     284        r = block_get(&b, inst->handle, zone, BLOCK_FLAGS_NONE);
     285        if (r != EOK) {
     286                free(*ind_zone);
     287                return r;
     288        }
     289
     290        if (sbi->fs_version == MFS_VERSION_V1) {
     291                uint16_t *src_ptr = b->data;
     292
     293                for (i = 0; i < sbi->block_size / sizeof(uint16_t); ++i)
     294                        (*ind_zone)[i] = conv16(sbi->native, src_ptr[i]);
     295        } else {
     296                uint32_t *src_ptr = b->data;
     297
     298                for (i = 0; i < sbi->block_size / sizeof(uint32_t); ++i)
     299                        (*ind_zone)[i] = conv32(sbi->native, src_ptr[i]);
     300        }
     301
     302        block_put(b);
     303       
     304        return EOK;
     305}
     306
     307static int
     308write_ind_zone(struct mfs_instance *inst, uint32_t zone, uint32_t *ind_zone)
     309{
     310        struct mfs_sb_info *sbi = inst->sbi;
     311        int r;
     312        unsigned i;
     313        block_t *b;
     314
     315        r = block_get(&b, inst->handle, zone, BLOCK_FLAGS_NONE);
     316        if (r != EOK)
     317                return r;
     318
     319        if (sbi->fs_version == MFS_VERSION_V1) {
     320                uint16_t *dest_ptr = b->data;
     321
     322                for (i = 0; i < sbi->block_size / sizeof(uint16_t); ++i)
     323                        dest_ptr[i] = conv16(sbi->native, ind_zone[i]);
     324        } else {
     325                uint32_t *dest_ptr = b->data;
     326
     327                for (i = 0; i < sbi->block_size / sizeof(uint32_t); ++i)
     328                        dest_ptr[i] = conv32(sbi->native, ind_zone[i]);
     329
     330        }
     331        b->dirty = true;
     332        block_put(b);
     333        return EOK;
     334}
     335
    315336
    316337/**
Note: See TracChangeset for help on using the changeset viewer.