source: trunk/kernel/libk/bits.c @ 11

Last change on this file since 11 was 11, checked in by alain, 4 years ago

Merge all FS related files in one single vfs directory.

File size: 5.2 KB
Line 
1/*
2 * bits.c - bits manipulation functions implementation
3 *
4 * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
5 *         Alain Greiner    (2016)
6 *
7 * Copyright (c) UPMC Sorbonne Universites
8 *
9 * This file is part of ALMOS-MKH.
10 *
11 * ALMOS-MKH is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2.0 of the License.
14 *
15 * ALMOS-MKH is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with ALMOS-MKH; if not, write to the Free Software Foundation,
22 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25#include <hal_types.h>
26#include <bits.h>
27
28//////////////////////////////////////////
29inline void bitmap_set( bitmap_t * bitmap,
30                        uint32_t   index )
31{
32        uint32_t  word = index / 32;
33        uint32_t  bit  = index % 32;
34
35        bitmap[word] |= ( 1 << bit );
36}
37
38////////////////////////////////////////////
39inline void bitmap_clear( bitmap_t * bitmap, 
40                          uint32_t   index )
41{
42        uint32_t  word = index / 32;
43        uint32_t  bit  = index % 32;
44
45        bitmap[word] &= ~( 1 << bit );
46}
47
48//////////////////////////////////////////////
49inline bool_t bitmap_state( bitmap_t * bitmap, 
50                            uint32_t   index )
51{
52        uint32_t  word = index / 32;
53        uint32_t  bit  = index % 32;
54
55        return (bitmap[word] & ( 1 << bit )) && 1;
56}
57
58//////////////////////////////////////////
59void bitmap_set_range( bitmap_t * bitmap,
60                       uint32_t   index, 
61                       uint32_t   len )
62{
63        uint32_t val;
64        uint32_t word = index / 32;
65        uint32_t bit  = index % 32;
66 
67        while((len > 0))
68        {
69                if((len + bit) >= 32)
70                {
71                        val = (bit == 0) ? 0xFFFFFFFF : (1 << (32 - bit)) - 1;
72                        bitmap[word] |= (val << bit);
73                        word++;
74                        len -= (32 - bit);
75                        bit = 0;
76                }
77                else
78                {
79                        bitmap[word] |= (((1 << len ) - 1) << bit);
80                        break;
81                }
82        }
83}  // bitmap_set_range()
84
85///////////////////////////////////////////
86void bitmap_clear_range( bitmap_t * bitmap,
87                         uint32_t   index, 
88                         uint32_t   len )
89{
90    uint32_t val;
91        uint32_t word = index / 32;
92        uint32_t bit  = index % 32;
93
94        while((len > 0))
95        {
96                if((len + bit) >= 32)
97                {
98                        val = (bit == 0) ? 0xFFFFFFFF : (1 << (32 - bit)) - 1;
99                        bitmap[word] &= ~(val << bit);
100                        word++;
101                        len -= (32 - bit);
102                        bit = 0;
103                }
104                else
105                {
106                    bitmap[word] &= ~(((1 << len ) - 1) << bit);
107                        break;
108                }
109        }
110}  // bitmap_clear_range()
111
112///////////////////////////////////////
113uint32_t bitmap_ffs2( bitmap_t * bitmap,
114                      uint32_t   index,
115                      uint32_t   size )
116{
117    uint32_t max_word;
118        uint32_t word = index / 32; 
119        uint32_t bit  = index % 32; 
120 
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()
149
150///////////////////////////////////////
151uint32_t bitmap_ffc2( bitmap_t * bitmap,
152                      uint32_t   index,
153                      uint32_t   size )
154{
155    uint32_t max_word;
156        uint32_t word = index / 32;
157        uint32_t bit  = index % 32;
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()
187
188//////////////////////////////////////
189uint32_t bitmap_ffs( bitmap_t * bitmap,
190                     uint32_t   size )
191{
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;
221        uint32_t word;
222        uint32_t bit;
223 
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 TracBrowser for help on using the repository browser.