~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/bitmap.h

Version: ~ [ linux-5.13-rc7 ] ~ [ linux-5.12.12 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.45 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.127 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.195 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.237 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.273 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.273 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  2 #ifndef __LINUX_BITMAP_H
  3 #define __LINUX_BITMAP_H
  4 
  5 #ifndef __ASSEMBLY__
  6 
  7 #include <linux/types.h>
  8 #include <linux/bitops.h>
  9 #include <linux/string.h>
 10 #include <linux/kernel.h>
 11 
 12 /*
 13  * bitmaps provide bit arrays that consume one or more unsigned
 14  * longs.  The bitmap interface and available operations are listed
 15  * here, in bitmap.h
 16  *
 17  * Function implementations generic to all architectures are in
 18  * lib/bitmap.c.  Functions implementations that are architecture
 19  * specific are in various include/asm-<arch>/bitops.h headers
 20  * and other arch/<arch> specific files.
 21  *
 22  * See lib/bitmap.c for more details.
 23  */
 24 
 25 /**
 26  * DOC: bitmap overview
 27  *
 28  * The available bitmap operations and their rough meaning in the
 29  * case that the bitmap is a single unsigned long are thus:
 30  *
 31  * The generated code is more efficient when nbits is known at
 32  * compile-time and at most BITS_PER_LONG.
 33  *
 34  * ::
 35  *
 36  *  bitmap_zero(dst, nbits)                     *dst = 0UL
 37  *  bitmap_fill(dst, nbits)                     *dst = ~0UL
 38  *  bitmap_copy(dst, src, nbits)                *dst = *src
 39  *  bitmap_and(dst, src1, src2, nbits)          *dst = *src1 & *src2
 40  *  bitmap_or(dst, src1, src2, nbits)           *dst = *src1 | *src2
 41  *  bitmap_xor(dst, src1, src2, nbits)          *dst = *src1 ^ *src2
 42  *  bitmap_andnot(dst, src1, src2, nbits)       *dst = *src1 & ~(*src2)
 43  *  bitmap_complement(dst, src, nbits)          *dst = ~(*src)
 44  *  bitmap_equal(src1, src2, nbits)             Are *src1 and *src2 equal?
 45  *  bitmap_intersects(src1, src2, nbits)        Do *src1 and *src2 overlap?
 46  *  bitmap_subset(src1, src2, nbits)            Is *src1 a subset of *src2?
 47  *  bitmap_empty(src, nbits)                    Are all bits zero in *src?
 48  *  bitmap_full(src, nbits)                     Are all bits set in *src?
 49  *  bitmap_weight(src, nbits)                   Hamming Weight: number set bits
 50  *  bitmap_set(dst, pos, nbits)                 Set specified bit area
 51  *  bitmap_clear(dst, pos, nbits)               Clear specified bit area
 52  *  bitmap_find_next_zero_area(buf, len, pos, n, mask)  Find bit free area
 53  *  bitmap_find_next_zero_area_off(buf, len, pos, n, mask)  as above
 54  *  bitmap_shift_right(dst, src, n, nbits)      *dst = *src >> n
 55  *  bitmap_shift_left(dst, src, n, nbits)       *dst = *src << n
 56  *  bitmap_remap(dst, src, old, new, nbits)     *dst = map(old, new)(src)
 57  *  bitmap_bitremap(oldbit, old, new, nbits)    newbit = map(old, new)(oldbit)
 58  *  bitmap_onto(dst, orig, relmap, nbits)       *dst = orig relative to relmap
 59  *  bitmap_fold(dst, orig, sz, nbits)           dst bits = orig bits mod sz
 60  *  bitmap_parse(buf, buflen, dst, nbits)       Parse bitmap dst from kernel buf
 61  *  bitmap_parse_user(ubuf, ulen, dst, nbits)   Parse bitmap dst from user buf
 62  *  bitmap_parselist(buf, dst, nbits)           Parse bitmap dst from kernel buf
 63  *  bitmap_parselist_user(buf, dst, nbits)      Parse bitmap dst from user buf
 64  *  bitmap_find_free_region(bitmap, bits, order)  Find and allocate bit region
 65  *  bitmap_release_region(bitmap, pos, order)   Free specified bit region
 66  *  bitmap_allocate_region(bitmap, pos, order)  Allocate specified bit region
 67  *  bitmap_from_arr32(dst, buf, nbits)          Copy nbits from u32[] buf to dst
 68  *  bitmap_to_arr32(buf, src, nbits)            Copy nbits from buf to u32[] dst
 69  *
 70  * Note, bitmap_zero() and bitmap_fill() operate over the region of
 71  * unsigned longs, that is, bits behind bitmap till the unsigned long
 72  * boundary will be zeroed or filled as well. Consider to use
 73  * bitmap_clear() or bitmap_set() to make explicit zeroing or filling
 74  * respectively.
 75  */
 76 
 77 /**
 78  * DOC: bitmap bitops
 79  *
 80  * Also the following operations in asm/bitops.h apply to bitmaps.::
 81  *
 82  *  set_bit(bit, addr)                  *addr |= bit
 83  *  clear_bit(bit, addr)                *addr &= ~bit
 84  *  change_bit(bit, addr)               *addr ^= bit
 85  *  test_bit(bit, addr)                 Is bit set in *addr?
 86  *  test_and_set_bit(bit, addr)         Set bit and return old value
 87  *  test_and_clear_bit(bit, addr)       Clear bit and return old value
 88  *  test_and_change_bit(bit, addr)      Change bit and return old value
 89  *  find_first_zero_bit(addr, nbits)    Position first zero bit in *addr
 90  *  find_first_bit(addr, nbits)         Position first set bit in *addr
 91  *  find_next_zero_bit(addr, nbits, bit)
 92  *                                      Position next zero bit in *addr >= bit
 93  *  find_next_bit(addr, nbits, bit)     Position next set bit in *addr >= bit
 94  *  find_next_and_bit(addr1, addr2, nbits, bit)
 95  *                                      Same as find_next_bit, but in
 96  *                                      (*addr1 & *addr2)
 97  *
 98  */
 99 
100 /**
101  * DOC: declare bitmap
102  * The DECLARE_BITMAP(name,bits) macro, in linux/types.h, can be used
103  * to declare an array named 'name' of just enough unsigned longs to
104  * contain all bit positions from 0 to 'bits' - 1.
105  */
106 
107 /*
108  * Allocation and deallocation of bitmap.
109  * Provided in lib/bitmap.c to avoid circular dependency.
110  */
111 extern unsigned long *bitmap_alloc(unsigned int nbits, gfp_t flags);
112 extern unsigned long *bitmap_zalloc(unsigned int nbits, gfp_t flags);
113 extern void bitmap_free(const unsigned long *bitmap);
114 
115 /*
116  * lib/bitmap.c provides these functions:
117  */
118 
119 extern int __bitmap_empty(const unsigned long *bitmap, unsigned int nbits);
120 extern int __bitmap_full(const unsigned long *bitmap, unsigned int nbits);
121 extern int __bitmap_equal(const unsigned long *bitmap1,
122                           const unsigned long *bitmap2, unsigned int nbits);
123 extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
124                         unsigned int nbits);
125 extern void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,
126                                 unsigned int shift, unsigned int nbits);
127 extern void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,
128                                 unsigned int shift, unsigned int nbits);
129 extern int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
130                         const unsigned long *bitmap2, unsigned int nbits);
131 extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
132                         const unsigned long *bitmap2, unsigned int nbits);
133 extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
134                         const unsigned long *bitmap2, unsigned int nbits);
135 extern int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
136                         const unsigned long *bitmap2, unsigned int nbits);
137 extern int __bitmap_intersects(const unsigned long *bitmap1,
138                         const unsigned long *bitmap2, unsigned int nbits);
139 extern int __bitmap_subset(const unsigned long *bitmap1,
140                         const unsigned long *bitmap2, unsigned int nbits);
141 extern int __bitmap_weight(const unsigned long *bitmap, unsigned int nbits);
142 extern void __bitmap_set(unsigned long *map, unsigned int start, int len);
143 extern void __bitmap_clear(unsigned long *map, unsigned int start, int len);
144 
145 extern unsigned long bitmap_find_next_zero_area_off(unsigned long *map,
146                                                     unsigned long size,
147                                                     unsigned long start,
148                                                     unsigned int nr,
149                                                     unsigned long align_mask,
150                                                     unsigned long align_offset);
151 
152 /**
153  * bitmap_find_next_zero_area - find a contiguous aligned zero area
154  * @map: The address to base the search on
155  * @size: The bitmap size in bits
156  * @start: The bitnumber to start searching at
157  * @nr: The number of zeroed bits we're looking for
158  * @align_mask: Alignment mask for zero area
159  *
160  * The @align_mask should be one less than a power of 2; the effect is that
161  * the bit offset of all zero areas this function finds is multiples of that
162  * power of 2. A @align_mask of 0 means no alignment is required.
163  */
164 static inline unsigned long
165 bitmap_find_next_zero_area(unsigned long *map,
166                            unsigned long size,
167                            unsigned long start,
168                            unsigned int nr,
169                            unsigned long align_mask)
170 {
171         return bitmap_find_next_zero_area_off(map, size, start, nr,
172                                               align_mask, 0);
173 }
174 
175 extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user,
176                         unsigned long *dst, int nbits);
177 extern int bitmap_parse_user(const char __user *ubuf, unsigned int ulen,
178                         unsigned long *dst, int nbits);
179 extern int bitmap_parselist(const char *buf, unsigned long *maskp,
180                         int nmaskbits);
181 extern int bitmap_parselist_user(const char __user *ubuf, unsigned int ulen,
182                         unsigned long *dst, int nbits);
183 extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
184                 const unsigned long *old, const unsigned long *new, unsigned int nbits);
185 extern int bitmap_bitremap(int oldbit,
186                 const unsigned long *old, const unsigned long *new, int bits);
187 extern void bitmap_onto(unsigned long *dst, const unsigned long *orig,
188                 const unsigned long *relmap, unsigned int bits);
189 extern void bitmap_fold(unsigned long *dst, const unsigned long *orig,
190                 unsigned int sz, unsigned int nbits);
191 extern int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);
192 extern void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order);
193 extern int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);
194 
195 #ifdef __BIG_ENDIAN
196 extern void bitmap_copy_le(unsigned long *dst, const unsigned long *src, unsigned int nbits);
197 #else
198 #define bitmap_copy_le bitmap_copy
199 #endif
200 extern unsigned int bitmap_ord_to_pos(const unsigned long *bitmap, unsigned int ord, unsigned int nbits);
201 extern int bitmap_print_to_pagebuf(bool list, char *buf,
202                                    const unsigned long *maskp, int nmaskbits);
203 
204 #define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))
205 #define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))
206 
207 /*
208  * The static inlines below do not handle constant nbits==0 correctly,
209  * so make such users (should any ever turn up) call the out-of-line
210  * versions.
211  */
212 #define small_const_nbits(nbits) \
213         (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG && (nbits) > 0)
214 
215 static inline void bitmap_zero(unsigned long *dst, unsigned int nbits)
216 {
217         unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
218         memset(dst, 0, len);
219 }
220 
221 static inline void bitmap_fill(unsigned long *dst, unsigned int nbits)
222 {
223         unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
224         memset(dst, 0xff, len);
225 }
226 
227 static inline void bitmap_copy(unsigned long *dst, const unsigned long *src,
228                         unsigned int nbits)
229 {
230         unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
231         memcpy(dst, src, len);
232 }
233 
234 /*
235  * Copy bitmap and clear tail bits in last word.
236  */
237 static inline void bitmap_copy_clear_tail(unsigned long *dst,
238                 const unsigned long *src, unsigned int nbits)
239 {
240         bitmap_copy(dst, src, nbits);
241         if (nbits % BITS_PER_LONG)
242                 dst[nbits / BITS_PER_LONG] &= BITMAP_LAST_WORD_MASK(nbits);
243 }
244 
245 /*
246  * On 32-bit systems bitmaps are represented as u32 arrays internally, and
247  * therefore conversion is not needed when copying data from/to arrays of u32.
248  */
249 #if BITS_PER_LONG == 64
250 extern void bitmap_from_arr32(unsigned long *bitmap, const u32 *buf,
251                                                         unsigned int nbits);
252 extern void bitmap_to_arr32(u32 *buf, const unsigned long *bitmap,
253                                                         unsigned int nbits);
254 #else
255 #define bitmap_from_arr32(bitmap, buf, nbits)                   \
256         bitmap_copy_clear_tail((unsigned long *) (bitmap),      \
257                         (const unsigned long *) (buf), (nbits))
258 #define bitmap_to_arr32(buf, bitmap, nbits)                     \
259         bitmap_copy_clear_tail((unsigned long *) (buf),         \
260                         (const unsigned long *) (bitmap), (nbits))
261 #endif
262 
263 static inline int bitmap_and(unsigned long *dst, const unsigned long *src1,
264                         const unsigned long *src2, unsigned int nbits)
265 {
266         if (small_const_nbits(nbits))
267                 return (*dst = *src1 & *src2 & BITMAP_LAST_WORD_MASK(nbits)) != 0;
268         return __bitmap_and(dst, src1, src2, nbits);
269 }
270 
271 static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,
272                         const unsigned long *src2, unsigned int nbits)
273 {
274         if (small_const_nbits(nbits))
275                 *dst = *src1 | *src2;
276         else
277                 __bitmap_or(dst, src1, src2, nbits);
278 }
279 
280 static inline void bitmap_xor(unsigned long *dst, const unsigned long *src1,
281                         const unsigned long *src2, unsigned int nbits)
282 {
283         if (small_const_nbits(nbits))
284                 *dst = *src1 ^ *src2;
285         else
286                 __bitmap_xor(dst, src1, src2, nbits);
287 }
288 
289 static inline int bitmap_andnot(unsigned long *dst, const unsigned long *src1,
290                         const unsigned long *src2, unsigned int nbits)
291 {
292         if (small_const_nbits(nbits))
293                 return (*dst = *src1 & ~(*src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;
294         return __bitmap_andnot(dst, src1, src2, nbits);
295 }
296 
297 static inline void bitmap_complement(unsigned long *dst, const unsigned long *src,
298                         unsigned int nbits)
299 {
300         if (small_const_nbits(nbits))
301                 *dst = ~(*src);
302         else
303                 __bitmap_complement(dst, src, nbits);
304 }
305 
306 #ifdef __LITTLE_ENDIAN
307 #define BITMAP_MEM_ALIGNMENT 8
308 #else
309 #define BITMAP_MEM_ALIGNMENT (8 * sizeof(unsigned long))
310 #endif
311 #define BITMAP_MEM_MASK (BITMAP_MEM_ALIGNMENT - 1)
312 
313 static inline int bitmap_equal(const unsigned long *src1,
314                         const unsigned long *src2, unsigned int nbits)
315 {
316         if (small_const_nbits(nbits))
317                 return !((*src1 ^ *src2) & BITMAP_LAST_WORD_MASK(nbits));
318         if (__builtin_constant_p(nbits & BITMAP_MEM_MASK) &&
319             IS_ALIGNED(nbits, BITMAP_MEM_ALIGNMENT))
320                 return !memcmp(src1, src2, nbits / 8);
321         return __bitmap_equal(src1, src2, nbits);
322 }
323 
324 static inline int bitmap_intersects(const unsigned long *src1,
325                         const unsigned long *src2, unsigned int nbits)
326 {
327         if (small_const_nbits(nbits))
328                 return ((*src1 & *src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;
329         else
330                 return __bitmap_intersects(src1, src2, nbits);
331 }
332 
333 static inline int bitmap_subset(const unsigned long *src1,
334                         const unsigned long *src2, unsigned int nbits)
335 {
336         if (small_const_nbits(nbits))
337                 return ! ((*src1 & ~(*src2)) & BITMAP_LAST_WORD_MASK(nbits));
338         else
339                 return __bitmap_subset(src1, src2, nbits);
340 }
341 
342 static inline int bitmap_empty(const unsigned long *src, unsigned nbits)
343 {
344         if (small_const_nbits(nbits))
345                 return ! (*src & BITMAP_LAST_WORD_MASK(nbits));
346 
347         return find_first_bit(src, nbits) == nbits;
348 }
349 
350 static inline int bitmap_full(const unsigned long *src, unsigned int nbits)
351 {
352         if (small_const_nbits(nbits))
353                 return ! (~(*src) & BITMAP_LAST_WORD_MASK(nbits));
354 
355         return find_first_zero_bit(src, nbits) == nbits;
356 }
357 
358 static __always_inline int bitmap_weight(const unsigned long *src, unsigned int nbits)
359 {
360         if (small_const_nbits(nbits))
361                 return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits));
362         return __bitmap_weight(src, nbits);
363 }
364 
365 static __always_inline void bitmap_set(unsigned long *map, unsigned int start,
366                 unsigned int nbits)
367 {
368         if (__builtin_constant_p(nbits) && nbits == 1)
369                 __set_bit(start, map);
370         else if (__builtin_constant_p(start & BITMAP_MEM_MASK) &&
371                  IS_ALIGNED(start, BITMAP_MEM_ALIGNMENT) &&
372                  __builtin_constant_p(nbits & BITMAP_MEM_MASK) &&
373                  IS_ALIGNED(nbits, BITMAP_MEM_ALIGNMENT))
374                 memset((char *)map + start / 8, 0xff, nbits / 8);
375         else
376                 __bitmap_set(map, start, nbits);
377 }
378 
379 static __always_inline void bitmap_clear(unsigned long *map, unsigned int start,
380                 unsigned int nbits)
381 {
382         if (__builtin_constant_p(nbits) && nbits == 1)
383                 __clear_bit(start, map);
384         else if (__builtin_constant_p(start & BITMAP_MEM_MASK) &&
385                  IS_ALIGNED(start, BITMAP_MEM_ALIGNMENT) &&
386                  __builtin_constant_p(nbits & BITMAP_MEM_MASK) &&
387                  IS_ALIGNED(nbits, BITMAP_MEM_ALIGNMENT))
388                 memset((char *)map + start / 8, 0, nbits / 8);
389         else
390                 __bitmap_clear(map, start, nbits);
391 }
392 
393 static inline void bitmap_shift_right(unsigned long *dst, const unsigned long *src,
394                                 unsigned int shift, unsigned int nbits)
395 {
396         if (small_const_nbits(nbits))
397                 *dst = (*src & BITMAP_LAST_WORD_MASK(nbits)) >> shift;
398         else
399                 __bitmap_shift_right(dst, src, shift, nbits);
400 }
401 
402 static inline void bitmap_shift_left(unsigned long *dst, const unsigned long *src,
403                                 unsigned int shift, unsigned int nbits)
404 {
405         if (small_const_nbits(nbits))
406                 *dst = (*src << shift) & BITMAP_LAST_WORD_MASK(nbits);
407         else
408                 __bitmap_shift_left(dst, src, shift, nbits);
409 }
410 
411 static inline int bitmap_parse(const char *buf, unsigned int buflen,
412                         unsigned long *maskp, int nmaskbits)
413 {
414         return __bitmap_parse(buf, buflen, 0, maskp, nmaskbits);
415 }
416 
417 /**
418  * BITMAP_FROM_U64() - Represent u64 value in the format suitable for bitmap.
419  * @n: u64 value
420  *
421  * Linux bitmaps are internally arrays of unsigned longs, i.e. 32-bit
422  * integers in 32-bit environment, and 64-bit integers in 64-bit one.
423  *
424  * There are four combinations of endianness and length of the word in linux
425  * ABIs: LE64, BE64, LE32 and BE32.
426  *
427  * On 64-bit kernels 64-bit LE and BE numbers are naturally ordered in
428  * bitmaps and therefore don't require any special handling.
429  *
430  * On 32-bit kernels 32-bit LE ABI orders lo word of 64-bit number in memory
431  * prior to hi, and 32-bit BE orders hi word prior to lo. The bitmap on the
432  * other hand is represented as an array of 32-bit words and the position of
433  * bit N may therefore be calculated as: word #(N/32) and bit #(N%32) in that
434  * word.  For example, bit #42 is located at 10th position of 2nd word.
435  * It matches 32-bit LE ABI, and we can simply let the compiler store 64-bit
436  * values in memory as it usually does. But for BE we need to swap hi and lo
437  * words manually.
438  *
439  * With all that, the macro BITMAP_FROM_U64() does explicit reordering of hi and
440  * lo parts of u64.  For LE32 it does nothing, and for BE environment it swaps
441  * hi and lo words, as is expected by bitmap.
442  */
443 #if __BITS_PER_LONG == 64
444 #define BITMAP_FROM_U64(n) (n)
445 #else
446 #define BITMAP_FROM_U64(n) ((unsigned long) ((u64)(n) & ULONG_MAX)), \
447                                 ((unsigned long) ((u64)(n) >> 32))
448 #endif
449 
450 /**
451  * bitmap_from_u64 - Check and swap words within u64.
452  *  @mask: source bitmap
453  *  @dst:  destination bitmap
454  *
455  * In 32-bit Big Endian kernel, when using ``(u32 *)(&val)[*]``
456  * to read u64 mask, we will get the wrong word.
457  * That is ``(u32 *)(&val)[0]`` gets the upper 32 bits,
458  * but we expect the lower 32-bits of u64.
459  */
460 static inline void bitmap_from_u64(unsigned long *dst, u64 mask)
461 {
462         dst[0] = mask & ULONG_MAX;
463 
464         if (sizeof(mask) > sizeof(unsigned long))
465                 dst[1] = mask >> 32;
466 }
467 
468 #endif /* __ASSEMBLY__ */
469 
470 #endif /* __LINUX_BITMAP_H */
471 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp