Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/mfs/mfs_balloc.c

    rb2c96093 r64e63ce1  
    4444mfs_alloc_bit(struct mfs_instance *inst, uint32_t *idx, bmap_id_t bid);
    4545
    46 static int
    47 mfs_count_free_bits(struct mfs_instance *inst, bmap_id_t bid, uint32_t *free);
    48 
    49 
    5046/**Allocate a new inode.
    5147 *
     
    106102
    107103        return mfs_free_bit(inst, zone, BMAP_ZONE);
    108 }
    109 
    110 /** Count the number of free zones
    111  *
    112  * @param inst          Pointer to the instance structure.
    113  * @param zones         Pointer to the memory location where the result
    114  *                      will be stored.
    115  *
    116  * @return              EOK on success or a negative error code.
    117  */
    118 int
    119 mfs_count_free_zones(struct mfs_instance *inst, uint32_t *zones)
    120 {
    121         return mfs_count_free_bits(inst, BMAP_ZONE, zones);
    122 }
    123 
    124 /** Count the number of free inodes
    125  *
    126  * @param inst          Pointer to the instance structure.
    127  * @param zones         Pointer to the memory location where the result
    128  *                      will be stored.
    129  *
    130  * @return              EOK on success or a negative error code.
    131  */
    132 
    133 int
    134 mfs_count_free_inodes(struct mfs_instance *inst, uint32_t *inodes)
    135 {
    136         return mfs_count_free_bits(inst, BMAP_INODE, inodes);
    137 }
    138 
    139 /** Count the number of free bits in a bitmap
    140  *
    141  * @param inst          Pointer to the instance structure.
    142  * @param bid           Type of the bitmap (inode or zone).
    143  * @param free          Pointer to the memory location where the result
    144  *                      will be stores.
    145  *
    146  * @return              EOK on success or a negative error code.
    147  */
    148 static int
    149 mfs_count_free_bits(struct mfs_instance *inst, bmap_id_t bid, uint32_t *free)
    150 {
    151         int r;
    152         unsigned start_block;
    153         unsigned long nblocks;
    154         unsigned long nbits;
    155         unsigned long block;
    156         unsigned long free_bits = 0;
    157         bitchunk_t chunk;
    158         size_t const bitchunk_bits = sizeof(bitchunk_t) * 8;
    159         block_t *b;
    160         struct mfs_sb_info *sbi = inst->sbi;
    161 
    162         start_block = MFS_BMAP_START_BLOCK(sbi, bid);
    163         nblocks = MFS_BMAP_SIZE_BLOCKS(sbi, bid);
    164         nbits = MFS_BMAP_SIZE_BITS(sbi, bid);
    165 
    166         for (block = 0; block < nblocks; ++block) {
    167                 r = block_get(&b, inst->service_id, block + start_block,
    168                     BLOCK_FLAGS_NONE);
    169                 if (r != EOK)
    170                         return r;
    171 
    172                 size_t i;
    173                 bitchunk_t *data = (bitchunk_t *) b->data;
    174 
    175                 /* Read the bitmap block, chunk per chunk,
    176                  * counting the zero bits.
    177                  */
    178                 for (i = 0; i < sbi->block_size / sizeof(bitchunk_t); ++i) {
    179                         chunk = conv32(sbi->native, data[i]);
    180 
    181                         size_t bit;
    182                         for (bit = 0; bit < bitchunk_bits && nbits > 0;
    183                             ++bit, --nbits) {
    184                                 if (!(chunk & (1 << bit)))
    185                                         free_bits++;
    186                         }
    187 
    188                         if (nbits == 0)
    189                                 break;
    190                 }
    191 
    192                 r = block_put(b);
    193                 if (r != EOK)
    194                         return r;
    195         }
    196 
    197         *free = free_bits;
    198         assert(nbits == 0);
    199 
    200         return EOK;
    201104}
    202105
     
    221124        sbi = inst->sbi;
    222125
    223         start_block = MFS_BMAP_START_BLOCK(sbi, bid);
    224 
    225126        if (bid == BMAP_ZONE) {
    226127                search = &sbi->zsearch;
     128                start_block = 2 + sbi->ibmap_blocks;
    227129                if (idx > sbi->nzones) {
    228130                        printf(NAME ": Error! Trying to free beyond the "
     
    233135                /* bid == BMAP_INODE */
    234136                search = &sbi->isearch;
     137                start_block = 2;
    235138                if (idx > sbi->ninodes) {
    236139                        printf(NAME ": Error! Trying to free beyond the "
     
    289192        sbi = inst->sbi;
    290193
    291         start_block = MFS_BMAP_START_BLOCK(sbi, bid);
    292         limit = MFS_BMAP_SIZE_BITS(sbi, bid);
    293         nblocks = MFS_BMAP_SIZE_BLOCKS(sbi, bid);
    294 
    295194        if (bid == BMAP_ZONE) {
    296195                search = &sbi->zsearch;
     196                start_block = 2 + sbi->ibmap_blocks;
     197                nblocks = sbi->zbmap_blocks;
     198                limit = sbi->nzones - sbi->firstdatazone - 1;
    297199        } else {
    298200                /* bid == BMAP_INODE */
    299201                search = &sbi->isearch;
     202                start_block = 2;
     203                nblocks = sbi->ibmap_blocks;
     204                limit = sbi->ninodes - 1;
    300205        }
    301206        bits_per_block = sbi->block_size * 8;
Note: See TracChangeset for help on using the changeset viewer.