mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-11 13:04:03 +08:00
5e6a0e0527
There is no mutex protection of these state checking for 'stop' and 'detach' which can't guarantee there is no another instance is trying to do same operation. Consider two instances case: Instance1: echo stop > /sys/class/remoteproc/remoteproc0/state Instance2: echo stop > /sys/class/remoteproc/remoteproc0/state The issue is that the instance2 case may success, Or it may fail with -EINVAL, which is uncertain. So move this state checking in rproc_cdev_write() and state_store() for 'stop', 'detach' operation to 'rproc_shutdown' , 'rproc_detach' function under the mutex protection. Signed-off-by: Shengjiu Wang <shengjiu.wang@nxp.com> Link: https://lore.kernel.org/r/1648434012-16655-3-git-send-email-shengjiu.wang@nxp.com Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
276 lines
7.8 KiB
C
276 lines
7.8 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Remote Processor Framework
|
|
*/
|
|
|
|
#include <linux/remoteproc.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "remoteproc_internal.h"
|
|
|
|
#define to_rproc(d) container_of(d, struct rproc, dev)
|
|
|
|
static ssize_t recovery_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct rproc *rproc = to_rproc(dev);
|
|
|
|
return sysfs_emit(buf, "%s", rproc->recovery_disabled ? "disabled\n" : "enabled\n");
|
|
}
|
|
|
|
/*
|
|
* By writing to the 'recovery' sysfs entry, we control the behavior of the
|
|
* recovery mechanism dynamically. The default value of this entry is "enabled".
|
|
*
|
|
* The 'recovery' sysfs entry supports these commands:
|
|
*
|
|
* enabled: When enabled, the remote processor will be automatically
|
|
* recovered whenever it crashes. Moreover, if the remote
|
|
* processor crashes while recovery is disabled, it will
|
|
* be automatically recovered too as soon as recovery is enabled.
|
|
*
|
|
* disabled: When disabled, a remote processor will remain in a crashed
|
|
* state if it crashes. This is useful for debugging purposes;
|
|
* without it, debugging a crash is substantially harder.
|
|
*
|
|
* recover: This function will trigger an immediate recovery if the
|
|
* remote processor is in a crashed state, without changing
|
|
* or checking the recovery state (enabled/disabled).
|
|
* This is useful during debugging sessions, when one expects
|
|
* additional crashes to happen after enabling recovery. In this
|
|
* case, enabling recovery will make it hard to debug subsequent
|
|
* crashes, so it's recommended to keep recovery disabled, and
|
|
* instead use the "recover" command as needed.
|
|
*/
|
|
static ssize_t recovery_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct rproc *rproc = to_rproc(dev);
|
|
|
|
if (sysfs_streq(buf, "enabled")) {
|
|
/* change the flag and begin the recovery process if needed */
|
|
rproc->recovery_disabled = false;
|
|
rproc_trigger_recovery(rproc);
|
|
} else if (sysfs_streq(buf, "disabled")) {
|
|
rproc->recovery_disabled = true;
|
|
} else if (sysfs_streq(buf, "recover")) {
|
|
/* begin the recovery process without changing the flag */
|
|
rproc_trigger_recovery(rproc);
|
|
} else {
|
|
return -EINVAL;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
static DEVICE_ATTR_RW(recovery);
|
|
|
|
/*
|
|
* A coredump-configuration-to-string lookup table, for exposing a
|
|
* human readable configuration via sysfs. Always keep in sync with
|
|
* enum rproc_coredump_mechanism
|
|
*/
|
|
static const char * const rproc_coredump_str[] = {
|
|
[RPROC_COREDUMP_DISABLED] = "disabled",
|
|
[RPROC_COREDUMP_ENABLED] = "enabled",
|
|
[RPROC_COREDUMP_INLINE] = "inline",
|
|
};
|
|
|
|
/* Expose the current coredump configuration via debugfs */
|
|
static ssize_t coredump_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct rproc *rproc = to_rproc(dev);
|
|
|
|
return sysfs_emit(buf, "%s\n", rproc_coredump_str[rproc->dump_conf]);
|
|
}
|
|
|
|
/*
|
|
* By writing to the 'coredump' sysfs entry, we control the behavior of the
|
|
* coredump mechanism dynamically. The default value of this entry is "default".
|
|
*
|
|
* The 'coredump' sysfs entry supports these commands:
|
|
*
|
|
* disabled: This is the default coredump mechanism. Recovery will proceed
|
|
* without collecting any dump.
|
|
*
|
|
* default: When the remoteproc crashes the entire coredump will be
|
|
* copied to a separate buffer and exposed to userspace.
|
|
*
|
|
* inline: The coredump will not be copied to a separate buffer and the
|
|
* recovery process will have to wait until data is read by
|
|
* userspace. But this avoid usage of extra memory.
|
|
*/
|
|
static ssize_t coredump_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct rproc *rproc = to_rproc(dev);
|
|
|
|
if (rproc->state == RPROC_CRASHED) {
|
|
dev_err(&rproc->dev, "can't change coredump configuration\n");
|
|
return -EBUSY;
|
|
}
|
|
|
|
if (sysfs_streq(buf, "disabled")) {
|
|
rproc->dump_conf = RPROC_COREDUMP_DISABLED;
|
|
} else if (sysfs_streq(buf, "enabled")) {
|
|
rproc->dump_conf = RPROC_COREDUMP_ENABLED;
|
|
} else if (sysfs_streq(buf, "inline")) {
|
|
rproc->dump_conf = RPROC_COREDUMP_INLINE;
|
|
} else {
|
|
dev_err(&rproc->dev, "Invalid coredump configuration\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
static DEVICE_ATTR_RW(coredump);
|
|
|
|
/* Expose the loaded / running firmware name via sysfs */
|
|
static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct rproc *rproc = to_rproc(dev);
|
|
const char *firmware = rproc->firmware;
|
|
|
|
/*
|
|
* If the remote processor has been started by an external
|
|
* entity we have no idea of what image it is running. As such
|
|
* simply display a generic string rather then rproc->firmware.
|
|
*/
|
|
if (rproc->state == RPROC_ATTACHED)
|
|
firmware = "unknown";
|
|
|
|
return sprintf(buf, "%s\n", firmware);
|
|
}
|
|
|
|
/* Change firmware name via sysfs */
|
|
static ssize_t firmware_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct rproc *rproc = to_rproc(dev);
|
|
int err;
|
|
|
|
err = rproc_set_firmware(rproc, buf);
|
|
|
|
return err ? err : count;
|
|
}
|
|
static DEVICE_ATTR_RW(firmware);
|
|
|
|
/*
|
|
* A state-to-string lookup table, for exposing a human readable state
|
|
* via sysfs. Always keep in sync with enum rproc_state
|
|
*/
|
|
static const char * const rproc_state_string[] = {
|
|
[RPROC_OFFLINE] = "offline",
|
|
[RPROC_SUSPENDED] = "suspended",
|
|
[RPROC_RUNNING] = "running",
|
|
[RPROC_CRASHED] = "crashed",
|
|
[RPROC_DELETED] = "deleted",
|
|
[RPROC_ATTACHED] = "attached",
|
|
[RPROC_DETACHED] = "detached",
|
|
[RPROC_LAST] = "invalid",
|
|
};
|
|
|
|
/* Expose the state of the remote processor via sysfs */
|
|
static ssize_t state_show(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct rproc *rproc = to_rproc(dev);
|
|
unsigned int state;
|
|
|
|
state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
|
|
return sprintf(buf, "%s\n", rproc_state_string[state]);
|
|
}
|
|
|
|
/* Change remote processor state via sysfs */
|
|
static ssize_t state_store(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct rproc *rproc = to_rproc(dev);
|
|
int ret = 0;
|
|
|
|
if (sysfs_streq(buf, "start")) {
|
|
ret = rproc_boot(rproc);
|
|
if (ret)
|
|
dev_err(&rproc->dev, "Boot failed: %d\n", ret);
|
|
} else if (sysfs_streq(buf, "stop")) {
|
|
ret = rproc_shutdown(rproc);
|
|
} else if (sysfs_streq(buf, "detach")) {
|
|
ret = rproc_detach(rproc);
|
|
} else {
|
|
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
|
|
ret = -EINVAL;
|
|
}
|
|
return ret ? ret : count;
|
|
}
|
|
static DEVICE_ATTR_RW(state);
|
|
|
|
/* Expose the name of the remote processor via sysfs */
|
|
static ssize_t name_show(struct device *dev, struct device_attribute *attr,
|
|
char *buf)
|
|
{
|
|
struct rproc *rproc = to_rproc(dev);
|
|
|
|
return sprintf(buf, "%s\n", rproc->name);
|
|
}
|
|
static DEVICE_ATTR_RO(name);
|
|
|
|
static umode_t rproc_is_visible(struct kobject *kobj, struct attribute *attr,
|
|
int n)
|
|
{
|
|
struct device *dev = kobj_to_dev(kobj);
|
|
struct rproc *rproc = to_rproc(dev);
|
|
umode_t mode = attr->mode;
|
|
|
|
if (rproc->sysfs_read_only && (attr == &dev_attr_recovery.attr ||
|
|
attr == &dev_attr_firmware.attr ||
|
|
attr == &dev_attr_state.attr ||
|
|
attr == &dev_attr_coredump.attr))
|
|
mode = 0444;
|
|
|
|
return mode;
|
|
}
|
|
|
|
static struct attribute *rproc_attrs[] = {
|
|
&dev_attr_coredump.attr,
|
|
&dev_attr_recovery.attr,
|
|
&dev_attr_firmware.attr,
|
|
&dev_attr_state.attr,
|
|
&dev_attr_name.attr,
|
|
NULL
|
|
};
|
|
|
|
static const struct attribute_group rproc_devgroup = {
|
|
.attrs = rproc_attrs,
|
|
.is_visible = rproc_is_visible,
|
|
};
|
|
|
|
static const struct attribute_group *rproc_devgroups[] = {
|
|
&rproc_devgroup,
|
|
NULL
|
|
};
|
|
|
|
struct class rproc_class = {
|
|
.name = "remoteproc",
|
|
.dev_groups = rproc_devgroups,
|
|
};
|
|
|
|
int __init rproc_init_sysfs(void)
|
|
{
|
|
/* create remoteproc device class for sysfs */
|
|
int err = class_register(&rproc_class);
|
|
|
|
if (err)
|
|
pr_err("remoteproc: unable to register class\n");
|
|
return err;
|
|
}
|
|
|
|
void __exit rproc_exit_sysfs(void)
|
|
{
|
|
class_unregister(&rproc_class);
|
|
}
|