Changes in / [dcba819:bf1733d3] in mainline


Ignore:
Location:
uspace/lib/ext4
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/ext4/libext4_balloc.c

    rdcba819 rbf1733d3  
    3939#include "libext4.h"
    4040
    41 /** Compute number of block group from block address.
    42  *
    43  * @param sb         Superblock pointer.
    44  * @param block_addr Absolute address of block.
    45  *
    46  * @return Block group index
    47  *
    48  */
    49 static uint32_t ext4_balloc_get_bgid_of_block(ext4_superblock_t *sb,
    50     uint32_t block_addr)
    51 {
    52         uint32_t blocks_per_group =
    53             ext4_superblock_get_blocks_per_group(sb);
    54         uint32_t first_block =
    55             ext4_superblock_get_first_data_block(sb);
    56        
    57         /* First block == 0 or 1 */
    58         if (first_block == 0)
    59                 return block_addr / blocks_per_group;
    60         else
    61                 return (block_addr - 1) / blocks_per_group;
    62 }
    63 
    6441/** Free block.
    6542 *
     
    7653       
    7754        /* Compute indexes */
    78         uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, block_addr);
     55        uint32_t block_group = ext4_filesystem_blockaddr2group(sb, block_addr);
    7956        uint32_t index_in_group =
    8057            ext4_filesystem_blockaddr2_index_in_group(sb, block_addr);
     
    135112}
    136113
    137 /** Free continuous set of blocks.
    138  *
    139  * @param inode_ref Inode, where the blocks are allocated
    140  * @param first     First block to release
    141  * @param count     Number of blocks to release
    142  *
    143  */
    144 int ext4_balloc_free_blocks(ext4_inode_ref_t *inode_ref,
     114static int ext4_balloc_free_blocks_internal(ext4_inode_ref_t *inode_ref,
    145115    uint32_t first, uint32_t count)
    146116{
    147117        ext4_filesystem_t *fs = inode_ref->fs;
    148118        ext4_superblock_t *sb = fs->superblock;
    149        
     119
    150120        /* Compute indexes */
    151         uint32_t block_group_first =
    152             ext4_balloc_get_bgid_of_block(sb, first);
    153         uint32_t block_group_last =
    154             ext4_balloc_get_bgid_of_block(sb, first + count - 1);
    155        
     121        uint32_t block_group_first = ext4_filesystem_blockaddr2group(sb,
     122            first);
     123        uint32_t block_group_last = ext4_filesystem_blockaddr2group(sb,
     124            first + count - 1);
     125
    156126        assert(block_group_first == block_group_last);
    157        
     127
    158128        /* Load block group reference */
    159129        ext4_block_group_ref_t *bg_ref;
     
    161131        if (rc != EOK)
    162132                return rc;
    163        
     133
    164134        uint32_t index_in_group_first =
    165135            ext4_filesystem_blockaddr2_index_in_group(sb, first);
    166        
     136
    167137        /* Load block with bitmap */
    168138        uint32_t bitmap_block_addr =
    169139            ext4_block_group_get_block_bitmap(bg_ref->block_group, sb);
    170        
     140
    171141        block_t *bitmap_block;
    172142        rc = block_get(&bitmap_block, fs->device, bitmap_block_addr, 0);
     
    175145                return rc;
    176146        }
    177        
     147
    178148        /* Modify bitmap */
    179149        ext4_bitmap_free_bits(bitmap_block->data, index_in_group_first, count);
    180150        bitmap_block->dirty = true;
    181        
     151
    182152        /* Release block with bitmap */
    183153        rc = block_put(bitmap_block);
     
    187157                return rc;
    188158        }
    189        
     159
    190160        uint32_t block_size = ext4_superblock_get_block_size(sb);
    191        
     161
    192162        /* Update superblock free blocks count */
    193163        uint32_t sb_free_blocks =
     
    195165        sb_free_blocks += count;
    196166        ext4_superblock_set_free_blocks_count(sb, sb_free_blocks);
    197        
     167
    198168        /* Update inode blocks count */
    199169        uint64_t ino_blocks =
     
    202172        ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
    203173        inode_ref->dirty = true;
    204        
     174
    205175        /* Update block group free blocks count */
    206176        uint32_t free_blocks =
     
    210180            sb, free_blocks);
    211181        bg_ref->dirty = true;
    212        
     182
    213183        /* Release block group reference */
    214184        return ext4_filesystem_put_block_group_ref(bg_ref);
    215185}
    216186
     187/** Free continuous set of blocks.
     188 *
     189 * @param inode_ref Inode, where the blocks are allocated
     190 * @param first     First block to release
     191 * @param count     Number of blocks to release
     192 *
     193 */
     194int ext4_balloc_free_blocks(ext4_inode_ref_t *inode_ref,
     195    uint32_t first, uint32_t count)
     196{
     197        int r;
     198        uint32_t gid;
     199        uint64_t limit;
     200        ext4_filesystem_t *fs = inode_ref->fs;
     201        ext4_superblock_t *sb = fs->superblock;
     202
     203        while (count) {
     204                gid = ext4_filesystem_blockaddr2group(sb, first);
     205                limit = ext4_filesystem_index_in_group2blockaddr(sb, 0,
     206                    gid + 1);
     207
     208                if ((first + count) >= limit) {
     209                        /* This extent spans over 2 or more block groups,
     210                         * we'll break it into smaller parts.
     211                         */
     212                        uint32_t s = limit - first;
     213
     214                        r = ext4_balloc_free_blocks_internal(inode_ref,
     215                            first, s);
     216                        if (r != EOK)
     217                                return r;
     218
     219                        first = limit;
     220                        count -= s;
     221                } else {
     222                        return ext4_balloc_free_blocks_internal(inode_ref,
     223                            first, count);
     224                }
     225        }
     226
     227        return EOK;
     228}
     229
    217230/** Compute first block for data in block group.
    218231 *
     
    227240    ext4_block_group_ref_t *bg_ref)
    228241{
    229         uint32_t block_group_count = ext4_superblock_get_block_group_count(sb);
    230         uint32_t inode_table_first_block =
    231             ext4_block_group_get_inode_table_first_block(bg_ref->block_group, sb);
    232         uint16_t inode_table_item_size = ext4_superblock_get_inode_size(sb);
    233         uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
    234         uint32_t block_size = ext4_superblock_get_block_size(sb);
    235         uint32_t inode_table_bytes;
    236        
    237         if (bg_ref->index < block_group_count - 1) {
    238                 inode_table_bytes = inodes_per_group * inode_table_item_size;
    239         } else {
    240                 /* Last block group could be smaller */
    241                 uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb);
    242                 inode_table_bytes =
    243                     (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
    244                     inode_table_item_size;
    245         }
    246        
    247         uint32_t inode_table_blocks = inode_table_bytes / block_size;
    248        
    249         if (inode_table_bytes % block_size)
    250                 inode_table_blocks++;
    251        
    252         return inode_table_first_block + inode_table_blocks;
     242        uint32_t r;
     243        uint64_t itable = ext4_block_group_get_inode_table_first_block(
     244            bg_ref->block_group, sb);
     245        uint32_t itable_sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref);
     246
     247        if (!ext4_superblock_has_feature_incompatible(sb,
     248            EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
     249                /* If we are not using FLEX_BG, the first data block
     250                 * is always after the inode table.
     251                 */
     252                r = itable + itable_sz;
     253                return ext4_filesystem_blockaddr2_index_in_group(sb, r);
     254        }
     255
     256        uint64_t bbmap = ext4_block_group_get_block_bitmap(bg_ref->block_group,
     257            sb);
     258        uint64_t ibmap = ext4_block_group_get_inode_bitmap(bg_ref->block_group,
     259            sb);
     260
     261        r = ext4_filesystem_index_in_group2blockaddr(sb, 0, bg_ref->index);
     262        r += ext4_filesystem_bg_get_backup_blocks(bg_ref);
     263
     264        if (ext4_filesystem_blockaddr2group(sb, bbmap) != bg_ref->index)
     265                bbmap = -1; /* Invalid */
     266
     267        if (ext4_filesystem_blockaddr2group(sb, ibmap) != bg_ref->index)
     268                ibmap = -1;
     269
     270        while (1) {
     271                if (r == bbmap || r == ibmap)
     272                        r++;
     273                else if (r >= itable && r < (itable + itable_sz))
     274                        r = itable + itable_sz;
     275                else
     276                        break;
     277        }
     278
     279        return r;
    253280}
    254281
     
    264291        *goal = 0;
    265292        ext4_superblock_t *sb = inode_ref->fs->superblock;
    266        
     293
    267294        uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
    268295        uint32_t block_size = ext4_superblock_get_block_size(sb);
    269296        uint32_t inode_block_count = inode_size / block_size;
    270        
     297
    271298        if (inode_size % block_size != 0)
    272299                inode_block_count++;
    273        
     300
    274301        /* If inode has some blocks, get last block address + 1 */
    275302        if (inode_block_count > 0) {
     
    278305                if (rc != EOK)
    279306                        return rc;
    280                
     307
    281308                if (goal != 0) {
    282309                        (*goal)++;
    283310                        return EOK;
    284311                }
    285                
    286312                /* If goal == 0, sparse file -> continue */
    287313        }
    288        
     314
    289315        /* Identify block group of inode */
    290316        uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
    291317        uint32_t block_group = (inode_ref->index - 1) / inodes_per_group;
    292         block_size = ext4_superblock_get_block_size(sb);
    293        
     318
    294319        /* Load block group reference */
    295320        ext4_block_group_ref_t *bg_ref;
     
    298323        if (rc != EOK)
    299324                return rc;
    300        
    301         /* Compute indexes */
    302         uint32_t block_group_count = ext4_superblock_get_block_group_count(sb);
    303         uint32_t inode_table_first_block =
    304             ext4_block_group_get_inode_table_first_block(bg_ref->block_group, sb);
    305         uint16_t inode_table_item_size = ext4_superblock_get_inode_size(sb);
    306         uint32_t inode_table_bytes;
    307        
    308         /* Check for last block group */
    309         if (block_group < block_group_count - 1) {
    310                 inode_table_bytes = inodes_per_group * inode_table_item_size;
    311         } else {
    312                 /* Last block group could be smaller */
    313                 uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb);
    314                 inode_table_bytes =
    315                     (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
    316                     inode_table_item_size;
    317         }
    318        
    319         uint32_t inode_table_blocks = inode_table_bytes / block_size;
    320        
    321         if (inode_table_bytes % block_size)
    322                 inode_table_blocks++;
    323        
    324         *goal = inode_table_first_block + inode_table_blocks;
    325        
     325
     326        *goal = ext4_balloc_get_first_data_block_in_group(sb, bg_ref);
     327
    326328        return ext4_filesystem_put_block_group_ref(bg_ref);
    327329}
     
    353355       
    354356        /* Load block group number for goal and relative index */
    355         uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, goal);
     357        uint32_t block_group = ext4_filesystem_blockaddr2group(sb, goal);
    356358        uint32_t index_in_group =
    357359            ext4_filesystem_blockaddr2_index_in_group(sb, goal);
     
    626628       
    627629        /* Compute indexes */
    628         uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, fblock);
     630        uint32_t block_group = ext4_filesystem_blockaddr2group(sb, fblock);
    629631        uint32_t index_in_group =
    630632            ext4_filesystem_blockaddr2_index_in_group(sb, fblock);
  • uspace/lib/ext4/libext4_crc.c

    rdcba819 rbf1733d3  
    3939uint16_t crc16(uint16_t crc, const uint8_t *buffer, size_t len)
    4040{
    41         // TODO
    42         return 0;
     41        /* TODO */
     42        return 0;
    4343}
    4444
  • uspace/lib/ext4/libext4_filesystem.c

    rdcba819 rbf1733d3  
    4040#include <malloc.h>
    4141#include <ipc/vfs.h>
     42#include <align.h>
    4243#include "libext4.h"
    4344
     
    250251}
    251252
     253/** Convert the absolute block number to group number
     254 *
     255 * @param sb    Pointer to the superblock
     256 * @param b     Absolute block number
     257 *
     258 * @return      Group number
     259 */
     260uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *sb, uint64_t b)
     261{
     262        uint32_t blocks_per_group = ext4_superblock_get_blocks_per_group(sb);
     263        uint32_t first_block = ext4_superblock_get_first_data_block(sb);
     264
     265        return (b - first_block) / blocks_per_group;
     266}
     267
    252268/** Initialize block bitmap in block group.
    253269 *
     
    259275static int ext4_filesystem_init_block_bitmap(ext4_block_group_ref_t *bg_ref)
    260276{
     277        uint64_t itb;
     278        uint32_t sz;
     279        uint32_t i;
     280
    261281        /* Load bitmap */
    262         uint32_t bitmap_block_addr = ext4_block_group_get_block_bitmap(
     282        ext4_superblock_t *sb = bg_ref->fs->superblock;
     283        uint64_t bitmap_block_addr = ext4_block_group_get_block_bitmap(
     284            bg_ref->block_group, bg_ref->fs->superblock);
     285        uint64_t bitmap_inode_addr = ext4_block_group_get_inode_bitmap(
    263286            bg_ref->block_group, bg_ref->fs->superblock);
    264287       
     
    272295       
    273296        /* Initialize all bitmap bits to zero */
    274         uint32_t block_size = ext4_superblock_get_block_size(bg_ref->fs->superblock);
     297        uint32_t block_size = ext4_superblock_get_block_size(sb);
    275298        memset(bitmap, 0, block_size);
    276299       
    277         /* Determine first block and first data block in group */
    278         uint32_t first_idx = 0;
    279        
    280         uint32_t first_data = ext4_balloc_get_first_data_block_in_group(
    281             bg_ref->fs->superblock, bg_ref);
    282         uint32_t first_data_idx = ext4_filesystem_blockaddr2_index_in_group(
    283             bg_ref->fs->superblock, first_data);
    284        
     300        /* Determine the number of reserved blocks in the group */
     301        uint32_t reserved_cnt = ext4_filesystem_bg_get_backup_blocks(bg_ref);
     302
    285303        /* Set bits from to first block to first data block - 1 to one (allocated) */
    286         for (uint32_t block = first_idx; block < first_data_idx; ++block)
     304        for (uint32_t block = 0; block < reserved_cnt; ++block)
    287305                ext4_bitmap_set_bit(bitmap, block);
    288        
     306
     307        uint32_t bitmap_block_gid = ext4_filesystem_blockaddr2group(sb,
     308            bitmap_block_addr);
     309        if (bitmap_block_gid == bg_ref->index) {
     310                ext4_bitmap_set_bit(bitmap,
     311                    ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_block_addr));
     312        }
     313
     314        uint32_t bitmap_inode_gid = ext4_filesystem_blockaddr2group(sb,
     315            bitmap_inode_addr);
     316        if (bitmap_inode_gid == bg_ref->index) {
     317                ext4_bitmap_set_bit(bitmap,
     318                    ext4_filesystem_blockaddr2_index_in_group(sb, bitmap_inode_addr));
     319        }
     320
     321        itb = ext4_block_group_get_inode_table_first_block(bg_ref->block_group,
     322            sb);
     323        sz = ext4_filesystem_bg_get_itable_size(sb, bg_ref);
     324
     325        for (i = 0; i < sz; ++i, ++itb) {
     326                uint32_t gid = ext4_filesystem_blockaddr2group(sb, itb);
     327                if (gid == bg_ref->index) {
     328                        ext4_bitmap_set_bit(bitmap,
     329                            ext4_filesystem_blockaddr2_index_in_group(sb, itb));
     330                }
     331        }
     332
    289333        bitmap_block->dirty = true;
    290334       
     
    423467        }
    424468       
    425         /* Inititialize in-memory representation */
     469        /* Initialize in-memory representation */
    426470        newref->block_group = newref->block->data + offset;
    427471        newref->fs = fs;
     
    523567}
    524568
     569/** Get the size of the block group's inode table
     570 *
     571 * @param sb     Pointer to the superblock
     572 * @param bg_ref Pointer to the block group reference
     573 *
     574 * @return       Size of the inode table in blocks.
     575 */
     576uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb,
     577    ext4_block_group_ref_t *bg_ref)
     578{
     579        uint32_t itable_size;
     580        uint32_t block_group_count = ext4_superblock_get_block_group_count(sb);
     581        uint16_t inode_table_item_size = ext4_superblock_get_inode_size(sb);
     582        uint32_t inodes_per_group = ext4_superblock_get_inodes_per_group(sb);
     583        uint32_t block_size = ext4_superblock_get_block_size(sb);
     584
     585        if (bg_ref->index < block_group_count - 1) {
     586                itable_size = inodes_per_group * inode_table_item_size;
     587        } else {
     588                /* Last block group could be smaller */
     589                uint32_t inodes_count_total = ext4_superblock_get_inodes_count(sb);
     590                itable_size =
     591                    (inodes_count_total - ((block_group_count - 1) * inodes_per_group)) *
     592                    inode_table_item_size;
     593        }
     594
     595        return ROUND_UP(itable_size, block_size) / block_size;
     596}
     597
     598/* Check if n is a power of p */
     599static bool is_power_of(uint32_t n, unsigned p)
     600{
     601        if (p == 1 && n != p)
     602                return false;
     603
     604        while (n != p) {
     605                if (n < p)
     606                        return false;
     607                else if ((n % p) != 0)
     608                        return false;
     609
     610                n /= p;
     611        }
     612
     613        return true;
     614}
     615
     616/** Get the number of blocks used by superblock + gdt + reserved gdt backups
     617 *
     618 * @param bg    Pointer to block group
     619 *
     620 * @return      Number of blocks
     621 */
     622uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg)
     623{
     624        uint32_t const idx = bg->index;
     625        uint32_t r = 0;
     626        bool has_backups = false;
     627        ext4_superblock_t *sb = bg->fs->superblock;
     628
     629        /* First step: determine if the block group contains the backups */
     630
     631        if (idx <= 1)
     632                has_backups = true;
     633        else {
     634                if (ext4_superblock_has_feature_compatible(sb,
     635                    EXT4_FEATURE_COMPAT_SPARSE_SUPER2)) {
     636                        uint32_t g1, g2;
     637
     638                        ext4_superblock_get_backup_groups_sparse2(sb,
     639                            &g1, &g2);
     640
     641                        if (idx == g1 || idx == g2)
     642                                has_backups = true;
     643                } else if (!ext4_superblock_has_feature_read_only(sb,
     644                    EXT4_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
     645                        /* Very old fs were all block groups have
     646                         * superblock and block descriptors backups.
     647                         */
     648                        has_backups = true;
     649                } else {
     650                        if ((idx & 1) && (is_power_of(idx, 3) ||
     651                            is_power_of(idx, 5) || is_power_of(idx, 7)))
     652                                has_backups = true;
     653                }
     654        }
     655
     656        if (has_backups) {
     657                uint32_t bg_count;
     658                uint32_t bg_desc_sz;
     659                uint32_t gdt_table; /* Size of the GDT in blocks */
     660                uint32_t block_size = ext4_superblock_get_block_size(sb);
     661
     662                /* Now we know that this block group has backups,
     663                 * we have to compute how many blocks are reserved
     664                 * for them
     665                 */
     666
     667                if (idx == 0 && block_size == 1024) {
     668                        /* Special case for first group were the boot block
     669                         * resides
     670                         */
     671                        r++;
     672                }
     673
     674                /* This accounts for the superblock */
     675                r++;
     676
     677                /* Add the number of blocks used for the GDT */
     678                bg_count = ext4_superblock_get_block_group_count(sb);
     679                bg_desc_sz = ext4_superblock_get_desc_size(sb);
     680                gdt_table = ROUND_UP(bg_count * bg_desc_sz, block_size) /
     681                    block_size;
     682
     683                r += gdt_table;
     684
     685                /* And now the number of reserved GDT blocks */
     686                r += ext4_superblock_get_reserved_gdt_blocks(sb);
     687        }
     688
     689        return r;
     690}
     691
    525692/** Put reference to block group.
    526693 *
    527  * @oaram ref Pointer for reference to be put back
     694 * @param ref Pointer for reference to be put back
    528695 *
    529696 * @return Error code
  • uspace/lib/ext4/libext4_filesystem.h

    rdcba819 rbf1733d3  
    4747extern uint32_t ext4_filesystem_index_in_group2blockaddr(ext4_superblock_t *,
    4848    uint32_t, uint32_t);
     49extern uint32_t ext4_filesystem_blockaddr2group(ext4_superblock_t *, uint64_t);
    4950extern int ext4_filesystem_get_block_group_ref(ext4_filesystem_t *, uint32_t,
    5051    ext4_block_group_ref_t **);
     
    6465extern int ext4_filesystem_append_inode_block(ext4_inode_ref_t *, uint32_t *,
    6566    uint32_t *);
     67uint32_t ext4_filesystem_bg_get_backup_blocks(ext4_block_group_ref_t *bg);
     68uint32_t ext4_filesystem_bg_get_itable_size(ext4_superblock_t *sb,
     69    ext4_block_group_ref_t *bg_ref);
    6670
    6771#endif
  • uspace/lib/ext4/libext4_superblock.c

    rdcba819 rbf1733d3  
    12981298}
    12991299
     1300/** Get the backup groups used with SPARSE_SUPER2
     1301 *
     1302 * @param sb    Pointer to the superblock
     1303 * @param g1    Output pointer to the first backup group
     1304 * @param g2    Output pointer to the second backup group
     1305 */
     1306void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb,
     1307    uint32_t *g1, uint32_t *g2)
     1308{
     1309        *g1 = uint32_t_le2host(sb->backup_bgs[0]);
     1310        *g2 = uint32_t_le2host(sb->backup_bgs[1]);
     1311}
     1312
     1313/** Set the backup groups (SPARSE SUPER2)
     1314 *
     1315 * @param sb    Pointer to the superblock
     1316 * @param g1    Index of the first group
     1317 * @param g2    Index of the second group
     1318 */
     1319void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb,
     1320    uint32_t g1, uint32_t g2)
     1321{
     1322        sb->backup_bgs[0] = host2uint32_t_le(g1);
     1323        sb->backup_bgs[1] = host2uint32_t_le(g2);
     1324}
     1325
     1326/** Get the number of blocks (per group) reserved to GDT expansion
     1327 *
     1328 * @param sb    Pointer to the superblock
     1329 *
     1330 * @return      Number of blocks
     1331 */
     1332uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb)
     1333{
     1334        return uint32_t_le2host(sb->reserved_gdt_blocks);
     1335}
     1336
     1337/** Set the number of blocks (per group) reserved to GDT expansion
     1338 *
     1339 * @param sb    Pointer to the superblock
     1340 * @param n     Number of reserved blocks
     1341 */
     1342void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb,
     1343    uint32_t n)
     1344{
     1345        sb->reserved_gdt_blocks = host2uint32_t_le(n);
     1346}
     1347
    13001348/**
    13011349 * @}
  • uspace/lib/ext4/libext4_superblock.h

    rdcba819 rbf1733d3  
    135135extern void ext4_superblock_set_flags(ext4_superblock_t *, uint32_t);
    136136
     137extern void ext4_superblock_get_backup_groups_sparse2(ext4_superblock_t *sb,
     138    uint32_t *g1, uint32_t *g2);
     139extern void ext4_superblock_set_backup_groups_sparse2(ext4_superblock_t *sb,
     140    uint32_t g1, uint32_t g2);
     141
     142extern uint32_t ext4_superblock_get_reserved_gdt_blocks(ext4_superblock_t *sb);
     143extern void ext4_superblock_set_reserved_gdt_blocks(ext4_superblock_t *sb,
     144    uint32_t n);
     145
    137146/* More complex superblock functions */
    138147extern bool ext4_superblock_has_flag(ext4_superblock_t *, uint32_t);
  • uspace/lib/ext4/libext4_types.h

    rdcba819 rbf1733d3  
    8383         * happen if the EXT4_FEATURE_COMPAT_DIR_PREALLOC flag is on.
    8484         */
    85         uint8_t s_prealloc_blocks;       /* Number of blocks to try to preallocate */
    86         uint8_t s_prealloc_dir_blocks;   /* Number to preallocate for dirs */
    87         uint16_t s_reserved_gdt_blocks;  /* Per group desc for online growth */
     85        uint8_t prealloc_blocks;        /* Number of blocks to try to preallocate */
     86        uint8_t prealloc_dir_blocks;    /* Number to preallocate for dirs */
     87        uint16_t reserved_gdt_blocks;   /* Per group desc for online growth */
    8888       
    8989        /*
     
    133133        uint64_t last_error_block;          /* Block involved of last error */
    134134        uint8_t last_error_func[32];        /* Function where the error happened */
    135         uint8_t mount_opts[64];
    136         uint32_t padding[112];              /* Padding to the end of the block */
     135        uint8_t mount_opts[64];             /* String containing the mount options */
     136        uint32_t usr_quota_inum;            /* Inode number of user quota file */
     137        uint32_t grp_quota_inum;            /* Inode number of group quota file */
     138        uint32_t overhead_blocks;           /* Overhead blocks/clusters */
     139        uint32_t backup_bgs[2];             /* Block groups containing superblock backups (if SPARSE_SUPER2) */
     140        uint32_t encrypt_algos;             /* Encrypt algorithm in use */
     141        uint32_t padding[105];              /* Padding to the end of the block */
    137142} __attribute__((packed)) ext4_superblock_t;
    138143
     
    176181#define EXT4_FEATURE_COMPAT_RESIZE_INODE   0x0010
    177182#define EXT4_FEATURE_COMPAT_DIR_INDEX      0x0020
     183#define EXT4_FEATURE_COMPAT_SPARSE_SUPER2  0x0200
    178184
    179185/*
     
    208214        (EXT4_FEATURE_INCOMPAT_FILETYPE | \
    209215        EXT4_FEATURE_INCOMPAT_EXTENTS | \
    210         EXT4_FEATURE_INCOMPAT_64BIT)
     216        EXT4_FEATURE_INCOMPAT_64BIT | \
     217        EXT4_FEATURE_INCOMPAT_FLEX_BG)
    211218
    212219#define EXT4_FEATURE_RO_COMPAT_SUPP \
Note: See TracChangeset for help on using the changeset viewer.