Ignore:
Timestamp:
Apr 26, 2017, 2:29:23 PM (4 years ago)
Author:
alain
Message:

Merge all FS related files in one single vfs directory.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/libk/bits.c

    r1 r11  
    8181                }
    8282        }
    83 }
     83}  // bitmap_set_range()
    8484
    8585///////////////////////////////////////////
     
    108108                }
    109109        }
    110 }
     110}  // bitmap_clear_range()
    111111
    112112///////////////////////////////////////
     
    115115                      uint32_t   size )
    116116{
     117    uint32_t max_word;
    117118        uint32_t word = index / 32; 
    118119        uint32_t bit  = index % 32;
    119120 
    120         if(bit != 0)
    121         {
    122                 for(; bit < 32; bit++)
    123                 {
    124                         if(bitmap[word] & (1 << bit)) return (word*32 + bit);
    125                 }
    126                 word++;
    127         }
    128 
    129         for(; word < size/32; word++)
    130         {
    131                 if(bitmap[word] != 0)
    132                 {
    133                         for(bit = 0; bit < 32; bit++)
    134                         {
    135                                 if(bitmap[word] & (1 << bit)) return (word*32 + bit);
    136                         }
    137                 }
    138         }
    139         return 0xFFFFFFFF;
    140 }
     121    if( index < size )
     122    {
     123            if( bit != 0 )
     124            {
     125                    for( ; bit < 32; bit++)
     126                    {
     127                            if((bitmap[word] & (1 << bit)) ) return (word*32 + bit);
     128                    }
     129                    word++;
     130            }
     131
     132        max_word = ( (size-1) >>5 ) + 1;
     133
     134        for( ; word < max_word ; word++ )
     135            {
     136                    if(bitmap[word] != 0)
     137                    {
     138                            for(bit = 0 ; bit < 32 ; bit++)
     139                            {
     140                                    if( bitmap[word] & (1 << bit) ) return (word*32 + bit);
     141                            }
     142            }
     143                }
     144        }
     145
     146        return -1;
     147
     148}  // bitmap_ffs2()
    141149
    142150///////////////////////////////////////
     
    145153                      uint32_t   size )
    146154{
     155    uint32_t max_word;
    147156        uint32_t word = index / 32;
    148157        uint32_t bit  = index % 32;
    149  
    150         if(bit != 0)
    151         {
    152                 for(; bit < 32; bit++)
    153                 {
    154                         if((bitmap[word] & (1 << bit)) == 0) return (word*32 + bit);
    155                 }
    156                 word++;
    157         }
    158 
    159         for(; word < size/32; word++)
    160         {
    161                 if(bitmap[word] != 0xFFFFFFFF)
    162                 {
    163                         for(bit = 0; bit < 32; bit++)
    164                         {
    165                                 if((bitmap[word] & (1 << bit)) == 0) return (word*32 + bit);
    166                         }
    167                 }
    168         }
    169         return 0xFFFFFFFF;
    170 }
     158   
     159    if( index < size )
     160    {
     161            if( bit != 0 )
     162            {
     163                    for( ; bit < 32; bit++)
     164                    {
     165                            if( (bitmap[word] & (1 << bit)) == 0) return (word*32 + bit);
     166                    }
     167                    word++;
     168            }
     169
     170        max_word = ( (size-1) >>5 ) + 1;
     171
     172        for( ; word < max_word ; word++ )
     173            {
     174                    if(bitmap[word] != 0xFFFFFFFF)
     175                    {
     176                            for(bit = 0 ; bit < 32 ; bit++)
     177                            {
     178                                    if( (bitmap[word] & (1 << bit)) == 0 ) return (word*32 + bit);
     179                            }
     180            }
     181                }
     182        }
     183
     184        return -1;
     185
     186}  // bitmap_ffc2()
    171187
    172188//////////////////////////////////////
     
    174190                     uint32_t   size )
    175191{
     192    uint32_t max_word;
     193        uint32_t word;
     194        uint32_t bit;
     195
     196    if( size )
     197    {
     198        max_word = ( (size-1) >>5 ) + 1;
     199
     200        for( word = 0 ; word < max_word ; word++ )
     201            {
     202                    if(bitmap[word] != 0)
     203                    {
     204                            for(bit = 0 ; bit < 32 ; bit++)
     205                            {
     206                                    if( bitmap[word] & (1 << bit) ) return (word*32 + bit);
     207                            }
     208            }
     209                }
     210        }
     211
     212        return -1;
     213
     214}  // bitmap_ffs()
     215
     216//////////////////////////////////////
     217uint32_t bitmap_ffc( bitmap_t * bitmap,
     218                     uint32_t   size )
     219{
     220    uint32_t max_word;
    176221        uint32_t word;
    177222        uint32_t bit;
    178223 
    179         for(word = 0 ; word < size/32 ; word++)
    180         {
    181                 if(bitmap[word] != 0)
    182                 {
    183                         for(bit = 0 ; bit < 32 ; bit++)
    184                         {
    185                                 if( bitmap[word] & (1 << bit) ) return (word*32 + bit);
    186                         }
    187                 }
    188         }
    189         return 0xFFFFFFFF;
    190 }
    191 
    192 //////////////////////////////////////
    193 uint32_t bitmap_ffc( bitmap_t * bitmap,
    194                      uint32_t   size )
    195 {
    196         uint32_t word;
    197         uint32_t bit;
    198  
    199         for(word = 0 ; word < size/32 ; word++)
    200         {
    201                 if(bitmap[word] != 0)
    202                 {
    203                         for(bit = 0 ; bit < 32 ; bit++)
    204                         {
    205                                 if( (bitmap[word] & (1 << bit)) == 0 ) return (word*32 + bit);
    206                         }
    207                 }
    208         }
    209         return 0xFFFFFFFF;
    210 }
    211 
     224    if( size )
     225    {
     226        max_word = ( (size-1) >>5 ) + 1;
     227
     228        for( word = 0 ; word < max_word ; word++ )
     229            {
     230                    if(bitmap[word] != 0XFFFFFFFF)
     231                    {
     232                            for(bit = 0 ; bit < 32 ; bit++)
     233                            {
     234                                    if( (bitmap[word] & (1 << bit)) == 0 ) return (word*32 + bit);
     235                            }
     236            }
     237                }
     238        }
     239
     240        return -1;
     241
     242}  // bitmap_ffc()
     243
Note: See TracChangeset for help on using the changeset viewer.