From 4617721c502b2ddaa4e324e86da4997edf738fa5 Mon Sep 17 00:00:00 2001 From: Steven Rostedt Date: Wed, 2 Sep 2026 09:55:01 -0400 Subject: ftrace: Synchronize the initialization of ftrace_ops There's some internal state that ftrace_ops needs to have set, but since it can be declared outside of the ftrace.c code, it calls ftrace_ops_init() on the ops in every global function. The issue is that if two tasks call it on the same ops at the same time it is possible to have the initialization of one corrupt the initialization of the other call. Create a ops_mutex to use to synchronize every initialization of the ftrace_ops. The mutex is taken within checking the ftrace_ops flag that states it was initializied but the flag is checked again after the mutex has been taken. Checking first outside the mutex allows it to shortcut having to take the mutex. But then the check needs to be done again after the mute is taken in case of races. Cc: stable@vger.kernel.org Link: https://patch.msgid.link/20260902095501.6b59af20@gandalf.local.home Fixes: f04f24fb7e48d ("ftrace, kprobes: Fix a deadlock on ftrace_regex_lock") Reported-by: sashiko-bot@kernel.org Close: https://lore.kernel.org/all/20260829025528.49A831F000E9@smtp.kernel.org/ Signed-off-by: Steven Rostedt --- drivers/pnp/driver.c | 341 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 341 insertions(+) create mode 100644 drivers/pnp/driver.c (limited to 'drivers/pnp/driver.c') diff --git a/drivers/pnp/driver.c b/drivers/pnp/driver.c new file mode 100644 index 000000000..6d58b1465 --- /dev/null +++ b/drivers/pnp/driver.c @@ -0,0 +1,341 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * driver.c - device id matching, driver model, etc. + * + * Copyright 2002 Adam Belay + */ + +#include +#include +#include +#include +#include +#include +#include "base.h" + +static int compare_func(const char *ida, const char *idb) +{ + int i; + + /* we only need to compare the last 4 chars */ + for (i = 3; i < 7; i++) { + if (ida[i] != 'X' && + idb[i] != 'X' && toupper(ida[i]) != toupper(idb[i])) + return 0; + } + return 1; +} + +int compare_pnp_id(struct pnp_id *pos, const char *id) +{ + if (!pos || !id || (strlen(id) != 7)) + return 0; + if (memcmp(id, "ANYDEVS", 7) == 0) + return 1; + while (pos) { + if (memcmp(pos->id, id, 3) == 0) + if (compare_func(pos->id, id) == 1) + return 1; + pos = pos->next; + } + return 0; +} + +static const struct pnp_device_id *match_device(const struct pnp_driver *drv, + struct pnp_dev *dev) +{ + const struct pnp_device_id *drv_id = drv->id_table; + + if (!drv_id) + return NULL; + + while (*drv_id->id) { + if (compare_pnp_id(dev->id, drv_id->id)) + return drv_id; + drv_id++; + } + return NULL; +} + +int pnp_device_attach(struct pnp_dev *pnp_dev) +{ + mutex_lock(&pnp_lock); + if (pnp_dev->status != PNP_READY) { + mutex_unlock(&pnp_lock); + return -EBUSY; + } + pnp_dev->status = PNP_ATTACHED; + mutex_unlock(&pnp_lock); + return 0; +} +EXPORT_SYMBOL(pnp_device_attach); + +void pnp_device_detach(struct pnp_dev *pnp_dev) +{ + mutex_lock(&pnp_lock); + if (pnp_dev->status == PNP_ATTACHED) + pnp_dev->status = PNP_READY; + mutex_unlock(&pnp_lock); +} +EXPORT_SYMBOL(pnp_device_detach); + +static int pnp_device_probe(struct device *dev) +{ + int error; + struct pnp_driver *pnp_drv; + struct pnp_dev *pnp_dev; + const struct pnp_device_id *dev_id = NULL; + pnp_dev = to_pnp_dev(dev); + pnp_drv = to_pnp_driver(dev->driver); + + error = pnp_device_attach(pnp_dev); + if (error < 0) + return error; + + if (pnp_dev->active == 0) { + if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE)) { + error = pnp_activate_dev(pnp_dev); + if (error < 0) + return error; + } + } else if ((pnp_drv->flags & PNP_DRIVER_RES_DISABLE) + == PNP_DRIVER_RES_DISABLE) { + error = pnp_disable_dev(pnp_dev); + if (error < 0) + return error; + } + error = 0; + if (pnp_drv->probe) { + dev_id = match_device(pnp_drv, pnp_dev); + if (dev_id != NULL) + error = pnp_drv->probe(pnp_dev, dev_id); + } + if (error >= 0) { + pnp_dev->driver = pnp_drv; + error = 0; + } else + goto fail; + + return error; + +fail: + pnp_device_detach(pnp_dev); + return error; +} + +static void pnp_device_remove(struct device *dev) +{ + struct pnp_dev *pnp_dev = to_pnp_dev(dev); + struct pnp_driver *drv = pnp_dev->driver; + + if (drv) { + if (drv->remove) + drv->remove(pnp_dev); + pnp_dev->driver = NULL; + } + + if (pnp_dev->active && + (!drv || !(drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE))) + pnp_disable_dev(pnp_dev); + + pnp_device_detach(pnp_dev); +} + +static void pnp_device_shutdown(struct device *dev) +{ + struct pnp_dev *pnp_dev = to_pnp_dev(dev); + struct pnp_driver *drv = pnp_dev->driver; + + if (drv && drv->shutdown) + drv->shutdown(pnp_dev); +} + +static int pnp_uevent(const struct device *dev, struct kobj_uevent_env *env) +{ + struct pnp_id *pos; + const struct pnp_dev *pnp_dev = to_pnp_dev(dev); + + if (!dev) + return -ENODEV; + + pos = pnp_dev->id; + while (pos) { + if (add_uevent_var(env, "MODALIAS=pnp:d%s", pos->id)) + return -ENOMEM; + pos = pos->next; + } + + return 0; +} + +static int pnp_bus_match(struct device *dev, const struct device_driver *drv) +{ + struct pnp_dev *pnp_dev = to_pnp_dev(dev); + const struct pnp_driver *pnp_drv = to_pnp_driver(drv); + + if (match_device(pnp_drv, pnp_dev) == NULL) + return 0; + return 1; +} + +static int __pnp_bus_suspend(struct device *dev, pm_message_t state) +{ + struct pnp_dev *pnp_dev = to_pnp_dev(dev); + struct pnp_driver *pnp_drv = pnp_dev->driver; + int error; + + if (!pnp_drv) + return 0; + + if (pnp_drv->driver.pm && pnp_drv->driver.pm->suspend) { + error = pnp_drv->driver.pm->suspend(dev); + suspend_report_result(dev, pnp_drv->driver.pm->suspend, error); + if (error) + return error; + } + + if (pnp_drv->suspend) { + error = pnp_drv->suspend(pnp_dev, state); + if (error) + return error; + } + + /* can_write is necessary to be able to re-start the device on resume */ + if (pnp_can_disable(pnp_dev) && pnp_can_write(pnp_dev)) { + error = pnp_stop_dev(pnp_dev); + if (error) + return error; + } + + if (pnp_can_suspend(pnp_dev)) + pnp_dev->protocol->suspend(pnp_dev, state); + return 0; +} + +static int pnp_bus_suspend(struct device *dev) +{ + return __pnp_bus_suspend(dev, PMSG_SUSPEND); +} + +static int pnp_bus_freeze(struct device *dev) +{ + return __pnp_bus_suspend(dev, PMSG_FREEZE); +} + +static int pnp_bus_poweroff(struct device *dev) +{ + return __pnp_bus_suspend(dev, PMSG_HIBERNATE); +} + +static int pnp_bus_resume(struct device *dev) +{ + struct pnp_dev *pnp_dev = to_pnp_dev(dev); + struct pnp_driver *pnp_drv = pnp_dev->driver; + int error; + + if (!pnp_drv) + return 0; + + if (pnp_dev->protocol->resume) { + error = pnp_dev->protocol->resume(pnp_dev); + if (error) + return error; + } + + if (pnp_can_write(pnp_dev)) { + error = pnp_start_dev(pnp_dev); + if (error) + return error; + } + + if (pnp_drv->driver.pm && pnp_drv->driver.pm->resume) { + error = pnp_drv->driver.pm->resume(dev); + if (error) + return error; + } + + if (pnp_drv->resume) { + error = pnp_drv->resume(pnp_dev); + if (error) + return error; + } + + return 0; +} + +static const struct dev_pm_ops pnp_bus_dev_pm_ops = { + /* Suspend callbacks */ + .suspend = pnp_bus_suspend, + .resume = pnp_bus_resume, + /* Hibernate callbacks */ + .freeze = pnp_bus_freeze, + .thaw = pnp_bus_resume, + .poweroff = pnp_bus_poweroff, + .restore = pnp_bus_resume, +}; + +const struct bus_type pnp_bus_type = { + .name = "pnp", + .match = pnp_bus_match, + .uevent = pnp_uevent, + .probe = pnp_device_probe, + .remove = pnp_device_remove, + .shutdown = pnp_device_shutdown, + .pm = &pnp_bus_dev_pm_ops, + .dev_groups = pnp_dev_groups, +}; + +bool dev_is_pnp(const struct device *dev) +{ + return dev->bus == &pnp_bus_type; +} +EXPORT_SYMBOL_GPL(dev_is_pnp); + +int pnp_register_driver(struct pnp_driver *drv) +{ + drv->driver.name = drv->name; + drv->driver.bus = &pnp_bus_type; + + return driver_register(&drv->driver); +} +EXPORT_SYMBOL(pnp_register_driver); + +void pnp_unregister_driver(struct pnp_driver *drv) +{ + driver_unregister(&drv->driver); +} +EXPORT_SYMBOL(pnp_unregister_driver); + +/** + * pnp_add_id - adds an EISA id to the specified device + * @dev: pointer to the desired device + * @id: pointer to an EISA id string + */ +struct pnp_id *pnp_add_id(struct pnp_dev *dev, const char *id) +{ + struct pnp_id *dev_id, *ptr; + + dev_id = kzalloc_obj(struct pnp_id); + if (!dev_id) + return NULL; + + dev_id->id[0] = id[0]; + dev_id->id[1] = id[1]; + dev_id->id[2] = id[2]; + dev_id->id[3] = tolower(id[3]); + dev_id->id[4] = tolower(id[4]); + dev_id->id[5] = tolower(id[5]); + dev_id->id[6] = tolower(id[6]); + dev_id->id[7] = '\0'; + + dev_id->next = NULL; + ptr = dev->id; + while (ptr && ptr->next) + ptr = ptr->next; + if (ptr) + ptr->next = dev_id; + else + dev->id = dev_id; + + return dev_id; +} -- cgit v1.3.1