| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <20220721155950.747251-3-alexandr.lobakin@intel.com>
Date: Thu, 21 Jul 2022 17:59:48 +0200
From: Alexander Lobakin <alexandr.lobakin@...el.com>
To: "David S. Miller" <davem@...emloft.net>,
Eric Dumazet <edumazet@...gle.com>,
Jakub Kicinski <kuba@...nel.org>,
Paolo Abeni <pabeni@...hat.com>
Cc: Alexander Lobakin <alexandr.lobakin@...el.com>,
Yury Norov <yury.norov@...il.com>,
Andy Shevchenko <andriy.shevchenko@...ux.intel.com>,
Michal Swiatkowski <michal.swiatkowski@...ux.intel.com>,
Rasmus Villemoes <linux@...musvillemoes.dk>,
Nikolay Aleksandrov <razor@...ckwall.org>,
netdev@...r.kernel.org, linux-kernel@...r.kernel.org
Subject: [PATCH net-next 2/4] bitmap: add a couple more helpers to work with arrays of u64s
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@...el.com>
---
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
Powered by blists - more mailing lists