Ignore:
Timestamp:
2012-08-24T14:07:52Z (12 years ago)
Author:
Frantisek Princ <frantisek.princ@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
041ab64
Parents:
bd29f9c9 (diff), db81577 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge with mainline

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/ext4/libext4_block_group.c

    rbd29f9c9 rbeb9336  
    2929/** @addtogroup libext4
    3030 * @{
    31  */
    32 
     31 */
    3332/**
    34  * @file        libext4_block_group.c
    35  * @brief       Ext4 block group structure operations.
     33 * @file  libext4_block_group.c
     34 * @brief Ext4 block group structure operations.
    3635 */
    3736
    … …  
    4140/** Get address of block with data block bitmap.
    4241 *
    43  * @param bg    pointer to block group
    44  * @param sb    pointer to superblock
    45  * @return              address of block with block bitmap
     42 * @param bg Pointer to block group
     43 * @param sb Pointer to superblock
     44 *
     45 * @return Address of block with block bitmap
     46 *
    4647 */
    4748uint64_t ext4_block_group_get_block_bitmap(ext4_block_group_t *bg,
    48                 ext4_superblock_t *sb)
    49 {
    50         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
    51                 return ((uint64_t)uint32_t_le2host(bg->block_bitmap_hi) << 32) |
    52                         uint32_t_le2host(bg->block_bitmap_lo);
    53         } else {
     49    ext4_superblock_t *sb)
     50{
     51        if (ext4_superblock_get_desc_size(sb) >
     52            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
     53                return ((uint64_t) uint32_t_le2host(bg->block_bitmap_hi) << 32) |
     54                    uint32_t_le2host(bg->block_bitmap_lo);
     55        else
    5456                return uint32_t_le2host(bg->block_bitmap_lo);
    55         }
    5657}
    5758
    5859/** Set address of block with data block bitmap.
    5960 *
    60  * @param bg                    pointer to block group
    61  * @param sb                    pointer to superblock
    62  * @param block_bitmap  address of block with block bitmap
     61 * @param bg           Pointer to block group
     62 * @param sb           Pointer to superblock
     63 * @param block_bitmap Address of block with block bitmap
     64 *
    6365 */
    6466void ext4_block_group_set_block_bitmap(ext4_block_group_t *bg,
    65                 ext4_superblock_t *sb, uint64_t block_bitmap)
     67    ext4_superblock_t *sb, uint64_t block_bitmap)
    6668{
    6769        bg->block_bitmap_lo = host2uint32_t_le((block_bitmap << 32) >> 32);
    68 
    69         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
     70       
     71        if (ext4_superblock_get_desc_size(sb) >
     72            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
    7073                bg->block_bitmap_hi = host2uint32_t_le(block_bitmap >> 32);
    71         }
    7274}
    7375
    7476/** Get address of block with i-node bitmap.
    7577 *
    76  * @param bg    pointer to block group
    77  * @param sb    pointer to superblock
    78  * @return              address of block with i-node bitmap
     78 * @param bg Pointer to block group
     79 * @param sb Pointer to superblock
     80 *
     81 * @return Address of block with i-node bitmap
     82 *
    7983 */
    8084uint64_t ext4_block_group_get_inode_bitmap(ext4_block_group_t *bg,
    81                 ext4_superblock_t *sb)
    82 {
    83         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
    84                 return ((uint64_t)uint32_t_le2host(bg->inode_bitmap_hi) << 32) |
    85                         uint32_t_le2host(bg->inode_bitmap_lo);
    86         } else {
     85    ext4_superblock_t *sb)
     86{
     87        if (ext4_superblock_get_desc_size(sb) >
     88            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
     89                return ((uint64_t) uint32_t_le2host(bg->inode_bitmap_hi) << 32) |
     90                    uint32_t_le2host(bg->inode_bitmap_lo);
     91        else
    8792                return uint32_t_le2host(bg->inode_bitmap_lo);
    88         }
    89 
    9093}
    9194
    9295/** Set address of block with i-node bitmap.
    9396 *
    94  * @param bg                    pointer to block group
    95  * @param sb                    pointer to superblock
    96  * @param inode_bitmap  address of block with i-node bitmap
     97 * @param bg           Pointer to block group
     98 * @param sb           Pointer to superblock
     99 * @param inode_bitmap Address of block with i-node bitmap
     100 *
    97101 */
    98102void ext4_block_group_set_inode_bitmap(ext4_block_group_t *bg,
    99                 ext4_superblock_t *sb, uint64_t inode_bitmap)
     103    ext4_superblock_t *sb, uint64_t inode_bitmap)
    100104{
    101105        bg->inode_bitmap_lo = host2uint32_t_le((inode_bitmap << 32) >> 32);
    102 
    103         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
     106       
     107        if (ext4_superblock_get_desc_size(sb) >
     108            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
    104109                bg->inode_bitmap_hi = host2uint32_t_le(inode_bitmap >> 32);
    105         }
    106110}
    107111
    108112/** Get address of the first block of the i-node table.
    109113 *
    110  * @param bg    pointer to block group
    111  * @param sb    pointer to superblock
    112  * @return              address of first block of i-node table
     114 * @param bg Pointer to block group
     115 * @param sb Pointer to superblock
     116 *
     117 * @return Address of first block of i-node table
     118 *
    113119 */
    114120uint64_t ext4_block_group_get_inode_table_first_block(ext4_block_group_t *bg,
    115                 ext4_superblock_t *sb)
    116 {
    117         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
    118                 return ((uint64_t)uint32_t_le2host(bg->inode_table_first_block_hi) << 32) |
    119                         uint32_t_le2host(bg->inode_table_first_block_lo);
    120         } else {
     121    ext4_superblock_t *sb)
     122{
     123        if (ext4_superblock_get_desc_size(sb) >
     124            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
     125                return ((uint64_t)
     126                    uint32_t_le2host(bg->inode_table_first_block_hi) << 32) |
     127                    uint32_t_le2host(bg->inode_table_first_block_lo);
     128        else
    121129                return uint32_t_le2host(bg->inode_table_first_block_lo);
    122         }
    123130}
    124131
    125132/** Set address of the first block of the i-node table.
    126133 *
    127  * @param bg    pointer to block group
    128  * @param sb    pointer to superblock
    129  * @param inode_table_first address of first block of i-node table
     134 * @param bg                Pointer to block group
     135 * @param sb                Pointer to superblock
     136 * @param inode_table_first Address of first block of i-node table
     137 *
    130138 */
    131139void ext4_block_group_set_inode_table_first_block(ext4_block_group_t *bg,
    132                 ext4_superblock_t *sb, uint64_t inode_table_first)
     140    ext4_superblock_t *sb, uint64_t inode_table_first)
    133141{
    134142        bg->inode_table_first_block_lo =
    135                         host2uint32_t_le((inode_table_first << 32) >> 32);
    136 
    137         if (ext4_superblock_get_desc_size(sb) >
    138                         EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
    139 
     143            host2uint32_t_le((inode_table_first << 32) >> 32);
     144       
     145        if (ext4_superblock_get_desc_size(sb) >
     146            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
    140147                bg->inode_table_first_block_hi =
    141                                 host2uint32_t_le(inode_table_first >> 32);
    142         }
     148                    host2uint32_t_le(inode_table_first >> 32);
    143149}
    144150
    145151/** Get number of free blocks in block group.
    146152 *
    147  * @param bg    pointer to block group
    148  * @param sb    pointer to superblock
    149  * @return              number of free blocks in block group
     153 * @param bg Pointer to block group
     154 * @param sb Pointer to superblock
     155 *
     156 * @return Number of free blocks in block group
     157 *
    150158 */
    151159uint32_t ext4_block_group_get_free_blocks_count(ext4_block_group_t *bg,
    152                 ext4_superblock_t *sb)
    153 {
    154         if (ext4_superblock_get_desc_size(sb) >
    155                         EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
    156 
    157                 return ((uint32_t)uint16_t_le2host(bg->free_blocks_count_hi) << 16) |
    158                         uint16_t_le2host(bg->free_blocks_count_lo);
    159         } else {
     160    ext4_superblock_t *sb)
     161{
     162        if (ext4_superblock_get_desc_size(sb) >
     163            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
     164                return ((uint32_t)
     165                    uint16_t_le2host(bg->free_blocks_count_hi) << 16) |
     166                    uint16_t_le2host(bg->free_blocks_count_lo);
     167        else
    160168                return uint16_t_le2host(bg->free_blocks_count_lo);
    161         }
    162169}
    163170
    164171/** Set number of free blocks in block group.
    165172 *
    166  * @param bg    pointer to block group
    167  * @param sb    pointer to superblock
    168  * @param value number of free blocks in block group
     173 * @param bg    Pointer to block group
     174 * @param sb    Pointer to superblock
     175 * @param value Number of free blocks in block group
     176 *
    169177 */
    170178void ext4_block_group_set_free_blocks_count(ext4_block_group_t *bg,
    171                 ext4_superblock_t *sb, uint32_t value)
     179    ext4_superblock_t *sb, uint32_t value)
    172180{
    173181        bg->free_blocks_count_lo = host2uint16_t_le((value << 16) >> 16);
    174         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
     182        if (ext4_superblock_get_desc_size(sb) >
     183            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
    175184                bg->free_blocks_count_hi = host2uint16_t_le(value >> 16);
    176         }
    177185}
    178186
    179187/** Get number of free i-nodes in block group.
    180188 *
    181  * @param bg    pointer to block group
    182  * @param sb    pointer to superblock
    183  * @return              number of free i-nodes in block group
     189 * @param bg Pointer to block group
     190 * @param sb Pointer to superblock
     191 *
     192 * @return Number of free i-nodes in block group
     193 *
    184194 */
    185195uint32_t ext4_block_group_get_free_inodes_count(ext4_block_group_t *bg,
    186                 ext4_superblock_t *sb)
    187 {
    188         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
    189                 return ((uint32_t)uint16_t_le2host(bg->free_inodes_count_hi) << 16) |
    190                         uint16_t_le2host(bg->free_inodes_count_lo);
    191         } else {
     196    ext4_superblock_t *sb)
     197{
     198        if (ext4_superblock_get_desc_size(sb) >
     199            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
     200                return ((uint32_t)
     201                    uint16_t_le2host(bg->free_inodes_count_hi) << 16) |
     202                    uint16_t_le2host(bg->free_inodes_count_lo);
     203        else
    192204                return uint16_t_le2host(bg->free_inodes_count_lo);
    193         }
    194205}
    195206
    196207/** Set number of free i-nodes in block group.
    197208 *
    198  * @param bg    pointer to block group
    199  * @param sb    pointer to superblock
    200  * @param value number of free i-nodes in block group
     209 * @param bg    Pointer to block group
     210 * @param sb    Pointer to superblock
     211 * @param value Number of free i-nodes in block group
     212 *
    201213 */
    202214void ext4_block_group_set_free_inodes_count(ext4_block_group_t *bg,
    203                 ext4_superblock_t *sb, uint32_t value)
     215    ext4_superblock_t *sb, uint32_t value)
    204216{
    205217        bg->free_inodes_count_lo = host2uint16_t_le((value << 16) >> 16);
    206         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
     218        if (ext4_superblock_get_desc_size(sb) >
     219            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
    207220                bg->free_inodes_count_hi = host2uint16_t_le(value >> 16);
    208         }
    209221}
    210222
    211223/** Get number of used directories in block group.
    212224 *
    213  * @param bg    pointer to block group
    214  * @param sb    pointer to superblock
    215  * @return              number of used directories in block group
     225 * @param bg Pointer to block group
     226 * @param sb Pointer to superblock
     227 *
     228 * @return Number of used directories in block group
     229 *
    216230 */
    217231uint32_t ext4_block_group_get_used_dirs_count(ext4_block_group_t *bg,
    218                 ext4_superblock_t *sb)
    219 {
    220         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
    221                 return ((uint32_t)uint16_t_le2host(bg->used_dirs_count_hi) << 16) |
    222                         uint16_t_le2host(bg->used_dirs_count_lo);
    223         } else {
     232    ext4_superblock_t *sb)
     233{
     234        if (ext4_superblock_get_desc_size(sb) >
     235            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
     236                return ((uint32_t)
     237                    uint16_t_le2host(bg->used_dirs_count_hi) << 16) |
     238                    uint16_t_le2host(bg->used_dirs_count_lo);
     239        else
    224240                return uint16_t_le2host(bg->used_dirs_count_lo);
    225         }
    226241}
    227242
    228243/** Set number of used directories in block group.
    229244 *
    230  * @param bg    pointer to block group
    231  * @param sb    pointer to superblock
    232  * @param value number of used directories in block group
     245 * @param bg    Pointer to block group
     246 * @param sb    Pointer to superblock
     247 * @param value Number of used directories in block group
     248 *
    233249 */
    234250void ext4_block_group_set_used_dirs_count(ext4_block_group_t *bg,
    235                 ext4_superblock_t *sb, uint32_t count)
     251    ext4_superblock_t *sb, uint32_t count)
    236252{
    237253        bg->used_dirs_count_lo = host2uint16_t_le((count << 16) >> 16);
    238         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
     254        if (ext4_superblock_get_desc_size(sb) >
     255            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
    239256                bg->used_dirs_count_hi = host2uint16_t_le(count >> 16);
    240         }
    241257}
    242258
    243259/** Get flags of block group.
    244260 *
    245  * @param bg    pointer to block group
    246  * @return              flags of block group
     261 * @param bg Pointer to block group
     262 *
     263 * @return Flags of block group
     264 *
    247265 */
    248266uint16_t ext4_block_group_get_flags(ext4_block_group_t *bg)
    … …  
    253271/** Set flags for block group.
    254272 *
    255  * @param bg    pointer to block group
    256  * @param flags flags for block group
     273 * @param bg    Pointer to block group
     274 * @param flags Flags for block group
     275 *
    257276 */
    258277void ext4_block_group_set_flags(ext4_block_group_t *bg, uint16_t flags)
    … …  
    263282/** Get number of unused i-nodes.
    264283 *
    265  * @param bg    pointer to block group
    266  * @param sb    pointer to superblock
    267  * @return              number of unused i-nodes
     284 * @param bg Pointer to block group
     285 * @param sb Pointer to superblock
     286 *
     287 * @return Number of unused i-nodes
     288 *
    268289 */
    269290uint32_t ext4_block_group_get_itable_unused(ext4_block_group_t *bg,
    270                 ext4_superblock_t *sb)
    271 {
    272         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
    273                 return ((uint32_t)uint16_t_le2host(bg->itable_unused_hi) << 16) |
    274                         uint16_t_le2host(bg->itable_unused_lo);
    275         } else {
     291    ext4_superblock_t *sb)
     292{
     293        if (ext4_superblock_get_desc_size(sb) >
     294            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
     295                return ((uint32_t)
     296                    uint16_t_le2host(bg->itable_unused_hi) << 16) |
     297                    uint16_t_le2host(bg->itable_unused_lo);
     298        else
    276299                return uint16_t_le2host(bg->itable_unused_lo);
    277         }
    278300}
    279301
    280302/** Set number of unused i-nodes.
    281303 *
    282  * @param bg    pointer to block group
    283  * @param sb    pointer to superblock
    284  * @param value number of unused i-nodes
     304 * @param bg    Pointer to block group
     305 * @param sb    Pointer to superblock
     306 * @param value Number of unused i-nodes
     307 *
    285308 */
    286309void ext4_block_group_set_itable_unused(ext4_block_group_t *bg,
    287                 ext4_superblock_t *sb, uint32_t value)
     310    ext4_superblock_t *sb, uint32_t value)
    288311{
    289312        bg->itable_unused_lo = host2uint16_t_le((value << 16) >> 16);
    290         if (ext4_superblock_get_desc_size(sb) > EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE) {
     313        if (ext4_superblock_get_desc_size(sb) >
     314            EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE)
    291315                bg->itable_unused_hi = host2uint16_t_le(value >> 16);
    292         }
    293 
    294316}
    295317
    296318/** Get checksum of block group.
    297319 *
    298  * @param bg    pointer to block group
    299  * @return              checksum of block group
     320 * @param bg Pointer to block group
     321 *
     322 * @return checksum of block group
     323 *
    300324 */
    301325uint16_t ext4_block_group_get_checksum(ext4_block_group_t *bg)
    … …  
    306330/** Set checksum of block group.
    307331 *
    308  * @param bg            pointer to block group
    309  * @param checksum      cheksum of block group
     332 * @param bg       Pointer to block group
     333 * @param checksum Cheksum of block group
     334 *
    310335 */
    311336void ext4_block_group_set_checksum(ext4_block_group_t *bg, uint16_t checksum)
    … …  
    316341/** Check if block group has a flag.
    317342 *
    318  * @param bg    pointer to block group
    319  * @param flag  flag to be checked
    320  * @return              true if flag is set to 1
     343 * @param bg   Pointer to block group
     344 * @param flag Flag to be checked
     345 *
     346 * @return True if flag is set to 1
     347 *
    321348 */
    322349bool ext4_block_group_has_flag(ext4_block_group_t *bg, uint32_t flag)
    323350{
    324         if (ext4_block_group_get_flags(bg) & flag) {
     351        if (ext4_block_group_get_flags(bg) & flag)
    325352                return true;
    326         }
     353       
    327354        return false;
    328355}
    … …  
    330357/** Set (add) flag of block group.
    331358 *
    332  * @param bg    pointer to block group
    333  * @param flag  flag to be set
     359 * @param bg   Pointer to block group
     360 * @param flag Flag to be set
     361 *
    334362 */
    335363void ext4_block_group_set_flag(ext4_block_group_t *bg, uint32_t set_flag)
    … …  
    342370/** Clear (remove) flag of block group.
    343371 *
    344  * @param bg    pointer to block group
    345  * @param flag  flag to be cleared
     372 * @param bg   Pointer to block group
     373 * @param flag Flag to be cleared
     374 *
    346375 */
    347376void ext4_block_group_clear_flag(ext4_block_group_t *bg, uint32_t clear_flag)
    … …  
    352381}
    353382
    354 
    355383/**
    356384 * @}
    357  */ 
     385 */
Note: See TracChangeset for help on using the changeset viewer.