mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-06 02:50:43 +00:00
![Greg Kroah-Hartman](/assets/img/avatar_default.png)
A local function to the driver core to determine if a bus really is registered with the kernel or not. To be used only by the driver core code, as part of the driver registration path as it's not really "safe" because the bus could be unregistered instantly after being called. Cc: "Rafael J. Wysocki" <rafael@kernel.org> Link: https://lore.kernel.org/r/20230208111330.439504-17-gregkh@linuxfoundation.org Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
276 lines
6.8 KiB
C
276 lines
6.8 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* driver.c - centralized device driver management
|
|
*
|
|
* Copyright (c) 2002-3 Patrick Mochel
|
|
* Copyright (c) 2002-3 Open Source Development Labs
|
|
* Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de>
|
|
* Copyright (c) 2007 Novell Inc.
|
|
*/
|
|
|
|
#include <linux/device/driver.h>
|
|
#include <linux/device.h>
|
|
#include <linux/module.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/string.h>
|
|
#include <linux/sysfs.h>
|
|
#include "base.h"
|
|
|
|
static struct device *next_device(struct klist_iter *i)
|
|
{
|
|
struct klist_node *n = klist_next(i);
|
|
struct device *dev = NULL;
|
|
struct device_private *dev_prv;
|
|
|
|
if (n) {
|
|
dev_prv = to_device_private_driver(n);
|
|
dev = dev_prv->device;
|
|
}
|
|
return dev;
|
|
}
|
|
|
|
/**
|
|
* driver_set_override() - Helper to set or clear driver override.
|
|
* @dev: Device to change
|
|
* @override: Address of string to change (e.g. &device->driver_override);
|
|
* The contents will be freed and hold newly allocated override.
|
|
* @s: NUL-terminated string, new driver name to force a match, pass empty
|
|
* string to clear it ("" or "\n", where the latter is only for sysfs
|
|
* interface).
|
|
* @len: length of @s
|
|
*
|
|
* Helper to set or clear driver override in a device, intended for the cases
|
|
* when the driver_override field is allocated by driver/bus code.
|
|
*
|
|
* Returns: 0 on success or a negative error code on failure.
|
|
*/
|
|
int driver_set_override(struct device *dev, const char **override,
|
|
const char *s, size_t len)
|
|
{
|
|
const char *new, *old;
|
|
char *cp;
|
|
|
|
if (!override || !s)
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* The stored value will be used in sysfs show callback (sysfs_emit()),
|
|
* which has a length limit of PAGE_SIZE and adds a trailing newline.
|
|
* Thus we can store one character less to avoid truncation during sysfs
|
|
* show.
|
|
*/
|
|
if (len >= (PAGE_SIZE - 1))
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* Compute the real length of the string in case userspace sends us a
|
|
* bunch of \0 characters like python likes to do.
|
|
*/
|
|
len = strlen(s);
|
|
|
|
if (!len) {
|
|
/* Empty string passed - clear override */
|
|
device_lock(dev);
|
|
old = *override;
|
|
*override = NULL;
|
|
device_unlock(dev);
|
|
kfree(old);
|
|
|
|
return 0;
|
|
}
|
|
|
|
cp = strnchr(s, len, '\n');
|
|
if (cp)
|
|
len = cp - s;
|
|
|
|
new = kstrndup(s, len, GFP_KERNEL);
|
|
if (!new)
|
|
return -ENOMEM;
|
|
|
|
device_lock(dev);
|
|
old = *override;
|
|
if (cp != s) {
|
|
*override = new;
|
|
} else {
|
|
/* "\n" passed - clear override */
|
|
kfree(new);
|
|
*override = NULL;
|
|
}
|
|
device_unlock(dev);
|
|
|
|
kfree(old);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(driver_set_override);
|
|
|
|
/**
|
|
* driver_for_each_device - Iterator for devices bound to a driver.
|
|
* @drv: Driver we're iterating.
|
|
* @start: Device to begin with
|
|
* @data: Data to pass to the callback.
|
|
* @fn: Function to call for each device.
|
|
*
|
|
* Iterate over the @drv's list of devices calling @fn for each one.
|
|
*/
|
|
int driver_for_each_device(struct device_driver *drv, struct device *start,
|
|
void *data, int (*fn)(struct device *, void *))
|
|
{
|
|
struct klist_iter i;
|
|
struct device *dev;
|
|
int error = 0;
|
|
|
|
if (!drv)
|
|
return -EINVAL;
|
|
|
|
klist_iter_init_node(&drv->p->klist_devices, &i,
|
|
start ? &start->p->knode_driver : NULL);
|
|
while (!error && (dev = next_device(&i)))
|
|
error = fn(dev, data);
|
|
klist_iter_exit(&i);
|
|
return error;
|
|
}
|
|
EXPORT_SYMBOL_GPL(driver_for_each_device);
|
|
|
|
/**
|
|
* driver_find_device - device iterator for locating a particular device.
|
|
* @drv: The device's driver
|
|
* @start: Device to begin with
|
|
* @data: Data to pass to match function
|
|
* @match: Callback function to check device
|
|
*
|
|
* This is similar to the driver_for_each_device() function above, but
|
|
* it returns a reference to a device that is 'found' for later use, as
|
|
* determined by the @match callback.
|
|
*
|
|
* The callback should return 0 if the device doesn't match and non-zero
|
|
* if it does. If the callback returns non-zero, this function will
|
|
* return to the caller and not iterate over any more devices.
|
|
*/
|
|
struct device *driver_find_device(struct device_driver *drv,
|
|
struct device *start, const void *data,
|
|
int (*match)(struct device *dev, const void *data))
|
|
{
|
|
struct klist_iter i;
|
|
struct device *dev;
|
|
|
|
if (!drv || !drv->p)
|
|
return NULL;
|
|
|
|
klist_iter_init_node(&drv->p->klist_devices, &i,
|
|
(start ? &start->p->knode_driver : NULL));
|
|
while ((dev = next_device(&i)))
|
|
if (match(dev, data) && get_device(dev))
|
|
break;
|
|
klist_iter_exit(&i);
|
|
return dev;
|
|
}
|
|
EXPORT_SYMBOL_GPL(driver_find_device);
|
|
|
|
/**
|
|
* driver_create_file - create sysfs file for driver.
|
|
* @drv: driver.
|
|
* @attr: driver attribute descriptor.
|
|
*/
|
|
int driver_create_file(struct device_driver *drv,
|
|
const struct driver_attribute *attr)
|
|
{
|
|
int error;
|
|
|
|
if (drv)
|
|
error = sysfs_create_file(&drv->p->kobj, &attr->attr);
|
|
else
|
|
error = -EINVAL;
|
|
return error;
|
|
}
|
|
EXPORT_SYMBOL_GPL(driver_create_file);
|
|
|
|
/**
|
|
* driver_remove_file - remove sysfs file for driver.
|
|
* @drv: driver.
|
|
* @attr: driver attribute descriptor.
|
|
*/
|
|
void driver_remove_file(struct device_driver *drv,
|
|
const struct driver_attribute *attr)
|
|
{
|
|
if (drv)
|
|
sysfs_remove_file(&drv->p->kobj, &attr->attr);
|
|
}
|
|
EXPORT_SYMBOL_GPL(driver_remove_file);
|
|
|
|
int driver_add_groups(struct device_driver *drv,
|
|
const struct attribute_group **groups)
|
|
{
|
|
return sysfs_create_groups(&drv->p->kobj, groups);
|
|
}
|
|
|
|
void driver_remove_groups(struct device_driver *drv,
|
|
const struct attribute_group **groups)
|
|
{
|
|
sysfs_remove_groups(&drv->p->kobj, groups);
|
|
}
|
|
|
|
/**
|
|
* driver_register - register driver with bus
|
|
* @drv: driver to register
|
|
*
|
|
* We pass off most of the work to the bus_add_driver() call,
|
|
* since most of the things we have to do deal with the bus
|
|
* structures.
|
|
*/
|
|
int driver_register(struct device_driver *drv)
|
|
{
|
|
int ret;
|
|
struct device_driver *other;
|
|
|
|
if (!bus_is_registered(drv->bus)) {
|
|
pr_err("Driver '%s' was unable to register with bus_type '%s' because the bus was not initialized.\n",
|
|
drv->name, drv->bus->name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ((drv->bus->probe && drv->probe) ||
|
|
(drv->bus->remove && drv->remove) ||
|
|
(drv->bus->shutdown && drv->shutdown))
|
|
pr_warn("Driver '%s' needs updating - please use "
|
|
"bus_type methods\n", drv->name);
|
|
|
|
other = driver_find(drv->name, drv->bus);
|
|
if (other) {
|
|
pr_err("Error: Driver '%s' is already registered, "
|
|
"aborting...\n", drv->name);
|
|
return -EBUSY;
|
|
}
|
|
|
|
ret = bus_add_driver(drv);
|
|
if (ret)
|
|
return ret;
|
|
ret = driver_add_groups(drv, drv->groups);
|
|
if (ret) {
|
|
bus_remove_driver(drv);
|
|
return ret;
|
|
}
|
|
kobject_uevent(&drv->p->kobj, KOBJ_ADD);
|
|
deferred_probe_extend_timeout();
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(driver_register);
|
|
|
|
/**
|
|
* driver_unregister - remove driver from system.
|
|
* @drv: driver.
|
|
*
|
|
* Again, we pass off most of the work to the bus-level call.
|
|
*/
|
|
void driver_unregister(struct device_driver *drv)
|
|
{
|
|
if (!drv || !drv->p) {
|
|
WARN(1, "Unexpected driver unregister!\n");
|
|
return;
|
|
}
|
|
driver_remove_groups(drv, drv->groups);
|
|
bus_remove_driver(drv);
|
|
}
|
|
EXPORT_SYMBOL_GPL(driver_unregister);
|