// SPDX-License-Identifier: GPL-2.0-or-later/* Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. */ #include <net/devlink.h> #include "devl_internal.h" static LIST_HEAD(shd_list);static DEFINE_MUTEX(shd_mutex); /* Protects shd_list and shd->list */ /* This structure represents a shared devlink instance, * there is one created per identifier (e.g., serial number). */struct devlink_shd {	struct list_head list; /* Node in shd list */	const char *id; /* Identifier string (e.g., serial number) */	refcount_t refcount; /* Reference count */	size_t priv_size; /* Size of driver private data */	char priv[] __aligned(NETDEV_ALIGN) __counted_by(priv_size);}; static struct devlink_shd *devlink_shd_lookup(const char *id){	struct devlink_shd *shd; 	list_for_each_entry(shd, &shd_list, list) {		if (!strcmp(shd->id, id))			return shd;	} 	return NULL;} static struct devlink_shd *devlink_shd_create(const char *id,					      const struct devlink_ops *ops,					      size_t priv_size,					      const struct device_driver *driver){	struct devlink_shd *shd;	struct devlink *devlink; 	devlink = __devlink_alloc(ops, sizeof(struct devlink_shd) + priv_size,				  &init_net, NULL, driver);	if (!devlink)		return NULL;	shd = devlink_priv(devlink); 	shd->id = kstrdup(id, GFP_KERNEL);	if (!shd->id)		goto err_devlink_free;	shd->priv_size = priv_size;	refcount_set(&shd->refcount, 1); 	devl_lock(devlink);	devl_register(devlink);	devl_unlock(devlink); 	list_add_tail(&shd->list, &shd_list); 	return shd; err_devlink_free:	devlink_free(devlink);	return NULL;} static void devlink_shd_destroy(struct devlink_shd *shd){	struct devlink *devlink = priv_to_devlink(shd); 	list_del(&shd->list);	devl_lock(devlink);	devl_unregister(devlink);	devl_unlock(devlink);	kfree(shd->id);	devlink_free(devlink);} /** * devlink_shd_get - Get or create a shared devlink instance * @id: Identifier string (e.g., serial number) for the shared instance * @ops: Devlink operations structure * @priv_size: Size of private data structure * @driver: Driver associated with the shared devlink instance * * Get an existing shared devlink instance identified by @id, or create * a new one if it doesn't exist. Return the devlink instance with a * reference held. The caller must call devlink_shd_put() when done. * * All callers sharing the same @id must pass identical @ops, @priv_size * and @driver. A mismatch triggers a warning and returns NULL. * * Return: Pointer to the shared devlink instance on success, *         NULL on failure */struct devlink *devlink_shd_get(const char *id,				const struct devlink_ops *ops,				size_t priv_size,				const struct device_driver *driver){	struct devlink *devlink;	struct devlink_shd *shd; 	mutex_lock(&shd_mutex); 	shd = devlink_shd_lookup(id);	if (!shd) {		shd = devlink_shd_create(id, ops, priv_size, driver);		goto unlock;	} 	devlink = priv_to_devlink(shd);	if (WARN_ON_ONCE(devlink->ops != ops ||			 shd->priv_size != priv_size ||			 devlink->dev_driver != driver)) {		shd = NULL;		goto unlock;	}	refcount_inc(&shd->refcount); unlock:	mutex_unlock(&shd_mutex);	return shd ? priv_to_devlink(shd) : NULL;}EXPORT_SYMBOL_GPL(devlink_shd_get); /** * devlink_shd_put - Release a reference on a shared devlink instance * @devlink: Shared devlink instance * * Release a reference on a shared devlink instance obtained via * devlink_shd_get(). */void devlink_shd_put(struct devlink *devlink){	struct devlink_shd *shd; 	mutex_lock(&shd_mutex);	shd = devlink_priv(devlink);	if (refcount_dec_and_test(&shd->refcount))		devlink_shd_destroy(shd);	mutex_unlock(&shd_mutex);}EXPORT_SYMBOL_GPL(devlink_shd_put); /** * devlink_shd_get_priv - Get private data from shared devlink instance * @devlink: Devlink instance * * Returns a pointer to the driver's private data structure within * the shared devlink instance. * * Return: Pointer to private data */void *devlink_shd_get_priv(struct devlink *devlink){	struct devlink_shd *shd = devlink_priv(devlink); 	return shd->priv;}EXPORT_SYMBOL_GPL(devlink_shd_get_priv);