[PATCH net-next 2/4] bitmap: add a couple more helpers to work with arrays of u64s

[Alexander Lobakin]

Add two new functions to work on arr64s:

* bitmap_arr64_size() - takes number of bits to be stored in arr64
  and returns number of bytes required to store such arr64, can be
  useful when allocating memory for arr64 containers;
* bitmap_validate_arr64{,_type}() - takes pointer to an arr64 and
  its size in bytes, plus expected number of bits and array
  Endianness. Ensures that the size is valid (must be a multiply
  of `sizeof(u64)`) and no bits past the number is set (for the
  specified byteorder).

Signed-off-by: Alexander Lobakin <alexandr.lobakin@xxxxxxxxx>
---
 include/linux/bitmap.h | 22 ++++++++++++++-
 lib/bitmap.c           | 63 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 1 deletion(-)

diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 95408d6e0f94..14add46e06e4 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -7,7 +7,8 @@
 #include <linux/align.h>
 #include <linux/bitops.h>
 #include <linux/find.h>
-#include <linux/limits.h>
+#include <linux/math.h>
+#include <linux/overflow.h>
 #include <linux/string.h>
 #include <linux/types.h>
 
@@ -76,6 +77,9 @@ struct device;
  *  bitmap_to_arr32(buf, src, nbits)            Copy nbits from buf to u32[] dst
  *  bitmap_to_arr64(buf, src, nbits)            Copy nbits from buf to u64[] dst
  *  bitmap_to_arr64_type(buf, src, nbits, type)  Copy nbits to {u,be,le}64[] dst
+ *  bitmap_validate_arr64_type(buf, len, nbits, type)  Validate {u,be,le}64[]
+ *  bitmap_validate_arr64(buf, len, nbits)      Validate u64[] buf of len bytes
+ *  bitmap_arr64_size(nbits)                    Get size of u64[] arr for nbits
  *  bitmap_get_value8(map, start)               Get 8bit value from map at start
  *  bitmap_set_value8(map, value, start)        Set 8bit value to map at start
  *
@@ -317,6 +321,8 @@ void __bitmap_from_arr64_type(unsigned long *bitmap, const void *buf,
 			      unsigned int nbits, u32 type);
 void __bitmap_to_arr64_type(void *arr, const unsigned long *buf,
 			    unsigned int nbits, u32 type);
+int bitmap_validate_arr64_type(const void *buf, size_t len, size_t nbits,
+			       u32 type);
 
 /*
  * On 64-bit systems bitmaps are represented as u64 arrays internally. On LE32
@@ -358,6 +364,20 @@ static __always_inline void bitmap_to_arr64_type(void *buf,
 	bitmap_from_arr64_type((bitmap), (buf), (nbits), BITMAP_ARR_U64)
 #define bitmap_to_arr64(buf, bitmap, nbits)				\
 	bitmap_to_arr64_type((buf), (bitmap), (nbits), BITMAP_ARR_U64)
+#define bitmap_validate_arr64(buf, len, nbits)				\
+	bitmap_validate_arr64_type((buf), (len), (nbits), BITMAP_ARR_U64)
+
+/**
+ * bitmap_arr64_size - determine the size of array of u64s for a number of bits
+ * @nbits: number of bits to store in the array
+ *
+ * Returns the size in bytes of a u64s-array needed to carry the specified
+ * number of bits.
+ */
+static inline size_t bitmap_arr64_size(size_t nbits)
+{
+	return array_size(BITS_TO_U64(nbits), sizeof(u64));
+}
 
 static inline bool bitmap_and(unsigned long *dst, const unsigned long *src1,
 			const unsigned long *src2, unsigned int nbits)
diff --git a/lib/bitmap.c b/lib/bitmap.c
index e660077f2099..5ad6f18f27dc 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -1613,3 +1613,66 @@ void __bitmap_to_arr64_type(void *buf, const unsigned long *bitmap,
 	}
 }
 EXPORT_SYMBOL(__bitmap_to_arr64_type);
+
+/**
+ * bitmap_validate_arr64_type - perform validation of a u64-array bitmap
+ * @buf: array of u64/__be64/__le64, the dest bitmap
+ * @len: length of the array, in bytes
+ * @nbits: expected/supported number of bits in the bitmap
+ * @type: expected array type (%BITMAP_*64)
+ *
+ * Returns 0 if the array passed the checks (see below), -%EINVAL otherwise.
+ */
+int bitmap_validate_arr64_type(const void *buf, size_t len, size_t nbits,
+			       u32 type)
+{
+	size_t word = (nbits - 1) / BITS_PER_TYPE(u64);
+	u32 pos = (nbits - 1) % BITS_PER_TYPE(u64);
+	const union {
+		__be64	be;
+		__le64	le;
+		u64	u;
+	} *arr = buf;
+	u64 last;
+
+	/* Must consist of 1...n full u64s */
+	if (!len || len % sizeof(u64))
+		return -EINVAL;
+
+	/*
+	 * If the array is shorter than expected, assume we support
+	 * all of the bits set there
+	 */
+	if (word >= len / sizeof(u64))
+		return 0;
+
+	switch (type) {
+#ifdef __LITTLE_ENDIAN
+	case BITMAP_ARR_BE64:
+		last = be64_to_cpu(arr[word].be);
+		break;
+#else
+	case BITMAP_ARR_LE64:
+		last = le64_to_cpu(arr[word].le);
+		break;
+#endif
+	default:
+		last = arr[word].u;
+		break;
+	}
+
+	/* Last word must not contain any bits past the expected number */
+	if (last & ~GENMASK_ULL(pos, 0))
+		return -EINVAL;
+
+	/*
+	 * If the array is longer than expected, make sure all the bytes
+	 * past the expected length are zeroed
+	 */
+	len -= bitmap_arr64_size(nbits);
+	if (len && memchr_inv(&arr[word + 1], 0, len))
+		return -EINVAL;
+
+	return 0;
+}
+EXPORT_SYMBOL(bitmap_validate_arr64_type);
-- 
2.36.1