From patchwork Thu Aug 27 19:48:49 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rishabh Bhatnagar X-Patchwork-Id: 11741761 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 5755316B1 for ; Thu, 27 Aug 2020 19:49:45 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 3DF6A22BEB for ; Thu, 27 Aug 2020 19:49:45 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mg.codeaurora.org header.i=@mg.codeaurora.org header.b="Vpqo6HPV" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726344AbgH0Tto (ORCPT ); Thu, 27 Aug 2020 15:49:44 -0400 Received: from mail29.static.mailgun.info ([104.130.122.29]:51487 "EHLO mail29.static.mailgun.info" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728043AbgH0Ttk (ORCPT ); Thu, 27 Aug 2020 15:49:40 -0400 DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=mg.codeaurora.org; q=dns/txt; s=smtp; t=1598557780; h=References: In-Reply-To: Message-Id: Date: Subject: Cc: To: From: Sender; bh=NaYKWRYtlz24wBCiVhLhyrMbm0vV1UjfOtA7OUUm/ko=; b=Vpqo6HPVOFodN4cOMubXTybuZxj4kCvqjgHJaSwgzgqoDRW2M5EeY8PPbdRhv8jldbDtDMnu eaWTz01yooE1OFqGlDRgu42nHYlomASp2JPplyhYboxsJ8x4j+aGnskq/ssSXOE7tRs1Nvcz UArTeNRCkE/ZsdXz7bch52zG1qg= X-Mailgun-Sending-Ip: 104.130.122.29 X-Mailgun-Sid: WyI4ZWZiZiIsICJsaW51eC1yZW1vdGVwcm9jQHZnZXIua2VybmVsLm9yZyIsICJiZTllNGEiXQ== Received: from smtp.codeaurora.org (ec2-35-166-182-171.us-west-2.compute.amazonaws.com [35.166.182.171]) by smtp-out-n05.prod.us-west-2.postgun.com with SMTP id 5f480e43d6f74c6f9cb2da69 (version=TLS1.2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256); Thu, 27 Aug 2020 19:49:23 GMT Received: by smtp.codeaurora.org (Postfix, from userid 1001) id E1ACEC43395; Thu, 27 Aug 2020 19:49:22 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-caf-mail-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-1.0 required=2.0 tests=ALL_TRUSTED,SPF_NONE autolearn=ham autolearn_force=no version=3.4.0 Received: from rishabhb-linux.qualcomm.com (i-global254.qualcomm.com [199.106.103.254]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: rishabhb) by smtp.codeaurora.org (Postfix) with ESMTPSA id 31103C433CA; Thu, 27 Aug 2020 19:49:22 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org 31103C433CA Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; spf=none smtp.mailfrom=rishabhb@codeaurora.org From: Rishabh Bhatnagar To: linux-remoteproc@vger.kernel.org, linux-kernel@vger.kernel.org Cc: bjorn.andersson@linaro.org, mathieu.poirier@linaro.org, tsoni@codeaurora.org, psodagud@codeaurora.org, sidgup@codeaurora.org, Rishabh Bhatnagar Subject: [PATCH v2 1/3] remoteproc: Expose remoteproc configuration through sysfs Date: Thu, 27 Aug 2020 12:48:49 -0700 Message-Id: <1598557731-1566-2-git-send-email-rishabhb@codeaurora.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1598557731-1566-1-git-send-email-rishabhb@codeaurora.org> References: <1598557731-1566-1-git-send-email-rishabhb@codeaurora.org> Sender: linux-remoteproc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-remoteproc@vger.kernel.org Add a feature flag to expose some of the remoteproc configuration through sysfs. This feature is helpful in systems where debugfs is not available/mounted. Currently the recovery and coredump configuration is exposed through sysfs rather than debugfs when this feature is selected. Signed-off-by: Rishabh Bhatnagar --- drivers/remoteproc/Kconfig | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig index c6659dfe..8aecf70 100644 --- a/drivers/remoteproc/Kconfig +++ b/drivers/remoteproc/Kconfig @@ -275,6 +275,18 @@ config TI_K3_DSP_REMOTEPROC It's safe to say N here if you're not interested in utilizing the DSP slave processors. +config RPROC_SYSFS_CONFIGURATION_SUPPORT + bool "Expose remoteproc configuration sysfs entries" + default n + help + Say y here to expose recovery and coredump configuration sysfs + entries. This will remove the corresponding entries from debugfs + and expose it through sysfs. This is helpful in operating systems + where debugfs is not available. + + It's safe to say N here if you are not interested in accessing + recovery and coredump configuration through sysfs. + endif # REMOTEPROC endmenu From patchwork Thu Aug 27 19:48:50 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rishabh Bhatnagar X-Patchwork-Id: 11741771 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 24A0D14E5 for ; Thu, 27 Aug 2020 19:50:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 05CE1207F7 for ; Thu, 27 Aug 2020 19:50:32 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mg.codeaurora.org header.i=@mg.codeaurora.org header.b="Z5YmhZLz" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728121AbgH0TuQ (ORCPT ); Thu, 27 Aug 2020 15:50:16 -0400 Received: from m43-7.mailgun.net ([69.72.43.7]:15150 "EHLO m43-7.mailgun.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727813AbgH0TuO (ORCPT ); Thu, 27 Aug 2020 15:50:14 -0400 DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=mg.codeaurora.org; q=dns/txt; s=smtp; t=1598557814; h=References: In-Reply-To: Message-Id: Date: Subject: Cc: To: From: Sender; bh=jQ/gIuY2mY0oFoFD/iITvJMPLZuXd04x2UZpRd55VRM=; b=Z5YmhZLztejFkTkya7IB7Q4FwW8AIx/GTr1eiS99i6OESpYr8uGPslPb1NkTGHCPW/ckS3+u g4CMVc6+/GKL5aUrQvpY1rcCfdLqtS33Yln9w276hYXPhsBNdF0SaBop29vmnxhkdd4NdeaB 51cBvr8fQJ0XixbtzUCZgIkIvQc= X-Mailgun-Sending-Ip: 69.72.43.7 X-Mailgun-Sid: WyI4ZWZiZiIsICJsaW51eC1yZW1vdGVwcm9jQHZnZXIua2VybmVsLm9yZyIsICJiZTllNGEiXQ== Received: from smtp.codeaurora.org (ec2-35-166-182-171.us-west-2.compute.amazonaws.com [35.166.182.171]) by smtp-out-n07.prod.us-west-2.postgun.com with SMTP id 5f480e45630b177c472cd170 (version=TLS1.2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256); Thu, 27 Aug 2020 19:49:25 GMT Received: by smtp.codeaurora.org (Postfix, from userid 1001) id 126EBC433CA; Thu, 27 Aug 2020 19:49:25 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-caf-mail-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-1.0 required=2.0 tests=ALL_TRUSTED,SPF_NONE autolearn=unavailable autolearn_force=no version=3.4.0 Received: from rishabhb-linux.qualcomm.com (i-global254.qualcomm.com [199.106.103.254]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: rishabhb) by smtp.codeaurora.org (Postfix) with ESMTPSA id B8C24C43387; Thu, 27 Aug 2020 19:49:22 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org B8C24C43387 Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; spf=none smtp.mailfrom=rishabhb@codeaurora.org From: Rishabh Bhatnagar To: linux-remoteproc@vger.kernel.org, linux-kernel@vger.kernel.org Cc: bjorn.andersson@linaro.org, mathieu.poirier@linaro.org, tsoni@codeaurora.org, psodagud@codeaurora.org, sidgup@codeaurora.org, Rishabh Bhatnagar Subject: [PATCH v2 2/3] remoteproc: Add coredump configuration to sysfs Date: Thu, 27 Aug 2020 12:48:50 -0700 Message-Id: <1598557731-1566-3-git-send-email-rishabhb@codeaurora.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1598557731-1566-1-git-send-email-rishabhb@codeaurora.org> References: <1598557731-1566-1-git-send-email-rishabhb@codeaurora.org> Sender: linux-remoteproc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-remoteproc@vger.kernel.org Expose coredump configuration in sysfs under a feature flag. This is useful for systems where access to debugfs might be limited. Signed-off-by: Rishabh Bhatnagar --- Documentation/ABI/testing/sysfs-class-remoteproc | 24 +++++++++ drivers/remoteproc/remoteproc_debugfs.c | 4 ++ drivers/remoteproc/remoteproc_sysfs.c | 68 ++++++++++++++++++++++++ 3 files changed, 96 insertions(+) diff --git a/Documentation/ABI/testing/sysfs-class-remoteproc b/Documentation/ABI/testing/sysfs-class-remoteproc index 36094fb..f6c44fa 100644 --- a/Documentation/ABI/testing/sysfs-class-remoteproc +++ b/Documentation/ABI/testing/sysfs-class-remoteproc @@ -58,3 +58,27 @@ Description: Remote processor name Reports the name of the remote processor. This can be used by userspace in exactly identifying a remote processor and ease up the usage in modifying the 'firmware' or 'state' files. + +What: /sys/class/remoteproc/.../coredump +Date: July 2020 +Contact: Bjorn Andersson , Ohad Ben-Cohen +Description: Remote processor coredump configuration + + Reports the coredump configuration of the remote processor, + which will be one of: + + "default" + "inline" + "disabled" + + "default" means when the remote processor's coredump is + collected it will be copied to a separate buffer and that + buffer is exposed to userspace. + + "inline" means when the remote processor's coredump is + collected userspace will directly read from the remote + processor's device memory. Extra buffer will not be used to + copy the dump. Also recovery process will not proceed until + all data is read by usersapce. + + "disabled" means no dump will be collected. diff --git a/drivers/remoteproc/remoteproc_debugfs.c b/drivers/remoteproc/remoteproc_debugfs.c index 2e3b3e2..48dfd0a 100644 --- a/drivers/remoteproc/remoteproc_debugfs.c +++ b/drivers/remoteproc/remoteproc_debugfs.c @@ -27,6 +27,7 @@ /* remoteproc debugfs parent dir */ static struct dentry *rproc_dbg; +#if (!IS_ENABLED(CONFIG_RPROC_SYSFS_CONFIGURATION_SUPPORT)) /* * A coredump-configuration-to-string lookup table, for exposing a * human readable configuration via debugfs. Always keep in sync with @@ -114,6 +115,7 @@ static const struct file_operations rproc_coredump_fops = { .open = simple_open, .llseek = generic_file_llseek, }; +#endif /* * Some remote processors may support dumping trace logs into a shared @@ -425,8 +427,10 @@ void rproc_create_debug_dir(struct rproc *rproc) rproc, &rproc_rsc_table_fops); debugfs_create_file("carveout_memories", 0400, rproc->dbg_dir, rproc, &rproc_carveouts_fops); +#if (!IS_ENABLED(CONFIG_RPROC_SYSFS_CONFIGURATION_SUPPORT)) debugfs_create_file("coredump", 0600, rproc->dbg_dir, rproc, &rproc_coredump_fops); +#endif } void __init rproc_init_debugfs(void) diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c index eea514c..89b301a 100644 --- a/drivers/remoteproc/remoteproc_sysfs.c +++ b/drivers/remoteproc/remoteproc_sysfs.c @@ -10,6 +10,71 @@ #define to_rproc(d) container_of(d, struct rproc, dev) +#if IS_ENABLED(CONFIG_RPROC_SYSFS_CONFIGURATION_SUPPORT) +/* + * A coredump-configuration-to-string lookup table, for exposing a + * human readable configuration via sysfs. Always keep in sync with + * enum rproc_coredump_mechanism + */ +static const char * const rproc_coredump_str[] = { + [RPROC_COREDUMP_DEFAULT] = "default", + [RPROC_COREDUMP_INLINE] = "inline", + [RPROC_COREDUMP_DISABLED] = "disabled", +}; + +/* Expose the current coredump configuration via debugfs */ +static ssize_t coredump_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct rproc *rproc = to_rproc(dev); + + return sprintf(buf, "%s\n", rproc_coredump_str[rproc->dump_conf]); +} + +/* + * By writing to the 'coredump' sysfs entry, we control the behavior of the + * coredump mechanism dynamically. The default value of this entry is "default". + * + * The 'coredump' sysfs entry supports these commands: + * + * default: This is the default coredump mechanism. When the remoteproc + * crashes the entire coredump will be copied to a separate buffer + * and exposed to userspace. + * + * inline: The coredump will not be copied to a separate buffer and the + * recovery process will have to wait until data is read by + * userspace. But this avoid usage of extra memory. + * + * disabled: This will disable coredump. Recovery will proceed without + * collecting any dump. + */ +static ssize_t coredump_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct rproc *rproc = to_rproc(dev); + + if (rproc->state == RPROC_CRASHED) { + dev_err(&rproc->dev, "can't change coredump configuration\n"); + return -EBUSY; + } + + if (sysfs_streq(buf, "disable")) { + rproc->dump_conf = RPROC_COREDUMP_DISABLED; + } else if (sysfs_streq(buf, "inline")) { + rproc->dump_conf = RPROC_COREDUMP_INLINE; + } else if (sysfs_streq(buf, "default")) { + rproc->dump_conf = RPROC_COREDUMP_DEFAULT; + } else { + dev_err(&rproc->dev, "Invalid coredump configuration\n"); + return -EINVAL; + } + + return count; +} +static DEVICE_ATTR_RW(coredump); +#endif + /* Expose the loaded / running firmware name via sysfs */ static ssize_t firmware_show(struct device *dev, struct device_attribute *attr, char *buf) @@ -138,6 +203,9 @@ static ssize_t name_show(struct device *dev, struct device_attribute *attr, static DEVICE_ATTR_RO(name); static struct attribute *rproc_attrs[] = { +#if IS_ENABLED(CONFIG_RPROC_SYSFS_CONFIGURATION_SUPPORT) + &dev_attr_coredump.attr, +#endif &dev_attr_firmware.attr, &dev_attr_state.attr, &dev_attr_name.attr, From patchwork Thu Aug 27 19:48:51 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Rishabh Bhatnagar X-Patchwork-Id: 11741759 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id CE25A1575 for ; Thu, 27 Aug 2020 19:49:44 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id A61D6207F7 for ; Thu, 27 Aug 2020 19:49:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mg.codeaurora.org header.i=@mg.codeaurora.org header.b="SgabqXEr" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727116AbgH0Tti (ORCPT ); Thu, 27 Aug 2020 15:49:38 -0400 Received: from m43-7.mailgun.net ([69.72.43.7]:15150 "EHLO m43-7.mailgun.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727949AbgH0Ttg (ORCPT ); Thu, 27 Aug 2020 15:49:36 -0400 DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=mg.codeaurora.org; q=dns/txt; s=smtp; t=1598557775; h=References: In-Reply-To: Message-Id: Date: Subject: Cc: To: From: Sender; bh=bdHYAMPgcy3cvjCiidfmeFTYKUu3fscjSsmkXsVM6sw=; b=SgabqXErybvus7iJrdbt3aFex8nw6P9EJZ1JYwxhIxkzTUH7KHKzaxvFi+/FK3Rb8aG57nxP Jb/vVP/x3AVuKdqjjK8xNNHRjov0qk3dF7EIdqMVNM0nJQ/x2Jfod4MswBrK0WiipphF/Ice JpTp92rp7d+fdPjSv+9WoWLQlzM= X-Mailgun-Sending-Ip: 69.72.43.7 X-Mailgun-Sid: WyI4ZWZiZiIsICJsaW51eC1yZW1vdGVwcm9jQHZnZXIua2VybmVsLm9yZyIsICJiZTllNGEiXQ== Received: from smtp.codeaurora.org (ec2-35-166-182-171.us-west-2.compute.amazonaws.com [35.166.182.171]) by smtp-out-n02.prod.us-west-2.postgun.com with SMTP id 5f480e4491574590bff134bd (version=TLS1.2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256); Thu, 27 Aug 2020 19:49:24 GMT Received: by smtp.codeaurora.org (Postfix, from userid 1001) id 60EF3C433A0; Thu, 27 Aug 2020 19:49:24 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-caf-mail-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-1.0 required=2.0 tests=ALL_TRUSTED,SPF_NONE autolearn=ham autolearn_force=no version=3.4.0 Received: from rishabhb-linux.qualcomm.com (i-global254.qualcomm.com [199.106.103.254]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: rishabhb) by smtp.codeaurora.org (Postfix) with ESMTPSA id 41D88C43395; Thu, 27 Aug 2020 19:49:23 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org 41D88C43395 Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: aws-us-west-2-caf-mail-1.web.codeaurora.org; spf=none smtp.mailfrom=rishabhb@codeaurora.org From: Rishabh Bhatnagar To: linux-remoteproc@vger.kernel.org, linux-kernel@vger.kernel.org Cc: bjorn.andersson@linaro.org, mathieu.poirier@linaro.org, tsoni@codeaurora.org, psodagud@codeaurora.org, sidgup@codeaurora.org, Rishabh Bhatnagar Subject: [PATCH v2 3/3] remoteproc: Add recovery configuration to sysfs Date: Thu, 27 Aug 2020 12:48:51 -0700 Message-Id: <1598557731-1566-4-git-send-email-rishabhb@codeaurora.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1598557731-1566-1-git-send-email-rishabhb@codeaurora.org> References: <1598557731-1566-1-git-send-email-rishabhb@codeaurora.org> Sender: linux-remoteproc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-remoteproc@vger.kernel.org Expose recovery configuration in sysfs under a feature flag. This is useful for systems where access to debugfs might be limited. Signed-off-by: Rishabh Bhatnagar --- Documentation/ABI/testing/sysfs-class-remoteproc | 20 ++++++++ drivers/remoteproc/remoteproc_debugfs.c | 6 ++- drivers/remoteproc/remoteproc_sysfs.c | 58 ++++++++++++++++++++++++ 3 files changed, 82 insertions(+), 2 deletions(-) diff --git a/Documentation/ABI/testing/sysfs-class-remoteproc b/Documentation/ABI/testing/sysfs-class-remoteproc index f6c44fa..7368b50 100644 --- a/Documentation/ABI/testing/sysfs-class-remoteproc +++ b/Documentation/ABI/testing/sysfs-class-remoteproc @@ -82,3 +82,23 @@ Description: Remote processor coredump configuration all data is read by usersapce. "disabled" means no dump will be collected. + +What: /sys/class/remoteproc/.../recovery +Date: July 2020 +Contact: Bjorn Andersson , Ohad Ben-Cohen +Description: Remote processor recovery mechanism + + Reports the recovery mechanism of the remote processor, + which will be one of: + + "enabled" + "disabled" + + "enabled" means, the remote processor will be automatically + recovered whenever it crashes. Moreover, if the remote + processor crashes while recovery is disabled, it will + be automatically recovered too as soon as recovery is enabled. + + "disabled" means, a remote processor will remain in a crashed + state if it crashes. This is useful for debugging purposes; + without it, debugging a crash is substantially harder. diff --git a/drivers/remoteproc/remoteproc_debugfs.c b/drivers/remoteproc/remoteproc_debugfs.c index 48dfd0a..415a9ff 100644 --- a/drivers/remoteproc/remoteproc_debugfs.c +++ b/drivers/remoteproc/remoteproc_debugfs.c @@ -174,6 +174,7 @@ static const struct file_operations rproc_name_ops = { .llseek = generic_file_llseek, }; +#if (!IS_ENABLED(CONFIG_RPROC_SYSFS_CONFIGURATION_SUPPORT)) /* expose recovery flag via debugfs */ static ssize_t rproc_recovery_read(struct file *filp, char __user *userbuf, size_t count, loff_t *ppos) @@ -249,6 +250,7 @@ static const struct file_operations rproc_recovery_ops = { .open = simple_open, .llseek = generic_file_llseek, }; +#endif /* expose the crash trigger via debugfs */ static ssize_t @@ -419,8 +421,6 @@ void rproc_create_debug_dir(struct rproc *rproc) debugfs_create_file("name", 0400, rproc->dbg_dir, rproc, &rproc_name_ops); - debugfs_create_file("recovery", 0600, rproc->dbg_dir, - rproc, &rproc_recovery_ops); debugfs_create_file("crash", 0200, rproc->dbg_dir, rproc, &rproc_crash_ops); debugfs_create_file("resource_table", 0400, rproc->dbg_dir, @@ -430,6 +430,8 @@ void rproc_create_debug_dir(struct rproc *rproc) #if (!IS_ENABLED(CONFIG_RPROC_SYSFS_CONFIGURATION_SUPPORT)) debugfs_create_file("coredump", 0600, rproc->dbg_dir, rproc, &rproc_coredump_fops); + debugfs_create_file("recovery", 0600, rproc->dbg_dir, + rproc, &rproc_recovery_ops); #endif } diff --git a/drivers/remoteproc/remoteproc_sysfs.c b/drivers/remoteproc/remoteproc_sysfs.c index 89b301a..45cae4f 100644 --- a/drivers/remoteproc/remoteproc_sysfs.c +++ b/drivers/remoteproc/remoteproc_sysfs.c @@ -11,6 +11,63 @@ #define to_rproc(d) container_of(d, struct rproc, dev) #if IS_ENABLED(CONFIG_RPROC_SYSFS_CONFIGURATION_SUPPORT) + +/* expose recovery flag via sysfs */ +static ssize_t recovery_show(struct device *dev, + struct device_attribute *attr, char *buf) +{ + struct rproc *rproc = to_rproc(dev); + + return sprintf(buf, "%s", rproc->recovery_disabled ? "disabled\n" : "enabled\n"); +} + +/* + * By writing to the 'recovery' sysfs entry, we control the behavior of the + * recovery mechanism dynamically. The default value of this entry is "enabled". + * + * The 'recovery' sysfs entry supports these commands: + * + * enabled: When enabled, the remote processor will be automatically + * recovered whenever it crashes. Moreover, if the remote + * processor crashes while recovery is disabled, it will + * be automatically recovered too as soon as recovery is enabled. + * + * disabled: When disabled, a remote processor will remain in a crashed + * state if it crashes. This is useful for debugging purposes; + * without it, debugging a crash is substantially harder. + * + * recover: This function will trigger an immediate recovery if the + * remote processor is in a crashed state, without changing + * or checking the recovery state (enabled/disabled). + * This is useful during debugging sessions, when one expects + * additional crashes to happen after enabling recovery. In this + * case, enabling recovery will make it hard to debug subsequent + * crashes, so it's recommended to keep recovery disabled, and + * instead use the "recover" command as needed. + */ +static ssize_t recovery_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct rproc *rproc = to_rproc(dev); + + if (sysfs_streq(buf, "enabled")) { + /* change the flag and begin the recovery process if needed */ + rproc->recovery_disabled = false; + rproc_trigger_recovery(rproc); + } else if (sysfs_streq(buf, "disabled")) { + rproc->recovery_disabled = true; + } else if (sysfs_streq(buf, "recover")) { + /* begin the recovery process without changing the flag */ + rproc_trigger_recovery(rproc); + } else { + return -EINVAL; + } + + return count; +} +static DEVICE_ATTR_RW(recovery); + /* * A coredump-configuration-to-string lookup table, for exposing a * human readable configuration via sysfs. Always keep in sync with @@ -205,6 +262,7 @@ static DEVICE_ATTR_RO(name); static struct attribute *rproc_attrs[] = { #if IS_ENABLED(CONFIG_RPROC_SYSFS_CONFIGURATION_SUPPORT) &dev_attr_coredump.attr, + &dev_attr_recovery.attr, #endif &dev_attr_firmware.attr, &dev_attr_state.attr,