WebSVN – Kolibri OS – Diff – /drivers/ddk/linux/bitmap.c


/*
 * lib/bitmap.c
 * Helper functions for bitmap.h.
 *
 * This source code is licensed under the GNU General Public License,
 * Version 2.  See the file COPYING for more details.
 */
#include 
#include 
//#include 
#include 
#include 
#include 
#include 
#include 
//#include 
 
/*
 * bitmaps provide an array of bits, implemented using an an
 * array of unsigned longs.  The number of valid bits in a
 * given bitmap does _not_ need to be an exact multiple of
 * BITS_PER_LONG.
 *
 * The possible unused bits in the last, partially used word
 * of a bitmap are 'don't care'.  The implementation makes
 * no particular effort to keep them zero.  It ensures that
 * their value will not affect the results of any operation.
 * The bitmap operations that return Boolean (bitmap_empty,
 * for example) or scalar (bitmap_weight, for example) results
 * carefully filter out these unused bits from impacting their
 * results.
 *
 * These operations actually hold to a slightly stronger rule:
 * if you don't input any bitmaps to these ops that have some
 * unused bits set, then they won't output any set unused bits
 * in output bitmaps.
 *
 * The byte ordering of bitmaps is more natural on little
 * endian architectures.  See the big-endian headers
 * include/asm-ppc64/bitops.h and include/asm-s390/bitops.h
 * for the best explanations of this ordering.
 */
 
int __bitmap_empty(const unsigned long *bitmap, unsigned int bits)
{
	unsigned int k, lim = bits/BITS_PER_LONG;
	for (k = 0; k < lim; ++k)
		if (bitmap[k])
			return 0;
 
	if (bits % BITS_PER_LONG)
		if (bitmap[k] & BITMAP_LAST_WORD_MASK(bits))
			return 0;
 
	return 1;
}
EXPORT_SYMBOL(__bitmap_empty);
 
int __bitmap_full(const unsigned long *bitmap, unsigned int bits)
{
	unsigned int k, lim = bits/BITS_PER_LONG;
	for (k = 0; k < lim; ++k)
		if (~bitmap[k])
			return 0;
 
	if (bits % BITS_PER_LONG)
		if (~bitmap[k] & BITMAP_LAST_WORD_MASK(bits))
			return 0;
 
	return 1;
}
EXPORT_SYMBOL(__bitmap_full);
 
int __bitmap_equal(const unsigned long *bitmap1,
		const unsigned long *bitmap2, unsigned int bits)
{
	unsigned int k, lim = bits/BITS_PER_LONG;
	for (k = 0; k < lim; ++k)
		if (bitmap1[k] != bitmap2[k])
			return 0;
 
	if (bits % BITS_PER_LONG)
		if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
			return 0;
 
	return 1;
}
EXPORT_SYMBOL(__bitmap_equal);
 
void __bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int bits)
{
	unsigned int k, lim = bits/BITS_PER_LONG;
	for (k = 0; k < lim; ++k)
		dst[k] = ~src[k];
 
	if (bits % BITS_PER_LONG)
		dst[k] = ~src[k];
}
EXPORT_SYMBOL(__bitmap_complement);
 
/**
 * __bitmap_shift_right - logical right shift of the bits in a bitmap
 *   @dst : destination bitmap
 *   @src : source bitmap
 *   @shift : shift by this many bits
 *   @bits : bitmap size, in bits
 *
 * Shifting right (dividing) means moving bits in the MS -> LS bit
 * direction.  Zeros are fed into the vacated MS positions and the
 * LS bits shifted off the bottom are lost.
 */
void __bitmap_shift_right(unsigned long *dst,
			const unsigned long *src, int shift, int bits)
{
	int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;
	int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
	unsigned long mask = (1UL << left) - 1;
	for (k = 0; off + k < lim; ++k) {
		unsigned long upper, lower;
 
		/*
		 * If shift is not word aligned, take lower rem bits of
		 * word above and make them the top rem bits of result.
		 */
		if (!rem || off + k + 1 >= lim)
			upper = 0;
		else {
			upper = src[off + k + 1];
			if (off + k + 1 == lim - 1 && left)
				upper &= mask;
		}
		lower = src[off + k];
		if (left && off + k == lim - 1)
			lower &= mask;
		dst[k] = lower >> rem;
		if (rem)
			dst[k] |= upper << (BITS_PER_LONG - rem);
		if (left && k == lim - 1)
			dst[k] &= mask;
	}
	if (off)
		memset(&dst[lim - off], 0, off*sizeof(unsigned long));
}
EXPORT_SYMBOL(__bitmap_shift_right);
 
 
/**
 * __bitmap_shift_left - logical left shift of the bits in a bitmap
 *   @dst : destination bitmap
 *   @src : source bitmap
 *   @shift : shift by this many bits
 *   @bits : bitmap size, in bits
 *
 * Shifting left (multiplying) means moving bits in the LS -> MS
 * direction.  Zeros are fed into the vacated LS bit positions
 * and those MS bits shifted off the top are lost.
 */
 
void __bitmap_shift_left(unsigned long *dst,
			const unsigned long *src, int shift, int bits)
{
	int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;
	int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
	for (k = lim - off - 1; k >= 0; --k) {
		unsigned long upper, lower;
 
		/*
		 * If shift is not word aligned, take upper rem bits of
		 * word below and make them the bottom rem bits of result.
		 */
		if (rem && k > 0)
			lower = src[k - 1];
		else
			lower = 0;
		upper = src[k];
		if (left && k == lim - 1)
			upper &= (1UL << left) - 1;
		dst[k + off] = upper << rem;
		if (rem)
			dst[k + off] |= lower >> (BITS_PER_LONG - rem);
		if (left && k + off == lim - 1)
			dst[k + off] &= (1UL << left) - 1;
	}
	if (off)
		memset(dst, 0, off*sizeof(unsigned long));
}
EXPORT_SYMBOL(__bitmap_shift_left);
 
int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
				const unsigned long *bitmap2, unsigned int bits)
{
	unsigned int k;
	unsigned int lim = bits/BITS_PER_LONG;
	unsigned long result = 0;
 
	for (k = 0; k < lim; k++)
		result |= (dst[k] = bitmap1[k] & bitmap2[k]);
	if (bits % BITS_PER_LONG)
		result |= (dst[k] = bitmap1[k] & bitmap2[k] &
			   BITMAP_LAST_WORD_MASK(bits));
	return result != 0;
}
EXPORT_SYMBOL(__bitmap_and);
 
void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
				const unsigned long *bitmap2, unsigned int bits)
{
	unsigned int k;
	unsigned int nr = BITS_TO_LONGS(bits);
 
	for (k = 0; k < nr; k++)
		dst[k] = bitmap1[k] | bitmap2[k];
}
EXPORT_SYMBOL(__bitmap_or);
 
void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
				const unsigned long *bitmap2, unsigned int bits)
{
	unsigned int k;
	unsigned int nr = BITS_TO_LONGS(bits);
 
	for (k = 0; k < nr; k++)
		dst[k] = bitmap1[k] ^ bitmap2[k];
}
EXPORT_SYMBOL(__bitmap_xor);
 
int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
				const unsigned long *bitmap2, unsigned int bits)
{
	unsigned int k;
	unsigned int lim = bits/BITS_PER_LONG;
	unsigned long result = 0;
 
	for (k = 0; k < lim; k++)
		result |= (dst[k] = bitmap1[k] & ~bitmap2[k]);
	if (bits % BITS_PER_LONG)
		result |= (dst[k] = bitmap1[k] & ~bitmap2[k] &
			   BITMAP_LAST_WORD_MASK(bits));
	return result != 0;
}
EXPORT_SYMBOL(__bitmap_andnot);
 
int __bitmap_intersects(const unsigned long *bitmap1,
			const unsigned long *bitmap2, unsigned int bits)
{
	unsigned int k, lim = bits/BITS_PER_LONG;
	for (k = 0; k < lim; ++k)
		if (bitmap1[k] & bitmap2[k])
			return 1;
 
	if (bits % BITS_PER_LONG)
		if ((bitmap1[k] & bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
			return 1;
	return 0;
}
EXPORT_SYMBOL(__bitmap_intersects);
 
int __bitmap_subset(const unsigned long *bitmap1,
		    const unsigned long *bitmap2, unsigned int bits)
{
	unsigned int k, lim = bits/BITS_PER_LONG;
	for (k = 0; k < lim; ++k)
		if (bitmap1[k] & ~bitmap2[k])
			return 0;
 
	if (bits % BITS_PER_LONG)
		if ((bitmap1[k] & ~bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
			return 0;
	return 1;
}
EXPORT_SYMBOL(__bitmap_subset);
 
int __bitmap_weight(const unsigned long *bitmap, unsigned int bits)
{
	unsigned int k, lim = bits/BITS_PER_LONG;
	int w = 0;
 
	for (k = 0; k < lim; k++)
		w += hweight_long(bitmap[k]);
 
	if (bits % BITS_PER_LONG)
		w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
 
	return w;
}
EXPORT_SYMBOL(__bitmap_weight);
 
void bitmap_set(unsigned long *map, unsigned int start, int len)
{
	unsigned long *p = map + BIT_WORD(start);
	const unsigned int size = start + len;
	int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
	unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
 
	while (len - bits_to_set >= 0) {
		*p |= mask_to_set;
		len -= bits_to_set;
		bits_to_set = BITS_PER_LONG;
		mask_to_set = ~0UL;
		p++;
	}
	if (len) {
		mask_to_set &= BITMAP_LAST_WORD_MASK(size);
		*p |= mask_to_set;
	}
}
EXPORT_SYMBOL(bitmap_set);
 
void bitmap_clear(unsigned long *map, unsigned int start, int len)
{
	unsigned long *p = map + BIT_WORD(start);
	const unsigned int size = start + len;
	int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
	unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
 
	while (len - bits_to_clear >= 0) {
		*p &= ~mask_to_clear;
		len -= bits_to_clear;
		bits_to_clear = BITS_PER_LONG;
		mask_to_clear = ~0UL;
		p++;
	}
	if (len) {
		mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
		*p &= ~mask_to_clear;
	}
}
EXPORT_SYMBOL(bitmap_clear);
 
/**
 * bitmap_find_next_zero_area_off - find a contiguous aligned zero area
 * @map: The address to base the search on
 * @size: The bitmap size in bits
 * @start: The bitnumber to start searching at
 * @nr: The number of zeroed bits we're looking for
 * @align_mask: Alignment mask for zero area
 * @align_offset: Alignment offset for zero area.
 *
 * The @align_mask should be one less than a power of 2; the effect is that
 * the bit offset of all zero areas this function finds plus @align_offset
 * is multiple of that power of 2.
 */
unsigned long bitmap_find_next_zero_area_off(unsigned long *map,
					 unsigned long size,
					 unsigned long start,
					 unsigned int nr,
					     unsigned long align_mask,
					     unsigned long align_offset)
{
	unsigned long index, end, i;
again:
	index = find_next_zero_bit(map, size, start);
 
	/* Align allocation */
	index = __ALIGN_MASK(index + align_offset, align_mask) - align_offset;
 
	end = index + nr;
	if (end > size)
		return end;
	i = find_next_bit(map, end, index);
	if (i < end) {
		start = i + 1;
		goto again;
	}
	return index;
}
EXPORT_SYMBOL(bitmap_find_next_zero_area_off);
 
/*
 * Bitmap printing & parsing functions: first version by Nadia Yvette Chambers,
 * second version by Paul Jackson, third by Joe Korty.
 */
 
#define CHUNKSZ				32
#define nbits_to_hold_value(val)	fls(val)
#define BASEDEC 10		/* fancier cpuset lists input in decimal */
 
 
 
 
 
/**
 * bitmap_pos_to_ord - find ordinal of set bit at given position in bitmap
 *	@buf: pointer to a bitmap
 *	@pos: a bit position in @buf (0 <= @pos < @bits)
 *	@bits: number of valid bit positions in @buf
 *
 * Map the bit at position @pos in @buf (of length @bits) to the
 * ordinal of which set bit it is.  If it is not set or if @pos
 * is not a valid bit position, map to -1.
 *
 * If for example, just bits 4 through 7 are set in @buf, then @pos
 * values 4 through 7 will get mapped to 0 through 3, respectively,
 * and other @pos values will get mapped to -1.  When @pos value 7
 * gets mapped to (returns) @ord value 3 in this example, that means
 * that bit 7 is the 3rd (starting with 0th) set bit in @buf.
 *
 * The bit positions 0 through @bits are valid positions in @buf.
 */
static int bitmap_pos_to_ord(const unsigned long *buf, int pos, int bits)
{
	int i, ord;
 
	if (pos < 0 || pos >= bits || !test_bit(pos, buf))
		return -1;
 
	i = find_first_bit(buf, bits);
	ord = 0;
	while (i < pos) {
		i = find_next_bit(buf, bits, i + 1);
	     	ord++;
	}
	BUG_ON(i != pos);
 
	return ord;
}
 
/**
 * bitmap_ord_to_pos - find position of n-th set bit in bitmap
 *	@buf: pointer to bitmap
 *	@ord: ordinal bit position (n-th set bit, n >= 0)
 *	@bits: number of valid bit positions in @buf
 *
 * Map the ordinal offset of bit @ord in @buf to its position in @buf.
 * Value of @ord should be in range 0 <= @ord < weight(buf), else
 * results are undefined.
 *
 * If for example, just bits 4 through 7 are set in @buf, then @ord
 * values 0 through 3 will get mapped to 4 through 7, respectively,
 * and all other @ord values return undefined values.  When @ord value 3
 * gets mapped to (returns) @pos value 7 in this example, that means
 * that the 3rd set bit (starting with 0th) is at position 7 in @buf.
 *
 * The bit positions 0 through @bits are valid positions in @buf.
 */
int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits)
{
	int pos = 0;
 
	if (ord >= 0 && ord < bits) {
		int i;
 
		for (i = find_first_bit(buf, bits);
		     i < bits && ord > 0;
		     i = find_next_bit(buf, bits, i + 1))
	     		ord--;
		if (i < bits && ord == 0)
			pos = i;
	}
 
	return pos;
}
 
/**
 * bitmap_remap - Apply map defined by a pair of bitmaps to another bitmap
 *	@dst: remapped result
 *	@src: subset to be remapped
 *	@old: defines domain of map
 *	@new: defines range of map
 *	@bits: number of bits in each of these bitmaps
 *
 * Let @old and @new define a mapping of bit positions, such that
 * whatever position is held by the n-th set bit in @old is mapped
 * to the n-th set bit in @new.  In the more general case, allowing
 * for the possibility that the weight 'w' of @new is less than the
 * weight of @old, map the position of the n-th set bit in @old to
 * the position of the m-th set bit in @new, where m == n % w.
 *
 * If either of the @old and @new bitmaps are empty, or if @src and
 * @dst point to the same location, then this routine copies @src
 * to @dst.
 *
 * The positions of unset bits in @old are mapped to themselves
 * (the identify map).
 *
 * Apply the above specified mapping to @src, placing the result in
 * @dst, clearing any bits previously set in @dst.
 *
 * For example, lets say that @old has bits 4 through 7 set, and
 * @new has bits 12 through 15 set.  This defines the mapping of bit
 * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other
 * bit positions unchanged.  So if say @src comes into this routine
 * with bits 1, 5 and 7 set, then @dst should leave with bits 1,
 * 13 and 15 set.
 */
void bitmap_remap(unsigned long *dst, const unsigned long *src,
		const unsigned long *old, const unsigned long *new,
		int bits)
{
	int oldbit, w;
 
	if (dst == src)		/* following doesn't handle inplace remaps */
		return;
	bitmap_zero(dst, bits);
 
	w = bitmap_weight(new, bits);
	for_each_set_bit(oldbit, src, bits) {
	     	int n = bitmap_pos_to_ord(old, oldbit, bits);
 
		if (n < 0 || w == 0)
			set_bit(oldbit, dst);	/* identity map */
		else
			set_bit(bitmap_ord_to_pos(new, n % w, bits), dst);
	}
}
EXPORT_SYMBOL(bitmap_remap);
 
/**
 * bitmap_bitremap - Apply map defined by a pair of bitmaps to a single bit
 *	@oldbit: bit position to be mapped
 *	@old: defines domain of map
 *	@new: defines range of map
 *	@bits: number of bits in each of these bitmaps
 *
 * Let @old and @new define a mapping of bit positions, such that
 * whatever position is held by the n-th set bit in @old is mapped
 * to the n-th set bit in @new.  In the more general case, allowing
 * for the possibility that the weight 'w' of @new is less than the
 * weight of @old, map the position of the n-th set bit in @old to
 * the position of the m-th set bit in @new, where m == n % w.
 *
 * The positions of unset bits in @old are mapped to themselves
 * (the identify map).
 *
 * Apply the above specified mapping to bit position @oldbit, returning
 * the new bit position.
 *
 * For example, lets say that @old has bits 4 through 7 set, and
 * @new has bits 12 through 15 set.  This defines the mapping of bit
 * position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other
 * bit positions unchanged.  So if say @oldbit is 5, then this routine
 * returns 13.
 */
int bitmap_bitremap(int oldbit, const unsigned long *old,
				const unsigned long *new, int bits)
{
	int w = bitmap_weight(new, bits);
	int n = bitmap_pos_to_ord(old, oldbit, bits);
	if (n < 0 || w == 0)
		return oldbit;
	else
		return bitmap_ord_to_pos(new, n % w, bits);
}
EXPORT_SYMBOL(bitmap_bitremap);
 
/**
 * bitmap_onto - translate one bitmap relative to another
 *	@dst: resulting translated bitmap
 * 	@orig: original untranslated bitmap
 * 	@relmap: bitmap relative to which translated
 *	@bits: number of bits in each of these bitmaps
 *
 * Set the n-th bit of @dst iff there exists some m such that the
 * n-th bit of @relmap is set, the m-th bit of @orig is set, and
 * the n-th bit of @relmap is also the m-th _set_ bit of @relmap.
 * (If you understood the previous sentence the first time your
 * read it, you're overqualified for your current job.)
 *
 * In other words, @orig is mapped onto (surjectively) @dst,
 * using the the map {  | the n-th bit of @relmap is the
 * m-th set bit of @relmap }.
 *
 * Any set bits in @orig above bit number W, where W is the
 * weight of (number of set bits in) @relmap are mapped nowhere.
 * In particular, if for all bits m set in @orig, m >= W, then
 * @dst will end up empty.  In situations where the possibility
 * of such an empty result is not desired, one way to avoid it is
 * to use the bitmap_fold() operator, below, to first fold the
 * @orig bitmap over itself so that all its set bits x are in the
 * range 0 <= x < W.  The bitmap_fold() operator does this by
 * setting the bit (m % W) in @dst, for each bit (m) set in @orig.
 *
 * Example [1] for bitmap_onto():
 *  Let's say @relmap has bits 30-39 set, and @orig has bits
 *  1, 3, 5, 7, 9 and 11 set.  Then on return from this routine,
 *  @dst will have bits 31, 33, 35, 37 and 39 set.
 *
 *  When bit 0 is set in @orig, it means turn on the bit in
 *  @dst corresponding to whatever is the first bit (if any)
 *  that is turned on in @relmap.  Since bit 0 was off in the
 *  above example, we leave off that bit (bit 30) in @dst.
 *
 *  When bit 1 is set in @orig (as in the above example), it
 *  means turn on the bit in @dst corresponding to whatever
 *  is the second bit that is turned on in @relmap.  The second
 *  bit in @relmap that was turned on in the above example was
 *  bit 31, so we turned on bit 31 in @dst.
 *
 *  Similarly, we turned on bits 33, 35, 37 and 39 in @dst,
 *  because they were the 4th, 6th, 8th and 10th set bits
 *  set in @relmap, and the 4th, 6th, 8th and 10th bits of
 *  @orig (i.e. bits 3, 5, 7 and 9) were also set.
 *
 *  When bit 11 is set in @orig, it means turn on the bit in
 *  @dst corresponding to whatever is the twelfth bit that is
 *  turned on in @relmap.  In the above example, there were
 *  only ten bits turned on in @relmap (30..39), so that bit
 *  11 was set in @orig had no affect on @dst.
 *
 * Example [2] for bitmap_fold() + bitmap_onto():
 *  Let's say @relmap has these ten bits set:
 *		40 41 42 43 45 48 53 61 74 95
 *  (for the curious, that's 40 plus the first ten terms of the
 *  Fibonacci sequence.)
 *
 *  Further lets say we use the following code, invoking
 *  bitmap_fold() then bitmap_onto, as suggested above to
 *  avoid the possibility of an empty @dst result:
 *
 *	unsigned long *tmp;	// a temporary bitmap's bits
 *
 *	bitmap_fold(tmp, orig, bitmap_weight(relmap, bits), bits);
 *	bitmap_onto(dst, tmp, relmap, bits);
 *
 *  Then this table shows what various values of @dst would be, for
 *  various @orig's.  I list the zero-based positions of each set bit.
 *  The tmp column shows the intermediate result, as computed by
 *  using bitmap_fold() to fold the @orig bitmap modulo ten
 *  (the weight of @relmap).
 *
 *      @orig           tmp            @dst
 *      0                0             40
 *      1                1             41
 *      9                9             95
 *      10               0             40 (*)
 *      1 3 5 7          1 3 5 7       41 43 48 61
 *      0 1 2 3 4        0 1 2 3 4     40 41 42 43 45
 *      0 9 18 27        0 9 8 7       40 61 74 95
 *      0 10 20 30       0             40
 *      0 11 22 33       0 1 2 3       40 41 42 43
 *      0 12 24 36       0 2 4 6       40 42 45 53
 *      78 102 211       1 2 8         41 42 74 (*)
 *
 * (*) For these marked lines, if we hadn't first done bitmap_fold()
 *     into tmp, then the @dst result would have been empty.
 *
 * If either of @orig or @relmap is empty (no set bits), then @dst
 * will be returned empty.
 *
 * If (as explained above) the only set bits in @orig are in positions
 * m where m >= W, (where W is the weight of @relmap) then @dst will
 * once again be returned empty.
 *
 * All bits in @dst not set by the above rule are cleared.
 */
void bitmap_onto(unsigned long *dst, const unsigned long *orig,
			const unsigned long *relmap, int bits)
{
	int n, m;       	/* same meaning as in above comment */
 
	if (dst == orig)	/* following doesn't handle inplace mappings */
		return;
	bitmap_zero(dst, bits);
 
	/*
	 * The following code is a more efficient, but less
	 * obvious, equivalent to the loop:
	 *	for (m = 0; m < bitmap_weight(relmap, bits); m++) {
	 *		n = bitmap_ord_to_pos(orig, m, bits);
	 *		if (test_bit(m, orig))
	 *			set_bit(n, dst);
	 *	}
	 */
 
	m = 0;
	for_each_set_bit(n, relmap, bits) {
		/* m == bitmap_pos_to_ord(relmap, n, bits) */
		if (test_bit(m, orig))
			set_bit(n, dst);
		m++;
	}
}
EXPORT_SYMBOL(bitmap_onto);
 
/**
 * bitmap_fold - fold larger bitmap into smaller, modulo specified size
 *	@dst: resulting smaller bitmap
 *	@orig: original larger bitmap
 *	@sz: specified size
 *	@bits: number of bits in each of these bitmaps
 *
 * For each bit oldbit in @orig, set bit oldbit mod @sz in @dst.
 * Clear all other bits in @dst.  See further the comment and
 * Example [2] for bitmap_onto() for why and how to use this.
 */
void bitmap_fold(unsigned long *dst, const unsigned long *orig,
			int sz, int bits)
{
	int oldbit;
 
	if (dst == orig)	/* following doesn't handle inplace mappings */
		return;
	bitmap_zero(dst, bits);
 
	for_each_set_bit(oldbit, orig, bits)
		set_bit(oldbit % sz, dst);
}
EXPORT_SYMBOL(bitmap_fold);
 
/*
 * Common code for bitmap_*_region() routines.
 *	bitmap: array of unsigned longs corresponding to the bitmap
 *	pos: the beginning of the region
 *	order: region size (log base 2 of number of bits)
 *	reg_op: operation(s) to perform on that region of bitmap
 *
 * Can set, verify and/or release a region of bits in a bitmap,
 * depending on which combination of REG_OP_* flag bits is set.
 *
 * A region of a bitmap is a sequence of bits in the bitmap, of
 * some size '1 << order' (a power of two), aligned to that same
 * '1 << order' power of two.
 *
 * Returns 1 if REG_OP_ISFREE succeeds (region is all zero bits).
 * Returns 0 in all other cases and reg_ops.
 */
 
enum {
	REG_OP_ISFREE,		/* true if region is all zero bits */
	REG_OP_ALLOC,		/* set all bits in region */
	REG_OP_RELEASE,		/* clear all bits in region */
};
 
static int __reg_op(unsigned long *bitmap, unsigned int pos, int order, int reg_op)
{
	int nbits_reg;		/* number of bits in region */
	int index;		/* index first long of region in bitmap */
	int offset;		/* bit offset region in bitmap[index] */
	int nlongs_reg;		/* num longs spanned by region in bitmap */
	int nbitsinlong;	/* num bits of region in each spanned long */
	unsigned long mask;	/* bitmask for one long of region */
	int i;			/* scans bitmap by longs */
	int ret = 0;		/* return value */
 
	/*
	 * Either nlongs_reg == 1 (for small orders that fit in one long)
	 * or (offset == 0 && mask == ~0UL) (for larger multiword orders.)
	 */
	nbits_reg = 1 << order;
	index = pos / BITS_PER_LONG;
	offset = pos - (index * BITS_PER_LONG);
	nlongs_reg = BITS_TO_LONGS(nbits_reg);
	nbitsinlong = min(nbits_reg,  BITS_PER_LONG);
 
	/*
	 * Can't do "mask = (1UL << nbitsinlong) - 1", as that
	 * overflows if nbitsinlong == BITS_PER_LONG.
	 */
	mask = (1UL << (nbitsinlong - 1));
	mask += mask - 1;
	mask <<= offset;
 
	switch (reg_op) {
	case REG_OP_ISFREE:
		for (i = 0; i < nlongs_reg; i++) {
			if (bitmap[index + i] & mask)
				goto done;
		}
		ret = 1;	/* all bits in region free (zero) */
		break;
 
	case REG_OP_ALLOC:
		for (i = 0; i < nlongs_reg; i++)
			bitmap[index + i] |= mask;
		break;
 
	case REG_OP_RELEASE:
		for (i = 0; i < nlongs_reg; i++)
			bitmap[index + i] &= ~mask;
		break;
	}
done:
	return ret;
}
 
/**
 * bitmap_find_free_region - find a contiguous aligned mem region
 *	@bitmap: array of unsigned longs corresponding to the bitmap
 *	@bits: number of bits in the bitmap
 *	@order: region size (log base 2 of number of bits) to find
 *
 * Find a region of free (zero) bits in a @bitmap of @bits bits and
 * allocate them (set them to one).  Only consider regions of length
 * a power (@order) of two, aligned to that power of two, which
 * makes the search algorithm much faster.
 *
 * Return the bit offset in bitmap of the allocated region,
 * or -errno on failure.
 */
int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order)
{
	unsigned int pos, end;		/* scans bitmap by regions of size order */
 
	for (pos = 0 ; (end = pos + (1U << order)) <= bits; pos = end) {
		if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
			continue;
		__reg_op(bitmap, pos, order, REG_OP_ALLOC);
		return pos;
	}
	return -ENOMEM;
}
EXPORT_SYMBOL(bitmap_find_free_region);
 
/**
 * bitmap_release_region - release allocated bitmap region
 *	@bitmap: array of unsigned longs corresponding to the bitmap
 *	@pos: beginning of bit region to release
 *	@order: region size (log base 2 of number of bits) to release
 *
 * This is the complement to __bitmap_find_free_region() and releases
 * the found region (by clearing it in the bitmap).
 *
 * No return value.
 */
void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order)
{
	__reg_op(bitmap, pos, order, REG_OP_RELEASE);
}
EXPORT_SYMBOL(bitmap_release_region);
 
/**
 * bitmap_allocate_region - allocate bitmap region
 *	@bitmap: array of unsigned longs corresponding to the bitmap
 *	@pos: beginning of bit region to allocate
 *	@order: region size (log base 2 of number of bits) to allocate
 *
 * Allocate (set bits in) a specified region of a bitmap.
 *
 * Return 0 on success, or %-EBUSY if specified region wasn't
 * free (not all bits were zero).
 */
int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order)
{
	if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
		return -EBUSY;
	return __reg_op(bitmap, pos, order, REG_OP_ALLOC);
}
EXPORT_SYMBOL(bitmap_allocate_region);
 
/**
 * bitmap_copy_le - copy a bitmap, putting the bits into little-endian order.
 * @dst:   destination buffer
 * @src:   bitmap to copy
 * @nbits: number of bits in the bitmap
 *
 * Require nbits % BITS_PER_LONG == 0.
 */
void bitmap_copy_le(void *dst, const unsigned long *src, int nbits)
{
	unsigned long *d = dst;
	int i;
 
	for (i = 0; i < nbits/BITS_PER_LONG; i++) {
		if (BITS_PER_LONG == 64)
			d[i] = cpu_to_le64(src[i]);
		else
			d[i] = cpu_to_le32(src[i]);
	}
}
EXPORT_SYMBOL(bitmap_copy_le);

Rev 5056	Rev 5270
1	/*	1	/*
2	* lib/bitmap.c	2	* lib/bitmap.c
3	* Helper functions for bitmap.h.	3	* Helper functions for bitmap.h.
4	*	4	*
5	* This source code is licensed under the GNU General Public License,	5	* This source code is licensed under the GNU General Public License,
6	* Version 2. See the file COPYING for more details.	6	* Version 2. See the file COPYING for more details.
7	*/	7	*/
8	#include	8	#include
9	#include	9	#include
10	//#include	10	//#include
11	#include	11	#include
12	#include	12	#include
13	#include	13	#include
14	#include	14	#include
15	#include	15	#include
16	//#include	16	//#include
17		17
18	/*	18	/*
19	* bitmaps provide an array of bits, implemented using an an	19	* bitmaps provide an array of bits, implemented using an an
20	* array of unsigned longs. The number of valid bits in a	20	* array of unsigned longs. The number of valid bits in a
21	* given bitmap does _not_ need to be an exact multiple of	21	* given bitmap does _not_ need to be an exact multiple of
22	* BITS_PER_LONG.	22	* BITS_PER_LONG.
23	*	23	*
24	* The possible unused bits in the last, partially used word	24	* The possible unused bits in the last, partially used word
25	* of a bitmap are 'don't care'. The implementation makes	25	* of a bitmap are 'don't care'. The implementation makes
26	* no particular effort to keep them zero. It ensures that	26	* no particular effort to keep them zero. It ensures that
27	* their value will not affect the results of any operation.	27	* their value will not affect the results of any operation.
28	* The bitmap operations that return Boolean (bitmap_empty,	28	* The bitmap operations that return Boolean (bitmap_empty,
29	* for example) or scalar (bitmap_weight, for example) results	29	* for example) or scalar (bitmap_weight, for example) results
30	* carefully filter out these unused bits from impacting their	30	* carefully filter out these unused bits from impacting their
31	* results.	31	* results.
32	*	32	*
33	* These operations actually hold to a slightly stronger rule:	33	* These operations actually hold to a slightly stronger rule:
34	* if you don't input any bitmaps to these ops that have some	34	* if you don't input any bitmaps to these ops that have some
35	* unused bits set, then they won't output any set unused bits	35	* unused bits set, then they won't output any set unused bits
36	* in output bitmaps.	36	* in output bitmaps.
37	*	37	*
38	* The byte ordering of bitmaps is more natural on little	38	* The byte ordering of bitmaps is more natural on little
39	* endian architectures. See the big-endian headers	39	* endian architectures. See the big-endian headers
40	* include/asm-ppc64/bitops.h and include/asm-s390/bitops.h	40	* include/asm-ppc64/bitops.h and include/asm-s390/bitops.h
41	* for the best explanations of this ordering.	41	* for the best explanations of this ordering.
42	*/	42	*/
43		43
44	int __bitmap_empty(const unsigned long *bitmap, unsigned int bits)	44	int __bitmap_empty(const unsigned long *bitmap, unsigned int bits)
45	{	45	{
46	unsigned int k, lim = bits/BITS_PER_LONG;	46	unsigned int k, lim = bits/BITS_PER_LONG;
47	for (k = 0; k < lim; ++k)	47	for (k = 0; k < lim; ++k)
48	if (bitmap[k])	48	if (bitmap[k])
49	return 0;	49	return 0;
50		50
51	if (bits % BITS_PER_LONG)	51	if (bits % BITS_PER_LONG)
52	if (bitmap[k] & BITMAP_LAST_WORD_MASK(bits))	52	if (bitmap[k] & BITMAP_LAST_WORD_MASK(bits))
53	return 0;	53	return 0;
54		54
55	return 1;	55	return 1;
56	}	56	}
57	EXPORT_SYMBOL(__bitmap_empty);	57	EXPORT_SYMBOL(__bitmap_empty);
58		58
59	int __bitmap_full(const unsigned long *bitmap, unsigned int bits)	59	int __bitmap_full(const unsigned long *bitmap, unsigned int bits)
60	{	60	{
61	unsigned int k, lim = bits/BITS_PER_LONG;	61	unsigned int k, lim = bits/BITS_PER_LONG;
62	for (k = 0; k < lim; ++k)	62	for (k = 0; k < lim; ++k)
63	if (~bitmap[k])	63	if (~bitmap[k])
64	return 0;	64	return 0;
65		65
66	if (bits % BITS_PER_LONG)	66	if (bits % BITS_PER_LONG)
67	if (~bitmap[k] & BITMAP_LAST_WORD_MASK(bits))	67	if (~bitmap[k] & BITMAP_LAST_WORD_MASK(bits))
68	return 0;	68	return 0;
69		69
70	return 1;	70	return 1;
71	}	71	}
72	EXPORT_SYMBOL(__bitmap_full);	72	EXPORT_SYMBOL(__bitmap_full);
73		73
74	int __bitmap_equal(const unsigned long *bitmap1,	74	int __bitmap_equal(const unsigned long *bitmap1,
75	const unsigned long *bitmap2, unsigned int bits)	75	const unsigned long *bitmap2, unsigned int bits)
76	{	76	{
77	unsigned int k, lim = bits/BITS_PER_LONG;	77	unsigned int k, lim = bits/BITS_PER_LONG;
78	for (k = 0; k < lim; ++k)	78	for (k = 0; k < lim; ++k)
79	if (bitmap1[k] != bitmap2[k])	79	if (bitmap1[k] != bitmap2[k])
80	return 0;	80	return 0;
81		81
82	if (bits % BITS_PER_LONG)	82	if (bits % BITS_PER_LONG)
83	if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))	83	if ((bitmap1[k] ^ bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
84	return 0;	84	return 0;
85		85
86	return 1;	86	return 1;
87	}	87	}
88	EXPORT_SYMBOL(__bitmap_equal);	88	EXPORT_SYMBOL(__bitmap_equal);
89		89
90	void __bitmap_complement(unsigned long dst, const unsigned long src, unsigned int bits)	90	void __bitmap_complement(unsigned long dst, const unsigned long src, unsigned int bits)
91	{	91	{
92	unsigned int k, lim = bits/BITS_PER_LONG;	92	unsigned int k, lim = bits/BITS_PER_LONG;
93	for (k = 0; k < lim; ++k)	93	for (k = 0; k < lim; ++k)
94	dst[k] = ~src[k];	94	dst[k] = ~src[k];
95		95
96	if (bits % BITS_PER_LONG)	96	if (bits % BITS_PER_LONG)
97	dst[k] = ~src[k];	97	dst[k] = ~src[k];
98	}	98	}
99	EXPORT_SYMBOL(__bitmap_complement);	99	EXPORT_SYMBOL(__bitmap_complement);
100		100
101	/**	101	/**
102	* __bitmap_shift_right - logical right shift of the bits in a bitmap	102	* __bitmap_shift_right - logical right shift of the bits in a bitmap
103	* @dst : destination bitmap	103	* @dst : destination bitmap
104	* @src : source bitmap	104	* @src : source bitmap
105	* @shift : shift by this many bits	105	* @shift : shift by this many bits
106	* @bits : bitmap size, in bits	106	* @bits : bitmap size, in bits
107	*	107	*
108	* Shifting right (dividing) means moving bits in the MS -> LS bit	108	* Shifting right (dividing) means moving bits in the MS -> LS bit
109	* direction. Zeros are fed into the vacated MS positions and the	109	* direction. Zeros are fed into the vacated MS positions and the
110	* LS bits shifted off the bottom are lost.	110	* LS bits shifted off the bottom are lost.
111	*/	111	*/
112	void __bitmap_shift_right(unsigned long *dst,	112	void __bitmap_shift_right(unsigned long *dst,
113	const unsigned long *src, int shift, int bits)	113	const unsigned long *src, int shift, int bits)
114	{	114	{
115	int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;	115	int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;
116	int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;	116	int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
117	unsigned long mask = (1UL << left) - 1;	117	unsigned long mask = (1UL << left) - 1;
118	for (k = 0; off + k < lim; ++k) {	118	for (k = 0; off + k < lim; ++k) {
119	unsigned long upper, lower;	119	unsigned long upper, lower;
120		120
121	/*	121	/*
122	* If shift is not word aligned, take lower rem bits of	122	* If shift is not word aligned, take lower rem bits of
123	* word above and make them the top rem bits of result.	123	* word above and make them the top rem bits of result.
124	*/	124	*/
125	if (!rem \|\| off + k + 1 >= lim)	125	if (!rem \|\| off + k + 1 >= lim)
126	upper = 0;	126	upper = 0;
127	else {	127	else {
128	upper = src[off + k + 1];	128	upper = src[off + k + 1];
129	if (off + k + 1 == lim - 1 && left)	129	if (off + k + 1 == lim - 1 && left)
130	upper &= mask;	130	upper &= mask;
131	}	131	}
132	lower = src[off + k];	132	lower = src[off + k];
133	if (left && off + k == lim - 1)	133	if (left && off + k == lim - 1)
134	lower &= mask;	134	lower &= mask;
-		135	dst[k] = lower >> rem;
-		136	if (rem)
135	dst[k] = upper << (BITS_PER_LONG - rem) \| lower >> rem;	137	dst[k] \|= upper << (BITS_PER_LONG - rem);
136	if (left && k == lim - 1)	138	if (left && k == lim - 1)
137	dst[k] &= mask;	139	dst[k] &= mask;
138	}	140	}
139	if (off)	141	if (off)
140	memset(&dst[lim - off], 0, off*sizeof(unsigned long));	142	memset(&dst[lim - off], 0, off*sizeof(unsigned long));
141	}	143	}
142	EXPORT_SYMBOL(__bitmap_shift_right);	144	EXPORT_SYMBOL(__bitmap_shift_right);
143		145
144		146
145	/**	147	/**
146	* __bitmap_shift_left - logical left shift of the bits in a bitmap	148	* __bitmap_shift_left - logical left shift of the bits in a bitmap
147	* @dst : destination bitmap	149	* @dst : destination bitmap
148	* @src : source bitmap	150	* @src : source bitmap
149	* @shift : shift by this many bits	151	* @shift : shift by this many bits
150	* @bits : bitmap size, in bits	152	* @bits : bitmap size, in bits
151	*	153	*
152	* Shifting left (multiplying) means moving bits in the LS -> MS	154	* Shifting left (multiplying) means moving bits in the LS -> MS
153	* direction. Zeros are fed into the vacated LS bit positions	155	* direction. Zeros are fed into the vacated LS bit positions
154	* and those MS bits shifted off the top are lost.	156	* and those MS bits shifted off the top are lost.
155	*/	157	*/
156		158
157	void __bitmap_shift_left(unsigned long *dst,	159	void __bitmap_shift_left(unsigned long *dst,
158	const unsigned long *src, int shift, int bits)	160	const unsigned long *src, int shift, int bits)
159	{	161	{
160	int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;	162	int k, lim = BITS_TO_LONGS(bits), left = bits % BITS_PER_LONG;
161	int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;	163	int off = shift/BITS_PER_LONG, rem = shift % BITS_PER_LONG;
162	for (k = lim - off - 1; k >= 0; --k) {	164	for (k = lim - off - 1; k >= 0; --k) {
163	unsigned long upper, lower;	165	unsigned long upper, lower;
164		166
165	/*	167	/*
166	* If shift is not word aligned, take upper rem bits of	168	* If shift is not word aligned, take upper rem bits of
167	* word below and make them the bottom rem bits of result.	169	* word below and make them the bottom rem bits of result.
168	*/	170	*/
169	if (rem && k > 0)	171	if (rem && k > 0)
170	lower = src[k - 1];	172	lower = src[k - 1];
171	else	173	else
172	lower = 0;	174	lower = 0;
173	upper = src[k];	175	upper = src[k];
174	if (left && k == lim - 1)	176	if (left && k == lim - 1)
175	upper &= (1UL << left) - 1;	177	upper &= (1UL << left) - 1;
-		178	dst[k + off] = upper << rem;
-		179	if (rem)
176	dst[k + off] = lower >> (BITS_PER_LONG - rem) \| upper << rem;	180	dst[k + off] \|= lower >> (BITS_PER_LONG - rem);
177	if (left && k + off == lim - 1)	181	if (left && k + off == lim - 1)
178	dst[k + off] &= (1UL << left) - 1;	182	dst[k + off] &= (1UL << left) - 1;
179	}	183	}
180	if (off)	184	if (off)
181	memset(dst, 0, off*sizeof(unsigned long));	185	memset(dst, 0, off*sizeof(unsigned long));
182	}	186	}
183	EXPORT_SYMBOL(__bitmap_shift_left);	187	EXPORT_SYMBOL(__bitmap_shift_left);
184		188
185	int __bitmap_and(unsigned long dst, const unsigned long bitmap1,	189	int __bitmap_and(unsigned long dst, const unsigned long bitmap1,
186	const unsigned long *bitmap2, unsigned int bits)	190	const unsigned long *bitmap2, unsigned int bits)
187	{	191	{
188	unsigned int k;	192	unsigned int k;
189	unsigned int lim = bits/BITS_PER_LONG;	193	unsigned int lim = bits/BITS_PER_LONG;
190	unsigned long result = 0;	194	unsigned long result = 0;
191		195
192	for (k = 0; k < lim; k++)	196	for (k = 0; k < lim; k++)
193	result \|= (dst[k] = bitmap1[k] & bitmap2[k]);	197	result \|= (dst[k] = bitmap1[k] & bitmap2[k]);
194	if (bits % BITS_PER_LONG)	198	if (bits % BITS_PER_LONG)
195	result \|= (dst[k] = bitmap1[k] & bitmap2[k] &	199	result \|= (dst[k] = bitmap1[k] & bitmap2[k] &
196	BITMAP_LAST_WORD_MASK(bits));	200	BITMAP_LAST_WORD_MASK(bits));
197	return result != 0;	201	return result != 0;
198	}	202	}
199	EXPORT_SYMBOL(__bitmap_and);	203	EXPORT_SYMBOL(__bitmap_and);
200		204
201	void __bitmap_or(unsigned long dst, const unsigned long bitmap1,	205	void __bitmap_or(unsigned long dst, const unsigned long bitmap1,
202	const unsigned long *bitmap2, unsigned int bits)	206	const unsigned long *bitmap2, unsigned int bits)
203	{	207	{
204	unsigned int k;	208	unsigned int k;
205	unsigned int nr = BITS_TO_LONGS(bits);	209	unsigned int nr = BITS_TO_LONGS(bits);
206		210
207	for (k = 0; k < nr; k++)	211	for (k = 0; k < nr; k++)
208	dst[k] = bitmap1[k] \| bitmap2[k];	212	dst[k] = bitmap1[k] \| bitmap2[k];
209	}	213	}
210	EXPORT_SYMBOL(__bitmap_or);	214	EXPORT_SYMBOL(__bitmap_or);
211		215
212	void __bitmap_xor(unsigned long dst, const unsigned long bitmap1,	216	void __bitmap_xor(unsigned long dst, const unsigned long bitmap1,
213	const unsigned long *bitmap2, unsigned int bits)	217	const unsigned long *bitmap2, unsigned int bits)
214	{	218	{
215	unsigned int k;	219	unsigned int k;
216	unsigned int nr = BITS_TO_LONGS(bits);	220	unsigned int nr = BITS_TO_LONGS(bits);
217		221
218	for (k = 0; k < nr; k++)	222	for (k = 0; k < nr; k++)
219	dst[k] = bitmap1[k] ^ bitmap2[k];	223	dst[k] = bitmap1[k] ^ bitmap2[k];
220	}	224	}
221	EXPORT_SYMBOL(__bitmap_xor);	225	EXPORT_SYMBOL(__bitmap_xor);
222		226
223	int __bitmap_andnot(unsigned long dst, const unsigned long bitmap1,	227	int __bitmap_andnot(unsigned long dst, const unsigned long bitmap1,
224	const unsigned long *bitmap2, unsigned int bits)	228	const unsigned long *bitmap2, unsigned int bits)
225	{	229	{
226	unsigned int k;	230	unsigned int k;
227	unsigned int lim = bits/BITS_PER_LONG;	231	unsigned int lim = bits/BITS_PER_LONG;
228	unsigned long result = 0;	232	unsigned long result = 0;
229		233
230	for (k = 0; k < lim; k++)	234	for (k = 0; k < lim; k++)
231	result \|= (dst[k] = bitmap1[k] & ~bitmap2[k]);	235	result \|= (dst[k] = bitmap1[k] & ~bitmap2[k]);
232	if (bits % BITS_PER_LONG)	236	if (bits % BITS_PER_LONG)
233	result \|= (dst[k] = bitmap1[k] & ~bitmap2[k] &	237	result \|= (dst[k] = bitmap1[k] & ~bitmap2[k] &
234	BITMAP_LAST_WORD_MASK(bits));	238	BITMAP_LAST_WORD_MASK(bits));
235	return result != 0;	239	return result != 0;
236	}	240	}
237	EXPORT_SYMBOL(__bitmap_andnot);	241	EXPORT_SYMBOL(__bitmap_andnot);
238		242
239	int __bitmap_intersects(const unsigned long *bitmap1,	243	int __bitmap_intersects(const unsigned long *bitmap1,
240	const unsigned long *bitmap2, unsigned int bits)	244	const unsigned long *bitmap2, unsigned int bits)
241	{	245	{
242	unsigned int k, lim = bits/BITS_PER_LONG;	246	unsigned int k, lim = bits/BITS_PER_LONG;
243	for (k = 0; k < lim; ++k)	247	for (k = 0; k < lim; ++k)
244	if (bitmap1[k] & bitmap2[k])	248	if (bitmap1[k] & bitmap2[k])
245	return 1;	249	return 1;
246		250
247	if (bits % BITS_PER_LONG)	251	if (bits % BITS_PER_LONG)
248	if ((bitmap1[k] & bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))	252	if ((bitmap1[k] & bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
249	return 1;	253	return 1;
250	return 0;	254	return 0;
251	}	255	}
252	EXPORT_SYMBOL(__bitmap_intersects);	256	EXPORT_SYMBOL(__bitmap_intersects);
253		257
254	int __bitmap_subset(const unsigned long *bitmap1,	258	int __bitmap_subset(const unsigned long *bitmap1,
255	const unsigned long *bitmap2, unsigned int bits)	259	const unsigned long *bitmap2, unsigned int bits)
256	{	260	{
257	unsigned int k, lim = bits/BITS_PER_LONG;	261	unsigned int k, lim = bits/BITS_PER_LONG;
258	for (k = 0; k < lim; ++k)	262	for (k = 0; k < lim; ++k)
259	if (bitmap1[k] & ~bitmap2[k])	263	if (bitmap1[k] & ~bitmap2[k])
260	return 0;	264	return 0;
261		265
262	if (bits % BITS_PER_LONG)	266	if (bits % BITS_PER_LONG)
263	if ((bitmap1[k] & ~bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))	267	if ((bitmap1[k] & ~bitmap2[k]) & BITMAP_LAST_WORD_MASK(bits))
264	return 0;	268	return 0;
265	return 1;	269	return 1;
266	}	270	}
267	EXPORT_SYMBOL(__bitmap_subset);	271	EXPORT_SYMBOL(__bitmap_subset);
268		272
269	int __bitmap_weight(const unsigned long *bitmap, unsigned int bits)	273	int __bitmap_weight(const unsigned long *bitmap, unsigned int bits)
270	{	274	{
271	unsigned int k, lim = bits/BITS_PER_LONG;	275	unsigned int k, lim = bits/BITS_PER_LONG;
272	int w = 0;	276	int w = 0;
273		277
274	for (k = 0; k < lim; k++)	278	for (k = 0; k < lim; k++)
275	w += hweight_long(bitmap[k]);	279	w += hweight_long(bitmap[k]);
276		280
277	if (bits % BITS_PER_LONG)	281	if (bits % BITS_PER_LONG)
278	w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));	282	w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
279		283
280	return w;	284	return w;
281	}	285	}
282	EXPORT_SYMBOL(__bitmap_weight);	286	EXPORT_SYMBOL(__bitmap_weight);
283		287
284	void bitmap_set(unsigned long *map, unsigned int start, int len)	288	void bitmap_set(unsigned long *map, unsigned int start, int len)
285	{	289	{
286	unsigned long *p = map + BIT_WORD(start);	290	unsigned long *p = map + BIT_WORD(start);
287	const unsigned int size = start + len;	291	const unsigned int size = start + len;
288	int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);	292	int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
289	unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);	293	unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
290		294
291	while (len - bits_to_set >= 0) {	295	while (len - bits_to_set >= 0) {
292	*p \|= mask_to_set;	296	*p \|= mask_to_set;
293	len -= bits_to_set;	297	len -= bits_to_set;
294	bits_to_set = BITS_PER_LONG;	298	bits_to_set = BITS_PER_LONG;
295	mask_to_set = ~0UL;	299	mask_to_set = ~0UL;
296	p++;	300	p++;
297	}	301	}
298	if (len) {	302	if (len) {
299	mask_to_set &= BITMAP_LAST_WORD_MASK(size);	303	mask_to_set &= BITMAP_LAST_WORD_MASK(size);
300	*p \|= mask_to_set;	304	*p \|= mask_to_set;
301	}	305	}
302	}	306	}
303	EXPORT_SYMBOL(bitmap_set);	307	EXPORT_SYMBOL(bitmap_set);
304		308
305	void bitmap_clear(unsigned long *map, unsigned int start, int len)	309	void bitmap_clear(unsigned long *map, unsigned int start, int len)
306	{	310	{
307	unsigned long *p = map + BIT_WORD(start);	311	unsigned long *p = map + BIT_WORD(start);
308	const unsigned int size = start + len;	312	const unsigned int size = start + len;
309	int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);	313	int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
310	unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);	314	unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
311		315
312	while (len - bits_to_clear >= 0) {	316	while (len - bits_to_clear >= 0) {
313	*p &= ~mask_to_clear;	317	*p &= ~mask_to_clear;
314	len -= bits_to_clear;	318	len -= bits_to_clear;
315	bits_to_clear = BITS_PER_LONG;	319	bits_to_clear = BITS_PER_LONG;
316	mask_to_clear = ~0UL;	320	mask_to_clear = ~0UL;
317	p++;	321	p++;
318	}	322	}
319	if (len) {	323	if (len) {
320	mask_to_clear &= BITMAP_LAST_WORD_MASK(size);	324	mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
321	*p &= ~mask_to_clear;	325	*p &= ~mask_to_clear;
322	}	326	}
323	}	327	}
324	EXPORT_SYMBOL(bitmap_clear);	328	EXPORT_SYMBOL(bitmap_clear);
325		329
326	/*	330	/**
327	* bitmap_find_next_zero_area - find a contiguous aligned zero area	331	* bitmap_find_next_zero_area_off - find a contiguous aligned zero area
328	* @map: The address to base the search on	332	* @map: The address to base the search on
329	* @size: The bitmap size in bits	333	* @size: The bitmap size in bits
330	* @start: The bitnumber to start searching at	334	* @start: The bitnumber to start searching at
331	* @nr: The number of zeroed bits we're looking for	335	* @nr: The number of zeroed bits we're looking for
332	* @align_mask: Alignment mask for zero area	336	* @align_mask: Alignment mask for zero area
-		337	* @align_offset: Alignment offset for zero area.
333	*	338	*
334	* The @align_mask should be one less than a power of 2; the effect is that	339	* The @align_mask should be one less than a power of 2; the effect is that
335	* the bit offset of all zero areas this function finds is multiples of that	340	* the bit offset of all zero areas this function finds plus @align_offset
336	* power of 2. A @align_mask of 0 means no alignment is required.	341	* is multiple of that power of 2.
337	*/	342	*/
338	unsigned long bitmap_find_next_zero_area(unsigned long *map,	343	unsigned long bitmap_find_next_zero_area_off(unsigned long *map,
339	unsigned long size,	344	unsigned long size,
340	unsigned long start,	345	unsigned long start,
341	unsigned int nr,	346	unsigned int nr,
342	unsigned long align_mask)	347	unsigned long align_mask,
-		348	unsigned long align_offset)
343	{	349	{
344	unsigned long index, end, i;	350	unsigned long index, end, i;
345	again:	351	again:
346	index = find_next_zero_bit(map, size, start);	352	index = find_next_zero_bit(map, size, start);
347		353
348	/* Align allocation */	354	/* Align allocation */
349	index = __ALIGN_MASK(index, align_mask);	355	index = __ALIGN_MASK(index + align_offset, align_mask) - align_offset;
350		356
351	end = index + nr;	357	end = index + nr;
352	if (end > size)	358	if (end > size)
353	return end;	359	return end;
354	i = find_next_bit(map, end, index);	360	i = find_next_bit(map, end, index);
355	if (i < end) {	361	if (i < end) {
356	start = i + 1;	362	start = i + 1;
357	goto again;	363	goto again;
358	}	364	}
359	return index;	365	return index;
360	}	366	}
361	EXPORT_SYMBOL(bitmap_find_next_zero_area);	367	EXPORT_SYMBOL(bitmap_find_next_zero_area_off);
362		368
363	/*	369	/*
364	* Bitmap printing & parsing functions: first version by Nadia Yvette Chambers,	370	* Bitmap printing & parsing functions: first version by Nadia Yvette Chambers,
365	* second version by Paul Jackson, third by Joe Korty.	371	* second version by Paul Jackson, third by Joe Korty.
366	*/	372	*/
367		373
368	#define CHUNKSZ 32	374	#define CHUNKSZ 32
369	#define nbits_to_hold_value(val) fls(val)	375	#define nbits_to_hold_value(val) fls(val)
370	#define BASEDEC 10 /* fancier cpuset lists input in decimal */	376	#define BASEDEC 10 /* fancier cpuset lists input in decimal */
371		377
372		378
373		379
374		380
375		381
376	/**	382	/**
377	* bitmap_pos_to_ord - find ordinal of set bit at given position in bitmap	383	* bitmap_pos_to_ord - find ordinal of set bit at given position in bitmap
378	* @buf: pointer to a bitmap	384	* @buf: pointer to a bitmap
379	* @pos: a bit position in @buf (0 <= @pos < @bits)	385	* @pos: a bit position in @buf (0 <= @pos < @bits)
380	* @bits: number of valid bit positions in @buf	386	* @bits: number of valid bit positions in @buf
381	*	387	*
382	* Map the bit at position @pos in @buf (of length @bits) to the	388	* Map the bit at position @pos in @buf (of length @bits) to the
383	* ordinal of which set bit it is. If it is not set or if @pos	389	* ordinal of which set bit it is. If it is not set or if @pos
384	* is not a valid bit position, map to -1.	390	* is not a valid bit position, map to -1.
385	*	391	*
386	* If for example, just bits 4 through 7 are set in @buf, then @pos	392	* If for example, just bits 4 through 7 are set in @buf, then @pos
387	* values 4 through 7 will get mapped to 0 through 3, respectively,	393	* values 4 through 7 will get mapped to 0 through 3, respectively,
388	* and other @pos values will get mapped to -1. When @pos value 7	394	* and other @pos values will get mapped to -1. When @pos value 7
389	* gets mapped to (returns) @ord value 3 in this example, that means	395	* gets mapped to (returns) @ord value 3 in this example, that means
390	* that bit 7 is the 3rd (starting with 0th) set bit in @buf.	396	* that bit 7 is the 3rd (starting with 0th) set bit in @buf.
391	*	397	*
392	* The bit positions 0 through @bits are valid positions in @buf.	398	* The bit positions 0 through @bits are valid positions in @buf.
393	*/	399	*/
394	static int bitmap_pos_to_ord(const unsigned long *buf, int pos, int bits)	400	static int bitmap_pos_to_ord(const unsigned long *buf, int pos, int bits)
395	{	401	{
396	int i, ord;	402	int i, ord;
397		403
398	if (pos < 0 \|\| pos >= bits \|\| !test_bit(pos, buf))	404	if (pos < 0 \|\| pos >= bits \|\| !test_bit(pos, buf))
399	return -1;	405	return -1;
400		406
401	i = find_first_bit(buf, bits);	407	i = find_first_bit(buf, bits);
402	ord = 0;	408	ord = 0;
403	while (i < pos) {	409	while (i < pos) {
404	i = find_next_bit(buf, bits, i + 1);	410	i = find_next_bit(buf, bits, i + 1);
405	ord++;	411	ord++;
406	}	412	}
407	BUG_ON(i != pos);	413	BUG_ON(i != pos);
408		414
409	return ord;	415	return ord;
410	}	416	}
411		417
412	/**	418	/**
413	* bitmap_ord_to_pos - find position of n-th set bit in bitmap	419	* bitmap_ord_to_pos - find position of n-th set bit in bitmap
414	* @buf: pointer to bitmap	420	* @buf: pointer to bitmap
415	* @ord: ordinal bit position (n-th set bit, n >= 0)	421	* @ord: ordinal bit position (n-th set bit, n >= 0)
416	* @bits: number of valid bit positions in @buf	422	* @bits: number of valid bit positions in @buf
417	*	423	*
418	* Map the ordinal offset of bit @ord in @buf to its position in @buf.	424	* Map the ordinal offset of bit @ord in @buf to its position in @buf.
419	* Value of @ord should be in range 0 <= @ord < weight(buf), else	425	* Value of @ord should be in range 0 <= @ord < weight(buf), else
420	* results are undefined.	426	* results are undefined.
421	*	427	*
422	* If for example, just bits 4 through 7 are set in @buf, then @ord	428	* If for example, just bits 4 through 7 are set in @buf, then @ord
423	* values 0 through 3 will get mapped to 4 through 7, respectively,	429	* values 0 through 3 will get mapped to 4 through 7, respectively,
424	* and all other @ord values return undefined values. When @ord value 3	430	* and all other @ord values return undefined values. When @ord value 3
425	* gets mapped to (returns) @pos value 7 in this example, that means	431	* gets mapped to (returns) @pos value 7 in this example, that means
426	* that the 3rd set bit (starting with 0th) is at position 7 in @buf.	432	* that the 3rd set bit (starting with 0th) is at position 7 in @buf.
427	*	433	*
428	* The bit positions 0 through @bits are valid positions in @buf.	434	* The bit positions 0 through @bits are valid positions in @buf.
429	*/	435	*/
430	int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits)	436	int bitmap_ord_to_pos(const unsigned long *buf, int ord, int bits)
431	{	437	{
432	int pos = 0;	438	int pos = 0;
433		439
434	if (ord >= 0 && ord < bits) {	440	if (ord >= 0 && ord < bits) {
435	int i;	441	int i;
436		442
437	for (i = find_first_bit(buf, bits);	443	for (i = find_first_bit(buf, bits);
438	i < bits && ord > 0;	444	i < bits && ord > 0;
439	i = find_next_bit(buf, bits, i + 1))	445	i = find_next_bit(buf, bits, i + 1))
440	ord--;	446	ord--;
441	if (i < bits && ord == 0)	447	if (i < bits && ord == 0)
442	pos = i;	448	pos = i;
443	}	449	}
444		450
445	return pos;	451	return pos;
446	}	452	}
447		453
448	/**	454	/**
449	* bitmap_remap - Apply map defined by a pair of bitmaps to another bitmap	455	* bitmap_remap - Apply map defined by a pair of bitmaps to another bitmap
450	* @dst: remapped result	456	* @dst: remapped result
451	* @src: subset to be remapped	457	* @src: subset to be remapped
452	* @old: defines domain of map	458	* @old: defines domain of map
453	* @new: defines range of map	459	* @new: defines range of map
454	* @bits: number of bits in each of these bitmaps	460	* @bits: number of bits in each of these bitmaps
455	*	461	*
456	* Let @old and @new define a mapping of bit positions, such that	462	* Let @old and @new define a mapping of bit positions, such that
457	* whatever position is held by the n-th set bit in @old is mapped	463	* whatever position is held by the n-th set bit in @old is mapped
458	* to the n-th set bit in @new. In the more general case, allowing	464	* to the n-th set bit in @new. In the more general case, allowing
459	* for the possibility that the weight 'w' of @new is less than the	465	* for the possibility that the weight 'w' of @new is less than the
460	* weight of @old, map the position of the n-th set bit in @old to	466	* weight of @old, map the position of the n-th set bit in @old to
461	* the position of the m-th set bit in @new, where m == n % w.	467	* the position of the m-th set bit in @new, where m == n % w.
462	*	468	*
463	* If either of the @old and @new bitmaps are empty, or if @src and	469	* If either of the @old and @new bitmaps are empty, or if @src and
464	* @dst point to the same location, then this routine copies @src	470	* @dst point to the same location, then this routine copies @src
465	* to @dst.	471	* to @dst.
466	*	472	*
467	* The positions of unset bits in @old are mapped to themselves	473	* The positions of unset bits in @old are mapped to themselves
468	* (the identify map).	474	* (the identify map).
469	*	475	*
470	* Apply the above specified mapping to @src, placing the result in	476	* Apply the above specified mapping to @src, placing the result in
471	* @dst, clearing any bits previously set in @dst.	477	* @dst, clearing any bits previously set in @dst.
472	*	478	*
473	* For example, lets say that @old has bits 4 through 7 set, and	479	* For example, lets say that @old has bits 4 through 7 set, and
474	* @new has bits 12 through 15 set. This defines the mapping of bit	480	* @new has bits 12 through 15 set. This defines the mapping of bit
475	* position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other	481	* position 4 to 12, 5 to 13, 6 to 14 and 7 to 15, and of all other
476	* bit positions unchanged. So if say @src comes into this routine	482	* bit positions unchanged. So if say @src comes into this routine
477	* with bits 1, 5 and 7 set, then @dst should leave with bits 1,	483	* with bits 1, 5 and 7 set, then @dst should leave with bits 1,
478	* 13 and 15 set.	484	* 13 and 15 set.
479	*/	485	*/
480	void bitmap_remap(unsigned long dst, const unsigned long src,	486	void bitmap_remap(unsigned long dst, const unsigned long src,
481	const unsigned long old, const unsigned long new,	487	const unsigned long old, const unsigned long new,
482	int bits)	488	int bits)
483	{	489	{
484	int oldbit, w;	490	int oldbit, w;
485		491
486	if (dst == src) /* following doesn't handle inplace remaps */	492	if (dst == src) /* following doesn't handle inplace remaps */
487	return;	493	return;
488	bitmap_zero(dst, bits);	494	bitmap_zero(dst, bits);
489		495
490	w = bitmap_weight(new, bits);	496	w = bitmap_weight(new, bits);
491	for_each_set_bit(oldbit, src, bits) {	497	for_each_set_bit(oldbit, src, bits) {
492	int n = bitmap_pos_to_ord(old, oldbit, bits);	498	int n = bitmap_pos_to_ord(old, oldbit, bits);
493		499
494	if (n < 0 \|\| w == 0)	500	if (n < 0 \|\| w == 0)

Subversion Repositories Kolibri OS

(root)/drivers/ddk/linux/bitmap.c – Rev 5056 → 5270