Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 1878386 in mainline


Ignore:
Timestamp:
2011-06-20T19:17:37Z (11 years ago)
Author:
Maurizio Lombardi <m.lombardi85@…>
Branches:
lfn, master
Children:
01accb7
Parents:
1affcdf3
Message:

Add function to free unused indirect zones when a file is resized.
Use on_error() macro instead of if() else..

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

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/minixfs/mfs.h

    r1affcdf3 r1878386  
    199199free_zone(struct mfs_node *mnode, const uint32_t zone);
    200200
     201extern int
     202prune_ind_zones(struct mfs_node *mnode, size_t new_size);
     203
    201204/*mfs_dentry.c*/
    202205extern int
  • uspace/srv/fs/minixfs/mfs_inode.c

    r1affcdf3 r1878386  
    343343
    344344        ino_i->i_size = new_size;
    345         return EOK;
     345
     346        return prune_ind_zones(mnode, new_size);
    346347
    347348exit_error:
  • uspace/srv/fs/minixfs/mfs_rw.c

    r1affcdf3 r1878386  
    9797
    9898        r = rw_map_ondisk(&old_zone, mnode, zone, true, 0);
    99         if (r != EOK)
    100                 return r;
     99        on_error(r, return r);
    101100
    102101        if (old_zone > 0)
     
    163162
    164163                r = read_ind_zone(inst, ino_i->i_izone[0], &ind_zone);
    165                 if (r != EOK)
    166                         return r;
     164                on_error(r, return r);
    167165
    168166                *b = ind_zone[rblock];
     
    184182                        uint32_t zone;
    185183                        r = alloc_zone_and_clear(inst, &zone);
    186                         if (r != EOK)
    187                                 return r;
     184                        on_error(r, return r);
    188185
    189186                        ino_i->i_izone[1] = zone;
     
    194191
    195192        r = read_ind_zone(inst, ino_i->i_izone[1], &ind_zone);
    196         if (r != EOK)
    197                 return r;
     193        on_error(r, return r);
    198194
    199195        /*
     
    208204                        uint32_t zone;
    209205                        r = alloc_zone_and_clear(inst, &zone);
    210                         if(r != EOK)
    211                                 goto out_free_ind1;
     206                        on_error(r, goto out_free_ind1);
     207
    212208                        ind_zone[ind2_off] = zone;
    213209                        write_ind_zone(inst, ino_i->i_izone[1], ind_zone);
     
    219215
    220216        r = read_ind_zone(inst, ind_zone[ind2_off], &ind2_zone);
    221         if (r != EOK)
    222                 goto out_free_ind1;
     217        on_error(r, goto out_free_ind1);
    223218
    224219        *b = ind2_zone[ind2_off % ptrs_per_block];
     
    236231}
    237232
     233/*Free unused indirect zones*/
     234int
     235prune_ind_zones(struct mfs_node *mnode, size_t new_size)
     236{
     237        struct mfs_instance *inst = mnode->instance;
     238        struct mfs_sb_info *sbi = inst->sbi;
     239        struct mfs_ino_info *ino_i = mnode->ino_i;
     240        int nr_direct, ptrs_per_block, rblock, r;
     241        int i;
     242
     243        mfs_version_t fs_version = sbi->fs_version;
     244       
     245        if (fs_version == MFS_VERSION_V1) {
     246                nr_direct = V1_NR_DIRECT_ZONES;
     247                ptrs_per_block = MFS_BLOCKSIZE / sizeof(uint16_t);
     248        } else {
     249                nr_direct = V2_NR_DIRECT_ZONES;
     250                ptrs_per_block = sbi->block_size / sizeof(uint32_t);
     251        }
     252
     253        rblock = new_size / sbi->block_size;
     254
     255        if (rblock < nr_direct) {
     256                /*free the single indirect zone*/
     257                if (ino_i->i_izone[0]) {
     258                        r = mfs_free_bit(inst, ino_i->i_izone[0], BMAP_ZONE);
     259                        on_error(r, return r);
     260
     261                        ino_i->i_izone[0] = 0;
     262                        ino_i->dirty = true;
     263                }
     264        }
     265
     266        rblock -= nr_direct + ptrs_per_block;
     267
     268        int fzone_to_free = (rblock < 0 ? 0 : rblock) / ptrs_per_block;
     269
     270        /*free the entire double indirect zone*/
     271        uint32_t *dbl_zone;
     272
     273        r = read_ind_zone(inst, ino_i->i_izone[1], &dbl_zone);
     274        on_error(r, return r);
     275
     276        for (i = fzone_to_free; i < ptrs_per_block; ++i) {
     277                if (dbl_zone[i] == 0)
     278                        continue;
     279
     280                r = mfs_free_bit(inst, dbl_zone[i], BMAP_ZONE);
     281                on_error(r, return r);
     282        }
     283
     284        if (fzone_to_free) {
     285                r = mfs_free_bit(inst, ino_i->i_izone[1], BMAP_ZONE);
     286                ino_i->i_izone[1] = 0;
     287                ino_i->dirty = true;
     288        }
     289        free(dbl_zone);
     290
     291        return r;
     292}
    238293
    239294static int
     
    244299
    245300        r = block_get(&b, inst->handle, zone, BLOCK_FLAGS_NOREAD);
    246         if (r != EOK)
    247                 return r;
     301        on_error(r, return r);
    248302
    249303        memset(b->data, 0, b->size);
     
    260314
    261315        r = mfs_alloc_bit(inst, zone, BMAP_ZONE);
    262         if (r != EOK)
    263                 goto out;
     316        on_error(r, return r);
    264317
    265318        r = reset_zone_content(inst, *zone);
    266 out:
    267319        return r;
    268320}
     
    314366
    315367        r = block_get(&b, inst->handle, zone, BLOCK_FLAGS_NONE);
    316         if (r != EOK)
    317                 return r;
     368        on_error(r, return r);
    318369
    319370        if (sbi->fs_version == MFS_VERSION_V1) {
Note: See TracChangeset for help on using the changeset viewer.