bitmap: introduce BITMAP_FROM_U64() (60ef6900) · Commits · 戴 / test

include/linux/bitmap.h

+32 −0

Original line number	Diff line number	Diff line
		@@ -360,6 +360,38 @@ static inline int bitmap_parse(const char *buf, unsigned int buflen,
		return __bitmap_parse(buf, buflen, 0, maskp, nmaskbits);
		}

		/*
		* BITMAP_FROM_U64() - Represent u64 value in the format suitable for bitmap.
		*
		* Linux bitmaps are internally arrays of unsigned longs, i.e. 32-bit
		* integers in 32-bit environment, and 64-bit integers in 64-bit one.
		*
		* There are four combinations of endianness and length of the word in linux
		* ABIs: LE64, BE64, LE32 and BE32.
		*
		* On 64-bit kernels 64-bit LE and BE numbers are naturally ordered in
		* bitmaps and therefore don't require any special handling.
		*
		* On 32-bit kernels 32-bit LE ABI orders lo word of 64-bit number in memory
		* prior to hi, and 32-bit BE orders hi word prior to lo. The bitmap on the
		* other hand is represented as an array of 32-bit words and the position of
		* bit N may therefore be calculated as: word #(N/32) and bit #(N%32) in that
		* word. For example, bit #42 is located at 10th position of 2nd word.
		* It matches 32-bit LE ABI, and we can simply let the compiler store 64-bit
		* values in memory as it usually does. But for BE we need to swap hi and lo
		* words manually.
		*
		* With all that, the macro BITMAP_FROM_U64() does explicit reordering of hi and
		* lo parts of u64. For LE32 it does nothing, and for BE environment it swaps
		* hi and lo words, as is expected by bitmap.
		*/
		#if __BITS_PER_LONG == 64
		#define BITMAP_FROM_U64(n) (n)
		#else
		#define BITMAP_FROM_U64(n) ((unsigned long) ((u64)(n) & ULONG_MAX)), \
		((unsigned long) ((u64)(n) >> 32))
		#endif

		/*
		* bitmap_from_u64 - Check and swap words within u64.
		* @mask: source bitmap

lib/test_bitmap.c

+32 −15

Original line number	Diff line number	Diff line
		@@ -175,24 +175,41 @@ struct test_bitmap_parselist{
		const int flags;
		};

		static const unsigned long exp[] = {1, 2, 0x0000ffff, 0xffff0000, 0x55555555,
		0xaaaaaaaa, 0x11111111, 0x22222222, 0xffffffff,
		0xfffffffe, 0x3333333311111111, 0xffffffff77777777};
		static const unsigned long exp2[] = {0x3333333311111111, 0xffffffff77777777};
		static const unsigned long exp[] __initconst = {
		BITMAP_FROM_U64(1),
		BITMAP_FROM_U64(2),
		BITMAP_FROM_U64(0x0000ffff),
		BITMAP_FROM_U64(0xffff0000),
		BITMAP_FROM_U64(0x55555555),
		BITMAP_FROM_U64(0xaaaaaaaa),
		BITMAP_FROM_U64(0x11111111),
		BITMAP_FROM_U64(0x22222222),
		BITMAP_FROM_U64(0xffffffff),
		BITMAP_FROM_U64(0xfffffffe),
		BITMAP_FROM_U64(0x3333333311111111),
		BITMAP_FROM_U64(0xffffffff77777777)
		};

		static const unsigned long exp2[] __initconst = {
		BITMAP_FROM_U64(0x3333333311111111),
		BITMAP_FROM_U64(0xffffffff77777777)
		};

		static const struct test_bitmap_parselist parselist_tests[] __initconst = {
		#define step (sizeof(u64) / sizeof(unsigned long))

		{0, "0", &exp[0], 8, 0},
		{0, "1", &exp[1], 8, 0},
		{0, "0-15", &exp[2], 32, 0},
		{0, "16-31", &exp[3], 32, 0},
		{0, "0-31:1/2", &exp[4], 32, 0},
		{0, "1-31:1/2", &exp[5], 32, 0},
		{0, "0-31:1/4", &exp[6], 32, 0},
		{0, "1-31:1/4", &exp[7], 32, 0},
		{0, "0-31:4/4", &exp[8], 32, 0},
		{0, "1-31:4/4", &exp[9], 32, 0},
		{0, "0-31:1/4,32-63:2/4", &exp[10], 64, 0},
		{0, "0-31:3/4,32-63:4/4", &exp[11], 64, 0},
		{0, "1", &exp[1 * step], 8, 0},
		{0, "0-15", &exp[2 * step], 32, 0},
		{0, "16-31", &exp[3 * step], 32, 0},
		{0, "0-31:1/2", &exp[4 * step], 32, 0},
		{0, "1-31:1/2", &exp[5 * step], 32, 0},
		{0, "0-31:1/4", &exp[6 * step], 32, 0},
		{0, "1-31:1/4", &exp[7 * step], 32, 0},
		{0, "0-31:4/4", &exp[8 * step], 32, 0},
		{0, "1-31:4/4", &exp[9 * step], 32, 0},
		{0, "0-31:1/4,32-63:2/4", &exp[10 * step], 64, 0},
		{0, "0-31:3/4,32-63:4/4", &exp[11 * step], 64, 0},

		{0, "0-31:1/4,32-63:2/4,64-95:3/4,96-127:4/4", exp2, 128, 0},

Admin message