1baacf047SPaolo Bonzini /*
2baacf047SPaolo Bonzini * Bitmap Module
3baacf047SPaolo Bonzini *
4baacf047SPaolo Bonzini * Stolen from linux/src/lib/bitmap.c
5baacf047SPaolo Bonzini *
6baacf047SPaolo Bonzini * Copyright (C) 2010 Corentin Chary
7baacf047SPaolo Bonzini *
8baacf047SPaolo Bonzini * This source code is licensed under the GNU General Public License,
9baacf047SPaolo Bonzini * Version 2.
10baacf047SPaolo Bonzini */
11baacf047SPaolo Bonzini
12aafd7584SPeter Maydell #include "qemu/osdep.h"
13baacf047SPaolo Bonzini #include "qemu/bitops.h"
14baacf047SPaolo Bonzini #include "qemu/bitmap.h"
159f02cfc8SStefan Hajnoczi #include "qemu/atomic.h"
16baacf047SPaolo Bonzini
17baacf047SPaolo Bonzini /*
18b6af0975SDaniel P. Berrange * bitmaps provide an array of bits, implemented using an
19baacf047SPaolo Bonzini * array of unsigned longs. The number of valid bits in a
20baacf047SPaolo Bonzini * given bitmap does _not_ need to be an exact multiple of
21baacf047SPaolo Bonzini * BITS_PER_LONG.
22baacf047SPaolo Bonzini *
23baacf047SPaolo Bonzini * The possible unused bits in the last, partially used word
24baacf047SPaolo Bonzini * of a bitmap are 'don't care'. The implementation makes
25baacf047SPaolo Bonzini * no particular effort to keep them zero. It ensures that
26baacf047SPaolo Bonzini * their value will not affect the results of any operation.
27baacf047SPaolo Bonzini * The bitmap operations that return Boolean (bitmap_empty,
28baacf047SPaolo Bonzini * for example) or scalar (bitmap_weight, for example) results
29baacf047SPaolo Bonzini * carefully filter out these unused bits from impacting their
30baacf047SPaolo Bonzini * results.
31baacf047SPaolo Bonzini *
32baacf047SPaolo Bonzini * These operations actually hold to a slightly stronger rule:
33baacf047SPaolo Bonzini * if you don't input any bitmaps to these ops that have some
34baacf047SPaolo Bonzini * unused bits set, then they won't output any set unused bits
35baacf047SPaolo Bonzini * in output bitmaps.
36baacf047SPaolo Bonzini *
37baacf047SPaolo Bonzini * The byte ordering of bitmaps is more natural on little
38baacf047SPaolo Bonzini * endian architectures.
39baacf047SPaolo Bonzini */
40baacf047SPaolo Bonzini
slow_bitmap_empty(const unsigned long * bitmap,long bits)419c22687eSJuan Quintela int slow_bitmap_empty(const unsigned long *bitmap, long bits)
42baacf047SPaolo Bonzini {
439c22687eSJuan Quintela long k, lim = bits/BITS_PER_LONG;
44baacf047SPaolo Bonzini
45baacf047SPaolo Bonzini for (k = 0; k < lim; ++k) {
46baacf047SPaolo Bonzini if (bitmap[k]) {
47baacf047SPaolo Bonzini return 0;
48baacf047SPaolo Bonzini }
49baacf047SPaolo Bonzini }
50baacf047SPaolo Bonzini if (bits % BITS_PER_LONG) {
51baacf047SPaolo Bonzini if (bitmap[k] & BITMAP_LAST_WORD_MASK(bits)) {
52baacf047SPaolo Bonzini return 0;
53baacf047SPaolo Bonzini }
54baacf047SPaolo Bonzini }
55baacf047SPaolo Bonzini
56baacf047SPaolo Bonzini return 1;
57baacf047SPaolo Bonzini }
58baacf047SPaolo Bonzini
slow_bitmap_full(const unsigned long * bitmap,long bits)599c22687eSJuan Quintela int slow_bitmap_full(const unsigned long *bitmap, long bits)
60baacf047SPaolo Bonzini {
619c22687eSJuan Quintela long k, lim = bits/BITS_PER_LONG;
62baacf047SPaolo Bonzini
63baacf047SPaolo Bonzini for (k = 0; k < lim; ++k) {
64baacf047SPaolo Bonzini if (~bitmap[k]) {
65baacf047SPaolo Bonzini return 0;
66baacf047SPaolo Bonzini }
67baacf047SPaolo Bonzini }
68baacf047SPaolo Bonzini
69baacf047SPaolo Bonzini if (bits % BITS_PER_LONG) {
70baacf047SPaolo Bonzini if (~bitmap[k] & BITMAP_LAST_WORD_MASK(bits)) {
71baacf047SPaolo Bonzini return 0;
72baacf047SPaolo Bonzini }
73baacf047SPaolo Bonzini }
74baacf047SPaolo Bonzini
75baacf047SPaolo Bonzini return 1;
76baacf047SPaolo Bonzini }
77baacf047SPaolo Bonzini
slow_bitmap_equal(const unsigned long * bitmap1,const unsigned long * bitmap2,long bits)78baacf047SPaolo Bonzini int slow_bitmap_equal(const unsigned long *bitmap1,
799c22687eSJuan Quintela const unsigned long *bitmap2, long bits)
80baacf047SPaolo Bonzini {
819c22687eSJuan Quintela long k, lim = bits/BITS_PER_LONG;
82baacf047SPaolo Bonzini
83baacf047SPaolo Bonzini for (k = 0; k < lim; ++k) {
84baacf047SPaolo Bonzini if (bitmap1[k] != bitmap2[k]) {
85baacf047SPaolo Bonzini return 0;
86baacf047SPaolo Bonzini }
87baacf047SPaolo Bonzini }
88baacf047SPaolo Bonzini
89baacf047SPaolo Bonzini if (bits % BITS_PER_LONG) {
90baacf047SPaolo Bonzini if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits)) {
91baacf047SPaolo Bonzini return 0;
92baacf047SPaolo Bonzini }
93baacf047SPaolo Bonzini }
94baacf047SPaolo Bonzini
95baacf047SPaolo Bonzini return 1;
96baacf047SPaolo Bonzini }
97baacf047SPaolo Bonzini
slow_bitmap_complement(unsigned long * dst,const unsigned long * src,long bits)98baacf047SPaolo Bonzini void slow_bitmap_complement(unsigned long *dst, const unsigned long *src,
999c22687eSJuan Quintela long bits)
100baacf047SPaolo Bonzini {
1019c22687eSJuan Quintela long k, lim = bits/BITS_PER_LONG;
102baacf047SPaolo Bonzini
103baacf047SPaolo Bonzini for (k = 0; k < lim; ++k) {
104baacf047SPaolo Bonzini dst[k] = ~src[k];
105baacf047SPaolo Bonzini }
106baacf047SPaolo Bonzini
107baacf047SPaolo Bonzini if (bits % BITS_PER_LONG) {
108baacf047SPaolo Bonzini dst[k] = ~src[k] & BITMAP_LAST_WORD_MASK(bits);
109baacf047SPaolo Bonzini }
110baacf047SPaolo Bonzini }
111baacf047SPaolo Bonzini
slow_bitmap_and(unsigned long * dst,const unsigned long * bitmap1,const unsigned long * bitmap2,long bits)112baacf047SPaolo Bonzini int slow_bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
1139c22687eSJuan Quintela const unsigned long *bitmap2, long bits)
114baacf047SPaolo Bonzini {
1159c22687eSJuan Quintela long k;
1169c22687eSJuan Quintela long nr = BITS_TO_LONGS(bits);
117baacf047SPaolo Bonzini unsigned long result = 0;
118baacf047SPaolo Bonzini
119baacf047SPaolo Bonzini for (k = 0; k < nr; k++) {
120baacf047SPaolo Bonzini result |= (dst[k] = bitmap1[k] & bitmap2[k]);
121baacf047SPaolo Bonzini }
122baacf047SPaolo Bonzini return result != 0;
123baacf047SPaolo Bonzini }
124baacf047SPaolo Bonzini
slow_bitmap_or(unsigned long * dst,const unsigned long * bitmap1,const unsigned long * bitmap2,long bits)125baacf047SPaolo Bonzini void slow_bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
1269c22687eSJuan Quintela const unsigned long *bitmap2, long bits)
127baacf047SPaolo Bonzini {
1289c22687eSJuan Quintela long k;
1299c22687eSJuan Quintela long nr = BITS_TO_LONGS(bits);
130baacf047SPaolo Bonzini
131baacf047SPaolo Bonzini for (k = 0; k < nr; k++) {
132baacf047SPaolo Bonzini dst[k] = bitmap1[k] | bitmap2[k];
133baacf047SPaolo Bonzini }
134baacf047SPaolo Bonzini }
135baacf047SPaolo Bonzini
slow_bitmap_xor(unsigned long * dst,const unsigned long * bitmap1,const unsigned long * bitmap2,long bits)136baacf047SPaolo Bonzini void slow_bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
1379c22687eSJuan Quintela const unsigned long *bitmap2, long bits)
138baacf047SPaolo Bonzini {
1399c22687eSJuan Quintela long k;
1409c22687eSJuan Quintela long nr = BITS_TO_LONGS(bits);
141baacf047SPaolo Bonzini
142baacf047SPaolo Bonzini for (k = 0; k < nr; k++) {
143baacf047SPaolo Bonzini dst[k] = bitmap1[k] ^ bitmap2[k];
144baacf047SPaolo Bonzini }
145baacf047SPaolo Bonzini }
146baacf047SPaolo Bonzini
slow_bitmap_andnot(unsigned long * dst,const unsigned long * bitmap1,const unsigned long * bitmap2,long bits)147baacf047SPaolo Bonzini int slow_bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
1489c22687eSJuan Quintela const unsigned long *bitmap2, long bits)
149baacf047SPaolo Bonzini {
1509c22687eSJuan Quintela long k;
1519c22687eSJuan Quintela long nr = BITS_TO_LONGS(bits);
152baacf047SPaolo Bonzini unsigned long result = 0;
153baacf047SPaolo Bonzini
154baacf047SPaolo Bonzini for (k = 0; k < nr; k++) {
155baacf047SPaolo Bonzini result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);
156baacf047SPaolo Bonzini }
157baacf047SPaolo Bonzini return result != 0;
158baacf047SPaolo Bonzini }
159baacf047SPaolo Bonzini
bitmap_set(unsigned long * map,long start,long nr)1609c22687eSJuan Quintela void bitmap_set(unsigned long *map, long start, long nr)
161baacf047SPaolo Bonzini {
162baacf047SPaolo Bonzini unsigned long *p = map + BIT_WORD(start);
1639c22687eSJuan Quintela const long size = start + nr;
164baacf047SPaolo Bonzini int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
165baacf047SPaolo Bonzini unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
166baacf047SPaolo Bonzini
167e12ed72eSPeter Lieven assert(start >= 0 && nr >= 0);
168e12ed72eSPeter Lieven
169baacf047SPaolo Bonzini while (nr - bits_to_set >= 0) {
170baacf047SPaolo Bonzini *p |= mask_to_set;
171baacf047SPaolo Bonzini nr -= bits_to_set;
172baacf047SPaolo Bonzini bits_to_set = BITS_PER_LONG;
173baacf047SPaolo Bonzini mask_to_set = ~0UL;
174baacf047SPaolo Bonzini p++;
175baacf047SPaolo Bonzini }
176baacf047SPaolo Bonzini if (nr) {
177baacf047SPaolo Bonzini mask_to_set &= BITMAP_LAST_WORD_MASK(size);
178baacf047SPaolo Bonzini *p |= mask_to_set;
179baacf047SPaolo Bonzini }
180baacf047SPaolo Bonzini }
181baacf047SPaolo Bonzini
bitmap_set_atomic(unsigned long * map,long start,long nr)1829f02cfc8SStefan Hajnoczi void bitmap_set_atomic(unsigned long *map, long start, long nr)
1839f02cfc8SStefan Hajnoczi {
1849f02cfc8SStefan Hajnoczi unsigned long *p = map + BIT_WORD(start);
1859f02cfc8SStefan Hajnoczi const long size = start + nr;
1869f02cfc8SStefan Hajnoczi int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
1879f02cfc8SStefan Hajnoczi unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
1889f02cfc8SStefan Hajnoczi
189e12ed72eSPeter Lieven assert(start >= 0 && nr >= 0);
190e12ed72eSPeter Lieven
1919f02cfc8SStefan Hajnoczi /* First word */
1929f02cfc8SStefan Hajnoczi if (nr - bits_to_set > 0) {
193d73415a3SStefan Hajnoczi qatomic_or(p, mask_to_set);
1949f02cfc8SStefan Hajnoczi nr -= bits_to_set;
1959f02cfc8SStefan Hajnoczi bits_to_set = BITS_PER_LONG;
1969f02cfc8SStefan Hajnoczi mask_to_set = ~0UL;
1979f02cfc8SStefan Hajnoczi p++;
1989f02cfc8SStefan Hajnoczi }
1999f02cfc8SStefan Hajnoczi
2009f02cfc8SStefan Hajnoczi /* Full words */
2019f02cfc8SStefan Hajnoczi if (bits_to_set == BITS_PER_LONG) {
2029f02cfc8SStefan Hajnoczi while (nr >= BITS_PER_LONG) {
2039f02cfc8SStefan Hajnoczi *p = ~0UL;
2049f02cfc8SStefan Hajnoczi nr -= BITS_PER_LONG;
2059f02cfc8SStefan Hajnoczi p++;
2069f02cfc8SStefan Hajnoczi }
2079f02cfc8SStefan Hajnoczi }
2089f02cfc8SStefan Hajnoczi
2099f02cfc8SStefan Hajnoczi /* Last word */
2109f02cfc8SStefan Hajnoczi if (nr) {
2119f02cfc8SStefan Hajnoczi mask_to_set &= BITMAP_LAST_WORD_MASK(size);
212d73415a3SStefan Hajnoczi qatomic_or(p, mask_to_set);
2139f02cfc8SStefan Hajnoczi } else {
214d73415a3SStefan Hajnoczi /* If we avoided the full barrier in qatomic_or(), issue a
2159f02cfc8SStefan Hajnoczi * barrier to account for the assignments in the while loop.
2169f02cfc8SStefan Hajnoczi */
2179f02cfc8SStefan Hajnoczi smp_mb();
2189f02cfc8SStefan Hajnoczi }
2199f02cfc8SStefan Hajnoczi }
2209f02cfc8SStefan Hajnoczi
bitmap_clear(unsigned long * map,long start,long nr)2219c22687eSJuan Quintela void bitmap_clear(unsigned long *map, long start, long nr)
222baacf047SPaolo Bonzini {
223baacf047SPaolo Bonzini unsigned long *p = map + BIT_WORD(start);
2249c22687eSJuan Quintela const long size = start + nr;
225baacf047SPaolo Bonzini int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
226baacf047SPaolo Bonzini unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
227baacf047SPaolo Bonzini
228e12ed72eSPeter Lieven assert(start >= 0 && nr >= 0);
229e12ed72eSPeter Lieven
230baacf047SPaolo Bonzini while (nr - bits_to_clear >= 0) {
231baacf047SPaolo Bonzini *p &= ~mask_to_clear;
232baacf047SPaolo Bonzini nr -= bits_to_clear;
233baacf047SPaolo Bonzini bits_to_clear = BITS_PER_LONG;
234baacf047SPaolo Bonzini mask_to_clear = ~0UL;
235baacf047SPaolo Bonzini p++;
236baacf047SPaolo Bonzini }
237baacf047SPaolo Bonzini if (nr) {
238baacf047SPaolo Bonzini mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
239baacf047SPaolo Bonzini *p &= ~mask_to_clear;
240baacf047SPaolo Bonzini }
241baacf047SPaolo Bonzini }
242baacf047SPaolo Bonzini
bitmap_test_and_clear(unsigned long * map,long start,long nr)243*cedb70eaSPeter Xu bool bitmap_test_and_clear(unsigned long *map, long start, long nr)
244*cedb70eaSPeter Xu {
245*cedb70eaSPeter Xu unsigned long *p = map + BIT_WORD(start);
246*cedb70eaSPeter Xu const long size = start + nr;
247*cedb70eaSPeter Xu int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
248*cedb70eaSPeter Xu unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
249*cedb70eaSPeter Xu bool dirty = false;
250*cedb70eaSPeter Xu
251*cedb70eaSPeter Xu assert(start >= 0 && nr >= 0);
252*cedb70eaSPeter Xu
253*cedb70eaSPeter Xu /* First word */
254*cedb70eaSPeter Xu if (nr - bits_to_clear > 0) {
255*cedb70eaSPeter Xu if ((*p) & mask_to_clear) {
256*cedb70eaSPeter Xu dirty = true;
257*cedb70eaSPeter Xu }
258*cedb70eaSPeter Xu *p &= ~mask_to_clear;
259*cedb70eaSPeter Xu nr -= bits_to_clear;
260*cedb70eaSPeter Xu bits_to_clear = BITS_PER_LONG;
261*cedb70eaSPeter Xu p++;
262*cedb70eaSPeter Xu }
263*cedb70eaSPeter Xu
264*cedb70eaSPeter Xu /* Full words */
265*cedb70eaSPeter Xu if (bits_to_clear == BITS_PER_LONG) {
266*cedb70eaSPeter Xu while (nr >= BITS_PER_LONG) {
267*cedb70eaSPeter Xu if (*p) {
268*cedb70eaSPeter Xu dirty = true;
269*cedb70eaSPeter Xu *p = 0;
270*cedb70eaSPeter Xu }
271*cedb70eaSPeter Xu nr -= BITS_PER_LONG;
272*cedb70eaSPeter Xu p++;
273*cedb70eaSPeter Xu }
274*cedb70eaSPeter Xu }
275*cedb70eaSPeter Xu
276*cedb70eaSPeter Xu /* Last word */
277*cedb70eaSPeter Xu if (nr) {
278*cedb70eaSPeter Xu mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
279*cedb70eaSPeter Xu if ((*p) & mask_to_clear) {
280*cedb70eaSPeter Xu dirty = true;
281*cedb70eaSPeter Xu }
282*cedb70eaSPeter Xu *p &= ~mask_to_clear;
283*cedb70eaSPeter Xu }
284*cedb70eaSPeter Xu
285*cedb70eaSPeter Xu return dirty;
286*cedb70eaSPeter Xu }
287*cedb70eaSPeter Xu
bitmap_test_and_clear_atomic(unsigned long * map,long start,long nr)28836546e5bSStefan Hajnoczi bool bitmap_test_and_clear_atomic(unsigned long *map, long start, long nr)
28936546e5bSStefan Hajnoczi {
29036546e5bSStefan Hajnoczi unsigned long *p = map + BIT_WORD(start);
29136546e5bSStefan Hajnoczi const long size = start + nr;
29236546e5bSStefan Hajnoczi int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
29336546e5bSStefan Hajnoczi unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
29436546e5bSStefan Hajnoczi unsigned long dirty = 0;
29536546e5bSStefan Hajnoczi unsigned long old_bits;
29636546e5bSStefan Hajnoczi
297e12ed72eSPeter Lieven assert(start >= 0 && nr >= 0);
298e12ed72eSPeter Lieven
29936546e5bSStefan Hajnoczi /* First word */
30036546e5bSStefan Hajnoczi if (nr - bits_to_clear > 0) {
301d73415a3SStefan Hajnoczi old_bits = qatomic_fetch_and(p, ~mask_to_clear);
30236546e5bSStefan Hajnoczi dirty |= old_bits & mask_to_clear;
30336546e5bSStefan Hajnoczi nr -= bits_to_clear;
30436546e5bSStefan Hajnoczi bits_to_clear = BITS_PER_LONG;
30536546e5bSStefan Hajnoczi mask_to_clear = ~0UL;
30636546e5bSStefan Hajnoczi p++;
30736546e5bSStefan Hajnoczi }
30836546e5bSStefan Hajnoczi
30936546e5bSStefan Hajnoczi /* Full words */
31036546e5bSStefan Hajnoczi if (bits_to_clear == BITS_PER_LONG) {
31136546e5bSStefan Hajnoczi while (nr >= BITS_PER_LONG) {
31236546e5bSStefan Hajnoczi if (*p) {
313d73415a3SStefan Hajnoczi old_bits = qatomic_xchg(p, 0);
31436546e5bSStefan Hajnoczi dirty |= old_bits;
31536546e5bSStefan Hajnoczi }
31636546e5bSStefan Hajnoczi nr -= BITS_PER_LONG;
31736546e5bSStefan Hajnoczi p++;
31836546e5bSStefan Hajnoczi }
31936546e5bSStefan Hajnoczi }
32036546e5bSStefan Hajnoczi
32136546e5bSStefan Hajnoczi /* Last word */
32236546e5bSStefan Hajnoczi if (nr) {
32336546e5bSStefan Hajnoczi mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
324d73415a3SStefan Hajnoczi old_bits = qatomic_fetch_and(p, ~mask_to_clear);
32536546e5bSStefan Hajnoczi dirty |= old_bits & mask_to_clear;
32636546e5bSStefan Hajnoczi } else {
32736546e5bSStefan Hajnoczi if (!dirty) {
32836546e5bSStefan Hajnoczi smp_mb();
32936546e5bSStefan Hajnoczi }
33036546e5bSStefan Hajnoczi }
33136546e5bSStefan Hajnoczi
33236546e5bSStefan Hajnoczi return dirty != 0;
33336546e5bSStefan Hajnoczi }
33436546e5bSStefan Hajnoczi
bitmap_copy_and_clear_atomic(unsigned long * dst,unsigned long * src,long nr)335d6eb1413SGerd Hoffmann void bitmap_copy_and_clear_atomic(unsigned long *dst, unsigned long *src,
336d6eb1413SGerd Hoffmann long nr)
337d6eb1413SGerd Hoffmann {
338d6eb1413SGerd Hoffmann while (nr > 0) {
339d73415a3SStefan Hajnoczi *dst = qatomic_xchg(src, 0);
340d6eb1413SGerd Hoffmann dst++;
341d6eb1413SGerd Hoffmann src++;
342d6eb1413SGerd Hoffmann nr -= BITS_PER_LONG;
343d6eb1413SGerd Hoffmann }
344d6eb1413SGerd Hoffmann }
345d6eb1413SGerd Hoffmann
346baacf047SPaolo Bonzini #define ALIGN_MASK(x,mask) (((x)+(mask))&~(mask))
347baacf047SPaolo Bonzini
348baacf047SPaolo Bonzini /**
349baacf047SPaolo Bonzini * bitmap_find_next_zero_area - find a contiguous aligned zero area
350baacf047SPaolo Bonzini * @map: The address to base the search on
351baacf047SPaolo Bonzini * @size: The bitmap size in bits
352baacf047SPaolo Bonzini * @start: The bitnumber to start searching at
353baacf047SPaolo Bonzini * @nr: The number of zeroed bits we're looking for
354baacf047SPaolo Bonzini * @align_mask: Alignment mask for zero area
355baacf047SPaolo Bonzini *
356baacf047SPaolo Bonzini * The @align_mask should be one less than a power of 2; the effect is that
357baacf047SPaolo Bonzini * the bit offset of all zero areas this function finds is multiples of that
358baacf047SPaolo Bonzini * power of 2. A @align_mask of 0 means no alignment is required.
359baacf047SPaolo Bonzini */
bitmap_find_next_zero_area(unsigned long * map,unsigned long size,unsigned long start,unsigned long nr,unsigned long align_mask)360baacf047SPaolo Bonzini unsigned long bitmap_find_next_zero_area(unsigned long *map,
361baacf047SPaolo Bonzini unsigned long size,
362baacf047SPaolo Bonzini unsigned long start,
3639c22687eSJuan Quintela unsigned long nr,
364baacf047SPaolo Bonzini unsigned long align_mask)
365baacf047SPaolo Bonzini {
366baacf047SPaolo Bonzini unsigned long index, end, i;
367baacf047SPaolo Bonzini again:
368baacf047SPaolo Bonzini index = find_next_zero_bit(map, size, start);
369baacf047SPaolo Bonzini
370baacf047SPaolo Bonzini /* Align allocation */
371baacf047SPaolo Bonzini index = ALIGN_MASK(index, align_mask);
372baacf047SPaolo Bonzini
373baacf047SPaolo Bonzini end = index + nr;
374baacf047SPaolo Bonzini if (end > size) {
375baacf047SPaolo Bonzini return end;
376baacf047SPaolo Bonzini }
377baacf047SPaolo Bonzini i = find_next_bit(map, end, index);
378baacf047SPaolo Bonzini if (i < end) {
379baacf047SPaolo Bonzini start = i + 1;
380baacf047SPaolo Bonzini goto again;
381baacf047SPaolo Bonzini }
382baacf047SPaolo Bonzini return index;
383baacf047SPaolo Bonzini }
384baacf047SPaolo Bonzini
slow_bitmap_intersects(const unsigned long * bitmap1,const unsigned long * bitmap2,long bits)385baacf047SPaolo Bonzini int slow_bitmap_intersects(const unsigned long *bitmap1,
3869c22687eSJuan Quintela const unsigned long *bitmap2, long bits)
387baacf047SPaolo Bonzini {
3889c22687eSJuan Quintela long k, lim = bits/BITS_PER_LONG;
389baacf047SPaolo Bonzini
390baacf047SPaolo Bonzini for (k = 0; k < lim; ++k) {
391baacf047SPaolo Bonzini if (bitmap1[k] & bitmap2[k]) {
392baacf047SPaolo Bonzini return 1;
393baacf047SPaolo Bonzini }
394baacf047SPaolo Bonzini }
395baacf047SPaolo Bonzini
396baacf047SPaolo Bonzini if (bits % BITS_PER_LONG) {
397baacf047SPaolo Bonzini if ((bitmap1[k] & bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits)) {
398baacf047SPaolo Bonzini return 1;
399baacf047SPaolo Bonzini }
400baacf047SPaolo Bonzini }
401baacf047SPaolo Bonzini return 0;
402baacf047SPaolo Bonzini }
403fc7deeeaSPeter Xu
slow_bitmap_count_one(const unsigned long * bitmap,long nbits)404fc7deeeaSPeter Xu long slow_bitmap_count_one(const unsigned long *bitmap, long nbits)
405fc7deeeaSPeter Xu {
406fc7deeeaSPeter Xu long k, lim = nbits / BITS_PER_LONG, result = 0;
407fc7deeeaSPeter Xu
408fc7deeeaSPeter Xu for (k = 0; k < lim; k++) {
409fc7deeeaSPeter Xu result += ctpopl(bitmap[k]);
410fc7deeeaSPeter Xu }
411fc7deeeaSPeter Xu
412fc7deeeaSPeter Xu if (nbits % BITS_PER_LONG) {
413fc7deeeaSPeter Xu result += ctpopl(bitmap[k] & BITMAP_LAST_WORD_MASK(nbits));
414fc7deeeaSPeter Xu }
415fc7deeeaSPeter Xu
416fc7deeeaSPeter Xu return result;
417fc7deeeaSPeter Xu }
418d7788151SPeter Xu
bitmap_to_from_le(unsigned long * dst,const unsigned long * src,long nbits)419d7788151SPeter Xu static void bitmap_to_from_le(unsigned long *dst,
420d7788151SPeter Xu const unsigned long *src, long nbits)
421d7788151SPeter Xu {
422d7788151SPeter Xu long len = BITS_TO_LONGS(nbits);
423d7788151SPeter Xu
424e03b5686SMarc-André Lureau #if HOST_BIG_ENDIAN
425d7788151SPeter Xu long index;
426d7788151SPeter Xu
427d7788151SPeter Xu for (index = 0; index < len; index++) {
428d7788151SPeter Xu # if HOST_LONG_BITS == 64
429d7788151SPeter Xu dst[index] = bswap64(src[index]);
430d7788151SPeter Xu # else
431d7788151SPeter Xu dst[index] = bswap32(src[index]);
432d7788151SPeter Xu # endif
433d7788151SPeter Xu }
434d7788151SPeter Xu #else
435d7788151SPeter Xu memcpy(dst, src, len * sizeof(unsigned long));
436d7788151SPeter Xu #endif
437d7788151SPeter Xu }
438d7788151SPeter Xu
bitmap_from_le(unsigned long * dst,const unsigned long * src,long nbits)439d7788151SPeter Xu void bitmap_from_le(unsigned long *dst, const unsigned long *src,
440d7788151SPeter Xu long nbits)
441d7788151SPeter Xu {
442d7788151SPeter Xu bitmap_to_from_le(dst, src, nbits);
443d7788151SPeter Xu }
444d7788151SPeter Xu
bitmap_to_le(unsigned long * dst,const unsigned long * src,long nbits)445d7788151SPeter Xu void bitmap_to_le(unsigned long *dst, const unsigned long *src,
446d7788151SPeter Xu long nbits)
447d7788151SPeter Xu {
448d7788151SPeter Xu bitmap_to_from_le(dst, src, nbits);
449d7788151SPeter Xu }
450ad37f24dSPeter Xu
451ad37f24dSPeter Xu /*
452ad37f24dSPeter Xu * Copy "src" bitmap with a positive offset and put it into the "dst"
453ad37f24dSPeter Xu * bitmap. The caller needs to make sure the bitmap size of "src"
454ad37f24dSPeter Xu * is bigger than (shift + nbits).
455ad37f24dSPeter Xu */
bitmap_copy_with_src_offset(unsigned long * dst,const unsigned long * src,unsigned long shift,unsigned long nbits)456ad37f24dSPeter Xu void bitmap_copy_with_src_offset(unsigned long *dst, const unsigned long *src,
457ad37f24dSPeter Xu unsigned long shift, unsigned long nbits)
458ad37f24dSPeter Xu {
459ad37f24dSPeter Xu unsigned long left_mask, right_mask, last_mask;
460ad37f24dSPeter Xu
461ad37f24dSPeter Xu /* Proper shift src pointer to the first word to copy from */
462ad37f24dSPeter Xu src += BIT_WORD(shift);
463ad37f24dSPeter Xu shift %= BITS_PER_LONG;
464ad37f24dSPeter Xu
465ad37f24dSPeter Xu if (!shift) {
466ad37f24dSPeter Xu /* Fast path */
467ad37f24dSPeter Xu bitmap_copy(dst, src, nbits);
468ad37f24dSPeter Xu return;
469ad37f24dSPeter Xu }
470ad37f24dSPeter Xu
471ad37f24dSPeter Xu right_mask = (1ul << shift) - 1;
472ad37f24dSPeter Xu left_mask = ~right_mask;
473ad37f24dSPeter Xu
474ad37f24dSPeter Xu while (nbits >= BITS_PER_LONG) {
475ad37f24dSPeter Xu *dst = (*src & left_mask) >> shift;
476ad37f24dSPeter Xu *dst |= (src[1] & right_mask) << (BITS_PER_LONG - shift);
477ad37f24dSPeter Xu dst++;
478ad37f24dSPeter Xu src++;
479ad37f24dSPeter Xu nbits -= BITS_PER_LONG;
480ad37f24dSPeter Xu }
481ad37f24dSPeter Xu
482ad37f24dSPeter Xu if (nbits > BITS_PER_LONG - shift) {
483ad37f24dSPeter Xu *dst = (*src & left_mask) >> shift;
484ad37f24dSPeter Xu nbits -= BITS_PER_LONG - shift;
485ad37f24dSPeter Xu last_mask = (1ul << nbits) - 1;
486ad37f24dSPeter Xu *dst |= (src[1] & last_mask) << (BITS_PER_LONG - shift);
487ad37f24dSPeter Xu } else if (nbits) {
488ad37f24dSPeter Xu last_mask = (1ul << nbits) - 1;
489ad37f24dSPeter Xu *dst = (*src >> shift) & last_mask;
490ad37f24dSPeter Xu }
491ad37f24dSPeter Xu }
492ad37f24dSPeter Xu
493ad37f24dSPeter Xu /*
494ad37f24dSPeter Xu * Copy "src" bitmap into the "dst" bitmap with an offset in the
495ad37f24dSPeter Xu * "dst". The caller needs to make sure the bitmap size of "dst" is
496ad37f24dSPeter Xu * bigger than (shift + nbits).
497ad37f24dSPeter Xu */
bitmap_copy_with_dst_offset(unsigned long * dst,const unsigned long * src,unsigned long shift,unsigned long nbits)498ad37f24dSPeter Xu void bitmap_copy_with_dst_offset(unsigned long *dst, const unsigned long *src,
499ad37f24dSPeter Xu unsigned long shift, unsigned long nbits)
500ad37f24dSPeter Xu {
501ad37f24dSPeter Xu unsigned long left_mask, right_mask, last_mask;
502ad37f24dSPeter Xu
503ad37f24dSPeter Xu /* Proper shift dst pointer to the first word to copy from */
504ad37f24dSPeter Xu dst += BIT_WORD(shift);
505ad37f24dSPeter Xu shift %= BITS_PER_LONG;
506ad37f24dSPeter Xu
507ad37f24dSPeter Xu if (!shift) {
508ad37f24dSPeter Xu /* Fast path */
509ad37f24dSPeter Xu bitmap_copy(dst, src, nbits);
510ad37f24dSPeter Xu return;
511ad37f24dSPeter Xu }
512ad37f24dSPeter Xu
513ad37f24dSPeter Xu right_mask = (1ul << (BITS_PER_LONG - shift)) - 1;
514ad37f24dSPeter Xu left_mask = ~right_mask;
515ad37f24dSPeter Xu
516ad37f24dSPeter Xu *dst &= (1ul << shift) - 1;
517ad37f24dSPeter Xu while (nbits >= BITS_PER_LONG) {
518ad37f24dSPeter Xu *dst |= (*src & right_mask) << shift;
519ad37f24dSPeter Xu dst[1] = (*src & left_mask) >> (BITS_PER_LONG - shift);
520ad37f24dSPeter Xu dst++;
521ad37f24dSPeter Xu src++;
522ad37f24dSPeter Xu nbits -= BITS_PER_LONG;
523ad37f24dSPeter Xu }
524ad37f24dSPeter Xu
525ad37f24dSPeter Xu if (nbits > BITS_PER_LONG - shift) {
526ad37f24dSPeter Xu *dst |= (*src & right_mask) << shift;
527ad37f24dSPeter Xu nbits -= BITS_PER_LONG - shift;
528ad37f24dSPeter Xu last_mask = ((1ul << nbits) - 1) << (BITS_PER_LONG - shift);
529ad37f24dSPeter Xu dst[1] = (*src & last_mask) >> (BITS_PER_LONG - shift);
530ad37f24dSPeter Xu } else if (nbits) {
531ad37f24dSPeter Xu last_mask = (1ul << nbits) - 1;
532ad37f24dSPeter Xu *dst |= (*src & last_mask) << shift;
533ad37f24dSPeter Xu }
534ad37f24dSPeter Xu }
535