Migrate the minor number allocation from the legacy IDR API to the modern XArray API to take advantage of its built-in thread safety.
As part of this migration, the global `table_lock` mutex has been removed. Mutating operations now rely on XArray's internal spinlocks, and the lookup logic in get_gb_by_minor() has been updated to use rcu_read_lock() combined with kref_get_unless_zero() to safely pin the device reference without blocking.
Signed-off-by: Aviv Levinson levinson.aviv@gmail.com --- drivers/staging/greybus/uart.c | 37 ++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 17 deletions(-)
diff --git a/drivers/staging/greybus/uart.c b/drivers/staging/greybus/uart.c index e1b73db6a17c..2b1a5d4671dd 100644 --- a/drivers/staging/greybus/uart.c +++ b/drivers/staging/greybus/uart.c @@ -22,7 +22,7 @@ #include <linux/serial.h> #include <linux/tty_driver.h> #include <linux/tty_flip.h> -#include <linux/idr.h> +#include <linux/xarray.h> #include <linux/fs.h> #include <linux/kdev_t.h> #include <linux/kfifo.h> @@ -66,8 +66,7 @@ struct gb_tty { };
static struct tty_driver *gb_tty_driver; -static DEFINE_IDR(tty_minors); -static DEFINE_MUTEX(table_lock); +static DEFINE_XARRAY_ALLOC(tty_minors);
static int gb_uart_receive_data_handler(struct gb_operation *op) { @@ -340,31 +339,37 @@ static struct gb_tty *get_gb_by_minor(unsigned int minor) { struct gb_tty *gb_tty;
- mutex_lock(&table_lock); - gb_tty = idr_find(&tty_minors, minor); + rcu_read_lock(); + gb_tty = xa_load(&tty_minors, minor); + if (gb_tty) { + if (!kref_get_unless_zero(&gb_tty->port.kref)) + gb_tty = NULL; + } + rcu_read_unlock(); + if (gb_tty) { mutex_lock(&gb_tty->mutex); if (gb_tty->disconnected) { mutex_unlock(&gb_tty->mutex); + tty_port_put(&gb_tty->port); gb_tty = NULL; } else { - tty_port_get(&gb_tty->port); mutex_unlock(&gb_tty->mutex); } } - mutex_unlock(&table_lock); + return gb_tty; }
static int alloc_minor(struct gb_tty *gb_tty) { - int minor; + unsigned int minor; + int ret;
- mutex_lock(&table_lock); - minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL); - mutex_unlock(&table_lock); - if (minor >= 0) - gb_tty->minor = minor; + ret = xa_alloc(&tty_minors, &minor, gb_tty, XA_LIMIT(0, GB_NUM_MINORS - 1), GFP_KERNEL); + if (ret) + return ret; + gb_tty->minor = minor; return minor; }
@@ -373,9 +378,7 @@ static void release_minor(struct gb_tty *gb_tty) int minor = gb_tty->minor;
gb_tty->minor = 0; /* Maybe should use an invalid value instead */ - mutex_lock(&table_lock); - idr_remove(&tty_minors, minor); - mutex_unlock(&table_lock); + xa_erase(&tty_minors, minor); }
static int gb_tty_install(struct tty_driver *driver, struct tty_struct *tty) @@ -991,7 +994,7 @@ static void gb_tty_exit(void) { tty_unregister_driver(gb_tty_driver); tty_driver_kref_put(gb_tty_driver); - idr_destroy(&tty_minors); + xa_destroy(&tty_minors); }
static const struct gbphy_device_id gb_uart_id_table[] = {
On Wed, Nov 11, 2026 at 08:23:30PM +0200, Aviv Levinson wrote:
Migrate the minor number allocation from the legacy IDR API to the modern XArray API to take advantage of its built-in thread safety.
But why?
As part of this migration, the global `table_lock` mutex has been removed. Mutating operations now rely on XArray's internal spinlocks, and the lookup logic in get_gb_by_minor() has been updated to use rcu_read_lock() combined with kref_get_unless_zero() to safely pin the device reference without blocking.
How was this found and generated and tested?
And kref_get_unless_zero() is almost always a call you never want to make.
Signed-off-by: Aviv Levinson levinson.aviv@gmail.com
drivers/staging/greybus/uart.c | 37 ++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 17 deletions(-)
So now there is more code? That feels like a step backwards, don't you think?
thanks,
greg k-h
Hi Greg, Thank you for the review.
I am looking to start contributing to the kernel and thought drivers/staging/ was a good place to start. I used the checkpatch.pl tool that flagged the use of the deprecated IDR.
I wrote the patch manually and it was only compile tested.
I understand that the use of kref_get_unless_zero() is not a good practice, so checked current drivers that implement the use of XArray (drivers/gpu/drm/drm_drv.c) and tried using similar methods that I am sending in the v2 patch.
בתאריך יום ה׳, 12 בנוב׳ 2026 ב-14:37 מאת Greg KH <gregkh@linuxfoundation.org>:
On Wed, Nov 11, 2026 at 08:23:30PM +0200, Aviv Levinson wrote:
Migrate the minor number allocation from the legacy IDR API to the modern XArray API to take advantage of its built-in thread safety.
But why?
As part of this migration, the global `table_lock` mutex has been removed. Mutating operations now rely on XArray's internal spinlocks, and the lookup logic in get_gb_by_minor() has been updated to use rcu_read_lock() combined with kref_get_unless_zero() to safely pin the device reference without blocking.
How was this found and generated and tested?
And kref_get_unless_zero() is almost always a call you never want to make.
Signed-off-by: Aviv Levinson levinson.aviv@gmail.com
drivers/staging/greybus/uart.c | 37 ++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 17 deletions(-)
So now there is more code? That feels like a step backwards, don't you think?
thanks,
greg k-h
The legacy IDR API is deprecated in favor of the modern XArray API. Convert the tty_minors IDR to an XArray.
To prevent locking the entire gb_tty object while loading the minor, switch IDR to XArray and use the internal XArray's spinlock (xa_lock). To respect TTY encapsulation, use tty_port_get() instead of direct kref_get_unless_zero().
Signed-off-by: Aviv Levinson levinson.aviv@gmail.com --- drivers/staging/greybus/uart.c | 27 ++++++++++++--------------- 1 file changed, 12 insertions(+), 15 deletions(-)
diff --git a/drivers/staging/greybus/uart.c b/drivers/staging/greybus/uart.c index 2b1a5d4671dd..054bdc232942 100644 --- a/drivers/staging/greybus/uart.c +++ b/drivers/staging/greybus/uart.c @@ -339,24 +339,21 @@ static struct gb_tty *get_gb_by_minor(unsigned int minor) { struct gb_tty *gb_tty;
- rcu_read_lock(); + xa_lock(&tty_minors); gb_tty = xa_load(&tty_minors, minor); - if (gb_tty) { - if (!kref_get_unless_zero(&gb_tty->port.kref)) - gb_tty = NULL; - } - rcu_read_unlock(); + if (gb_tty) + tty_port_get(&gb_tty->port); + xa_unlock(&tty_minors);
- if (gb_tty) { - mutex_lock(&gb_tty->mutex); - if (gb_tty->disconnected) { - mutex_unlock(&gb_tty->mutex); - tty_port_put(&gb_tty->port); - gb_tty = NULL; - } else { - mutex_unlock(&gb_tty->mutex); - } + if (!gb_tty) + return NULL; + mutex_lock(&gb_tty->mutex); + if (gb_tty->disconnected) { + mutex_unlock(&gb_tty->mutex); + tty_port_put(&gb_tty->port); + return NULL; } + mutex_unlock(&gb_tty->mutex);
return gb_tty; }