@@ -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)
@@ -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);
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@intel.com> --- include/linux/bitmap.h | 22 ++++++++++++++- lib/bitmap.c | 63 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 84 insertions(+), 1 deletion(-)