From patchwork Tue Apr 21 21:14:40 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Doug Anderson X-Patchwork-Id: 214084 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.9 required=3.0 tests=DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 83F02C55185 for ; Tue, 21 Apr 2020 21:15:23 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 6399B20747 for ; Tue, 21 Apr 2020 21:15:23 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="PKvElx00" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726079AbgDUVPV (ORCPT ); Tue, 21 Apr 2020 17:15:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55140 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726055AbgDUVPV (ORCPT ); Tue, 21 Apr 2020 17:15:21 -0400 Received: from mail-pj1-x1042.google.com (mail-pj1-x1042.google.com [IPv6:2607:f8b0:4864:20::1042]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 37013C0610D5 for ; Tue, 21 Apr 2020 14:15:21 -0700 (PDT) Received: by mail-pj1-x1042.google.com with SMTP id a5so1152030pjh.2 for ; Tue, 21 Apr 2020 14:15:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=u1Fvyyf5nczEffjGBcL+8ckFidnOh9Vp/pUQ4gio37U=; b=PKvElx00HHdwyyEhNv9HrFEWal6afEqN2MXBKrf15GbVJ1eqTVjzJ6PBhfgwxArQ19 utaZDQ51WhLVHhZzbl4Ndd3g3CEgTOuSoyzsZq6y/bGCEj9EjYU3rkyWXz+mEGaXN0ri A/vxKbYEYsvT+2dcKVPlQPPPY8HZwtQmJYTV0= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=u1Fvyyf5nczEffjGBcL+8ckFidnOh9Vp/pUQ4gio37U=; b=VFtbJWjNOzIejQBNojDsxsLdyLEIVLeFF0DG9N1lZR3vbs2T/TrN7I8XHF0rvJNxPe Lgl+52xTT+cW820ej2iCErZk7ZRk4xklphMC+0s4tmfjGH1JVNWdRCtfxYWrp0P3+u8H m4OzCJ5elEwMOOEtzMhyKlWBeuhshNKhBm06n+5vVkLRiUiqCp51XXOWsX7lULNbKZMQ teFn0UEStKqTB4bL2zEP8wxUuE/KySeDLOP6NQAeU25kno86ccruzubLn0IvRRR7FmYc SEmwFJTBCOtY0nka3H9VrGVOLXxe2/ejwtgopltkGbJ0yZX7W9xO+RRUE038TQuUD16S lbCg== X-Gm-Message-State: AGi0PuasV6p8tbz2pkC2NdI+LvWgLsP8SVxoOuTAFwfIZmAwa2Chayko huxe97FTaj582wb3LaMR1VDBjg== X-Google-Smtp-Source: APiQypLO8Vq+2uFDtn1QekfYaQkMUKtaot3jc7Cj/gRVKWbD0siljhiALve3Rxk+OpHLYMMkTVAwJA== X-Received: by 2002:a17:902:c111:: with SMTP id 17mr23179231pli.334.1587503720751; Tue, 21 Apr 2020 14:15:20 -0700 (PDT) Received: from tictac2.mtv.corp.google.com ([2620:15c:202:1:24fa:e766:52c9:e3b2]) by smtp.gmail.com with ESMTPSA id c1sm3287880pfo.152.2020.04.21.14.15.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 21 Apr 2020 14:15:20 -0700 (PDT) From: Douglas Anderson To: jason.wessel@windriver.com, daniel.thompson@linaro.org, gregkh@linuxfoundation.org Cc: kgdb-bugreport@lists.sourceforge.net, mingo@redhat.com, hpa@zytor.com, bp@alien8.de, linux-serial@vger.kernel.org, agross@kernel.org, tglx@linutronix.de, frowand.list@gmail.com, bjorn.andersson@linaro.org, jslaby@suse.com, catalin.marinas@arm.com, corbet@lwn.net, will@kernel.org, Douglas Anderson , linux-kernel@vger.kernel.org Subject: [PATCH v2 2/9] Revert "kgdboc: disable the console lock when in kgdb" Date: Tue, 21 Apr 2020 14:14:40 -0700 Message-Id: <20200421141234.v2.2.I02258eee1497e55bcbe8dc477de90369c7c7c2c5@changeid> X-Mailer: git-send-email 2.26.1.301.g55bc3eb7cb9-goog In-Reply-To: <20200421211447.193860-1-dianders@chromium.org> References: <20200421211447.193860-1-dianders@chromium.org> MIME-Version: 1.0 Sender: linux-serial-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-serial@vger.kernel.org This reverts commit 81eaadcae81b4c1bf01649a3053d1f54e2d81cf1. Commit 81eaadcae81b ("kgdboc: disable the console lock when in kgdb") is no longer needed now that we have the patch ("kgdb: Disable WARN_CONSOLE_UNLOCKED for all kgdb"). Revert it. Signed-off-by: Douglas Anderson --- Changes in v2: - ("Revert "kgdboc: disable the console lock when in kgdb"") new for v2. drivers/tty/serial/kgdboc.c | 4 ---- 1 file changed, 4 deletions(-) diff --git a/drivers/tty/serial/kgdboc.c b/drivers/tty/serial/kgdboc.c index c9f94fa82be4..8a1a4d1b6768 100644 --- a/drivers/tty/serial/kgdboc.c +++ b/drivers/tty/serial/kgdboc.c @@ -275,14 +275,10 @@ static void kgdboc_pre_exp_handler(void) /* Increment the module count when the debugger is active */ if (!kgdb_connected) try_module_get(THIS_MODULE); - - atomic_inc(&ignore_console_lock_warning); } static void kgdboc_post_exp_handler(void) { - atomic_dec(&ignore_console_lock_warning); - /* decrement the module count when the debugger detaches */ if (!kgdb_connected) module_put(THIS_MODULE); From patchwork Tue Apr 21 21:14:41 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Doug Anderson X-Patchwork-Id: 214080 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.9 required=3.0 tests=DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 823EDC54FCC for ; Tue, 21 Apr 2020 21:16:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5F6F820736 for ; Tue, 21 Apr 2020 21:16:04 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="YQCSPXa3" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726379AbgDUVPy (ORCPT ); Tue, 21 Apr 2020 17:15:54 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55152 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726324AbgDUVPX (ORCPT ); Tue, 21 Apr 2020 17:15:23 -0400 Received: from mail-pg1-x543.google.com (mail-pg1-x543.google.com [IPv6:2607:f8b0:4864:20::543]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 98DCEC0610D5 for ; Tue, 21 Apr 2020 14:15:22 -0700 (PDT) Received: by mail-pg1-x543.google.com with SMTP id h69so7370045pgc.8 for ; Tue, 21 Apr 2020 14:15:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=dyr7DgRSAApkGKypjtWiO+J/nBVrflnd2ro7wp+lCpU=; b=YQCSPXa3O6FWgeur8tmhetM7QnBo4yeaYGNe6L/Rh5ocCkAxg2cxAkq4Fwg4HI3OhY yh6G01RnYc0W3jSisfLjS0rnepBRdrEKh0uJZEIj74yY1TB2UwAO4qnVFZMb6YKc++Qk w5QYl+cFLMm8tzfI5gdZXzpEiMNkZcokYmtec= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=dyr7DgRSAApkGKypjtWiO+J/nBVrflnd2ro7wp+lCpU=; b=YGbSXxXcCGlZTmWXLQh2S1a57+nf7NLvTcYGs+tq50wRcq+cuDCn4TWN1ZW88cI1SA yQAPtMia94joJsGwNu8IRqQ+MtsiEX7ud5g+V9V2Xf/u9BpW/t5kEUjwMYK9HVMh5p3u hVE8GjYfXL3dGT1j5yVl8P7MLkKTyNyuoQhvhCPIlTmJ/GQMn2/sgqry5idXeFQv/9dW LvGQIxkp5gGttNFLkUM31aCQanuwGqCdCGpcuzWMRsfI62l9YGMWZ5G+5tgmsxFT9hBP 1dzRxrvTuFsp5bZUXjXS9CW5597CxUgGzjZym0cWVam2QMm2qKfmzzV2+h/D/Fwb9y8f 3orA== X-Gm-Message-State: AGi0PuY6qV+3LJiAMWR70X4d4MGxW3kp/6bfP4jOihidDMBPGWv8gKvj 7x4dXjI9bzFd/bjl0bxiI1wz1A== X-Google-Smtp-Source: APiQypJYAevjNX0zt/cxP4Ps5JCKih9ahvdWxD4Kn/bSHY+zcFSbNZa+IDmvA7VSOHJ1eP897e2+oQ== X-Received: by 2002:aa7:8f26:: with SMTP id y6mr24224435pfr.36.1587503722029; Tue, 21 Apr 2020 14:15:22 -0700 (PDT) Received: from tictac2.mtv.corp.google.com ([2620:15c:202:1:24fa:e766:52c9:e3b2]) by smtp.gmail.com with ESMTPSA id c1sm3287880pfo.152.2020.04.21.14.15.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 21 Apr 2020 14:15:21 -0700 (PDT) From: Douglas Anderson To: jason.wessel@windriver.com, daniel.thompson@linaro.org, gregkh@linuxfoundation.org Cc: kgdb-bugreport@lists.sourceforge.net, mingo@redhat.com, hpa@zytor.com, bp@alien8.de, linux-serial@vger.kernel.org, agross@kernel.org, tglx@linutronix.de, frowand.list@gmail.com, bjorn.andersson@linaro.org, jslaby@suse.com, catalin.marinas@arm.com, corbet@lwn.net, will@kernel.org, Douglas Anderson , linux-kernel@vger.kernel.org Subject: [PATCH v2 3/9] kgdboc: Use a platform device to handle tty drivers showing up late Date: Tue, 21 Apr 2020 14:14:41 -0700 Message-Id: <20200421141234.v2.3.I4a493cfb0f9f740ce8fd2ab58e62dc92d18fed30@changeid> X-Mailer: git-send-email 2.26.1.301.g55bc3eb7cb9-goog In-Reply-To: <20200421211447.193860-1-dianders@chromium.org> References: <20200421211447.193860-1-dianders@chromium.org> MIME-Version: 1.0 Sender: linux-serial-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-serial@vger.kernel.org If you build CONFIG_KGDB_SERIAL_CONSOLE into the kernel then you should be able to have KGDB init itself at bootup by specifying the "kgdboc=..." kernel command line parameter. This has worked OK for me for many years, but on a new device I switched to it stopped working. The problem is that on this new device the serial driver gets its probe deferred. Now when kgdb initializes it can't find the tty driver and when it gives up it never tries again. We could try to find ways to move up the initialization of the serial driver and such a thing might be worthwhile, but it's nice to be robust against serial drivers that load late. We could move kgdb to init itself later but that penalizes our ability to debug early boot code on systems where the driver inits early. We could roll our own system of detecting when new tty drivers get loaded and then use that to figure out when kgdb can init, but that's ugly. Instead, let's jump on the -EPROBE_DEFER bandwagon. We'll create a singleton instance of a "kgdboc" platform device. If we can't find our tty device when the singleton "kgdboc" probes we'll return -EPROBE_DEFER which means that the system will call us back later to try again when the tty device might be there. We won't fully transition all of the kgdboc to a platform device because early kgdb initialization (via the "ekgdboc" kernel command line parameter) still runs before the platform device has been created. The kgdb platform device is merely used as a convenient way to hook into the system's normal probe deferral mechanisms. As part of this, we'll ever-so-slightly change how the "kgdboc=..." kernel command line parameter works. Previously if you booted up and kgdb couldn't find the tty driver then later reading '/sys/module/kgdboc/parameters/kgdboc' would return a blank string. Now kgdb will keep track of the string that came as part of the command line and give it back to you. It's expected that this should be an OK change. Signed-off-by: Douglas Anderson --- Changes in v2: None drivers/tty/serial/kgdboc.c | 126 +++++++++++++++++++++++++++++------- 1 file changed, 101 insertions(+), 25 deletions(-) diff --git a/drivers/tty/serial/kgdboc.c b/drivers/tty/serial/kgdboc.c index 8a1a4d1b6768..519d8cfbfbed 100644 --- a/drivers/tty/serial/kgdboc.c +++ b/drivers/tty/serial/kgdboc.c @@ -20,6 +20,7 @@ #include #include #include +#include #define MAX_CONFIG_LEN 40 @@ -27,6 +28,7 @@ static struct kgdb_io kgdboc_io_ops; /* -1 = init not run yet, 0 = unconfigured, 1 = configured. */ static int configured = -1; +DEFINE_MUTEX(config_mutex); static char config[MAX_CONFIG_LEN]; static struct kparam_string kps = { @@ -38,6 +40,8 @@ static int kgdboc_use_kms; /* 1 if we use kernel mode switching */ static struct tty_driver *kgdb_tty_driver; static int kgdb_tty_line; +static struct platform_device *kgdboc_pdev; + #ifdef CONFIG_KDB_KEYBOARD static int kgdboc_reset_connect(struct input_handler *handler, struct input_dev *dev, @@ -133,11 +137,13 @@ static void kgdboc_unregister_kbd(void) static void cleanup_kgdboc(void) { + if (configured != 1) + return; + if (kgdb_unregister_nmi_console()) return; kgdboc_unregister_kbd(); - if (configured == 1) - kgdb_unregister_io_module(&kgdboc_io_ops); + kgdb_unregister_io_module(&kgdboc_io_ops); } static int configure_kgdboc(void) @@ -198,20 +204,79 @@ static int configure_kgdboc(void) kgdb_unregister_io_module(&kgdboc_io_ops); noconfig: kgdboc_unregister_kbd(); - config[0] = 0; configured = 0; - cleanup_kgdboc(); return err; } +static int kgdboc_probe(struct platform_device *pdev) +{ + int ret = 0; + + mutex_lock(&config_mutex); + if (configured != 1) { + ret = configure_kgdboc(); + + /* Convert "no device" to "defer" so we'll keep trying */ + if (ret == -ENODEV) + ret = -EPROBE_DEFER; + } + mutex_unlock(&config_mutex); + + return ret; +} + +static struct platform_driver kgdboc_platform_driver = { + .probe = kgdboc_probe, + .driver = { + .name = "kgdboc", + .suppress_bind_attrs = true, + }, +}; + static int __init init_kgdboc(void) { - /* Already configured? */ - if (configured == 1) + int ret; + + /* + * kgdboc is a little bit of an odd "platform_driver". It can be + * up and running long before the platform_driver object is + * created and thus doesn't actually store anything in it. There's + * only one instance of kgdb so anything is stored as global state. + * The platform_driver is only created so that we can leverage the + * kernel's mechanisms (like -EPROBE_DEFER) to call us when our + * underlying tty is ready. Here we init our platform driver and + * then create the single kgdboc instance. + */ + ret = platform_driver_register(&kgdboc_platform_driver); + if (ret) + return ret; + + kgdboc_pdev = platform_device_alloc("kgdboc", PLATFORM_DEVID_NONE); + if (!kgdboc_pdev) { + ret = -ENOMEM; + goto err_did_register; + } + + ret = platform_device_add(kgdboc_pdev); + if (!ret) return 0; - return configure_kgdboc(); + platform_device_put(kgdboc_pdev); + +err_did_register: + platform_driver_unregister(&kgdboc_platform_driver); + return ret; +} + +static void exit_kgdboc(void) +{ + mutex_lock(&config_mutex); + cleanup_kgdboc(); + mutex_unlock(&config_mutex); + + platform_device_unregister(kgdboc_pdev); + platform_driver_unregister(&kgdboc_platform_driver); } static int kgdboc_get_char(void) @@ -234,24 +299,20 @@ static int param_set_kgdboc_var(const char *kmessage, const struct kernel_param *kp) { size_t len = strlen(kmessage); + int ret = 0; if (len >= MAX_CONFIG_LEN) { pr_err("config string too long\n"); return -ENOSPC; } - /* Only copy in the string if the init function has not run yet */ - if (configured < 0) { - strcpy(config, kmessage); - return 0; - } - if (kgdb_connected) { pr_err("Cannot reconfigure while KGDB is connected.\n"); - return -EBUSY; } + mutex_lock(&config_mutex); + strcpy(config, kmessage); /* Chop out \n char as a result of echo */ if (len && config[len - 1] == '\n') @@ -260,8 +321,30 @@ static int param_set_kgdboc_var(const char *kmessage, if (configured == 1) cleanup_kgdboc(); - /* Go and configure with the new params. */ - return configure_kgdboc(); + /* + * Configure with the new params as long as init already ran. + * Note that we can get called before init if someone loads us + * with "modprobe kgdboc kgdboc=..." or if they happen to use the + * the odd syntax of "kgdboc.kgdboc=..." on the kernel command. + */ + if (configured >= 0) + ret = configure_kgdboc(); + + /* + * If we couldn't configure then clear out the config. Note that + * specifying an invalid config on the kernel command line vs. + * through sysfs have slightly different behaviors. If we fail + * to configure what was specified on the kernel command line + * we'll leave it in the 'config' and return -EPROBE_DEFER from + * our probe. When specified through sysfs userspace is + * responsible for loading the tty driver before setting up. + */ + if (ret) + config[0] = '\0'; + + mutex_unlock(&config_mutex); + + return ret; } static int dbg_restore_graphics; @@ -320,15 +403,8 @@ __setup("kgdboc=", kgdboc_option_setup); /* This is only available if kgdboc is a built in for early debugging */ static int __init kgdboc_early_init(char *opt) { - /* save the first character of the config string because the - * init routine can destroy it. - */ - char save_ch; - kgdboc_option_setup(opt); - save_ch = config[0]; - init_kgdboc(); - config[0] = save_ch; + configure_kgdboc(); return 0; } @@ -336,7 +412,7 @@ early_param("ekgdboc", kgdboc_early_init); #endif /* CONFIG_KGDB_SERIAL_CONSOLE */ module_init(init_kgdboc); -module_exit(cleanup_kgdboc); +module_exit(exit_kgdboc); module_param_call(kgdboc, param_set_kgdboc_var, param_get_string, &kps, 0644); MODULE_PARM_DESC(kgdboc, "[,baud]"); MODULE_DESCRIPTION("KGDB Console TTY Driver"); From patchwork Tue Apr 21 21:14:42 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Doug Anderson X-Patchwork-Id: 214083 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.9 required=3.0 tests=DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id BEE29C55186 for ; Tue, 21 Apr 2020 21:15:28 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 9B5AD20753 for ; Tue, 21 Apr 2020 21:15:28 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="kJd+C8iy" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726361AbgDUVP0 (ORCPT ); Tue, 21 Apr 2020 17:15:26 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55156 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726358AbgDUVPZ (ORCPT ); Tue, 21 Apr 2020 17:15:25 -0400 Received: from mail-pg1-x544.google.com (mail-pg1-x544.google.com [IPv6:2607:f8b0:4864:20::544]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CF293C0610D6 for ; Tue, 21 Apr 2020 14:15:23 -0700 (PDT) Received: by mail-pg1-x544.google.com with SMTP id o10so4135360pgb.6 for ; Tue, 21 Apr 2020 14:15:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=mJYvH0CE4/wZqoor5a8GmQPL/6GeWa4KAGNJ8Y7uZEA=; b=kJd+C8iy2SgY/FLRXeSVkJO+nnv/1XJy9qd6f5ZyeBeyuC32MXYg2CH+onXXoLPo1r 3EdZjhqsCb9jR3VQqZmIzjos5lIINXu+31S8eaG4KH8oHBIImlJnPftFei+NhUHvL4LV W1hnG7L8iG0ikcFUJamvna3SSc1bFgLHEMFjU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=mJYvH0CE4/wZqoor5a8GmQPL/6GeWa4KAGNJ8Y7uZEA=; b=cKRpwNuKo7SodaLb+HgSH2k+BTbvrL3g2mB8O20iokXdbeylVFooqSiSJdJKe1ur9t YHt8kwqeXAReZ3hFKvA7wxfeAmZ4hBE4w02BM5ObqyrzgaRGdKWNALBDUdt7JDAUJYsG W+dpGW55LVnI8Udt0K+Kolxh66QQUq6Z1NVabIFA7Aq7XvLujxh/kkNGVZZwQkUpuH6U U6K3MJe7D/FRYZuyAUZezHuTIuOGszyJZsrQ/1h2yUwIy0CcbgjLinPjRQHO9PExAJDR 1zggMsRGRdvpOLgxM5/AZWN0o67oIygKZcFRpCPrhEDvt6qsF1eL2Iyzvm1WLjHtEnQv L33Q== X-Gm-Message-State: AGi0PubZGFdleENRjNOQIcMXvJFu7oGMdFfP3BHLr63Ax9a4WVi0KhrO 2+Vivps+cuSxvznjCb6S3XN/7g== X-Google-Smtp-Source: APiQypKrAIjcvppHX3VAMktxpR9SjBHsIStBZJyRzzJ6SK0xC6kDonOdrw5X4atf+9cmrdmnE7gllQ== X-Received: by 2002:a62:7b03:: with SMTP id w3mr17166118pfc.313.1587503723328; Tue, 21 Apr 2020 14:15:23 -0700 (PDT) Received: from tictac2.mtv.corp.google.com ([2620:15c:202:1:24fa:e766:52c9:e3b2]) by smtp.gmail.com with ESMTPSA id c1sm3287880pfo.152.2020.04.21.14.15.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 21 Apr 2020 14:15:22 -0700 (PDT) From: Douglas Anderson To: jason.wessel@windriver.com, daniel.thompson@linaro.org, gregkh@linuxfoundation.org Cc: kgdb-bugreport@lists.sourceforge.net, mingo@redhat.com, hpa@zytor.com, bp@alien8.de, linux-serial@vger.kernel.org, agross@kernel.org, tglx@linutronix.de, frowand.list@gmail.com, bjorn.andersson@linaro.org, jslaby@suse.com, catalin.marinas@arm.com, corbet@lwn.net, will@kernel.org, Douglas Anderson , Matt Mullins , Nadav Amit , Peter Zijlstra , Rick Edgecombe , linux-kernel@vger.kernel.org, x86@kernel.org Subject: [PATCH v2 4/9] kgdb: Delay "kgdbwait" to dbg_late_init() by default Date: Tue, 21 Apr 2020 14:14:42 -0700 Message-Id: <20200421141234.v2.4.I3113aea1b08d8ce36dc3720209392ae8b815201b@changeid> X-Mailer: git-send-email 2.26.1.301.g55bc3eb7cb9-goog In-Reply-To: <20200421211447.193860-1-dianders@chromium.org> References: <20200421211447.193860-1-dianders@chromium.org> MIME-Version: 1.0 Sender: linux-serial-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-serial@vger.kernel.org Using kgdb requires at least some level of architecture-level initialization. If nothing else, it relies on the architecture to pass breakpoints / crashes onto kgdb. On some architectures this all works super early, specifically it starts working at some point in time before Linux parses early_params's. On other architectures it doesn't. A survey of a few platforms: a) x86: Presumably it all works early since "ekgdboc" is documented to work here. b) arm64: Catching crashes works; with a simple patch breakpoints can also be made to work. c) arm: Nothing in kgdb works until paging_init() -> devicemaps_init() -> early_trap_init() Let's be conservative and, by default, process "kgdbwait" (which tells the kernel to drop into the debugger ASAP at boot) a bit later at dbg_late_init() time. If an architecture has tested it and wants to re-enable super early debugging, they can implement the weak function kgdb_arch_can_debug_early() to return true. We'll do this for x86 to start. It should be noted that dbg_late_init() is still called quite early in the system. Note that this patch doesn't affect when kgdb runs its init. If kgdb is set to initialize early it will still initialize when parsing early_params's. This patch _only_ inhibits the initial breakpoint from "kgdbwait". This means: * Without any extra patches arm64 platforms will at least catch crashes after kgdb inits. * arm platforms will catch crashes (and could handle a hardcoded kgdb_breakpoint()) any time after early_trap_init() runs, even before dbg_late_init(). Signed-off-by: Douglas Anderson Cc: Thomas Gleixner Cc: Ingo Molnar Cc: Borislav Petkov --- Changes in v2: None arch/x86/kernel/kgdb.c | 5 +++++ include/linux/kgdb.h | 22 ++++++++++++++++++++++ kernel/debug/debug_core.c | 29 +++++++++++++++++++---------- 3 files changed, 46 insertions(+), 10 deletions(-) diff --git a/arch/x86/kernel/kgdb.c b/arch/x86/kernel/kgdb.c index c44fe7d8d9a4..60c47787c588 100644 --- a/arch/x86/kernel/kgdb.c +++ b/arch/x86/kernel/kgdb.c @@ -673,6 +673,11 @@ void kgdb_arch_late(void) } } +bool kgdb_arch_can_debug_early(void) +{ + return true; +} + /** * kgdb_arch_exit - Perform any architecture specific uninitalization. * diff --git a/include/linux/kgdb.h b/include/linux/kgdb.h index b072aeb1fd78..7371517aeacc 100644 --- a/include/linux/kgdb.h +++ b/include/linux/kgdb.h @@ -226,6 +226,28 @@ extern int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt); */ extern void kgdb_arch_late(void); +/** + * kgdb_arch_can_debug_early - Check if OK to break before dbg_late_init() + * + * If an architecture can definitely handle entering the debugger when + * early_param's are parsed then it can override this function to return + * true. Otherwise if "kgdbwait" is passed on the kernel command line it + * won't actually be processed until dbg_late_init() just after the call + * to kgdb_arch_late() is made. + * + * NOTE: Even if this returns false we will still try to register kgdb to + * handle breakpoints and crashes when early_params's are parsed, we just + * won't act on the "kgdbwait" parameter until dbg_late_init(). If you + * get a crash and try to drop into kgdb somewhere between these two + * places you might or might not end up being able to use kgdb depending + * on exactly how far along the architecture has initted. + * + * ALSO: dbg_late_init() is actually still fairly early in the system + * boot process. + * + * Return: true if platform can handle kgdb early. + */ +extern bool kgdb_arch_can_debug_early(void); /** * struct kgdb_arch - Describe architecture specific values. diff --git a/kernel/debug/debug_core.c b/kernel/debug/debug_core.c index 950dc667c823..8f178239856d 100644 --- a/kernel/debug/debug_core.c +++ b/kernel/debug/debug_core.c @@ -950,16 +950,32 @@ void kgdb_panic(const char *msg) kgdb_breakpoint(); } +static void kgdb_initial_breakpoint(void) +{ + kgdb_break_asap = 0; + + pr_crit("Waiting for connection from remote gdb...\n"); + kgdb_breakpoint(); +} + void __weak kgdb_arch_late(void) { } +bool __weak kgdb_arch_can_debug_early(void) +{ + return false; +} + void __init dbg_late_init(void) { dbg_is_early = false; if (kgdb_io_module_registered) kgdb_arch_late(); kdb_init(KDB_INIT_FULL); + + if (kgdb_io_module_registered && kgdb_break_asap) + kgdb_initial_breakpoint(); } static int @@ -1055,14 +1071,6 @@ void kgdb_schedule_breakpoint(void) } EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint); -static void kgdb_initial_breakpoint(void) -{ - kgdb_break_asap = 0; - - pr_crit("Waiting for connection from remote gdb...\n"); - kgdb_breakpoint(); -} - /** * kgdb_register_io_module - register KGDB IO module * @new_dbg_io_ops: the io ops vector @@ -1099,7 +1107,8 @@ int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops) /* Arm KGDB now. */ kgdb_register_callbacks(); - if (kgdb_break_asap) + if (kgdb_break_asap && + (!dbg_is_early || kgdb_arch_can_debug_early())) kgdb_initial_breakpoint(); return 0; @@ -1169,7 +1178,7 @@ static int __init opt_kgdb_wait(char *str) kgdb_break_asap = 1; kdb_init(KDB_INIT_EARLY); - if (kgdb_io_module_registered) + if (kgdb_io_module_registered && kgdb_arch_can_debug_early()) kgdb_initial_breakpoint(); return 0; From patchwork Tue Apr 21 21:14:44 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Doug Anderson X-Patchwork-Id: 214082 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.9 required=3.0 tests=DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2279EC55186 for ; Tue, 21 Apr 2020 21:15:35 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id EE7C12072D for ; Tue, 21 Apr 2020 21:15:34 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="LhwsWlb3" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726392AbgDUVP3 (ORCPT ); Tue, 21 Apr 2020 17:15:29 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55174 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726377AbgDUVP1 (ORCPT ); Tue, 21 Apr 2020 17:15:27 -0400 Received: from mail-pf1-x443.google.com (mail-pf1-x443.google.com [IPv6:2607:f8b0:4864:20::443]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 42F94C061BD3 for ; Tue, 21 Apr 2020 14:15:27 -0700 (PDT) Received: by mail-pf1-x443.google.com with SMTP id w65so7184291pfc.12 for ; Tue, 21 Apr 2020 14:15:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=TFVFnOOpVlGvEFGo5kr3EhCKzBoJW8HCLLx5yUURtKQ=; b=LhwsWlb3lrS/z2Pr98cyoOWe7Ljj6nN+XhJp/7xqppSUb0IsydJ1Sp/7AhyJFH1anJ 4ygIGY3Lk61mdaAksl/VU4REMQIy+srUm4YiFpFZt4Bxo38p89fi99bqEAq+Gr6jfwwI +7Ul9JImnnF5XQCwVd0xqpm6mNbk4icsFEMTw= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=TFVFnOOpVlGvEFGo5kr3EhCKzBoJW8HCLLx5yUURtKQ=; b=t6DpYgzSl64qqys/Hwq75I6vWgGzOf+4cxlBXRv8oHi8y2qnpp0fSgKmyvahewMC/W NoKHS0TAXNbD7ylmMfrrTUExpmcD7fHFS027FyEVN3CCya83fEiyqnAoivcqSxF9ZbVz yDxM3z77tOzFDUcy7vWAthzsFwuqG/iXo8oKBi8qsLiRiM9J4HE+xZUjvJtjEezX1wrS tu7QhR6ZW2SWz2Yg7Jqg6VufC1jOQOP7tTW/niS5n5MXt+ooRTP9mRjeoXWFjhSPlcS4 qWL6tzzauVjdK6TSev+s4oRbCLsql6AAnE6m1KVWjDTug5wGvd7wuNeLp+kodABNqbfz iDjw== X-Gm-Message-State: AGi0PuYJMveWaYgo+qff3Sup84bWKtbUCf+fuTW8AtrkdA5fSdfmgAVh 2Uh75iryBkWEdfeImpFuTtgIhnP7xrBOdA== X-Google-Smtp-Source: APiQypKJvdNz3IgpTrkgjxTqsEadteYHeMyWfvW+DGsfOWnP+9OEGG2PONKbDO+uA3mXSsHxEDLQqw== X-Received: by 2002:a63:5249:: with SMTP id s9mr10528406pgl.36.1587503726435; Tue, 21 Apr 2020 14:15:26 -0700 (PDT) Received: from tictac2.mtv.corp.google.com ([2620:15c:202:1:24fa:e766:52c9:e3b2]) by smtp.gmail.com with ESMTPSA id c1sm3287880pfo.152.2020.04.21.14.15.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 21 Apr 2020 14:15:25 -0700 (PDT) From: Douglas Anderson To: jason.wessel@windriver.com, daniel.thompson@linaro.org, gregkh@linuxfoundation.org Cc: kgdb-bugreport@lists.sourceforge.net, mingo@redhat.com, hpa@zytor.com, bp@alien8.de, linux-serial@vger.kernel.org, agross@kernel.org, tglx@linutronix.de, frowand.list@gmail.com, bjorn.andersson@linaro.org, jslaby@suse.com, catalin.marinas@arm.com, corbet@lwn.net, will@kernel.org, Douglas Anderson , Arnd Bergmann , linux-kernel@vger.kernel.org, linux-usb@vger.kernel.org Subject: [PATCH v2 6/9] kgdboc: Add earlycon_kgdboc to support early kgdb using boot consoles Date: Tue, 21 Apr 2020 14:14:44 -0700 Message-Id: <20200421141234.v2.6.I8fba5961bf452ab92350654aa61957f23ecf0100@changeid> X-Mailer: git-send-email 2.26.1.301.g55bc3eb7cb9-goog In-Reply-To: <20200421211447.193860-1-dianders@chromium.org> References: <20200421211447.193860-1-dianders@chromium.org> MIME-Version: 1.0 Sender: linux-serial-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-serial@vger.kernel.org We want to enable kgdb to debug the early parts of the kernel. Unfortunately kgdb normally is a client of the tty API in the kernel and serial drivers don't register to the tty layer until fairly late in the boot process. Serial drivers do, however, commonly register a boot console. Let's enable the kgdboc driver to work with boot consoles to provide early debugging. This change co-opts the existing read() function pointer that's part of "struct console". It's assumed that if a boot console (with the flag CON_BOOT) has implemented read() that both the read() and write() function are polling functions. That means they work without interrupts and read() will return immediately (with 0 bytes read) if there's nothing to read. This should be a safe assumption since it appears that no current boot consoles implement read() right now and there seems no reason to do so unless they wanted to support "earlycon_kgdboc". The console API isn't really intended to have clients work with it like we're doing. Specifically there doesn't appear to be any way for clients to be notified about a boot console being unregistered. We'll work around this by checking that our console is still valid before using it. We'll also try to transition off of the boot console and onto the "tty" API as quickly as possible. The normal/expected way to make all this work is to use "earlycon_kgdboc" and "kgdboc" together. You should point them both to the same physical serial connection. At boot time, as the system transitions from the boot console to the normal console, kgdb will switch over. If you don't use things in the normal/expected way it's a bit of a buyer-beware situation. Things thought about: - If you specify only "earlycon_kgdboc" but not "kgdboc" you still might end up dropping into kgdb upon a crash/sysrq but you may not be able to type. - If you use "keep_bootcon" (which is already a bit of a buyer-beware option) and specify "earlycon_kgdboc" but not "kgdboc" we'll keep trying to use your boot console for kgdb. - If your "earlycon_kgdboc" and "kgdboc" devices are not the same device things should work OK, but it'll be your job to switch over which device you're monitoring (including figuring out how to switch over gdb in-flight if you're using it). When trying to enable "earlycon_kgdboc" it should be noted that the names that are registered through the boot console layer and the tty layer are not the same for the same port. For example when debugging on one board I'd need to pass "earlycon_kgdboc=qcom_geni kgdboc=ttyMSM0" to enable things properly. Since digging up the boot console name is a pain and there will rarely be more than one boot console enabled, you can provide the "earlycon_kgdboc" parameter without specifying the name of the boot console. In this case we'll just pick the first boot that implements read() that we find. This new "earlycon_kgdboc" parameter should be contrasted to the existing "ekgdboc" parameter. While both provide a way to debug very early, the usage and mechanisms are quite different. Specifically "earlycon_kgdboc" is meant to be used in tandem with "kgdboc" and there is a transition from one to the other. The "ekgdboc" parameter, on the other hand, replaces the "kgdboc" parameter. It runs the same logic as the "kgdboc" parameter but just relies on your TTY driver being present super early. The only known usage of the old "ekgdboc" parameter is documented as "ekgdboc=kbd earlyprintk=vga". It should be noted that "kbd" has special treatment allowing it to init early as a tty device. Signed-off-by: Douglas Anderson --- This patch touches files in several different subsystems, but it touches a single line and that line is related to kgdb. I'm assuming this can all go through the kgdb tree, but if needed I can always introduce a new API call instead of modifying the old one and then just have the old API call be a thin wrapper on the new one. Changes in v2: - Assumes we have ("kgdb: Disable WARN_CONSOLE_UNLOCKED for all kgdb") - Fix kgdbts, tty/mips_ejtag_fdc, and usb/early/ehci-dbgp drivers/misc/kgdbts.c | 2 +- drivers/tty/mips_ejtag_fdc.c | 2 +- drivers/tty/serial/kgdboc.c | 132 +++++++++++++++++++++++++++++++++- drivers/usb/early/ehci-dbgp.c | 2 +- include/linux/kgdb.h | 3 +- kernel/debug/debug_core.c | 15 +++- 6 files changed, 149 insertions(+), 7 deletions(-) diff --git a/drivers/misc/kgdbts.c b/drivers/misc/kgdbts.c index bccd341e9ae1..5c4e4a8771cf 100644 --- a/drivers/misc/kgdbts.c +++ b/drivers/misc/kgdbts.c @@ -1077,7 +1077,7 @@ static int configure_kgdbts(void) final_ack = 0; run_plant_and_detach_test(1); - err = kgdb_register_io_module(&kgdbts_io_ops); + err = kgdb_register_io_module(&kgdbts_io_ops, false); if (err) { configured = 0; return err; diff --git a/drivers/tty/mips_ejtag_fdc.c b/drivers/tty/mips_ejtag_fdc.c index 21e76a2ec182..68817cca39ce 100644 --- a/drivers/tty/mips_ejtag_fdc.c +++ b/drivers/tty/mips_ejtag_fdc.c @@ -1265,7 +1265,7 @@ static struct kgdb_io kgdbfdc_io_ops = { static int __init kgdbfdc_init(void) { - kgdb_register_io_module(&kgdbfdc_io_ops); + kgdb_register_io_module(&kgdbfdc_io_ops, false); return 0; } early_initcall(kgdbfdc_init); diff --git a/drivers/tty/serial/kgdboc.c b/drivers/tty/serial/kgdboc.c index 519d8cfbfbed..2f526f2d2bea 100644 --- a/drivers/tty/serial/kgdboc.c +++ b/drivers/tty/serial/kgdboc.c @@ -21,6 +21,7 @@ #include #include #include +#include #define MAX_CONFIG_LEN 40 @@ -42,6 +43,14 @@ static int kgdb_tty_line; static struct platform_device *kgdboc_pdev; +#ifdef CONFIG_KGDB_SERIAL_CONSOLE +static struct kgdb_io earlycon_kgdboc_io_ops; +struct console *earlycon; +bool earlycon_neutered; +#else /* ! CONFIG_KGDB_SERIAL_CONSOLE */ +#define earlycon NULL +#endif /* ! CONFIG_KGDB_SERIAL_CONSOLE */ + #ifdef CONFIG_KDB_KEYBOARD static int kgdboc_reset_connect(struct input_handler *handler, struct input_dev *dev, @@ -135,8 +144,46 @@ static void kgdboc_unregister_kbd(void) #define kgdboc_restore_input() #endif /* ! CONFIG_KDB_KEYBOARD */ +#ifdef CONFIG_KGDB_SERIAL_CONSOLE + +static void cleanup_earlycon(bool unregister) +{ + if (earlycon && unregister) + kgdb_unregister_io_module(&earlycon_kgdboc_io_ops); + earlycon = NULL; +} + +static bool is_earlycon_still_valid(void) +{ + struct console *con; + + for_each_console(con) + if (con == earlycon) + return true; + return false; +} + +static void cleanup_earlycon_if_invalid(void) +{ + console_lock(); + if (earlycon && (earlycon_neutered || !is_earlycon_still_valid())) { + pr_warn("earlycon vanished; unregistering\n"); + cleanup_earlycon(true); + } + console_unlock(); +} + +#else /* ! CONFIG_KGDB_SERIAL_CONSOLE */ + +static inline void cleanup_earlycon(bool unregister) { ; } +static inline void cleanup_earlycon_if_invalid(void) { ; } + +#endif /* ! CONFIG_KGDB_SERIAL_CONSOLE */ + static void cleanup_kgdboc(void) { + cleanup_earlycon(true); + if (configured != 1) return; @@ -188,9 +235,10 @@ static int configure_kgdboc(void) kgdb_tty_line = tty_line; do_register: - err = kgdb_register_io_module(&kgdboc_io_ops); + err = kgdb_register_io_module(&kgdboc_io_ops, earlycon != NULL); if (err) goto noconfig; + cleanup_earlycon(false); err = kgdb_register_nmi_console(); if (err) @@ -206,6 +254,14 @@ static int configure_kgdboc(void) kgdboc_unregister_kbd(); configured = 0; + /* + * Each time we run configure_kgdboc() but don't find a console, use + * that as a chance to validate that our earlycon didn't vanish on + * us. If it vanished we should unregister which will disable kgdb + * if we're the last I/O module. + */ + cleanup_earlycon_if_invalid(); + return err; } @@ -409,6 +465,80 @@ static int __init kgdboc_early_init(char *opt) } early_param("ekgdboc", kgdboc_early_init); + +static int earlycon_kgdboc_get_char(void) +{ + char c; + + if (earlycon_neutered || !earlycon->read(earlycon, &c, 1)) + return NO_POLL_CHAR; + + return c; +} + +static void earlycon_kgdboc_put_char(u8 chr) +{ + if (!earlycon_neutered) + earlycon->write(earlycon, &chr, 1); +} + +static void earlycon_kgdboc_pre_exp_handler(void) +{ + /* + * We don't get notified when the boot console is unregistered. + * Double-check when we enter the debugger. Unfortunately we + * can't really unregister ourselves now, but at least don't crash. + */ + if (earlycon && !earlycon_neutered && !is_earlycon_still_valid()) { + pr_warn("Neutering kgdb since boot console vanished\n"); + earlycon_neutered = true; + } +} + +static struct kgdb_io earlycon_kgdboc_io_ops = { + .name = "earlycon_kgdboc", + .read_char = earlycon_kgdboc_get_char, + .write_char = earlycon_kgdboc_put_char, + .pre_exception = earlycon_kgdboc_pre_exp_handler, + .is_console = true, +}; + +static int __init earlycon_kgdboc_init(char *opt) +{ + struct console *con; + + kdb_init(KDB_INIT_EARLY); + + /* + * Look for a matching console, or if the name was left blank just + * pick the first one we find. + */ + console_lock(); + for_each_console(con) { + if (con->write && con->read && + (con->flags & (CON_BOOT | CON_ENABLED)) && + (!opt || !opt[0] || strcmp(con->name, opt) == 0)) + break; + } + console_unlock(); + + if (!con) { + pr_info("Couldn't find kgdb earlycon\n"); + return 0; + } + + earlycon = con; + pr_info("Going to register kgdb with earlycon '%s'\n", con->name); + if (kgdb_register_io_module(&earlycon_kgdboc_io_ops, false) != 0) { + earlycon = NULL; + pr_info("Failed to register kgdb with earlycon\n"); + return 0; + } + + return 0; +} + +early_param("earlycon_kgdboc", earlycon_kgdboc_init); #endif /* CONFIG_KGDB_SERIAL_CONSOLE */ module_init(init_kgdboc); diff --git a/drivers/usb/early/ehci-dbgp.c b/drivers/usb/early/ehci-dbgp.c index ea0d531c63e2..bb04c688e094 100644 --- a/drivers/usb/early/ehci-dbgp.c +++ b/drivers/usb/early/ehci-dbgp.c @@ -1057,7 +1057,7 @@ static int __init kgdbdbgp_parse_config(char *str) ptr++; kgdbdbgp_wait_time = simple_strtoul(ptr, &ptr, 10); } - kgdb_register_io_module(&kgdbdbgp_io_ops); + kgdb_register_io_module(&kgdbdbgp_io_ops, false); kgdbdbgp_io_ops.is_console = early_dbgp_console.index != -1; return 0; diff --git a/include/linux/kgdb.h b/include/linux/kgdb.h index 7371517aeacc..2e86307f2683 100644 --- a/include/linux/kgdb.h +++ b/include/linux/kgdb.h @@ -323,7 +323,8 @@ static inline int kgdb_unregister_nmi_console(void) { return 0; } static inline bool kgdb_nmi_poll_knock(void) { return 1; } #endif -extern int kgdb_register_io_module(struct kgdb_io *local_kgdb_io_ops); +extern int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops, + bool replace); extern void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops); extern struct kgdb_io *dbg_io_ops; diff --git a/kernel/debug/debug_core.c b/kernel/debug/debug_core.c index 8f178239856d..1b5435c6d92a 100644 --- a/kernel/debug/debug_core.c +++ b/kernel/debug/debug_core.c @@ -1074,16 +1074,21 @@ EXPORT_SYMBOL_GPL(kgdb_schedule_breakpoint); /** * kgdb_register_io_module - register KGDB IO module * @new_dbg_io_ops: the io ops vector + * @replace: If true it's OK if there were old ops. This is used + * to transition from early kgdb to normal kgdb. It's + * assumed these are the same device so kgdb can continue. * * Register it with the KGDB core. */ -int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops) +int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops, bool replace) { + struct kgdb_io *old_dbg_io_ops; int err; spin_lock(&kgdb_registration_lock); - if (dbg_io_ops) { + old_dbg_io_ops = dbg_io_ops; + if (dbg_io_ops && !replace) { spin_unlock(&kgdb_registration_lock); pr_err("Another I/O driver is already registered with KGDB\n"); @@ -1102,6 +1107,12 @@ int kgdb_register_io_module(struct kgdb_io *new_dbg_io_ops) spin_unlock(&kgdb_registration_lock); + if (replace) { + pr_info("Replaced I/O driver %s with %s\n", + old_dbg_io_ops->name, new_dbg_io_ops->name); + return 0; + } + pr_info("Registered I/O driver %s\n", new_dbg_io_ops->name); /* Arm KGDB now. */ From patchwork Tue Apr 21 21:14:45 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Doug Anderson X-Patchwork-Id: 214081 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.9 required=3.0 tests=DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH, MAILING_LIST_MULTI, SIGNED_OFF_BY, SPF_HELO_NONE, SPF_PASS, URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id ABB0AC55185 for ; Tue, 21 Apr 2020 21:15:44 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 8418620747 for ; Tue, 21 Apr 2020 21:15:44 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chromium.org header.i=@chromium.org header.b="DJykRx+t" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726245AbgDUVPn (ORCPT ); Tue, 21 Apr 2020 17:15:43 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55184 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726386AbgDUVP2 (ORCPT ); Tue, 21 Apr 2020 17:15:28 -0400 Received: from mail-pg1-x543.google.com (mail-pg1-x543.google.com [IPv6:2607:f8b0:4864:20::543]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8FE0DC061BD3 for ; Tue, 21 Apr 2020 14:15:28 -0700 (PDT) Received: by mail-pg1-x543.google.com with SMTP id n16so7372802pgb.7 for ; Tue, 21 Apr 2020 14:15:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chromium.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=aFTviJPrKuTMM7A/RFhxVuMj7vnHygi6BZ20JfR32qQ=; b=DJykRx+tWWAumEWwnSE3iLPH/LZN5hsuI9JxuBHfkBbrifQ+PTh/SAy2vB0gT+4ZGT 41raTO+9jGi733au3YEoRUgZ+wWSdTJP4kiLGz5Yb/9nmsQWucxZEds8LBLzz7IE++R4 rwed5Me4aZ97tVLFx2HbojUAkouKfjL/0tU3k= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=aFTviJPrKuTMM7A/RFhxVuMj7vnHygi6BZ20JfR32qQ=; b=qALddQ1j/rLJk5L3MLg/XP480Lg1liuG0xFBG06ghftVBaK3/QoPvmNVfHZQbKccgl IWkb/ObBmjwBbu8WsX6qhZQcZYUALKCwf8mm1XyjlUz3SoUBJ/9peZxziXaiUNG9XR5j KdWcoq2Wqipi5vQsxKm7484ShmIqslOScHftjq9ZNBQeGo4qwrMGFUJ9422DVhxKyX9G EEpH7jnx/Kyo6oGhyk0Z36AAp3zZyEfc4wRSbaU83k7nrj/kit+eH6emgz9RKVZaF8u6 skNvNt9by2HoqYHjycq1C0U5Q05T0wBFIGHS5nb9uDNyLTJ+nrZ0aHoWnguTH1WYkqiG 0Eug== X-Gm-Message-State: AGi0PubMl+Tg82Nnvlaiym0R0mip6MfT/6ZU/JGsFjQ7RyJpNAJYWsgu eb05UyJAC0eXicJgkWGyar20zQ== X-Google-Smtp-Source: APiQypLAD11AV9Mkwm3S1Q5SGQ1l09QLFYenxp/jtXM3LJz9RnpH2GYoSx8jPUB+F6dCGtfle08i1Q== X-Received: by 2002:a63:1506:: with SMTP id v6mr24334707pgl.365.1587503728073; Tue, 21 Apr 2020 14:15:28 -0700 (PDT) Received: from tictac2.mtv.corp.google.com ([2620:15c:202:1:24fa:e766:52c9:e3b2]) by smtp.gmail.com with ESMTPSA id c1sm3287880pfo.152.2020.04.21.14.15.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 21 Apr 2020 14:15:27 -0700 (PDT) From: Douglas Anderson To: jason.wessel@windriver.com, daniel.thompson@linaro.org, gregkh@linuxfoundation.org Cc: kgdb-bugreport@lists.sourceforge.net, mingo@redhat.com, hpa@zytor.com, bp@alien8.de, linux-serial@vger.kernel.org, agross@kernel.org, tglx@linutronix.de, frowand.list@gmail.com, bjorn.andersson@linaro.org, jslaby@suse.com, catalin.marinas@arm.com, corbet@lwn.net, will@kernel.org, Douglas Anderson , Andrew Morton , Borislav Petkov , Juergen Gross , Mauro Carvalho Chehab , Pawan Gupta , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v2 7/9] Documentation: kgdboc: Document new earlycon_kgdboc parameter Date: Tue, 21 Apr 2020 14:14:45 -0700 Message-Id: <20200421141234.v2.7.I7d5eb42c6180c831d47aef1af44d0b8be3fac559@changeid> X-Mailer: git-send-email 2.26.1.301.g55bc3eb7cb9-goog In-Reply-To: <20200421211447.193860-1-dianders@chromium.org> References: <20200421211447.193860-1-dianders@chromium.org> MIME-Version: 1.0 Sender: linux-serial-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-serial@vger.kernel.org The recent patch ("kgdboc: Add earlycon_kgdboc to support early kgdb using boot consoles") adds a new kernel command line parameter. Document it. Note that the patch adding the feature does some comparing/contrasting of "earlycon_kgdboc" vs. the existing "ekgdboc". See that patch for more details, but briefly "ekgdboc" can be used _instead_ of "kgdboc" and just makes "kgdboc" do its normal initialization early (only works if your tty driver is already ready). The new "earlycon_kgdboc" works in combination with "kgdboc" and is backed by boot consoles. Signed-off-by: Douglas Anderson --- Changes in v2: None .../admin-guide/kernel-parameters.txt | 20 +++++++++++++++++++ Documentation/dev-tools/kgdb.rst | 14 +++++++++++++ 2 files changed, 34 insertions(+) diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt index f2a93c8679e8..588625ec2993 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -1132,6 +1132,22 @@ address must be provided, and the serial port must already be setup and configured. + earlycon_kgdboc= [KGDB,HW] + If the boot console provides the ability to read + characters and can work in polling mode, you can use + this parameter to tell kgdb to use it as a backend + until the normal console is registered. Intended to + be used together with the kgdboc parameter which + specifies the normal console to transition to. + + The the name of the early console should be specified + as the value of this parameter. Note that the name of + the early console might be different than the tty + name passed to kgdboc. If only one boot console with + a read() function is enabled it's OK to leave the + value blank and the first boot console that implements + read() will be picked. + earlyprintk= [X86,SH,ARM,M68k,S390] earlyprintk=vga earlyprintk=sclp @@ -1190,6 +1206,10 @@ This is designed to be used in conjunction with the boot argument: earlyprintk=vga + This parameter works in place of the kgdboc parameter + but can only be used if the backing tty is available + very early in the boot process. + edd= [EDD] Format: {"off" | "on" | "skip[mbr]"} diff --git a/Documentation/dev-tools/kgdb.rst b/Documentation/dev-tools/kgdb.rst index d38be58f872a..c0b321403d9a 100644 --- a/Documentation/dev-tools/kgdb.rst +++ b/Documentation/dev-tools/kgdb.rst @@ -274,6 +274,20 @@ don't like this are to hack gdb to send the :kbd:`SysRq-G` for you as well as on the initial connect, or to use a debugger proxy that allows an unmodified gdb to do the debugging. +Kernel parameter: ``earlycon_kgdboc`` +------------------------------------- + +If you specify the kernel parameter ``earlycon_kgdboc`` and your serial +driver registers a boot console that supports polling (doesn't need +interrupts and implements a nonblocking read() function) kgdb will attempt +to work using the boot console until it can transition to the regular +tty driver specified by the ``kgdboc`` parameter. + +Normally there is only one boot console (especially that implements the +read() function) so just adding ``earlycon_kgdboc`` on its own is +sufficient to make this work. If you have more than one boot console you +can add the boot console's name to differentiate. + Kernel parameter: ``kgdbwait`` ------------------------------