subject:"deal"

From: Greg Kroah-Hartman 

From: Vladimir Oltean 

[ Upstream commit 86c4ad9a7876777c12fd5a7010152e4141fcb94d ]

Now that we have a central TX reallocation procedure that accounts for
the tagger's needed headroom in a generic way, we can remove the
skb_cow_head call.

Cc: Per Forlin 
Cc: Oleksij Rempel 
Signed-off-by: Vladimir Oltean 
Tested-by: Oleksij Rempel 
Reviewed-by: Florian Fainelli 
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 net/dsa/tag_ar9331.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/net/dsa/tag_ar9331.c b/net/dsa/tag_ar9331.c
index 55b00694cdba..002cf7f952e2 100644
--- a/net/dsa/tag_ar9331.c
+++ b/net/dsa/tag_ar9331.c
@@ -31,9 +31,6 @@ static struct sk_buff *ar9331_tag_xmit(struct sk_buff *skb,
__le16 *phdr;
u16 hdr;
 
-   if (skb_cow_head(skb, AR9331_HDR_LEN) < 0)
-   return NULL;
-
phdr = skb_push(skb, AR9331_HDR_LEN);
 
hdr = FIELD_PREP(AR9331_HDR_VERSION_MASK, AR9331_HDR_VERSION);
-- 
2.30.1

[PATCH 5.10 123/290] net: dsa: tag_gswip: let DSA core deal with TX reallocation

From: Greg Kroah-Hartman 

From: Vladimir Oltean 

[ Upstream commit 9b9826ae117f211bcbdc75db844d5fd8b159fc59 ]

Now that we have a central TX reallocation procedure that accounts for
the tagger's needed headroom in a generic way, we can remove the
skb_cow_head call.

This one is interesting, the DSA tag is 8 bytes on RX and 4 bytes on TX.
Because DSA is unaware of asymmetrical tag lengths, the overhead/needed
headroom is declared as 8 bytes and therefore 4 bytes larger than it
needs to be. If this becomes a problem, and the GSWIP driver can't be
converted to a uniform header length, we might need to make DSA aware of
separate RX/TX overhead values.

Cc: Hauke Mehrtens 
Signed-off-by: Vladimir Oltean 
Reviewed-by: Florian Fainelli 
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 net/dsa/tag_gswip.c | 5 -
 1 file changed, 5 deletions(-)

diff --git a/net/dsa/tag_gswip.c b/net/dsa/tag_gswip.c
index 408d4af390a0..2f5bd5e338ab 100644
--- a/net/dsa/tag_gswip.c
+++ b/net/dsa/tag_gswip.c
@@ -60,13 +60,8 @@ static struct sk_buff *gswip_tag_xmit(struct sk_buff *skb,
  struct net_device *dev)
 {
struct dsa_port *dp = dsa_slave_to_port(dev);
-   int err;
u8 *gswip_tag;

-   err = skb_cow_head(skb, GSWIP_TX_HEADER_LEN);
-   if (err)
-   return NULL;
-
skb_push(skb, GSWIP_TX_HEADER_LEN);

gswip_tag = skb->data;
-- 
2.30.1

[PATCH 5.10 122/290] net: dsa: tag_dsa: let DSA core deal with TX reallocation

From: Greg Kroah-Hartman 

From: Vladimir Oltean 

[ Upstream commit 952a06345015867e3bd37f8d9045fc1429637d43 ]

Now that we have a central TX reallocation procedure that accounts for
the tagger's needed headroom in a generic way, we can remove the
skb_cow_head call.

Similar to the EtherType DSA tagger, the old Marvell tagger can
transform an 802.1Q header if present into a DSA tag, so there is no
headroom required in that case. But we are ensuring that it exists,
regardless (practically speaking, the headroom must be 4 bytes larger
than it needs to be).

Signed-off-by: Vladimir Oltean 
Reviewed-by: Florian Fainelli 
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 net/dsa/tag_dsa.c | 5 -
 1 file changed, 5 deletions(-)

diff --git a/net/dsa/tag_dsa.c b/net/dsa/tag_dsa.c
index 0b756fae68a5..63d690a0fca6 100644
--- a/net/dsa/tag_dsa.c
+++ b/net/dsa/tag_dsa.c
@@ -23,9 +23,6 @@ static struct sk_buff *dsa_xmit(struct sk_buff *skb, struct 
net_device *dev)
 * the ethertype field for untagged packets.
 */
if (skb->protocol == htons(ETH_P_8021Q)) {
-   if (skb_cow_head(skb, 0) < 0)
-   return NULL;
-
/*
 * Construct tagged FROM_CPU DSA tag from 802.1q tag.
 */
@@ -41,8 +38,6 @@ static struct sk_buff *dsa_xmit(struct sk_buff *skb, struct 
net_device *dev)
dsa_header[2] &= ~0x10;
}
} else {
-   if (skb_cow_head(skb, DSA_HLEN) < 0)
-   return NULL;
skb_push(skb, DSA_HLEN);

memmove(skb->data, skb->data + DSA_HLEN, 2 * ETH_ALEN);
-- 
2.30.1

[PATCH 5.10 121/290] net: dsa: tag_brcm: let DSA core deal with TX reallocation

From: Greg Kroah-Hartman 

From: Vladimir Oltean 

[ Upstream commit 2f0d030c5ffec6660f79a32b4f522155f75a9d71 ]

Now that we have a central TX reallocation procedure that accounts for
the tagger's needed headroom in a generic way, we can remove the
skb_cow_head call.

Cc: Florian Fainelli 
Signed-off-by: Vladimir Oltean 
Reviewed-by: Florian Fainelli 
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 net/dsa/tag_brcm.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/net/dsa/tag_brcm.c b/net/dsa/tag_brcm.c
index ad72dff8d524..e934dace3922 100644
--- a/net/dsa/tag_brcm.c
+++ b/net/dsa/tag_brcm.c
@@ -66,9 +66,6 @@ static struct sk_buff *brcm_tag_xmit_ll(struct sk_buff *skb,
u16 queue = skb_get_queue_mapping(skb);
u8 *brcm_tag;
 
-   if (skb_cow_head(skb, BRCM_TAG_LEN) < 0)
-   return NULL;
-
/* The Ethernet switch we are interfaced with needs packets to be at
 * least 64 bytes (including FCS) otherwise they will be discarded when
 * they enter the switch port logic. When Broadcom tags are enabled, we
-- 
2.30.1

[PATCH 5.10 120/290] net: dsa: tag_edsa: let DSA core deal with TX reallocation

From: Greg Kroah-Hartman 

From: Vladimir Oltean 

[ Upstream commit c6c4e1237dfe731644e79fa06d073625f28cd945 ]

Now that we have a central TX reallocation procedure that accounts for
the tagger's needed headroom in a generic way, we can remove the
skb_cow_head call.

Note that the VLAN code path needs a smaller extra headroom than the
regular EtherType DSA path. That isn't a problem, because this tagger
declares the larger tag length (8 bytes vs 4) as the protocol overhead,
so we are covered in both cases.

Cc: Andrew Lunn 
Signed-off-by: Vladimir Oltean 
Reviewed-by: Florian Fainelli 
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 net/dsa/tag_edsa.c | 4 
 1 file changed, 4 deletions(-)

diff --git a/net/dsa/tag_edsa.c b/net/dsa/tag_edsa.c
index 120614240319..abf70a29deb4 100644
--- a/net/dsa/tag_edsa.c
+++ b/net/dsa/tag_edsa.c
@@ -35,8 +35,6 @@ static struct sk_buff *edsa_xmit(struct sk_buff *skb, struct 
net_device *dev)
 * current ethertype field if the packet is untagged.
 */
if (skb->protocol == htons(ETH_P_8021Q)) {
-   if (skb_cow_head(skb, DSA_HLEN) < 0)
-   return NULL;
skb_push(skb, DSA_HLEN);
 
memmove(skb->data, skb->data + DSA_HLEN, 2 * ETH_ALEN);
@@ -60,8 +58,6 @@ static struct sk_buff *edsa_xmit(struct sk_buff *skb, struct 
net_device *dev)
edsa_header[6] &= ~0x10;
}
} else {
-   if (skb_cow_head(skb, EDSA_HLEN) < 0)
-   return NULL;
skb_push(skb, EDSA_HLEN);
 
memmove(skb->data, skb->data + EDSA_HLEN, 2 * ETH_ALEN);
-- 
2.30.1

[PATCH 5.10 118/290] net: dsa: tag_mtk: let DSA core deal with TX reallocation

From: Greg Kroah-Hartman 

From: Vladimir Oltean 

[ Upstream commit 941f66beb7bb4e0e4726aa31336d9ccc1c3a3dc2 ]

Now that we have a central TX reallocation procedure that accounts for
the tagger's needed headroom in a generic way, we can remove the
skb_cow_head call.

Cc: DENG Qingfang 
Cc: Sean Wang 
Cc: John Crispin 
Signed-off-by: Vladimir Oltean 
Reviewed-by: Florian Fainelli 
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 net/dsa/tag_mtk.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/net/dsa/tag_mtk.c b/net/dsa/tag_mtk.c
index 4cdd9cf428fb..38dcdded74c0 100644
--- a/net/dsa/tag_mtk.c
+++ b/net/dsa/tag_mtk.c
@@ -34,9 +34,6 @@ static struct sk_buff *mtk_tag_xmit(struct sk_buff *skb,
 * table with VID.
 */
if (!skb_vlan_tagged(skb)) {
-   if (skb_cow_head(skb, MTK_HDR_LEN) < 0)
-   return NULL;
-
skb_push(skb, MTK_HDR_LEN);
memmove(skb->data, skb->data + MTK_HDR_LEN, 2 * ETH_ALEN);
is_vlan_skb = false;
-- 
2.30.1

[PATCH 5.10 119/290] net: dsa: tag_lan9303: let DSA core deal with TX reallocation

From: Greg Kroah-Hartman 

From: Vladimir Oltean 

[ Upstream commit 6ed94135f58372cdec34cafb60f7596893b0b371 ]

Now that we have a central TX reallocation procedure that accounts for
the tagger's needed headroom in a generic way, we can remove the
skb_cow_head call.

Signed-off-by: Vladimir Oltean 
Reviewed-by: Florian Fainelli 
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 net/dsa/tag_lan9303.c | 9 -
 1 file changed, 9 deletions(-)

diff --git a/net/dsa/tag_lan9303.c b/net/dsa/tag_lan9303.c
index ccfb6f641bbf..aa1318dccaf0 100644
--- a/net/dsa/tag_lan9303.c
+++ b/net/dsa/tag_lan9303.c
@@ -58,15 +58,6 @@ static struct sk_buff *lan9303_xmit(struct sk_buff *skb, 
struct net_device *dev)
__be16 *lan9303_tag;
u16 tag;
 
-   /* insert a special VLAN tag between the MAC addresses
-* and the current ethertype field.
-*/
-   if (skb_cow_head(skb, LAN9303_TAG_LEN) < 0) {
-   dev_dbg(&dev->dev,
-   "Cannot make room for the special tag. Dropping 
packet\n");
-   return NULL;
-   }
-
/* provide 'LAN9303_TAG_LEN' bytes additional space */
skb_push(skb, LAN9303_TAG_LEN);
 
-- 
2.30.1

[PATCH 5.10 117/290] net: dsa: tag_ocelot: let DSA core deal with TX reallocation

From: Greg Kroah-Hartman 

From: Vladimir Oltean 

[ Upstream commit 9c5c3bd00557e57c1049f7861f11e5e39f0fb42d ]

Now that we have a central TX reallocation procedure that accounts for
the tagger's needed headroom in a generic way, we can remove the
skb_cow_head call.

Signed-off-by: Vladimir Oltean 
Reviewed-by: Florian Fainelli 
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 net/dsa/tag_ocelot.c | 7 ---
 1 file changed, 7 deletions(-)

diff --git a/net/dsa/tag_ocelot.c b/net/dsa/tag_ocelot.c
index 3b468aca5c53..16a1afd5b8e1 100644
--- a/net/dsa/tag_ocelot.c
+++ b/net/dsa/tag_ocelot.c
@@ -143,13 +143,6 @@ static struct sk_buff *ocelot_xmit(struct sk_buff *skb,
struct ocelot_port *ocelot_port;
u8 *prefix, *injection;
u64 qos_class, rew_op;
-   int err;
-
-   err = skb_cow_head(skb, OCELOT_TOTAL_TAG_LEN);
-   if (unlikely(err < 0)) {
-   netdev_err(netdev, "Cannot make room for tag.\n");
-   return NULL;
-   }
 
ocelot_port = ocelot->ports[dp->index];
 
-- 
2.30.1

[PATCH 5.10 116/290] net: dsa: tag_qca: let DSA core deal with TX reallocation

From: Greg Kroah-Hartman 

From: Vladimir Oltean 

[ Upstream commit 9bbda29ae1044bc4c1c01a5b7c44688c4765785f ]

Now that we have a central TX reallocation procedure that accounts for
the tagger's needed headroom in a generic way, we can remove the
skb_cow_head call.

Cc: John Crispin 
Cc: Alexander Lobakin 
Signed-off-by: Vladimir Oltean 
Reviewed-by: Florian Fainelli 
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 net/dsa/tag_qca.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/net/dsa/tag_qca.c b/net/dsa/tag_qca.c
index 1b9e8507112b..88181b52f480 100644
--- a/net/dsa/tag_qca.c
+++ b/net/dsa/tag_qca.c
@@ -34,9 +34,6 @@ static struct sk_buff *qca_tag_xmit(struct sk_buff *skb, 
struct net_device *dev)
__be16 *phdr;
u16 hdr;
 
-   if (skb_cow_head(skb, QCA_HDR_LEN) < 0)
-   return NULL;
-
skb_push(skb, QCA_HDR_LEN);
 
memmove(skb->data, skb->data + QCA_HDR_LEN, 2 * ETH_ALEN);
-- 
2.30.1

[PATCH v8 13/17] remoteproc: Properly deal with a kernel panic when attached

The panic handler operation of registered remote processors
should also be called when remote processors have been
attached to.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_core.c | 6 +-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 37b3b7d494e5..c00f3f8bdfcc 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2728,7 +2728,11 @@ static int rproc_panic_handler(struct notifier_block 
*nb, unsigned long event,
 
rcu_read_lock();
list_for_each_entry_rcu(rproc, &rproc_list, node) {
-   if (!rproc->ops->panic || rproc->state != RPROC_RUNNING)
+   if (!rproc->ops->panic)
+   continue;
+
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
continue;
 
d = rproc->ops->panic(rproc);
-- 
2.25.1

[PATCH v8 16/17] remoteproc: Properly deal with a detach request when attached

This patch introduces the capability to detach a remote processor
that has been attached to by the remoteproc core.  For that to happen
a rproc::ops::detach() operation needs to be available.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 5 +
 drivers/remoteproc/remoteproc_sysfs.c | 5 +
 2 files changed, 10 insertions(+)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index 0249d8f6c3f8..2db494816d5f 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -43,6 +43,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
char __user *buf, size_
return -EINVAL;
 
rproc_shutdown(rproc);
+   } else if (!strncmp(cmd, "detach", len)) {
+   if (rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 09eb700c5e7e..ad3dd208024c 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -207,6 +207,11 @@ static ssize_t state_store(struct device *dev,
return -EINVAL;
 
rproc_shutdown(rproc);
+   } else if (sysfs_streq(buf, "detach")) {
+   if (rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
-- 
2.25.1

[PATCH v8 14/17] remoteproc: Properly deal with a start request when attached

This patch takes into account scenarios where a remote processor
has been attached to when receiving a "start" command from sysfs.

As with the case with the running state, the command can't be
carried out if the remote processor is already in operation.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
 drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index b19ea3057bde..b2cee9afb41b 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -32,7 +32,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char 
__user *buf, size_
return -EFAULT;
 
if (!strncmp(cmd, "start", len)) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index f9694def9b54..66801e6fe5cd 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -194,7 +194,8 @@ static ssize_t state_store(struct device *dev,
int ret = 0;
 
if (sysfs_streq(buf, "start")) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
-- 
2.25.1

[PATCH v8 15/17] remoteproc: Properly deal with a stop request when attached

Allow a remote processor that was started by another entity to be
switched off by the remoteproc core.  For that to happen a
rproc::ops::stop() operation needs to be available.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
 drivers/remoteproc/remoteproc_core.c  | 4 
 drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index b2cee9afb41b..0249d8f6c3f8 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -38,7 +38,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char 
__user *buf, size_
 
ret = rproc_boot(rproc);
} else if (!strncmp(cmd, "stop", len)) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
rproc_shutdown(rproc);
diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index c00f3f8bdfcc..c985c5f6f2f8 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1796,6 +1796,10 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
struct device *dev = &rproc->dev;
int ret;
 
+   /* No need to continue if a stop() operation has not been provided */
+   if (!rproc->ops->stop)
+   return -EINVAL;
+
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, crashed);
 
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 66801e6fe5cd..09eb700c5e7e 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -202,7 +202,8 @@ static ssize_t state_store(struct device *dev,
if (ret)
dev_err(&rproc->dev, "Boot failed: %d\n", ret);
} else if (sysfs_streq(buf, "stop")) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
rproc_shutdown(rproc);
-- 
2.25.1

[PATCH v8 11/17] remoteproc: Properly deal with the resource table when detaching

If it is possible to detach the remote processor, keep an untouched
copy of the resource table.  That way we can start from the same
resource table without having to worry about original values or what
elements the startup code has changed when re-attaching to the remote
processor.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
New for V8:
  - Checking return code for error in __rproc_datch(). 
---
 drivers/remoteproc/remoteproc_core.c | 82 
 include/linux/remoteproc.h   |  3 +
 2 files changed, 85 insertions(+)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 5eaa47c3ba92..0f151dbcdc36 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1556,6 +1556,24 @@ static int rproc_set_rsc_table(struct rproc *rproc)
return ret;
}
 
+   /*
+* If it is possible to detach the remote processor, keep an untouched
+* copy of the resource table.  That way we can start fresh again when
+* the remote processor is re-attached, that is:
+*
+*  DETACHED -> ATTACHED -> DETACHED -> ATTACHED
+*
+* Free'd in rproc_reset_rsc_table_on_detach() and
+* rproc_reset_rsc_table_on_stop().
+*/
+   if (rproc->ops->detach) {
+   rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
+   if (!rproc->clean_table)
+   return -ENOMEM;
+   } else {
+   rproc->clean_table = NULL;
+   }
+
rproc->cached_table = NULL;
rproc->table_ptr = table_ptr;
rproc->table_sz = table_sz;
@@ -1563,6 +1581,59 @@ static int rproc_set_rsc_table(struct rproc *rproc)
return 0;
 }
 
+static int rproc_reset_rsc_table_on_detach(struct rproc *rproc)
+{
+   struct resource_table *table_ptr;
+
+   /* A resource table was never retrieved, nothing to do here */
+   if (!rproc->table_ptr)
+   return 0;
+
+   /*
+* If we made it to this point a clean_table _must_ have been
+* allocated in rproc_set_rsc_table().  If one isn't present
+* something went really wrong and we must complain.
+*/
+   if (WARN_ON(!rproc->clean_table))
+   return -EINVAL;
+
+   /* Remember where the external entity installed the resource table */
+   table_ptr = rproc->table_ptr;
+
+   /*
+* If we made it here the remote processor was started by another
+* entity and a cache table doesn't exist.  As such make a copy of
+* the resource table currently used by the remote processor and
+* use that for the rest of the shutdown process.  The memory
+* allocated here is free'd in rproc_detach().
+*/
+   rproc->cached_table = kmemdup(rproc->table_ptr,
+ rproc->table_sz, GFP_KERNEL);
+   if (!rproc->cached_table)
+   return -ENOMEM;
+
+   /*
+* Use a copy of the resource table for the remainder of the
+* shutdown process.
+*/
+   rproc->table_ptr = rproc->cached_table;
+
+   /*
+* Reset the memory area where the firmware loaded the resource table
+* to its original value.  That way when we re-attach the remote
+* processor the resource table is clean and ready to be used again.
+*/
+   memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
+
+   /*
+* The clean resource table is no longer needed.  Allocated in
+* rproc_set_rsc_table().
+*/
+   kfree(rproc->clean_table);
+
+   return 0;
+}
+
 /*
  * Attach to remote processor - similar to rproc_fw_boot() but without
  * the steps that deal with the firmware image.
@@ -1721,6 +1792,14 @@ static int __rproc_detach(struct rproc *rproc)
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, false);
 
+   /* the installed resource table is no longer accessible */
+   ret = rproc_reset_rsc_table_on_detach(rproc);
+   if (ret) {
+   dev_err(dev, "can't reset resource table: %d\n", ret);
+   return ret;
+   }
+
+
/* Tell the remote processor the core isn't available anymore */
ret = rproc->ops->detach(rproc);
if (ret) {
@@ -1997,6 +2076,9 @@ int rproc_detach(struct rproc *rproc)
 
rproc_disable_iommu(rproc);
 
+   /* Free the copy of the resource table */
+   kfree(rproc->cached_table);
+   rproc->cached_table = NULL;
rproc->table_ptr = NULL;
 out:
mutex_unlock(&rproc->lock);
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index e1c843c19cc6..e5f52a12a650 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h

[PATCH v8 12/17] remoteproc: Properly deal with the resource table when stopping

When a remote processor that was attached to is stopped, special care
must be taken to make sure the shutdown process is similar to what
it would be had it been started by the remoteproc core.

This patch takes care of that by making a copy of the resource
table currently used by the remote processor.  From that point on
the copy is used, as if the remote processor had been started by
the remoteproc core.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
Reported-by: kernel test robot 
---
New for V8:
  - Removed variable @table_ptr as it served no purpose.
---
 drivers/remoteproc/remoteproc_core.c | 48 +++-
 1 file changed, 47 insertions(+), 1 deletion(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 0f151dbcdc36..37b3b7d494e5 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1634,6 +1634,47 @@ static int rproc_reset_rsc_table_on_detach(struct rproc 
*rproc)
return 0;
 }
 
+static int rproc_reset_rsc_table_on_stop(struct rproc *rproc)
+{
+   /* A resource table was never retrieved, nothing to do here */
+   if (!rproc->table_ptr)
+   return 0;
+
+   /*
+* If a cache table exists the remote processor was started by
+* the remoteproc core.  That cache table should be used for
+* the rest of the shutdown process.
+*/
+   if (rproc->cached_table)
+   goto out;
+
+   /*
+* If we made it here the remote processor was started by another
+* entity and a cache table doesn't exist.  As such make a copy of
+* the resource table currently used by the remote processor and
+* use that for the rest of the shutdown process.  The memory
+* allocated here is free'd in rproc_shutdown().
+*/
+   rproc->cached_table = kmemdup(rproc->table_ptr,
+ rproc->table_sz, GFP_KERNEL);
+   if (!rproc->cached_table)
+   return -ENOMEM;
+
+   /*
+* Since the remote processor is being switched off the clean table
+* won't be needed.  Allocated in rproc_set_rsc_table().
+*/
+   kfree(rproc->clean_table);
+
+out:
+   /*
+* Use a copy of the resource table for the remainder of the
+* shutdown process.
+*/
+   rproc->table_ptr = rproc->cached_table;
+   return 0;
+}
+
 /*
  * Attach to remote processor - similar to rproc_fw_boot() but without
  * the steps that deal with the firmware image.
@@ -1759,7 +1800,12 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
rproc_stop_subdevices(rproc, crashed);
 
/* the installed resource table is no longer accessible */
-   rproc->table_ptr = rproc->cached_table;
+   ret = rproc_reset_rsc_table_on_stop(rproc);
+   if (ret) {
+   dev_err(dev, "can't reset resource table: %d\n", ret);
+   return ret;
+   }
+
 
/* power off the remote processor */
ret = rproc->ops->stop(rproc);
-- 
2.25.1

Re: [PATCH v7 12/17] remoteproc: Properly deal with the resource table when stopping

2021-03-11 Thread Mathieu Poirier

On Wed, Mar 10, 2021 at 05:53:04PM -0600, Bjorn Andersson wrote:
> On Wed 10 Mar 15:10 CST 2021, Mathieu Poirier wrote:
> 
> > When a remote processor that was attached to is stopped, special care
> > must be taken to make sure the shutdown process is similar to what
> > it would be had it been started by the remoteproc core.
> > 
> > This patch takes care of that by making a copy of the resource
> > table currently used by the remote processor.  From that point on
> > the copy is used, as if the remote processor had been started by
> > the remoteproc core.
> > 
> > Signed-off-by: Mathieu Poirier 
> > ---
> > New for V7:
> >   New Patch, used to be part of 11/16 in V6.
> > ---
> >  drivers/remoteproc/remoteproc_core.c | 53 +++-
> >  1 file changed, 52 insertions(+), 1 deletion(-)
> > 
> > diff --git a/drivers/remoteproc/remoteproc_core.c 
> > b/drivers/remoteproc/remoteproc_core.c
> > index e9ea2558432d..c488b1aa6119 100644
> > --- a/drivers/remoteproc/remoteproc_core.c
> > +++ b/drivers/remoteproc/remoteproc_core.c
> > @@ -1634,6 +1634,52 @@ static int rproc_reset_rsc_table_on_detach(struct 
> > rproc *rproc)
> > return 0;
> >  }
> >  
> > +static int rproc_reset_rsc_table_on_stop(struct rproc *rproc)
> > +{
> > +   struct resource_table *table_ptr;
> > +
> > +   /* A resource table was never retrieved, nothing to do here */
> > +   if (!rproc->table_ptr)
> > +   return 0;
> > +
> > +   /*
> > +* If a cache table exists the remote processor was started by
> > +* the remoteproc core.  That cache table should be used for
> > +* the rest of the shutdown process.
> > +*/
> > +   if (rproc->cached_table)
> > +   goto out;
> > +
> > +   /* Remember where the external entity installed the resource table */
> > +   table_ptr = rproc->table_ptr;
> > +
> 
> Afaict this is just a remnant from the detach case.
> 
> I think the series looks really good now, please let me know and I can
> drop the local "table_ptr" as I apply the patches.

(sigh) No matter how long you stare at a patchset there is always one that gets
away.  I will address Arnaud's comment and fix this in a new revision.

Thanks,
Mathieu 

> 
> Regards,
> Bjorn
> 
> > +   /*
> > +* If we made it here the remote processor was started by another
> > +* entity and a cache table doesn't exist.  As such make a copy of
> > +* the resource table currently used by the remote processor and
> > +* use that for the rest of the shutdown process.  The memory
> > +* allocated here is free'd in rproc_shutdown().
> > +*/
> > +   rproc->cached_table = kmemdup(rproc->table_ptr,
> > + rproc->table_sz, GFP_KERNEL);
> > +   if (!rproc->cached_table)
> > +   return -ENOMEM;
> > +
> > +   /*
> > +* Since the remote processor is being switched off the clean table
> > +* won't be needed.  Allocated in rproc_set_rsc_table().
> > +*/
> > +   kfree(rproc->clean_table);
> > +
> > +out:
> > +   /*
> > +* Use a copy of the resource table for the remainder of the
> > +* shutdown process.
> > +*/
> > +   rproc->table_ptr = rproc->cached_table;
> > +   return 0;
> > +}
> > +
> >  /*
> >   * Attach to remote processor - similar to rproc_fw_boot() but without
> >   * the steps that deal with the firmware image.
> > @@ -1759,7 +1805,12 @@ static int rproc_stop(struct rproc *rproc, bool 
> > crashed)
> > rproc_stop_subdevices(rproc, crashed);
> >  
> > /* the installed resource table is no longer accessible */
> > -   rproc->table_ptr = rproc->cached_table;
> > +   ret = rproc_reset_rsc_table_on_stop(rproc);
> > +   if (ret) {
> > +   dev_err(dev, "can't reset resource table: %d\n", ret);
> > +   return ret;
> > +   }
> > +
> >  
> > /* power off the remote processor */
> > ret = rproc->ops->stop(rproc);
> > -- 
> > 2.25.1
> >

Re: [PATCH v7 12/17] remoteproc: Properly deal with the resource table when stopping

2021-03-11 Thread Arnaud POULIQUEN




On 3/11/21 12:53 AM, Bjorn Andersson wrote:
> On Wed 10 Mar 15:10 CST 2021, Mathieu Poirier wrote:
> 
>> When a remote processor that was attached to is stopped, special care
>> must be taken to make sure the shutdown process is similar to what
>> it would be had it been started by the remoteproc core.
>>
>> This patch takes care of that by making a copy of the resource
>> table currently used by the remote processor.  From that point on
>> the copy is used, as if the remote processor had been started by
>> the remoteproc core.
>>
>> Signed-off-by: Mathieu Poirier 
>> ---
>> New for V7:
>>   New Patch, used to be part of 11/16 in V6.
>> ---
>>  drivers/remoteproc/remoteproc_core.c | 53 +++-
>>  1 file changed, 52 insertions(+), 1 deletion(-)
>>
>> diff --git a/drivers/remoteproc/remoteproc_core.c 
>> b/drivers/remoteproc/remoteproc_core.c
>> index e9ea2558432d..c488b1aa6119 100644
>> --- a/drivers/remoteproc/remoteproc_core.c
>> +++ b/drivers/remoteproc/remoteproc_core.c
>> @@ -1634,6 +1634,52 @@ static int rproc_reset_rsc_table_on_detach(struct 
>> rproc *rproc)
>>  return 0;
>>  }
>>  
>> +static int rproc_reset_rsc_table_on_stop(struct rproc *rproc)
>> +{
>> +struct resource_table *table_ptr;
>> +
>> +/* A resource table was never retrieved, nothing to do here */
>> +if (!rproc->table_ptr)
>> +return 0;
>> +
>> +/*
>> + * If a cache table exists the remote processor was started by
>> + * the remoteproc core.  That cache table should be used for
>> + * the rest of the shutdown process.
>> + */
>> +if (rproc->cached_table)
>> +goto out;
>> +
>> +/* Remember where the external entity installed the resource table */
>> +table_ptr = rproc->table_ptr;
>> +
> 
> Afaict this is just a remnant from the detach case.
> 
> I think the series looks really good now, please let me know and I can
> drop the local "table_ptr" as I apply the patches.
> 

Just a minor comment on patch 11, then the series LGTM also,

For this one
Reviewed-by: Arnaud Pouliquen 

Thanks,
Arnaud

> Regards,
> Bjorn
> 
>> +/*
>> + * If we made it here the remote processor was started by another
>> + * entity and a cache table doesn't exist.  As such make a copy of
>> + * the resource table currently used by the remote processor and
>> + * use that for the rest of the shutdown process.  The memory
>> + * allocated here is free'd in rproc_shutdown().
>> + */
>> +rproc->cached_table = kmemdup(rproc->table_ptr,
>> +  rproc->table_sz, GFP_KERNEL);
>> +if (!rproc->cached_table)
>> +return -ENOMEM;
>> +
>> +/*
>> + * Since the remote processor is being switched off the clean table
>> + * won't be needed.  Allocated in rproc_set_rsc_table().
>> + */
>> +kfree(rproc->clean_table);
>> +
>> +out:
>> +/*
>> + * Use a copy of the resource table for the remainder of the
>> + * shutdown process.
>> + */
>> +rproc->table_ptr = rproc->cached_table;
>> +return 0;
>> +}
>> +
>>  /*
>>   * Attach to remote processor - similar to rproc_fw_boot() but without
>>   * the steps that deal with the firmware image.
>> @@ -1759,7 +1805,12 @@ static int rproc_stop(struct rproc *rproc, bool 
>> crashed)
>>  rproc_stop_subdevices(rproc, crashed);
>>  
>>  /* the installed resource table is no longer accessible */
>> -rproc->table_ptr = rproc->cached_table;
>> +ret = rproc_reset_rsc_table_on_stop(rproc);
>> +if (ret) {
>> +dev_err(dev, "can't reset resource table: %d\n", ret);
>> +return ret;
>> +}
>> +
>>  
>>  /* power off the remote processor */
>>  ret = rproc->ops->stop(rproc);
>> -- 
>> 2.25.1
>>

Re: [PATCH v7 11/17] remoteproc: Properly deal with the resource table when detaching

2021-03-11 Thread Arnaud POULIQUEN

Hi Mathieu,

Just a minor comment, with that
Reviewed-by: Arnaud Pouliquen 


On 3/10/21 10:10 PM, Mathieu Poirier wrote:
> If it is possible to detach the remote processor, keep an untouched
> copy of the resource table.  That way we can start from the same
> resource table without having to worry about original values or what
> elements the startup code has changed when re-attaching to the remote
> processor.
> 
> Signed-off-by: Mathieu Poirier 
> ---
> New for V7:
>   New Patch, used to be part of 11/16 in V6.
> ---
>  drivers/remoteproc/remoteproc_core.c | 77 
>  include/linux/remoteproc.h   |  3 ++
>  2 files changed, 80 insertions(+)
> 
> diff --git a/drivers/remoteproc/remoteproc_core.c 
> b/drivers/remoteproc/remoteproc_core.c
> index 5eaa47c3ba92..e9ea2558432d 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1556,6 +1556,24 @@ static int rproc_set_rsc_table(struct rproc *rproc)
>   return ret;
>   }
>  
> + /*
> +  * If it is possible to detach the remote processor, keep an untouched
> +  * copy of the resource table.  That way we can start fresh again when
> +  * the remote processor is re-attached, that is:
> +  *
> +  *  DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> +  *
> +  * Free'd in rproc_reset_rsc_table_on_detach() and
> +  * rproc_reset_rsc_table_on_stop().
> +  */
> + if (rproc->ops->detach) {
> + rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> + if (!rproc->clean_table)
> + return -ENOMEM;
> + } else {
> + rproc->clean_table = NULL;
> + }
> +
>   rproc->cached_table = NULL;
>   rproc->table_ptr = table_ptr;
>   rproc->table_sz = table_sz;
> @@ -1563,6 +1581,59 @@ static int rproc_set_rsc_table(struct rproc *rproc)
>   return 0;
>  }
>  
> +static int rproc_reset_rsc_table_on_detach(struct rproc *rproc)
> +{
> + struct resource_table *table_ptr;
> +
> + /* A resource table was never retrieved, nothing to do here */
> + if (!rproc->table_ptr)
> + return 0;
> +
> + /*
> +  * If we made it to this point a clean_table _must_ have been
> +  * allocated in rproc_set_rsc_table().  If one isn't present
> +  * something went really wrong and we must complain.
> +  */
> + if (WARN_ON(!rproc->clean_table))
> + return -EINVAL;
> +
> + /* Remember where the external entity installed the resource table */
> + table_ptr = rproc->table_ptr;
> +
> + /*
> +  * If we made it here the remote processor was started by another
> +  * entity and a cache table doesn't exist.  As such make a copy of
> +  * the resource table currently used by the remote processor and
> +  * use that for the rest of the shutdown process.  The memory
> +  * allocated here is free'd in rproc_detach().
> +  */
> + rproc->cached_table = kmemdup(rproc->table_ptr,
> +   rproc->table_sz, GFP_KERNEL);
> + if (!rproc->cached_table)
> + return -ENOMEM;
> +
> + /*
> +  * Use a copy of the resource table for the remainder of the
> +  * shutdown process.
> +  */
> + rproc->table_ptr = rproc->cached_table;
> +
> + /*
> +  * Reset the memory area where the firmware loaded the resource table
> +  * to its original value.  That way when we re-attach the remote
> +  * processor the resource table is clean and ready to be used again.
> +  */
> + memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
> +
> + /*
> +  * The clean resource table is no longer needed.  Allocated in
> +  * rproc_set_rsc_table().
> +  */
> + kfree(rproc->clean_table);
> +
> + return 0;
> +}
> +
>  /*
>   * Attach to remote processor - similar to rproc_fw_boot() but without
>   * the steps that deal with the firmware image.
> @@ -1721,6 +1792,9 @@ static int __rproc_detach(struct rproc *rproc)
>   /* Stop any subdevices for the remote processor */
>   rproc_stop_subdevices(rproc, false);
>  
> + /* the installed resource table is no longer accessible */
> + ret = rproc_reset_rsc_table_on_detach(rproc);
> +

Something seems missing here to treat the error case.

Regards,

Arnaud

>   /* Tell the remote processor the core isn't available anymore */
>   ret = rproc->ops->detach(rproc);
>   if (ret) {
> @@ -1997,6 +2071,9 @@ int rproc_detac

Re: [PATCH v7 12/17] remoteproc: Properly deal with the resource table when stopping

2021-03-10 Thread Bjorn Andersson

On Wed 10 Mar 15:10 CST 2021, Mathieu Poirier wrote:

> When a remote processor that was attached to is stopped, special care
> must be taken to make sure the shutdown process is similar to what
> it would be had it been started by the remoteproc core.
> 
> This patch takes care of that by making a copy of the resource
> table currently used by the remote processor.  From that point on
> the copy is used, as if the remote processor had been started by
> the remoteproc core.
> 
> Signed-off-by: Mathieu Poirier 
> ---
> New for V7:
>   New Patch, used to be part of 11/16 in V6.
> ---
>  drivers/remoteproc/remoteproc_core.c | 53 +++-
>  1 file changed, 52 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/remoteproc/remoteproc_core.c 
> b/drivers/remoteproc/remoteproc_core.c
> index e9ea2558432d..c488b1aa6119 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1634,6 +1634,52 @@ static int rproc_reset_rsc_table_on_detach(struct 
> rproc *rproc)
>   return 0;
>  }
>  
> +static int rproc_reset_rsc_table_on_stop(struct rproc *rproc)
> +{
> + struct resource_table *table_ptr;
> +
> + /* A resource table was never retrieved, nothing to do here */
> + if (!rproc->table_ptr)
> + return 0;
> +
> + /*
> +  * If a cache table exists the remote processor was started by
> +  * the remoteproc core.  That cache table should be used for
> +  * the rest of the shutdown process.
> +  */
> + if (rproc->cached_table)
> + goto out;
> +
> + /* Remember where the external entity installed the resource table */
> + table_ptr = rproc->table_ptr;
> +

Afaict this is just a remnant from the detach case.

I think the series looks really good now, please let me know and I can
drop the local "table_ptr" as I apply the patches.

Regards,
Bjorn

> + /*
> +  * If we made it here the remote processor was started by another
> +  * entity and a cache table doesn't exist.  As such make a copy of
> +  * the resource table currently used by the remote processor and
> +  * use that for the rest of the shutdown process.  The memory
> +  * allocated here is free'd in rproc_shutdown().
> +  */
> + rproc->cached_table = kmemdup(rproc->table_ptr,
> +   rproc->table_sz, GFP_KERNEL);
> + if (!rproc->cached_table)
> + return -ENOMEM;
> +
> + /*
> +  * Since the remote processor is being switched off the clean table
> +  * won't be needed.  Allocated in rproc_set_rsc_table().
> +  */
> + kfree(rproc->clean_table);
> +
> +out:
> + /*
> +  * Use a copy of the resource table for the remainder of the
> +  * shutdown process.
> +  */
> + rproc->table_ptr = rproc->cached_table;
> + return 0;
> +}
> +
>  /*
>   * Attach to remote processor - similar to rproc_fw_boot() but without
>   * the steps that deal with the firmware image.
> @@ -1759,7 +1805,12 @@ static int rproc_stop(struct rproc *rproc, bool 
> crashed)
>   rproc_stop_subdevices(rproc, crashed);
>  
>   /* the installed resource table is no longer accessible */
> - rproc->table_ptr = rproc->cached_table;
> + ret = rproc_reset_rsc_table_on_stop(rproc);
> + if (ret) {
> + dev_err(dev, "can't reset resource table: %d\n", ret);
> + return ret;
> + }
> +
>  
>   /* power off the remote processor */
>   ret = rproc->ops->stop(rproc);
> -- 
> 2.25.1
>

Re: [PATCH v7 12/17] remoteproc: Properly deal with the resource table when stopping

2021-03-10 Thread kernel test robot

Hi Mathieu,

I love your patch! Perhaps something to improve:

[auto build test WARNING on linux/master]
[also build test WARNING on linus/master v5.12-rc2 next-20210310]
[cannot apply to remoteproc/for-next rpmsg/for-next]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:
https://github.com/0day-ci/linux/commits/Mathieu-Poirier/remoteproc-Add-support-for-detaching-a-remote-processor/20210311-051242
base:   https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 
144c79ef33536b4ecb4951e07dbc1f2b7fa99d32
config: arm-randconfig-r036-20210310 (attached as .config)
compiler: arm-linux-gnueabi-gcc (GCC) 9.3.0
reproduce (this is a W=1 build):
wget 
https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O 
~/bin/make.cross
chmod +x ~/bin/make.cross
# 
https://github.com/0day-ci/linux/commit/6715f51e2b7ade7b5121eced81cad8065d4f5525
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review 
Mathieu-Poirier/remoteproc-Add-support-for-detaching-a-remote-processor/20210311-051242
git checkout 6715f51e2b7ade7b5121eced81cad8065d4f5525
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-9.3.0 make.cross ARCH=arm 

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot 

All warnings (new ones prefixed by >>):

   drivers/remoteproc/remoteproc_core.c: In function 
'rproc_reset_rsc_table_on_stop':
>> drivers/remoteproc/remoteproc_core.c:1639:25: warning: variable 'table_ptr' 
>> set but not used [-Wunused-but-set-variable]
1639 |  struct resource_table *table_ptr;
 | ^


vim +/table_ptr +1639 drivers/remoteproc/remoteproc_core.c

  1636  
  1637  static int rproc_reset_rsc_table_on_stop(struct rproc *rproc)
  1638  {
> 1639  struct resource_table *table_ptr;
  1640  
  1641  /* A resource table was never retrieved, nothing to do here */
  1642  if (!rproc->table_ptr)
  1643  return 0;
  1644  
  1645  /*
  1646   * If a cache table exists the remote processor was started by
  1647   * the remoteproc core.  That cache table should be used for
  1648   * the rest of the shutdown process.
  1649   */
  1650  if (rproc->cached_table)
  1651  goto out;
  1652  
  1653  /* Remember where the external entity installed the resource 
table */
  1654  table_ptr = rproc->table_ptr;
  1655  
  1656  /*
  1657   * If we made it here the remote processor was started by 
another
  1658   * entity and a cache table doesn't exist.  As such make a copy 
of
  1659   * the resource table currently used by the remote processor and
  1660   * use that for the rest of the shutdown process.  The memory
  1661   * allocated here is free'd in rproc_shutdown().
  1662   */
  1663  rproc->cached_table = kmemdup(rproc->table_ptr,
  1664rproc->table_sz, GFP_KERNEL);
  1665  if (!rproc->cached_table)
  1666  return -ENOMEM;
  1667  
  1668  /*
  1669   * Since the remote processor is being switched off the clean 
table
  1670   * won't be needed.  Allocated in rproc_set_rsc_table().
  1671   */
  1672  kfree(rproc->clean_table);
  1673  
  1674  out:
  1675  /*
  1676   * Use a copy of the resource table for the remainder of the
  1677   * shutdown process.
  1678   */
  1679  rproc->table_ptr = rproc->cached_table;
  1680  return 0;
  1681  }
  1682  

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-...@lists.01.org


.config.gz
Description: application/gzip

[PATCH v7 16/17] remoteproc: Properly deal with a detach request when attached

This patch introduces the capability to detach a remote processor
that has been attached to by the remoteproc core.  For that to happen
a rproc::ops::detach() operation needs to be available.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 5 +
 drivers/remoteproc/remoteproc_sysfs.c | 5 +
 2 files changed, 10 insertions(+)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index 0249d8f6c3f8..2db494816d5f 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -43,6 +43,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
char __user *buf, size_
return -EINVAL;
 
rproc_shutdown(rproc);
+   } else if (!strncmp(cmd, "detach", len)) {
+   if (rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 09eb700c5e7e..ad3dd208024c 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -207,6 +207,11 @@ static ssize_t state_store(struct device *dev,
return -EINVAL;
 
rproc_shutdown(rproc);
+   } else if (sysfs_streq(buf, "detach")) {
+   if (rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
-- 
2.25.1

[PATCH v7 15/17] remoteproc: Properly deal with a stop request when attached

Allow a remote processor that was started by another entity to be
switched off by the remoteproc core.  For that to happen a
rproc::ops::stop() operation needs to be available.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
 drivers/remoteproc/remoteproc_core.c  | 4 
 drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index b2cee9afb41b..0249d8f6c3f8 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -38,7 +38,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char 
__user *buf, size_
 
ret = rproc_boot(rproc);
} else if (!strncmp(cmd, "stop", len)) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
rproc_shutdown(rproc);
diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index f6f0813dade5..3670b70390dd 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1801,6 +1801,10 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
struct device *dev = &rproc->dev;
int ret;
 
+   /* No need to continue if a stop() operation has not been provided */
+   if (!rproc->ops->stop)
+   return -EINVAL;
+
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, crashed);
 
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 66801e6fe5cd..09eb700c5e7e 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -202,7 +202,8 @@ static ssize_t state_store(struct device *dev,
if (ret)
dev_err(&rproc->dev, "Boot failed: %d\n", ret);
} else if (sysfs_streq(buf, "stop")) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
rproc_shutdown(rproc);
-- 
2.25.1

[PATCH v7 13/17] remoteproc: Properly deal with a kernel panic when attached

The panic handler operation of registered remote processors
should also be called when remote processors have been
attached to.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_core.c | 6 +-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index c488b1aa6119..f6f0813dade5 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2728,7 +2728,11 @@ static int rproc_panic_handler(struct notifier_block 
*nb, unsigned long event,
 
rcu_read_lock();
list_for_each_entry_rcu(rproc, &rproc_list, node) {
-   if (!rproc->ops->panic || rproc->state != RPROC_RUNNING)
+   if (!rproc->ops->panic)
+   continue;
+
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
continue;
 
d = rproc->ops->panic(rproc);
-- 
2.25.1

[PATCH v7 12/17] remoteproc: Properly deal with the resource table when stopping

When a remote processor that was attached to is stopped, special care
must be taken to make sure the shutdown process is similar to what
it would be had it been started by the remoteproc core.

This patch takes care of that by making a copy of the resource
table currently used by the remote processor.  From that point on
the copy is used, as if the remote processor had been started by
the remoteproc core.

Signed-off-by: Mathieu Poirier 
---
New for V7:
  New Patch, used to be part of 11/16 in V6.
---
 drivers/remoteproc/remoteproc_core.c | 53 +++-
 1 file changed, 52 insertions(+), 1 deletion(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index e9ea2558432d..c488b1aa6119 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1634,6 +1634,52 @@ static int rproc_reset_rsc_table_on_detach(struct rproc 
*rproc)
return 0;
 }
 
+static int rproc_reset_rsc_table_on_stop(struct rproc *rproc)
+{
+   struct resource_table *table_ptr;
+
+   /* A resource table was never retrieved, nothing to do here */
+   if (!rproc->table_ptr)
+   return 0;
+
+   /*
+* If a cache table exists the remote processor was started by
+* the remoteproc core.  That cache table should be used for
+* the rest of the shutdown process.
+*/
+   if (rproc->cached_table)
+   goto out;
+
+   /* Remember where the external entity installed the resource table */
+   table_ptr = rproc->table_ptr;
+
+   /*
+* If we made it here the remote processor was started by another
+* entity and a cache table doesn't exist.  As such make a copy of
+* the resource table currently used by the remote processor and
+* use that for the rest of the shutdown process.  The memory
+* allocated here is free'd in rproc_shutdown().
+*/
+   rproc->cached_table = kmemdup(rproc->table_ptr,
+ rproc->table_sz, GFP_KERNEL);
+   if (!rproc->cached_table)
+   return -ENOMEM;
+
+   /*
+* Since the remote processor is being switched off the clean table
+* won't be needed.  Allocated in rproc_set_rsc_table().
+*/
+   kfree(rproc->clean_table);
+
+out:
+   /*
+* Use a copy of the resource table for the remainder of the
+* shutdown process.
+*/
+   rproc->table_ptr = rproc->cached_table;
+   return 0;
+}
+
 /*
  * Attach to remote processor - similar to rproc_fw_boot() but without
  * the steps that deal with the firmware image.
@@ -1759,7 +1805,12 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
rproc_stop_subdevices(rproc, crashed);
 
/* the installed resource table is no longer accessible */
-   rproc->table_ptr = rproc->cached_table;
+   ret = rproc_reset_rsc_table_on_stop(rproc);
+   if (ret) {
+   dev_err(dev, "can't reset resource table: %d\n", ret);
+   return ret;
+   }
+
 
/* power off the remote processor */
ret = rproc->ops->stop(rproc);
-- 
2.25.1

[PATCH v7 14/17] remoteproc: Properly deal with a start request when attached

This patch takes into account scenarios where a remote processor
has been attached to when receiving a "start" command from sysfs.

As with the case with the running state, the command can't be
carried out if the remote processor is already in operation.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
 drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index b19ea3057bde..b2cee9afb41b 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -32,7 +32,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char 
__user *buf, size_
return -EFAULT;
 
if (!strncmp(cmd, "start", len)) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index f9694def9b54..66801e6fe5cd 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -194,7 +194,8 @@ static ssize_t state_store(struct device *dev,
int ret = 0;
 
if (sysfs_streq(buf, "start")) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
-- 
2.25.1

[PATCH v7 11/17] remoteproc: Properly deal with the resource table when detaching

If it is possible to detach the remote processor, keep an untouched
copy of the resource table.  That way we can start from the same
resource table without having to worry about original values or what
elements the startup code has changed when re-attaching to the remote
processor.

Signed-off-by: Mathieu Poirier 
---
New for V7:
  New Patch, used to be part of 11/16 in V6.
---
 drivers/remoteproc/remoteproc_core.c | 77 
 include/linux/remoteproc.h   |  3 ++
 2 files changed, 80 insertions(+)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 5eaa47c3ba92..e9ea2558432d 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1556,6 +1556,24 @@ static int rproc_set_rsc_table(struct rproc *rproc)
return ret;
}
 
+   /*
+* If it is possible to detach the remote processor, keep an untouched
+* copy of the resource table.  That way we can start fresh again when
+* the remote processor is re-attached, that is:
+*
+*  DETACHED -> ATTACHED -> DETACHED -> ATTACHED
+*
+* Free'd in rproc_reset_rsc_table_on_detach() and
+* rproc_reset_rsc_table_on_stop().
+*/
+   if (rproc->ops->detach) {
+   rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
+   if (!rproc->clean_table)
+   return -ENOMEM;
+   } else {
+   rproc->clean_table = NULL;
+   }
+
rproc->cached_table = NULL;
rproc->table_ptr = table_ptr;
rproc->table_sz = table_sz;
@@ -1563,6 +1581,59 @@ static int rproc_set_rsc_table(struct rproc *rproc)
return 0;
 }
 
+static int rproc_reset_rsc_table_on_detach(struct rproc *rproc)
+{
+   struct resource_table *table_ptr;
+
+   /* A resource table was never retrieved, nothing to do here */
+   if (!rproc->table_ptr)
+   return 0;
+
+   /*
+* If we made it to this point a clean_table _must_ have been
+* allocated in rproc_set_rsc_table().  If one isn't present
+* something went really wrong and we must complain.
+*/
+   if (WARN_ON(!rproc->clean_table))
+   return -EINVAL;
+
+   /* Remember where the external entity installed the resource table */
+   table_ptr = rproc->table_ptr;
+
+   /*
+* If we made it here the remote processor was started by another
+* entity and a cache table doesn't exist.  As such make a copy of
+* the resource table currently used by the remote processor and
+* use that for the rest of the shutdown process.  The memory
+* allocated here is free'd in rproc_detach().
+*/
+   rproc->cached_table = kmemdup(rproc->table_ptr,
+ rproc->table_sz, GFP_KERNEL);
+   if (!rproc->cached_table)
+   return -ENOMEM;
+
+   /*
+* Use a copy of the resource table for the remainder of the
+* shutdown process.
+*/
+   rproc->table_ptr = rproc->cached_table;
+
+   /*
+* Reset the memory area where the firmware loaded the resource table
+* to its original value.  That way when we re-attach the remote
+* processor the resource table is clean and ready to be used again.
+*/
+   memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
+
+   /*
+* The clean resource table is no longer needed.  Allocated in
+* rproc_set_rsc_table().
+*/
+   kfree(rproc->clean_table);
+
+   return 0;
+}
+
 /*
  * Attach to remote processor - similar to rproc_fw_boot() but without
  * the steps that deal with the firmware image.
@@ -1721,6 +1792,9 @@ static int __rproc_detach(struct rproc *rproc)
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, false);
 
+   /* the installed resource table is no longer accessible */
+   ret = rproc_reset_rsc_table_on_detach(rproc);
+
/* Tell the remote processor the core isn't available anymore */
ret = rproc->ops->detach(rproc);
if (ret) {
@@ -1997,6 +2071,9 @@ int rproc_detach(struct rproc *rproc)
 
rproc_disable_iommu(rproc);
 
+   /* Free the copy of the resource table */
+   kfree(rproc->cached_table);
+   rproc->cached_table = NULL;
rproc->table_ptr = NULL;
 out:
mutex_unlock(&rproc->lock);
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index e1c843c19cc6..e5f52a12a650 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -514,6 +514,8 @@ struct rproc_dump_segment {
  * @recovery_disabled: flag that state if recovery was disabled
  * @max_notifyid: largest allocated notify id.
  * @table_pt

Re: [PATCH v6 11/16] remoteproc: Properly deal with the resource table when attached

2021-03-01 Thread Mathieu Poirier

On Fri, Feb 26, 2021 at 05:21:15PM +0100, Arnaud POULIQUEN wrote:
> 
> 
> On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> > If it is possible to detach the remote processor, keep an untouched
> > copy of the resource table.  That way we can start from the same
> > resource table without having to worry about original values or what
> > elements the startup code has changed when re-attaching to the remote
> > processor.
> > 
> > Signed-off-by: Mathieu Poirier 
> > ---
> > New for V6:
> > - Double free of the cached table has been fixed.
> > - rproc_reset_loaded_rsc_table() has seen a complete re-write.
> > - rproc_stop() now calls rproc_reset_loaded_rsc_table() rather than
> >   dealing with the cached.  This allows to properly shutdown a
> >   remote processor that was attached to.
> > ---
> > 
> >  drivers/remoteproc/remoteproc_core.c | 86 +++-
> >  include/linux/remoteproc.h   |  3 +
> >  2 files changed, 88 insertions(+), 1 deletion(-)
> > 
> > diff --git a/drivers/remoteproc/remoteproc_core.c 
> > b/drivers/remoteproc/remoteproc_core.c
> > index fc01b29290a6..3a4692cc5220 100644
> > --- a/drivers/remoteproc/remoteproc_core.c
> > +++ b/drivers/remoteproc/remoteproc_core.c
> > @@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc 
> > *rproc)
> > return ret;
> > }
> >  
> > +   /*
> > +* If it is possible to detach the remote processor, keep an untouched
> > +* copy of the resource table.  That way we can start fresh again when
> > +* the remote processor is re-attached, that is:
> > +*
> > +*  DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> > +*
> > +* Free'd in rproc_reset_loaded_rsc_table().
> > +*/
> > +   if (rproc->ops->detach) {
> > +   rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> > +   if (!rproc->clean_table)
> > +   return -ENOMEM;
> > +   }
> > +
> > rproc->cached_table = NULL;
> > rproc->table_ptr = table_ptr;
> > rproc->table_sz = table_sz;
> > @@ -1563,6 +1578,65 @@ static int rproc_set_loaded_rsc_table(struct rproc 
> > *rproc)
> > return 0;
> >  }
> >  
> > +static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
> 
> I spent some time to review this function that handles both the resource table
> for both the stop and detach. To make it easier to read, I would divide it 
> into
> two functions.

I suspected rproc_reset_loaded_rsc_table() was trying to do too many things for
its own good and you just confirmed that.

> I added a proposal at the end of this mail.
> 
> Regards,
> Arnaud
> 
> > +{
> > +   struct resource_table *table_ptr;
> > +
> > +   /*
> > +* The cached table is already set if the remote processor was started
> > +* by the remoteproc core.
> > +*/
> > +   if (rproc->state == RPROC_RUNNING) {
> > +   rproc->table_ptr = rproc->cached_table;
> > +   return 0;
> > +   }
> > +
> > +   /* A resource table was never retrieved, nothing to do here */
> > +   if (!rproc->table_ptr)
> > +   return 0;
> > +
> > +   /*
> > +* If we made it to this point a cached_table _must_ have been
> > +* allocated in rproc_set_loaded_rsc_table().  If one isn't present
> > +* something went really wrong and we must complain.
> > +*/
> > +   if (WARN_ON(!rproc->clean_table))
> > +   return -EINVAL;
> > +
> > +   /* Remember where the external entity installed the resource table */
> > +   table_ptr = rproc->table_ptr;
> > +
> > +   /*
> > +* Make a copy of the resource table currently used by the remote
> > +* processor.  Free'd in rproc_detach() or rproc_shutdown().
> > +*/
> > +   rproc->cached_table = kmemdup(rproc->table_ptr,
> > + rproc->table_sz, GFP_KERNEL);
> > +   if (!rproc->cached_table)
> > +   return -ENOMEM;
> > +
> > +   /*
> > +* Use a copy of the resource table for the remainder of the
> > +* shutdown process.
> > +*/
> > +   rproc->table_ptr = rproc->cached_table;
> > +
> > +   /*
> > +* Reset the memory area where the firmware loaded the resource table
> > +* to its original value.  That way when we re-attach the remote
> > +* processor the resource table is clean an

Re: [PATCH v6 15/16] remoteproc: Properly deal with a detach request when attached

2021-02-26 Thread Arnaud POULIQUEN




On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> This patch introduces the capability to detach a remote processor
> that has been attached by the remoteproc core.  For that to happen
> a rproc::ops::detach() operation needs to be available.
> 
> Signed-off-by: Mathieu Poirier 

Reviewed-by: Arnaud Pouliquen 

Thanks,
Arnaud

> ---
> New for V6:
> - The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted
>   to avoid dealing with complex resource table management problems.
> - Removed Peng and Arnaud's RB tags because of the above.
> ---
> 
>  drivers/remoteproc/remoteproc_cdev.c  | 5 +
>  drivers/remoteproc/remoteproc_sysfs.c | 5 +
>  2 files changed, 10 insertions(+)
> 
> diff --git a/drivers/remoteproc/remoteproc_cdev.c 
> b/drivers/remoteproc/remoteproc_cdev.c
> index 0249d8f6c3f8..2db494816d5f 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -43,6 +43,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
> char __user *buf, size_
>   return -EINVAL;
>  
>   rproc_shutdown(rproc);
> + } else if (!strncmp(cmd, "detach", len)) {
> + if (rproc->state != RPROC_ATTACHED)
> + return -EINVAL;
> +
> + ret = rproc_detach(rproc);
>   } else {
>   dev_err(&rproc->dev, "Unrecognized option\n");
>   ret = -EINVAL;
> diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
> b/drivers/remoteproc/remoteproc_sysfs.c
> index 09eb700c5e7e..ad3dd208024c 100644
> --- a/drivers/remoteproc/remoteproc_sysfs.c
> +++ b/drivers/remoteproc/remoteproc_sysfs.c
> @@ -207,6 +207,11 @@ static ssize_t state_store(struct device *dev,
>   return -EINVAL;
>  
>   rproc_shutdown(rproc);
> + } else if (sysfs_streq(buf, "detach")) {
> + if (rproc->state != RPROC_ATTACHED)
> + return -EINVAL;
> +
> + ret = rproc_detach(rproc);
>   } else {
>   dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
>   ret = -EINVAL;
>

Re: [PATCH v6 14/16] remoteproc: Properly deal with a stop request when attached

2021-02-26 Thread Arnaud POULIQUEN




On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> Allow a remote processor that was started by another entity to be
> switched off by the remoteproc core.  For that to happen a
> rproc::ops::stop() operation needs to be available.
> 
> Signed-off-by: Mathieu Poirier 

Reviewed-by: Arnaud Pouliquen 

Thanks,
Arnaud

> ---
> New for V6:
> - Removed state check in rproc_shutdown() as it is already done in
>   in calling functions.
> - rproc_shutdown() doesn't return an error code to keep legacy behevior.
> - Removed Peng and Arnaud's RB tags because of the above.
> ---
> 
>  drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
>  drivers/remoteproc/remoteproc_core.c  | 4 
>  drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
>  3 files changed, 8 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/remoteproc/remoteproc_cdev.c 
> b/drivers/remoteproc/remoteproc_cdev.c
> index b2cee9afb41b..0249d8f6c3f8 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -38,7 +38,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
> char __user *buf, size_
>  
>   ret = rproc_boot(rproc);
>   } else if (!strncmp(cmd, "stop", len)) {
> - if (rproc->state != RPROC_RUNNING)
> + if (rproc->state != RPROC_RUNNING &&
> + rproc->state != RPROC_ATTACHED)
>   return -EINVAL;
>  
>   rproc_shutdown(rproc);
> diff --git a/drivers/remoteproc/remoteproc_core.c 
> b/drivers/remoteproc/remoteproc_core.c
> index 0dc518a24104..00452da25fba 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1758,6 +1758,10 @@ static int rproc_stop(struct rproc *rproc, bool 
> crashed)
>   struct device *dev = &rproc->dev;
>   int ret;
>  
> + /* No need to continue if a stop() operation has not been provided */
> + if (!rproc->ops->stop)
> + return -EINVAL;
> +
>   /* Stop any subdevices for the remote processor */
>   rproc_stop_subdevices(rproc, crashed);
>  
> diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
> b/drivers/remoteproc/remoteproc_sysfs.c
> index 66801e6fe5cd..09eb700c5e7e 100644
> --- a/drivers/remoteproc/remoteproc_sysfs.c
> +++ b/drivers/remoteproc/remoteproc_sysfs.c
> @@ -202,7 +202,8 @@ static ssize_t state_store(struct device *dev,
>   if (ret)
>   dev_err(&rproc->dev, "Boot failed: %d\n", ret);
>   } else if (sysfs_streq(buf, "stop")) {
> - if (rproc->state != RPROC_RUNNING)
> + if (rproc->state != RPROC_RUNNING &&
> + rproc->state != RPROC_ATTACHED)
>   return -EINVAL;
>  
>   rproc_shutdown(rproc);
>

Re: [PATCH v6 11/16] remoteproc: Properly deal with the resource table when attached

2021-02-26 Thread Arnaud POULIQUEN




On 2/24/21 12:35 AM, Mathieu Poirier wrote:
> If it is possible to detach the remote processor, keep an untouched
> copy of the resource table.  That way we can start from the same
> resource table without having to worry about original values or what
> elements the startup code has changed when re-attaching to the remote
> processor.
> 
> Signed-off-by: Mathieu Poirier 
> ---
> New for V6:
> - Double free of the cached table has been fixed.
> - rproc_reset_loaded_rsc_table() has seen a complete re-write.
> - rproc_stop() now calls rproc_reset_loaded_rsc_table() rather than
>   dealing with the cached.  This allows to properly shutdown a
>   remote processor that was attached to.
> ---
> 
>  drivers/remoteproc/remoteproc_core.c | 86 +++-
>  include/linux/remoteproc.h   |  3 +
>  2 files changed, 88 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/remoteproc/remoteproc_core.c 
> b/drivers/remoteproc/remoteproc_core.c
> index fc01b29290a6..3a4692cc5220 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc 
> *rproc)
>   return ret;
>   }
>  
> + /*
> +  * If it is possible to detach the remote processor, keep an untouched
> +  * copy of the resource table.  That way we can start fresh again when
> +  * the remote processor is re-attached, that is:
> +  *
> +  *  DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> +  *
> +  * Free'd in rproc_reset_loaded_rsc_table().
> +  */
> + if (rproc->ops->detach) {
> + rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> + if (!rproc->clean_table)
> + return -ENOMEM;
> + }
> +
>   rproc->cached_table = NULL;
>   rproc->table_ptr = table_ptr;
>   rproc->table_sz = table_sz;
> @@ -1563,6 +1578,65 @@ static int rproc_set_loaded_rsc_table(struct rproc 
> *rproc)
>   return 0;
>  }
>  
> +static int rproc_reset_loaded_rsc_table(struct rproc *rproc)

I spent some time to review this function that handles both the resource table
for both the stop and detach. To make it easier to read, I would divide it into
two functions.
I added a proposal at the end of this mail.

Regards,
Arnaud

> +{
> + struct resource_table *table_ptr;
> +
> + /*
> +  * The cached table is already set if the remote processor was started
> +  * by the remoteproc core.
> +  */
> + if (rproc->state == RPROC_RUNNING) {
> + rproc->table_ptr = rproc->cached_table;
> + return 0;
> + }
> +
> + /* A resource table was never retrieved, nothing to do here */
> + if (!rproc->table_ptr)
> + return 0;
> +
> + /*
> +  * If we made it to this point a cached_table _must_ have been
> +  * allocated in rproc_set_loaded_rsc_table().  If one isn't present
> +  * something went really wrong and we must complain.
> +  */
> + if (WARN_ON(!rproc->clean_table))
> + return -EINVAL;
> +
> + /* Remember where the external entity installed the resource table */
> + table_ptr = rproc->table_ptr;
> +
> + /*
> +  * Make a copy of the resource table currently used by the remote
> +  * processor.  Free'd in rproc_detach() or rproc_shutdown().
> +  */
> + rproc->cached_table = kmemdup(rproc->table_ptr,
> +   rproc->table_sz, GFP_KERNEL);
> + if (!rproc->cached_table)
> + return -ENOMEM;
> +
> + /*
> +  * Use a copy of the resource table for the remainder of the
> +  * shutdown process.
> +  */
> + rproc->table_ptr = rproc->cached_table;
> +
> + /*
> +  * Reset the memory area where the firmware loaded the resource table
> +  * to its original value.  That way when we re-attach the remote
> +  * processor the resource table is clean and ready to be used again.
> +  */
> + memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
> +
> + /*
> +  * The clean resource table is no longer needed.  Allocated in
> +  * rproc_set_loaded_rsc_table().
> +  */
> + kfree(rproc->clean_table);
> +
> + return 0;
> +}
> +
>  /*
>   * Attach to remote processor - similar to rproc_fw_boot() but without
>   * the steps that deal with the firmware image.
> @@ -1688,7 +1762,11 @@ static int rproc_stop(struct rproc *rproc, bool 
> crashed)
>   rproc_stop_subdevices(rproc, crashed);
>

[PATCH v6 11/16] remoteproc: Properly deal with the resource table when attached

If it is possible to detach the remote processor, keep an untouched
copy of the resource table.  That way we can start from the same
resource table without having to worry about original values or what
elements the startup code has changed when re-attaching to the remote
processor.

Signed-off-by: Mathieu Poirier 
---
New for V6:
- Double free of the cached table has been fixed.
- rproc_reset_loaded_rsc_table() has seen a complete re-write.
- rproc_stop() now calls rproc_reset_loaded_rsc_table() rather than
  dealing with the cached.  This allows to properly shutdown a
  remote processor that was attached to.
---

 drivers/remoteproc/remoteproc_core.c | 86 +++-
 include/linux/remoteproc.h   |  3 +
 2 files changed, 88 insertions(+), 1 deletion(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index fc01b29290a6..3a4692cc5220 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1556,6 +1556,21 @@ static int rproc_set_loaded_rsc_table(struct rproc 
*rproc)
return ret;
}
 
+   /*
+* If it is possible to detach the remote processor, keep an untouched
+* copy of the resource table.  That way we can start fresh again when
+* the remote processor is re-attached, that is:
+*
+*  DETACHED -> ATTACHED -> DETACHED -> ATTACHED
+*
+* Free'd in rproc_reset_loaded_rsc_table().
+*/
+   if (rproc->ops->detach) {
+   rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
+   if (!rproc->clean_table)
+   return -ENOMEM;
+   }
+
rproc->cached_table = NULL;
rproc->table_ptr = table_ptr;
rproc->table_sz = table_sz;
@@ -1563,6 +1578,65 @@ static int rproc_set_loaded_rsc_table(struct rproc 
*rproc)
return 0;
 }
 
+static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
+{
+   struct resource_table *table_ptr;
+
+   /*
+* The cached table is already set if the remote processor was started
+* by the remoteproc core.
+*/
+   if (rproc->state == RPROC_RUNNING) {
+   rproc->table_ptr = rproc->cached_table;
+   return 0;
+   }
+
+   /* A resource table was never retrieved, nothing to do here */
+   if (!rproc->table_ptr)
+   return 0;
+
+   /*
+* If we made it to this point a cached_table _must_ have been
+* allocated in rproc_set_loaded_rsc_table().  If one isn't present
+* something went really wrong and we must complain.
+*/
+   if (WARN_ON(!rproc->clean_table))
+   return -EINVAL;
+
+   /* Remember where the external entity installed the resource table */
+   table_ptr = rproc->table_ptr;
+
+   /*
+* Make a copy of the resource table currently used by the remote
+* processor.  Free'd in rproc_detach() or rproc_shutdown().
+*/
+   rproc->cached_table = kmemdup(rproc->table_ptr,
+ rproc->table_sz, GFP_KERNEL);
+   if (!rproc->cached_table)
+   return -ENOMEM;
+
+   /*
+* Use a copy of the resource table for the remainder of the
+* shutdown process.
+*/
+   rproc->table_ptr = rproc->cached_table;
+
+   /*
+* Reset the memory area where the firmware loaded the resource table
+* to its original value.  That way when we re-attach the remote
+* processor the resource table is clean and ready to be used again.
+*/
+   memcpy(table_ptr, rproc->clean_table, rproc->table_sz);
+
+   /*
+* The clean resource table is no longer needed.  Allocated in
+* rproc_set_loaded_rsc_table().
+*/
+   kfree(rproc->clean_table);
+
+   return 0;
+}
+
 /*
  * Attach to remote processor - similar to rproc_fw_boot() but without
  * the steps that deal with the firmware image.
@@ -1688,7 +1762,11 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
rproc_stop_subdevices(rproc, crashed);
 
/* the installed resource table is no longer accessible */
-   rproc->table_ptr = rproc->cached_table;
+   ret = rproc_reset_loaded_rsc_table(rproc);
+   if (ret) {
+   dev_err(dev, "can't reset resource table: %d\n", ret);
+   return ret;
+   }
 
/* power off the remote processor */
ret = rproc->ops->stop(rproc);
@@ -1721,6 +1799,9 @@ static int __rproc_detach(struct rproc *rproc)
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, false);
 
+   /* the installed resource table is no longer accessible */
+   ret = rproc_reset_loaded_rsc_table(rproc);
+
/* Tell the remote processor the

[PATCH v6 12/16] remoteproc: Properly deal with a kernel panic when attached

The panic handler operation of registered remote processors
should also be called when remote processors have been
attached to.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_core.c | 6 +-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 3a4692cc5220..0dc518a24104 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2684,7 +2684,11 @@ static int rproc_panic_handler(struct notifier_block 
*nb, unsigned long event,
 
rcu_read_lock();
list_for_each_entry_rcu(rproc, &rproc_list, node) {
-   if (!rproc->ops->panic || rproc->state != RPROC_RUNNING)
+   if (!rproc->ops->panic)
+   continue;
+
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
continue;
 
d = rproc->ops->panic(rproc);
-- 
2.25.1

[PATCH v6 13/16] remoteproc: Properly deal with a start request when attached

This patch takes into account scenarios where a remote processor
has been attached to when receiving a "start" command from sysfs.

As with the case with the running state, the command can't be
carried out if the remote processor is already in operation.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
 drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index b19ea3057bde..b2cee9afb41b 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -32,7 +32,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char 
__user *buf, size_
return -EFAULT;
 
if (!strncmp(cmd, "start", len)) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index f9694def9b54..66801e6fe5cd 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -194,7 +194,8 @@ static ssize_t state_store(struct device *dev,
int ret = 0;
 
if (sysfs_streq(buf, "start")) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
-- 
2.25.1

[PATCH v6 14/16] remoteproc: Properly deal with a stop request when attached

Allow a remote processor that was started by another entity to be
switched off by the remoteproc core.  For that to happen a
rproc::ops::stop() operation needs to be available.

Signed-off-by: Mathieu Poirier 
---
New for V6:
- Removed state check in rproc_shutdown() as it is already done in
  in calling functions.
- rproc_shutdown() doesn't return an error code to keep legacy behevior.
- Removed Peng and Arnaud's RB tags because of the above.
---

 drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
 drivers/remoteproc/remoteproc_core.c  | 4 
 drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index b2cee9afb41b..0249d8f6c3f8 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -38,7 +38,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char 
__user *buf, size_
 
ret = rproc_boot(rproc);
} else if (!strncmp(cmd, "stop", len)) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
rproc_shutdown(rproc);
diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 0dc518a24104..00452da25fba 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1758,6 +1758,10 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
struct device *dev = &rproc->dev;
int ret;
 
+   /* No need to continue if a stop() operation has not been provided */
+   if (!rproc->ops->stop)
+   return -EINVAL;
+
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, crashed);
 
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 66801e6fe5cd..09eb700c5e7e 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -202,7 +202,8 @@ static ssize_t state_store(struct device *dev,
if (ret)
dev_err(&rproc->dev, "Boot failed: %d\n", ret);
} else if (sysfs_streq(buf, "stop")) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
rproc_shutdown(rproc);
-- 
2.25.1

[PATCH v6 15/16] remoteproc: Properly deal with a detach request when attached

This patch introduces the capability to detach a remote processor
that has been attached by the remoteproc core.  For that to happen
a rproc::ops::detach() operation needs to be available.

Signed-off-by: Mathieu Poirier 
---
New for V6:
- The RPROC_RUNNING -> RPROC_DETACHED transition is no longer permitted
  to avoid dealing with complex resource table management problems.
- Removed Peng and Arnaud's RB tags because of the above.
---

 drivers/remoteproc/remoteproc_cdev.c  | 5 +
 drivers/remoteproc/remoteproc_sysfs.c | 5 +
 2 files changed, 10 insertions(+)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index 0249d8f6c3f8..2db494816d5f 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -43,6 +43,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
char __user *buf, size_
return -EINVAL;
 
rproc_shutdown(rproc);
+   } else if (!strncmp(cmd, "detach", len)) {
+   if (rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 09eb700c5e7e..ad3dd208024c 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -207,6 +207,11 @@ static ssize_t state_store(struct device *dev,
return -EINVAL;
 
rproc_shutdown(rproc);
+   } else if (sysfs_streq(buf, "detach")) {
+   if (rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
-- 
2.25.1

Re: [PATCH v5 13/19] remoteproc: Properly deal with the resource table

2021-02-15 Thread Arnaud POULIQUEN




On 2/12/21 12:46 AM, Mathieu Poirier wrote:
> If it is possible to detach the remote processor, keep an untouched
> copy of the resource table.  That way we can start from the same
> resource table without having to worry about original values or what
> elements the startup code has changed when re-attaching to the remote
> processor.
> 
> Reported-by: Arnaud POULIQUEN 
> Signed-off-by: Mathieu Poirier 
> ---
>  drivers/remoteproc/remoteproc_core.c   | 70 ++
>  drivers/remoteproc/remoteproc_elf_loader.c | 24 +++-
>  include/linux/remoteproc.h |  3 +
>  3 files changed, 95 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/remoteproc/remoteproc_core.c 
> b/drivers/remoteproc/remoteproc_core.c
> index 660dcc002ff6..9a77cb6d6470 100644
> --- a/drivers/remoteproc/remoteproc_core.c
> +++ b/drivers/remoteproc/remoteproc_core.c
> @@ -1527,7 +1527,9 @@ static int rproc_fw_boot(struct rproc *rproc, const 
> struct firmware *fw)
>  clean_up_resources:
>   rproc_resource_cleanup(rproc);
>   kfree(rproc->cached_table);
> + kfree(rproc->clean_table);
>   rproc->cached_table = NULL;
> + rproc->clean_table = NULL;
>   rproc->table_ptr = NULL;
>  unprepare_rproc:
>   /* release HW resources if needed */
> @@ -1555,6 +1557,23 @@ static int rproc_set_loaded_rsc_table(struct rproc 
> *rproc)
>   return ret;
>   }
>  
> + /*
> +  * If it is possible to detach the remote processor, keep an untouched
> +  * copy of the resource table.  That way we can start fresh again when
> +  * the remote processor is re-attached, that is:
> +  *
> +  *  DETACHED -> ATTACHED -> DETACHED -> ATTACHED
> +  *
> +  * A clean copy of the table is also taken in rproc_elf_load_rsc_table()
> +  * for cases where the remote processor is booted by the remoteproc
> +  * core and later detached from.
> +  */
> + if (rproc->ops->detach) {
> + rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
> + if (!rproc->clean_table)
> + return -ENOMEM;
> + }
> +
>   /*
>* The resource table is already loaded in device memory, no need
>* to work with a cached table.
> @@ -1566,6 +1585,40 @@ static int rproc_set_loaded_rsc_table(struct rproc 
> *rproc)
>   return 0;
>  }
>  
> +static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
> +{
> + /*
> +  * In order to detach() from a remote processor a clean resource table
> +  * _must_ have been allocated at boot time, either from rproc_fw_boot()
> +  * or from rproc_attach().  If one isn't present something went really
> +  * wrong and we must complain.
> +  */
> + if (WARN_ON(!rproc->clean_table))
> + return -EINVAL;
> +
> + /*
> +  * Install the clean resource table where the firmware, i.e
> +  * rproc_get_loaded_rsc_table(), expects it.
> +  */
> + memcpy(rproc->table_ptr, rproc->clean_table, rproc->table_sz);
> +
> + /*
> +  * If the remote processors was started by the core then a cached_table
> +  * is present and we must follow the same cleanup sequence as we would
> +  * for a shutdown().  As it is in rproc_stop(), use the cached resource
> +  * table for the rest of the detach process since ->table_ptr will
> +  * become invalid as soon as carveouts are released in
> +  * rproc_resource_cleanup().
> +  *
> +  * If the remote processor was started by an external entity the
> +  * cached_table is NULL and the rest of the cleanup code in
> +  * rproc_free_vring() can deal with that.
> +  */
> + rproc->table_ptr = rproc->cached_table;
> +
> + return 0;
> +}
> +
>  /*
>   * Attach to remote processor - similar to rproc_fw_boot() but without
>   * the steps that deal with the firmware image.
> @@ -1947,7 +2000,10 @@ void rproc_shutdown(struct rproc *rproc)
>  
>   /* Free the copy of the resource table */
>   kfree(rproc->cached_table);
> + /* Free the clean resource table */
> + kfree(rproc->clean_table);
>   rproc->cached_table = NULL;
> + rproc->clean_table = NULL;
>   rproc->table_ptr = NULL;
>  out:
>   mutex_unlock(&rproc->lock);
> @@ -2000,6 +2056,16 @@ int rproc_detach(struct rproc *rproc)
>   goto out;
>   }
>  
> + /*
> +  * Install a clean resource table for re-attach while
> +  * rproc->table_ptr is still valid.
> +  */
> + ret = rproc_reset_loaded_rsc_table(rp

Re: [PATCH v5 13/19] remoteproc: Properly deal with the resource table

2021-02-15 Thread Dan Carpenter

Hi Mathieu,

url:
https://github.com/0day-ci/linux/commits/Mathieu-Poirier/remoteproc-Add-support-for-detaching-a-remote-processor/20210212-075607
base:   https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
config: ia64-randconfig-m031-20210209 (attached as .config)
compiler: ia64-linux-gcc (GCC) 9.3.0

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot 
Reported-by: Dan Carpenter 

smatch warnings:
drivers/remoteproc/remoteproc_core.c:2080 rproc_detach() error: double free of 
'rproc->cached_table'

vim +2080 drivers/remoteproc/remoteproc_core.c

eab58da78fe46f Mathieu Poirier 2021-02-11  2069 /* clean up all 
acquired resources */
eab58da78fe46f Mathieu Poirier 2021-02-11  2070 
rproc_resource_cleanup(rproc);
eab58da78fe46f Mathieu Poirier 2021-02-11  2071  
eab58da78fe46f Mathieu Poirier 2021-02-11  2072 /* release HW resources 
if needed */
eab58da78fe46f Mathieu Poirier 2021-02-11  2073 
rproc_unprepare_device(rproc);
eab58da78fe46f Mathieu Poirier 2021-02-11  2074  
eab58da78fe46f Mathieu Poirier 2021-02-11  2075 
rproc_disable_iommu(rproc);
eab58da78fe46f Mathieu Poirier 2021-02-11  2076  
66e2fed7a4bb20 Mathieu Poirier 2021-02-11  2077 /* Free the copy of the 
resource table */
66e2fed7a4bb20 Mathieu Poirier 2021-02-11  2078 
kfree(rproc->cached_table);

^^
eab58da78fe46f Mathieu Poirier 2021-02-11  2079 /* Follow the same 
sequence as in rproc_shutdown() */
eab58da78fe46f Mathieu Poirier 2021-02-11 @2080 
kfree(rproc->cached_table);

^^
Double free.

eab58da78fe46f Mathieu Poirier 2021-02-11  2081 rproc->cached_table = 
NULL;
66e2fed7a4bb20 Mathieu Poirier 2021-02-11  2082 rproc->clean_table = 
NULL;
eab58da78fe46f Mathieu Poirier 2021-02-11  2083 rproc->table_ptr = NULL;
66e2fed7a4bb20 Mathieu Poirier 2021-02-11  2084  
eab58da78fe46f Mathieu Poirier 2021-02-11  2085  out:
eab58da78fe46f Mathieu Poirier 2021-02-11  2086 
mutex_unlock(&rproc->lock);
eab58da78fe46f Mathieu Poirier 2021-02-11  2087 return ret;
eab58da78fe46f Mathieu Poirier 2021-02-11  2088  }

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-...@lists.01.org


.config.gz
Description: application/gzip

Re: [PATCH v5 13/19] remoteproc: Properly deal with the resource table (fwd)

2021-02-14 Thread Julia Lawall

There are identical kfrees on lines 2078 and 2080.

julia

-- Forwarded message --
Date: Fri, 12 Feb 2021 10:45:50 +0800
From: kernel test robot 
To: kbu...@lists.01.org
Cc: l...@intel.com, Julia Lawall 
Subject: Re: [PATCH v5 13/19] remoteproc: Properly deal with the resource table

CC: kbuild-...@lists.01.org
In-Reply-To: <20210211234627.2669674-14-mathieu.poir...@linaro.org>
References: <20210211234627.2669674-14-mathieu.poir...@linaro.org>
TO: Mathieu Poirier 
TO: o...@wizery.com
TO: bjorn.anders...@linaro.org
TO: arnaud.pouliq...@st.com
CC: robh...@kernel.org
CC: mcoquelin.st...@gmail.com
CC: alexandre.tor...@st.com
CC: linux-remotep...@vger.kernel.org
CC: devicet...@vger.kernel.org
CC: linux-kernel@vger.kernel.org
CC: linux-arm-ker...@lists.infradead.org

Hi Mathieu,

I love your patch! Perhaps something to improve:

[auto build test WARNING on robh/for-next]
[also build test WARNING on linus/master v5.11-rc7 next-20210211]
[cannot apply to remoteproc/for-next rpmsg/for-next]
[If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:
https://github.com/0day-ci/linux/commits/Mathieu-Poirier/remoteproc-Add-support-for-detaching-a-remote-processor/20210212-075607
base:   https://git.kernel.org/pub/scm/linux/kernel/git/robh/linux.git for-next
:: branch date: 3 hours ago
:: commit date: 3 hours ago
config: openrisc-randconfig-c003-20210209 (attached as .config)
compiler: or1k-linux-gcc (GCC) 9.3.0

If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot 
Reported-by: Julia Lawall 


"coccinelle warnings: (new ones prefixed by >>)"
>> drivers/remoteproc/remoteproc_core.c:2080:7-26: ERROR: reference preceded by 
>> free on line 2078

vim +2080 drivers/remoteproc/remoteproc_core.c

400e64df6b237e Ohad Ben-Cohen  2011-10-20  2012
eab58da78fe46f Mathieu Poirier 2021-02-11  2013  /**
eab58da78fe46f Mathieu Poirier 2021-02-11  2014   * rproc_detach() - Detach the 
remote processor from the
eab58da78fe46f Mathieu Poirier 2021-02-11  2015   * remoteproc core
eab58da78fe46f Mathieu Poirier 2021-02-11  2016   *
eab58da78fe46f Mathieu Poirier 2021-02-11  2017   * @rproc: the remote processor
eab58da78fe46f Mathieu Poirier 2021-02-11  2018   *
eab58da78fe46f Mathieu Poirier 2021-02-11  2019   * Detach a remote processor 
(previously attached to with rproc_attach()).
eab58da78fe46f Mathieu Poirier 2021-02-11  2020   *
eab58da78fe46f Mathieu Poirier 2021-02-11  2021   * In case @rproc is still 
being used by an additional user(s), then
eab58da78fe46f Mathieu Poirier 2021-02-11  2022   * this function will just 
decrement the power refcount and exit,
eab58da78fe46f Mathieu Poirier 2021-02-11  2023   * without disconnecting the 
device.
eab58da78fe46f Mathieu Poirier 2021-02-11  2024   *
eab58da78fe46f Mathieu Poirier 2021-02-11  2025   * Function rproc_detach() 
calls __rproc_detach() in order to let a remote
eab58da78fe46f Mathieu Poirier 2021-02-11  2026   * processor know that 
services provided by the application processor are
eab58da78fe46f Mathieu Poirier 2021-02-11  2027   * no longer available.  From 
there it should be possible to remove the
eab58da78fe46f Mathieu Poirier 2021-02-11  2028   * platform driver and even 
power cycle the application processor (if the HW
eab58da78fe46f Mathieu Poirier 2021-02-11  2029   * supports it) without 
needing to switch off the remote processor.
eab58da78fe46f Mathieu Poirier 2021-02-11  2030   */
eab58da78fe46f Mathieu Poirier 2021-02-11  2031  int rproc_detach(struct rproc 
*rproc)
eab58da78fe46f Mathieu Poirier 2021-02-11  2032  {
eab58da78fe46f Mathieu Poirier 2021-02-11  2033 struct device *dev = 
&rproc->dev;
eab58da78fe46f Mathieu Poirier 2021-02-11  2034 int ret;
eab58da78fe46f Mathieu Poirier 2021-02-11  2035
eab58da78fe46f Mathieu Poirier 2021-02-11  2036 ret = 
mutex_lock_interruptible(&rproc->lock);
eab58da78fe46f Mathieu Poirier 2021-02-11  2037 if (ret) {
eab58da78fe46f Mathieu Poirier 2021-02-11  2038 dev_err(dev, 
"can't lock rproc %s: %d\n", rproc->name, ret);
eab58da78fe46f Mathieu Poirier 2021-02-11  2039 return ret;
eab58da78fe46f Mathieu Poirier 2021-02-11  2040 }
eab58da78fe46f Mathieu Poirier 2021-02-11  2041
eab58da78fe46f Mathieu Poirier 2021-02-11  2042 if (rproc->state != 
RPROC_RUNNING && rproc->state != RPROC_ATTACHED) {
eab58da78fe46f Mathieu Poirier 2021-02-11  2043 ret = -EPERM;
eab58da78fe46f Mathieu Poirier 2021-02-11  2044 goto out;
eab58da78fe46f Mathieu Poirier 2021-02-11  2045 }
eab58da78fe46f Mathieu Poirier 2021-02-11  2046
eab58da78fe46f Mathieu Poirier 2021-02-11  2047 /* if the remote proc 
is still needed, bail out */

[tip: core/rcu] torture: Make torture.sh rcuscale and refscale deal with allmodconfig

2021-02-12 Thread tip-bot2 for Paul E. McKenney

The following commit has been merged into the core/rcu branch of tip:

Commit-ID: 7a99487c76aad613b7533e3ea1b8d3eaf30ca37e
Gitweb:
https://git.kernel.org/tip/7a99487c76aad613b7533e3ea1b8d3eaf30ca37e
Author:Paul E. McKenney 
AuthorDate:Tue, 24 Nov 2020 18:57:47 -08:00
Committer: Paul E. McKenney 
CommitterDate: Wed, 06 Jan 2021 17:03:42 -08:00

torture: Make torture.sh rcuscale and refscale deal with allmodconfig

The .mod.c files created by allmodconfig builds interfers with the approach
torture.sh uses to enumerate types of rcuscale and refscale runs.  This
commit therefore tightens the pattern matching to avoid this interference.

Signed-off-by: Paul E. McKenney 
---
 tools/testing/selftests/rcutorture/bin/torture.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/testing/selftests/rcutorture/bin/torture.sh 
b/tools/testing/selftests/rcutorture/bin/torture.sh
index 8e66797..a89b521 100755
--- a/tools/testing/selftests/rcutorture/bin/torture.sh
+++ b/tools/testing/selftests/rcutorture/bin/torture.sh
@@ -302,7 +302,7 @@ fi
 
 if test "$do_refscale" = yes
 then
-   primlist="`grep '\.name[]*=' kernel/rcu/refscale*.c | sed -e 
's/^[^"]*"//' -e 's/".*$//'`"
+   primlist="`grep '\.name[]*=' kernel/rcu/refscale.c | sed -e 
's/^[^"]*"//' -e 's/".*$//'`"
 else
primlist=
 fi
@@ -314,7 +314,7 @@ done
 
 if test "$do_rcuscale" = yes
 then
-   primlist="`grep '\.name[]*=' kernel/rcu/rcuscale*.c | sed -e 
's/^[^"]*"//' -e 's/".*$//'`"
+   primlist="`grep '\.name[]*=' kernel/rcu/rcuscale.c | sed -e 
's/^[^"]*"//' -e 's/".*$//'`"
 else
primlist=
 fi

[PATCH v5 18/19] remoteproc: Properly deal with detach request

This patch introduces the capability to detach a remote processor
that has been attached to or booted by the remoteproc core.  For
that to happen a rproc::ops::detach() operation need to be
available.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 6 ++
 drivers/remoteproc/remoteproc_sysfs.c | 6 ++
 2 files changed, 12 insertions(+)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index 61541bc7d26c..f7645f289563 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -43,6 +43,12 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
char __user *buf, size_
return -EINVAL;
 
ret = rproc_shutdown(rproc);
+   } else if (!strncmp(cmd, "detach", len)) {
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 7d281cfe3e03..5a239df5877e 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -207,6 +207,12 @@ static ssize_t state_store(struct device *dev,
return -EINVAL;
 
ret = rproc_shutdown(rproc);
+   } else if (sysfs_streq(buf, "detach")) {
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
-- 
2.25.1

[PATCH v5 17/19] remoteproc: Properly deal with a start request when attached

This patch takes into account scenarios where a remote processor
has been attached to when receiving a "start" command from sysfs.

As with the "running" case, the command can't be carried out if the
remote processor is already in operation.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
 drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index d06f8d4919c7..61541bc7d26c 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -32,7 +32,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char 
__user *buf, size_
return -EFAULT;
 
if (!strncmp(cmd, "start", len)) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 3696f2ccc785..7d281cfe3e03 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -194,7 +194,8 @@ static ssize_t state_store(struct device *dev,
int ret = 0;
 
if (sysfs_streq(buf, "start")) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
-- 
2.25.1

[PATCH v5 16/19] remoteproc: Properly deal with a stop request when attached

This patch introduces the capability to stop a remote processor
that has been attached to by the remoteproc core.  For that to
happen a rproc::ops::stop() operation need to be available.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 5 +++--
 drivers/remoteproc/remoteproc_core.c  | 6 +-
 drivers/remoteproc/remoteproc_sysfs.c | 5 +++--
 3 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index b19ea3057bde..d06f8d4919c7 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -37,10 +37,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
char __user *buf, size_
 
ret = rproc_boot(rproc);
} else if (!strncmp(cmd, "stop", len)) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
-   rproc_shutdown(rproc);
+   ret = rproc_shutdown(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 0dd9f02f52b6..12bd177aa8cd 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1740,6 +1740,10 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
struct device *dev = &rproc->dev;
int ret;
 
+   /* No need to continue if a stop() operation has not been provided */
+   if (!rproc->ops->stop)
+   return -EINVAL;
+
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, crashed);
 
@@ -1977,7 +1981,7 @@ int rproc_shutdown(struct rproc *rproc)
return ret;
}
 
-   if (rproc->state != RPROC_RUNNING) {
+   if (rproc->state != RPROC_RUNNING && rproc->state != RPROC_ATTACHED) {
ret = -EPERM;
goto out;
}
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index f9694def9b54..3696f2ccc785 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -201,10 +201,11 @@ static ssize_t state_store(struct device *dev,
if (ret)
dev_err(&rproc->dev, "Boot failed: %d\n", ret);
} else if (sysfs_streq(buf, "stop")) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
-   rproc_shutdown(rproc);
+   ret = rproc_shutdown(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
-- 
2.25.1

[PATCH v5 15/19] remoteproc: Properly deal with a kernel panic when attached

The panic handler operation of registered remote processors
should also be called when remote processors have been
attached to.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_core.c | 6 +-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 62f708662052..0dd9f02f52b6 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2693,7 +2693,11 @@ static int rproc_panic_handler(struct notifier_block 
*nb, unsigned long event,
 
rcu_read_lock();
list_for_each_entry_rcu(rproc, &rproc_list, node) {
-   if (!rproc->ops->panic || rproc->state != RPROC_RUNNING)
+   if (!rproc->ops->panic)
+   continue;
+
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
continue;
 
d = rproc->ops->panic(rproc);
-- 
2.25.1

[PATCH v5 13/19] remoteproc: Properly deal with the resource table

If it is possible to detach the remote processor, keep an untouched
copy of the resource table.  That way we can start from the same
resource table without having to worry about original values or what
elements the startup code has changed when re-attaching to the remote
processor.

Reported-by: Arnaud POULIQUEN 
Signed-off-by: Mathieu Poirier 
---
 drivers/remoteproc/remoteproc_core.c   | 70 ++
 drivers/remoteproc/remoteproc_elf_loader.c | 24 +++-
 include/linux/remoteproc.h |  3 +
 3 files changed, 95 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 660dcc002ff6..9a77cb6d6470 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1527,7 +1527,9 @@ static int rproc_fw_boot(struct rproc *rproc, const 
struct firmware *fw)
 clean_up_resources:
rproc_resource_cleanup(rproc);
kfree(rproc->cached_table);
+   kfree(rproc->clean_table);
rproc->cached_table = NULL;
+   rproc->clean_table = NULL;
rproc->table_ptr = NULL;
 unprepare_rproc:
/* release HW resources if needed */
@@ -1555,6 +1557,23 @@ static int rproc_set_loaded_rsc_table(struct rproc 
*rproc)
return ret;
}
 
+   /*
+* If it is possible to detach the remote processor, keep an untouched
+* copy of the resource table.  That way we can start fresh again when
+* the remote processor is re-attached, that is:
+*
+*  DETACHED -> ATTACHED -> DETACHED -> ATTACHED
+*
+* A clean copy of the table is also taken in rproc_elf_load_rsc_table()
+* for cases where the remote processor is booted by the remoteproc
+* core and later detached from.
+*/
+   if (rproc->ops->detach) {
+   rproc->clean_table = kmemdup(table_ptr, table_sz, GFP_KERNEL);
+   if (!rproc->clean_table)
+   return -ENOMEM;
+   }
+
/*
 * The resource table is already loaded in device memory, no need
 * to work with a cached table.
@@ -1566,6 +1585,40 @@ static int rproc_set_loaded_rsc_table(struct rproc 
*rproc)
return 0;
 }
 
+static int rproc_reset_loaded_rsc_table(struct rproc *rproc)
+{
+   /*
+* In order to detach() from a remote processor a clean resource table
+* _must_ have been allocated at boot time, either from rproc_fw_boot()
+* or from rproc_attach().  If one isn't present something went really
+* wrong and we must complain.
+*/
+   if (WARN_ON(!rproc->clean_table))
+   return -EINVAL;
+
+   /*
+* Install the clean resource table where the firmware, i.e
+* rproc_get_loaded_rsc_table(), expects it.
+*/
+   memcpy(rproc->table_ptr, rproc->clean_table, rproc->table_sz);
+
+   /*
+* If the remote processors was started by the core then a cached_table
+* is present and we must follow the same cleanup sequence as we would
+* for a shutdown().  As it is in rproc_stop(), use the cached resource
+* table for the rest of the detach process since ->table_ptr will
+* become invalid as soon as carveouts are released in
+* rproc_resource_cleanup().
+*
+* If the remote processor was started by an external entity the
+* cached_table is NULL and the rest of the cleanup code in
+* rproc_free_vring() can deal with that.
+*/
+   rproc->table_ptr = rproc->cached_table;
+
+   return 0;
+}
+
 /*
  * Attach to remote processor - similar to rproc_fw_boot() but without
  * the steps that deal with the firmware image.
@@ -1947,7 +2000,10 @@ void rproc_shutdown(struct rproc *rproc)
 
/* Free the copy of the resource table */
kfree(rproc->cached_table);
+   /* Free the clean resource table */
+   kfree(rproc->clean_table);
rproc->cached_table = NULL;
+   rproc->clean_table = NULL;
rproc->table_ptr = NULL;
 out:
mutex_unlock(&rproc->lock);
@@ -2000,6 +2056,16 @@ int rproc_detach(struct rproc *rproc)
goto out;
}
 
+   /*
+* Install a clean resource table for re-attach while
+* rproc->table_ptr is still valid.
+*/
+   ret = rproc_reset_loaded_rsc_table(rproc);
+   if (ret) {
+   atomic_inc(&rproc->power);
+   goto out;
+   }
+
/* clean up all acquired resources */
rproc_resource_cleanup(rproc);
 
@@ -2008,10 +2074,14 @@ int rproc_detach(struct rproc *rproc)
 
rproc_disable_iommu(rproc);
 
+   /* Free the copy of the resource table */
+   kfree(rproc->cached_table);
/* Follow the same sequence as in rproc_shutdown() */
kfree(rproc->cached_tab

[PATCH 2/3] rcu: dont special case "all" handling; let bitmask deal with it

2021-01-21 Thread Paul Gortmaker

Now that the core bitmap parse code respects the "all" parameter, there
is no need for RCU to have its own special check for it.

Cc: Yury Norov 
Cc: Peter Zijlstra 
Cc: "Paul E. McKenney" 
Signed-off-by: Paul Gortmaker 
---
 Documentation/admin-guide/kernel-parameters.txt |  4 +---
 kernel/rcu/tree_plugin.h| 13 -
 2 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/Documentation/admin-guide/kernel-parameters.txt 
b/Documentation/admin-guide/kernel-parameters.txt
index a10b545c2070..a116c0ff0a91 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -4037,9 +4037,7 @@
see CONFIG_RAS_CEC help text.
 
rcu_nocbs=  [KNL]
-   The argument is a cpu list, as described above,
-   except that the string "all" can be used to
-   specify every CPU on the system.
+   The argument is a cpu list, as described above.
 
In kernels built with CONFIG_RCU_NOCB_CPU=y, set
the specified list of CPUs to be no-callback CPUs.
diff --git a/kernel/rcu/tree_plugin.h b/kernel/rcu/tree_plugin.h
index 7e291ce0a1d6..642ebd6569c7 100644
--- a/kernel/rcu/tree_plugin.h
+++ b/kernel/rcu/tree_plugin.h
@@ -1463,20 +1463,15 @@ static void rcu_cleanup_after_idle(void)
 
 /*
  * Parse the boot-time rcu_nocb_mask CPU list from the kernel parameters.
- * The string after the "rcu_nocbs=" is either "all" for all CPUs, or a
- * comma-separated list of CPUs and/or CPU ranges.  If an invalid list is
- * given, a warning is emitted and all CPUs are offloaded.
+ * If the list is invalid, a warning is emitted and all CPUs are offloaded.
  */
 static int __init rcu_nocb_setup(char *str)
 {
alloc_bootmem_cpumask_var(&rcu_nocb_mask);
-   if (!strcasecmp(str, "all"))
+   if (cpulist_parse(str, rcu_nocb_mask)) {
+   pr_warn("rcu_nocbs= bad CPU range, all CPUs set\n");
cpumask_setall(rcu_nocb_mask);
-   else
-   if (cpulist_parse(str, rcu_nocb_mask)) {
-   pr_warn("rcu_nocbs= bad CPU range, all CPUs set\n");
-   cpumask_setall(rcu_nocb_mask);
-   }
+   }
return 1;
 }
 __setup("rcu_nocbs=", rcu_nocb_setup);
-- 
2.17.1

Grsecurity GPL Violations: Linus/FSF/SFConservancy won't defend. Claw back your copyrights. BSD-in-Practice was not the deal.

2021-01-09 Thread nipponmail

Silence is consent.

Are there FOSS developers making decent money via Patreon, GoFundMe,
whatever?

Yes, Grsecurity is making good money.
They simply added a no-redistribution agreement to their patch of the
Linux Kernel.
(
https://perens.com/2017/06/28/warning-grsecurity-potential-contributory-infringement-risk-for-customers/
)

The FSF, Software Freedom Conservancy, and the Corporate Linux Kernel
Developers all agree that this is fine (silence is consent).

https://twitter.com/spendergrsec/status/1293155787859206146
Importantly, neither the FSF nor the SFC, nor in fact any actual lawyer
agrees with this bizarre claim from an anonymous troll. More info about
the source of the claim can be found here:
https://grsecurity.net/setting_the_record_straight_on_oss_v_perens_part1

Thanks for doing your part, "Dr" to continue the troll's harrassment

LOL. " #GRSecurity violates both the Linux kernel's copyright and the
#GCC #copyright by forbidding redistribution of the patches (in their
Access Agreement): which are non-seperable derivative works...

Contributors should blanket-revoke their contributions from all
free-takers since they didn't agree to BSD-in-Practice. They should also
claw-back any transferred copyrights from the FSF using the 30 year
clawback provision in the US Copyright Act. Design of how a program
works is a copyrightable aspect (Ex: How RMS designed GCC 30 years ago
or so etc)

Had to repost this because the linux admins deleted the email:

https://lkml.org/lkml/2020/12/28/2518
The message you requested cannot be found.
The message you requested cannot be found. The message with the url
http://feisty.lkml.org/lkml/2020/12/28/2518 does not exist in the
database.

Grsecurity GPL Violations: Bring a CASE act claim every time GrSecurity
releases a new infringing work?

(GRSecurity blatantly violates the clause in the Linux kernel and
GCC copyright licenses regarding adding addtional terms between the
licensee of the kernel / gcc and furthur down-the-line licensees,
regarding derivative works)

(The linux kernel has 1000s of copyright holders)
(All who shake at the knees at the thought of initiating a federal
Copyright lawsuit)

[PATCH tip/core/rcu 08/18] torture: Make torture.sh rcuscale and refscale deal with allmodconfig

2021-01-06 Thread paulmck

From: "Paul E. McKenney" 

The .mod.c files created by allmodconfig builds interfers with the approach
torture.sh uses to enumerate types of rcuscale and refscale runs.  This
commit therefore tightens the pattern matching to avoid this interference.

Signed-off-by: Paul E. McKenney 
---
 tools/testing/selftests/rcutorture/bin/torture.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/testing/selftests/rcutorture/bin/torture.sh 
b/tools/testing/selftests/rcutorture/bin/torture.sh
index 8e66797..a89b521 100755
--- a/tools/testing/selftests/rcutorture/bin/torture.sh
+++ b/tools/testing/selftests/rcutorture/bin/torture.sh
@@ -302,7 +302,7 @@ fi
 
 if test "$do_refscale" = yes
 then
-   primlist="`grep '\.name[]*=' kernel/rcu/refscale*.c | sed -e 
's/^[^"]*"//' -e 's/".*$//'`"
+   primlist="`grep '\.name[]*=' kernel/rcu/refscale.c | sed -e 
's/^[^"]*"//' -e 's/".*$//'`"
 else
primlist=
 fi
@@ -314,7 +314,7 @@ done
 
 if test "$do_rcuscale" = yes
 then
-   primlist="`grep '\.name[]*=' kernel/rcu/rcuscale*.c | sed -e 
's/^[^"]*"//' -e 's/".*$//'`"
+   primlist="`grep '\.name[]*=' kernel/rcu/rcuscale.c | sed -e 
's/^[^"]*"//' -e 's/".*$//'`"
 else
primlist=
 fi
-- 
2.9.5

Grsecurity GPL Violations: Linus/FSF/SFConservancy won't defend. Claw back your copyrights. BSD-in-Practice was not the deal.

2021-01-01 Thread nipponmail

Silence is consent.

Are there FOSS developers making decent money via Patreon, GoFundMe,
whatever?

The FSF, Software Freedom Conservancy, and the Corporate Linux Kernel
Developers all agree that this is fine (silence is consent).

Thanks for doing your part, "Dr" to continue the troll's harrassment

Had to repost this because the linux admins deleted the email:

Grsecurity GPL Violations: Bring a CASE act claim every time GrSecurity
releases a new infringing work?

(The linux kernel has 1000s of copyright holders)
(All who shake at the knees at the thought of initiating a federal
Copyright lawsuit)

[PATCH 5.4 010/453] PM: runtime: Add pm_runtime_resume_and_get to deal with usage counter

2020-12-28 Thread Greg Kroah-Hartman

From: Zhang Qilong 

[ Upstream commit dd8088d5a8969dc2b42f71d7bc01c25c61a78066 ]

In many case, we need to check return value of pm_runtime_get_sync, but
it brings a trouble to the usage counter processing. Many callers forget
to decrease the usage counter when it failed, which could resulted in
reference leak. It has been discussed a lot[0][1]. So we add a function
to deal with the usage counter for better coding.

[0]https://lkml.org/lkml/2020/6/14/88
[1]https://patchwork.ozlabs.org/project/linux-tegra/list/?series=178139
Signed-off-by: Zhang Qilong 
Acked-by: Rafael J. Wysocki  
Signed-off-by: Jakub Kicinski 
Signed-off-by: Sasha Levin 
---
 include/linux/pm_runtime.h | 21 +
 1 file changed, 21 insertions(+)

diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index fe61e3b9a9ca2..7145795b4b9da 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -224,6 +224,27 @@ static inline int pm_runtime_get_sync(struct device *dev)
return __pm_runtime_resume(dev, RPM_GET_PUT);
 }
 
+/**
+ * pm_runtime_resume_and_get - Bump up usage counter of a device and resume it.
+ * @dev: Target device.
+ *
+ * Resume @dev synchronously and if that is successful, increment its runtime
+ * PM usage counter. Return 0 if the runtime PM usage counter of @dev has been
+ * incremented or a negative error code otherwise.
+ */
+static inline int pm_runtime_resume_and_get(struct device *dev)
+{
+   int ret;
+
+   ret = __pm_runtime_resume(dev, RPM_GET_PUT);
+   if (ret < 0) {
+   pm_runtime_put_noidle(dev);
+   return ret;
+   }
+
+   return 0;
+}
+
 static inline int pm_runtime_put(struct device *dev)
 {
return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
-- 
2.27.0

[PATCH v4 16/17] remoteproc: Properly deal with detach request

This patch introduces the capability to detach a remote processor
that has been attached to or booted by the remoteproc core.  For
that to happen a rproc::ops::detach() operation need to be
available.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 6 ++
 drivers/remoteproc/remoteproc_sysfs.c | 6 ++
 2 files changed, 12 insertions(+)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index 61541bc7d26c..f7645f289563 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -43,6 +43,12 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
char __user *buf, size_
return -EINVAL;
 
ret = rproc_shutdown(rproc);
+   } else if (!strncmp(cmd, "detach", len)) {
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 298052c9d068..ea7b067fe89a 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -236,6 +236,12 @@ static ssize_t state_store(struct device *dev,
return -EINVAL;
 
ret = rproc_shutdown(rproc);
+   } else if (sysfs_streq(buf, "detach")) {
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
-- 
2.25.1

[PATCH v4 09/17] remoteproc: Properly deal with a kernel panic when attached

The panic handler operation of registered remote processors
should also be called when remote processors have been
attached to.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_core.c | 6 +-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 19545b7925e2..fc28053c7f89 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2414,7 +2414,11 @@ static int rproc_panic_handler(struct notifier_block 
*nb, unsigned long event,
 
rcu_read_lock();
list_for_each_entry_rcu(rproc, &rproc_list, node) {
-   if (!rproc->ops->panic || rproc->state != RPROC_RUNNING)
+   if (!rproc->ops->panic)
+   continue;
+
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
continue;
 
d = rproc->ops->panic(rproc);
-- 
2.25.1

[PATCH v4 14/17] remoteproc: Properly deal with a stop request when attached

This patch introduces the capability to stop a remote processor
that has been attached to by the remoteproc core.  For that to
happen a rproc::ops::stop() operation need to be available.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 5 +++--
 drivers/remoteproc/remoteproc_core.c  | 6 +-
 drivers/remoteproc/remoteproc_sysfs.c | 5 +++--
 3 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index b19ea3057bde..d06f8d4919c7 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -37,10 +37,11 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
char __user *buf, size_
 
ret = rproc_boot(rproc);
} else if (!strncmp(cmd, "stop", len)) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
-   rproc_shutdown(rproc);
+   ret = rproc_shutdown(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 90057ad1bb6c..2fe42ac7ca89 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -1648,6 +1648,10 @@ static int rproc_stop(struct rproc *rproc, bool crashed)
struct device *dev = &rproc->dev;
int ret;
 
+   /* No need to continue if a stop() operation has not been provided */
+   if (!rproc->ops->stop)
+   return -EINVAL;
+
/* Stop any subdevices for the remote processor */
rproc_stop_subdevices(rproc, crashed);
 
@@ -1897,7 +1901,7 @@ int rproc_shutdown(struct rproc *rproc)
return ret;
}
 
-   if (rproc->state != RPROC_RUNNING) {
+   if (rproc->state != RPROC_RUNNING && rproc->state != RPROC_ATTACHED) {
ret = -EPERM;
goto out;
}
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 99ff51fd9707..96751c087585 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -230,10 +230,11 @@ static ssize_t state_store(struct device *dev,
if (ret)
dev_err(&rproc->dev, "Boot failed: %d\n", ret);
} else if (sysfs_streq(buf, "stop")) {
-   if (rproc->state != RPROC_RUNNING)
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
return -EINVAL;
 
-   rproc_shutdown(rproc);
+   ret = rproc_shutdown(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
-- 
2.25.1

[PATCH v4 15/17] remoteproc: Properly deal with a start request when attached

This patch takes into account scenarios where a remote processor
has been attached to when receiving a "start" command from sysfs.

As with the "running" case, the command can't be carried out if the
remote processor is already in operation.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
 drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index d06f8d4919c7..61541bc7d26c 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -32,7 +32,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char 
__user *buf, size_
return -EFAULT;
 
if (!strncmp(cmd, "start", len)) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 96751c087585..298052c9d068 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -223,7 +223,8 @@ static ssize_t state_store(struct device *dev,
int ret = 0;
 
if (sysfs_streq(buf, "start")) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
-- 
2.25.1

Re: [PATCH v3 14/15] remoteproc: Properly deal with detach request

2020-12-09 Thread Arnaud POULIQUEN




On 11/26/20 10:06 PM, Mathieu Poirier wrote:
> This patch introduces the capability to detach a remote processor
> that has been attached to or booted by the remoteproc core.  For
> that to happen a rproc::ops::detach() operation need to be
> available.
> 
> Signed-off-by: Mathieu Poirier 
> Reviewed-by: Peng Fan 

Reviewed-by: Arnaud Pouliquen 

Thanks,
Arnaud
> ---
>  drivers/remoteproc/remoteproc_cdev.c  | 6 ++
>  drivers/remoteproc/remoteproc_sysfs.c | 6 ++
>  2 files changed, 12 insertions(+)
> 
> diff --git a/drivers/remoteproc/remoteproc_cdev.c 
> b/drivers/remoteproc/remoteproc_cdev.c
> index 61541bc7d26c..f7645f289563 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -43,6 +43,12 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
> char __user *buf, size_
>   return -EINVAL;
>  
>   ret = rproc_shutdown(rproc);
> + } else if (!strncmp(cmd, "detach", len)) {
> + if (rproc->state != RPROC_RUNNING &&
> + rproc->state != RPROC_ATTACHED)
> + return -EINVAL;
> +
> + ret = rproc_detach(rproc);
>   } else {
>   dev_err(&rproc->dev, "Unrecognized option\n");
>   ret = -EINVAL;
> diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
> b/drivers/remoteproc/remoteproc_sysfs.c
> index 7d281cfe3e03..5a239df5877e 100644
> --- a/drivers/remoteproc/remoteproc_sysfs.c
> +++ b/drivers/remoteproc/remoteproc_sysfs.c
> @@ -207,6 +207,12 @@ static ssize_t state_store(struct device *dev,
>   return -EINVAL;
>  
>   ret = rproc_shutdown(rproc);
> + } else if (sysfs_streq(buf, "detach")) {
> + if (rproc->state != RPROC_RUNNING &&
> + rproc->state != RPROC_ATTACHED)
> + return -EINVAL;
> +
> + ret = rproc_detach(rproc);
>   } else {
>   dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
>   ret = -EINVAL;
>

Re: [PATCH v3 13/15] remoteproc: Properly deal with a start request when attached

2020-12-02 Thread Arnaud POULIQUEN




On 11/26/20 10:06 PM, Mathieu Poirier wrote:
> This patch takes into account scenarios where a remote processor
> has been attached to when receiving a "start" command from sysfs.
> 
> As with the "running" case, the command can't be carried out if the
> remote processor is already in operation.
> 
> Signed-off-by: Mathieu Poirier 


Reviewed-by: Arnaud Pouliquen 

Thanks,
Arnaud

> ---
>  drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
>  drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
>  2 files changed, 4 insertions(+), 2 deletions(-)
> 
> diff --git a/drivers/remoteproc/remoteproc_cdev.c 
> b/drivers/remoteproc/remoteproc_cdev.c
> index d06f8d4919c7..61541bc7d26c 100644
> --- a/drivers/remoteproc/remoteproc_cdev.c
> +++ b/drivers/remoteproc/remoteproc_cdev.c
> @@ -32,7 +32,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
> char __user *buf, size_
>   return -EFAULT;
>  
>   if (!strncmp(cmd, "start", len)) {
> - if (rproc->state == RPROC_RUNNING)
> + if (rproc->state == RPROC_RUNNING ||
> + rproc->state == RPROC_ATTACHED)
>   return -EBUSY;
>  
>   ret = rproc_boot(rproc);
> diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
> b/drivers/remoteproc/remoteproc_sysfs.c
> index 3696f2ccc785..7d281cfe3e03 100644
> --- a/drivers/remoteproc/remoteproc_sysfs.c
> +++ b/drivers/remoteproc/remoteproc_sysfs.c
> @@ -194,7 +194,8 @@ static ssize_t state_store(struct device *dev,
>   int ret = 0;
>  
>   if (sysfs_streq(buf, "start")) {
> - if (rproc->state == RPROC_RUNNING)
> + if (rproc->state == RPROC_RUNNING ||
> + rproc->state == RPROC_ATTACHED)
>   return -EBUSY;
>  
>   ret = rproc_boot(rproc);
>

[PATCH v3 06/15] remoteproc: Properly deal with a kernel panic when attached

The panic handler operation of registered remote processors
should also be called when remote processors have been
attached to.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
Reviewed-by: Arnaud Pouliquen 
---
 drivers/remoteproc/remoteproc_core.c | 6 +-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/drivers/remoteproc/remoteproc_core.c 
b/drivers/remoteproc/remoteproc_core.c
index 300785a18f03..539667948bc8 100644
--- a/drivers/remoteproc/remoteproc_core.c
+++ b/drivers/remoteproc/remoteproc_core.c
@@ -2471,7 +2471,11 @@ static int rproc_panic_handler(struct notifier_block 
*nb, unsigned long event,
 
rcu_read_lock();
list_for_each_entry_rcu(rproc, &rproc_list, node) {
-   if (!rproc->ops->panic || rproc->state != RPROC_RUNNING)
+   if (!rproc->ops->panic)
+   continue;
+
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
continue;
 
d = rproc->ops->panic(rproc);
-- 
2.25.1

[PATCH v3 14/15] remoteproc: Properly deal with detach request

This patch introduces the capability to detach a remote processor
that has been attached to or booted by the remoteproc core.  For
that to happen a rproc::ops::detach() operation need to be
available.

Signed-off-by: Mathieu Poirier 
Reviewed-by: Peng Fan 
---
 drivers/remoteproc/remoteproc_cdev.c  | 6 ++
 drivers/remoteproc/remoteproc_sysfs.c | 6 ++
 2 files changed, 12 insertions(+)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index 61541bc7d26c..f7645f289563 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -43,6 +43,12 @@ static ssize_t rproc_cdev_write(struct file *filp, const 
char __user *buf, size_
return -EINVAL;
 
ret = rproc_shutdown(rproc);
+   } else if (!strncmp(cmd, "detach", len)) {
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognized option\n");
ret = -EINVAL;
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 7d281cfe3e03..5a239df5877e 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -207,6 +207,12 @@ static ssize_t state_store(struct device *dev,
return -EINVAL;
 
ret = rproc_shutdown(rproc);
+   } else if (sysfs_streq(buf, "detach")) {
+   if (rproc->state != RPROC_RUNNING &&
+   rproc->state != RPROC_ATTACHED)
+   return -EINVAL;
+
+   ret = rproc_detach(rproc);
} else {
dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
ret = -EINVAL;
-- 
2.25.1

[PATCH v3 13/15] remoteproc: Properly deal with a start request when attached

This patch takes into account scenarios where a remote processor
has been attached to when receiving a "start" command from sysfs.

As with the "running" case, the command can't be carried out if the
remote processor is already in operation.

Signed-off-by: Mathieu Poirier 
---
 drivers/remoteproc/remoteproc_cdev.c  | 3 ++-
 drivers/remoteproc/remoteproc_sysfs.c | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/drivers/remoteproc/remoteproc_cdev.c 
b/drivers/remoteproc/remoteproc_cdev.c
index d06f8d4919c7..61541bc7d26c 100644
--- a/drivers/remoteproc/remoteproc_cdev.c
+++ b/drivers/remoteproc/remoteproc_cdev.c
@@ -32,7 +32,8 @@ static ssize_t rproc_cdev_write(struct file *filp, const char 
__user *buf, size_
return -EFAULT;
 
if (!strncmp(cmd, "start", len)) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
diff --git a/drivers/remoteproc/remoteproc_sysfs.c 
b/drivers/remoteproc/remoteproc_sysfs.c
index 3696f2ccc785..7d281cfe3e03 100644
--- a/drivers/remoteproc/remoteproc_sysfs.c
+++ b/drivers/remoteproc/remoteproc_sysfs.c
@@ -194,7 +194,8 @@ static ssize_t state_store(struct device *dev,
int ret = 0;
 
if (sysfs_streq(buf, "start")) {
-   if (rproc->state == RPROC_RUNNING)
+   if (rproc->state == RPROC_RUNNING ||
+   rproc->state == RPROC_ATTACHED)
return -EBUSY;
 
ret = rproc_boot(rproc);
-- 
2.25.1

[PATCH v3 12/15] remoteproc: Properly deal with a stop request when attached