KekenoBSD/src
3
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

linuxkpi: Add struct xa_limit support to xarray

Browse Source 
The `xa_alloc*()` functions family takes a `struct xa_limit` to describe
the range of IDs the caller wants to allocate. We were using a single
mask to qualify a maximum ID only.

This commit changes that to use the same `struct xa_limit`. The logic
did not change, except it now supports a minimum ID as well.

The definition of `XA_LIMIT()` macro is adapted, as well as the
definitions of `xa_limit_*` (only `xa_limit_32b` existed, the other two
are added with this commit).

The DRM generic code started to use this `struct xa_limit` in Linux
6.12.

Reviewed by:	bz
Sponsored by:	The FreeBSD Foundation
Differential Revision: https://reviews.freebsd.org/D56445
This commit is contained in:
Jean-Sébastien Pédron
2026-04-13 23:39:22 +02:00
parent b683fd0b32
commit 783d018cf9
2 changed files with 34 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sys/compat/linuxkpi/common/include/linux/xarray.h
+16 -10
View File
@@ -34,9 +34,6 @@
#include <sys/lock.h>
#include <sys/mutex.h>
#define XA_LIMIT(min, max) \
({ CTASSERT((min) == 0); (uint32_t)(max); })
#define XA_FLAGS_ALLOC (1U << 0)
#define XA_FLAGS_LOCK_IRQ (1U << 1)
#define XA_FLAGS_ALLOC1 (1U << 2)
@@ -47,8 +44,6 @@
#define xa_is_err(x) \
IS_ERR(x)
#define xa_limit_32b XA_LIMIT(0, 0xFFFFFFFF)
#define XA_ASSERT_LOCKED(xa) mtx_assert(&(xa)->xa_lock, MA_OWNED)
#define xa_lock(xa) mtx_lock(&(xa)->xa_lock)
#define xa_unlock(xa) mtx_unlock(&(xa)->xa_lock)
@@ -59,15 +54,26 @@ struct xarray {
uint32_t xa_flags; /* see XA_FLAGS_XXX */
};
struct xa_limit {
uint32_t max;
uint32_t min;
};
#define XA_LIMIT(min_, max_) (struct xa_limit){ .min = (min_), .max = (max_) }
#define xa_limit_16b XA_LIMIT(0, USHRT_MAX)
#define xa_limit_31b XA_LIMIT(0, INT_MAX)
#define xa_limit_32b XA_LIMIT(0, UINT_MAX)
/*
* Extensible arrays API implemented as a wrapper
* around the radix tree implementation.
*/
void *xa_erase(struct xarray *, uint32_t);
void *xa_load(struct xarray *, uint32_t);
int xa_alloc(struct xarray *, uint32_t *, void *, uint32_t, gfp_t);
int xa_alloc_cyclic(struct xarray *, uint32_t *, void *, uint32_t, uint32_t *, gfp_t);
int xa_alloc_cyclic_irq(struct xarray *, uint32_t *, void *, uint32_t, uint32_t *, gfp_t);
int xa_alloc(struct xarray *, uint32_t *, void *, struct xa_limit, gfp_t);
int xa_alloc_cyclic(struct xarray *, uint32_t *, void *, struct xa_limit, uint32_t *, gfp_t);
int xa_alloc_cyclic_irq(struct xarray *, uint32_t *, void *, struct xa_limit, uint32_t *, gfp_t);
int xa_insert(struct xarray *, uint32_t, void *, gfp_t);
void *xa_store(struct xarray *, uint32_t, void *, gfp_t);
void xa_init_flags(struct xarray *, uint32_t);
@@ -83,8 +89,8 @@ void *xa_next(struct xarray *, unsigned long *, bool);
* Unlocked version of functions above.
*/
void *__xa_erase(struct xarray *, uint32_t);
int __xa_alloc(struct xarray *, uint32_t *, void *, uint32_t, gfp_t);
int __xa_alloc_cyclic(struct xarray *, uint32_t *, void *, uint32_t, uint32_t *, gfp_t);
int __xa_alloc(struct xarray *, uint32_t *, void *, struct xa_limit, gfp_t);
int __xa_alloc_cyclic(struct xarray *, uint32_t *, void *, struct xa_limit, uint32_t *, gfp_t);
int __xa_insert(struct xarray *, uint32_t, void *, gfp_t);
void *__xa_store(struct xarray *, uint32_t, void *, gfp_t);
bool __xa_empty(struct xarray *);
sys/compat/linuxkpi/common/src/linux_xarray.c
+18 -23
View File
@@ -115,19 +115,16 @@ xa_vm_wait_locked(struct xarray *xa)
* available to complete the radix tree insertion.
*/
int
__xa_alloc(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask, gfp_t gfp)
__xa_alloc(struct xarray *xa, uint32_t *pindex, void *ptr, struct xa_limit limit, gfp_t gfp)
{
int retval;
XA_ASSERT_LOCKED(xa);
/* mask should allow to allocate at least one item */
MPASS(mask > ((xa->xa_flags & XA_FLAGS_ALLOC1) != 0 ? 1 : 0));
/* mask can be any power of two value minus one */
MPASS((mask & (mask + 1)) == 0);
MPASS(limit.max > limit.min);
*pindex = (xa->xa_flags & XA_FLAGS_ALLOC1) != 0 ? 1 : 0;
*pindex = MAX(*pindex, limit.min);
if (ptr == NULL)
ptr = NULL_VALUE;
retry:
@@ -135,7 +132,7 @@ __xa_alloc(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask, gfp_t
switch (retval) {
case -EEXIST:
if (likely(*pindex != mask)) {
if (likely(*pindex < limit.max)) {
(*pindex)++;
goto retry;
}
@@ -154,7 +151,7 @@ __xa_alloc(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask, gfp_t
}
int
xa_alloc(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask, gfp_t gfp)
xa_alloc(struct xarray *xa, uint32_t *pindex, void *ptr, struct xa_limit limit, gfp_t gfp)
{
int retval;
@@ -162,7 +159,7 @@ xa_alloc(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask, gfp_t gf
ptr = NULL_VALUE;
xa_lock(xa);
retval = __xa_alloc(xa, pindex, ptr, mask, gfp);
retval = __xa_alloc(xa, pindex, ptr, limit, gfp);
xa_unlock(xa);
return (retval);
@@ -175,7 +172,7 @@ xa_alloc(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask, gfp_t gf
* beginning of the array. If the xarray is full -ENOMEM is returned.
*/
int
__xa_alloc_cyclic(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask,
__xa_alloc_cyclic(struct xarray *xa, uint32_t *pindex, void *ptr, struct xa_limit limit,
uint32_t *pnext_index, gfp_t gfp)
{
int retval;
@@ -183,13 +180,10 @@ __xa_alloc_cyclic(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask,
XA_ASSERT_LOCKED(xa);
/* mask should allow to allocate at least one item */
MPASS(mask > ((xa->xa_flags & XA_FLAGS_ALLOC1) != 0 ? 1 : 0));
/* mask can be any power of two value minus one */
MPASS((mask & (mask + 1)) == 0);
MPASS(limit.max > limit.min);
*pnext_index = (xa->xa_flags & XA_FLAGS_ALLOC1) != 0 ? 1 : 0;
*pnext_index = MAX(*pnext_index, limit.min);
if (ptr == NULL)
ptr = NULL_VALUE;
retry:
@@ -197,14 +191,15 @@ __xa_alloc_cyclic(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask,
switch (retval) {
case -EEXIST:
if (unlikely(*pnext_index == mask) && !timeout--) {
if (unlikely(*pnext_index == limit.max) && !timeout--) {
retval = -ENOMEM;
break;
}
(*pnext_index)++;
(*pnext_index) &= mask;
if (*pnext_index == 0 && (xa->xa_flags & XA_FLAGS_ALLOC1) != 0)
(*pnext_index)++;
if (*pnext_index > limit.max) {
*pnext_index = (xa->xa_flags & XA_FLAGS_ALLOC1) != 0 ? 1 : 0;
*pnext_index = MAX(*pnext_index, limit.min);
}
goto retry;
case -ENOMEM:
if (likely(gfp & M_WAITOK)) {
@@ -221,13 +216,13 @@ __xa_alloc_cyclic(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask,
}
int
xa_alloc_cyclic(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask,
xa_alloc_cyclic(struct xarray *xa, uint32_t *pindex, void *ptr, struct xa_limit limit,
uint32_t *pnext_index, gfp_t gfp)
{
int retval;
xa_lock(xa);
retval = __xa_alloc_cyclic(xa, pindex, ptr, mask, pnext_index, gfp);
retval = __xa_alloc_cyclic(xa, pindex, ptr, limit, pnext_index, gfp);
xa_unlock(xa);
return (retval);
@@ -235,12 +230,12 @@ xa_alloc_cyclic(struct xarray *xa, uint32_t *pindex, void *ptr, uint32_t mask,
int
xa_alloc_cyclic_irq(struct xarray *xa, uint32_t *pindex, void *ptr,
uint32_t mask, uint32_t *pnext_index, gfp_t gfp)
struct xa_limit limit, uint32_t *pnext_index, gfp_t gfp)
{
int retval;
xa_lock_irq(xa);
retval = __xa_alloc_cyclic(xa, pindex, ptr, mask, pnext_index, gfp);
retval = __xa_alloc_cyclic(xa, pindex, ptr, limit, pnext_index, gfp);
xa_unlock_irq(xa);
return (retval);