From patchwork Tue Jul 9 15:04:05 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Saiapova, Natalia" X-Patchwork-Id: 93597 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 24AC938432E6 for ; Tue, 9 Jul 2024 15:05:57 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.15]) by sourceware.org (Postfix) with ESMTPS id E2E81386182A for ; Tue, 9 Jul 2024 15:05:26 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org E2E81386182A Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=intel.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org E2E81386182A Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=198.175.65.15 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537529; cv=none; b=sayg3AJDB8gWYKA/lIV9FLkqEgUG0y7BVdnpOlww8gUKFPiCxGwtozSMm24mBN6x2QOTDeohBYv1qOyh8WUYm8WwnFtjVieFeQnXK6EcDL3j8vJpWz1cgI7YqEaDPSHEBt+Pdnbf14pJv4j2GE6f9w42YXRk2jIBMTr2ZFKpA1Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537529; c=relaxed/simple; bh=7VolimiCZbkNRtUueMHFLCjFvFNiJpqwJfSdtVcGI/A=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=kquv+eHOxgqj5OzfWIy0JbZ896xSZnqNJ29vf95QVkdIQvohaUmx9zYXwZLRA7fptz9ZQa9yXTVnasPNaLnsAfC05l2DnrdHIvB4Y+RAwkMf31lwMDLw1LWjuFSSrDId/ZzlsokRHePJ+Cdz3g+x2Fmcv6xjHPN79fxMkKroQt4= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1720537527; x=1752073527; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=7VolimiCZbkNRtUueMHFLCjFvFNiJpqwJfSdtVcGI/A=; b=QiAX2WYDgptqcqMEBIeR32C6vGcnk9zZcEikVfgKrk0tVdqM4fXA/418 25MPQszN4PvssCELCuB7n/dH82ZStYHQ6ZX21rz9XAkE5Pzu1uKDb4T/L mnZB/kM9m1rGmuEJDOg82ESrUThjS+L87ss4dh1630lK5hBTg8ZFeu+pT q2w21BWn9M0bYBrkxCpUYBUt5GqyEoZR8bPtoZtrrLs+PRGoLRNIPJM8L 7SANfJbXxBJAqq96becOvvJhBBHVZrRL8gUVzXOb5qL0Eh3yoFIjI9uu6 ibXW2ouBcuCWz9FExuw7KKQnY791KJyEnWqMv31/SdtEP611NhsEg7Z3M A==; X-CSE-ConnectionGUID: Dw6ewjulTjWUTIjj9dkr1Q== X-CSE-MsgGUID: iPQ9tvSOQ0+osDPMWGUEIw== X-IronPort-AV: E=McAfee;i="6700,10204,11128"; a="21567389" X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="21567389" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa107.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:05:25 -0700 X-CSE-ConnectionGUID: lDIz1GTzTzmmGpAxu8+peQ== X-CSE-MsgGUID: m6XI6txLTFKq8o3V3Gnu6g== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="52184584" Received: from dut1061atsm.igk.intel.com (HELO localhost) ([10.211.177.242]) by fmviesa003-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:05:24 -0700 From: Natalia Saiapova To: gdb-patches@sourceware.org Subject: [PATCH v2 1/6] gdb: use schedlock_applies in user_visible_resume_ptid. Date: Tue, 9 Jul 2024 15:04:05 +0000 Message-Id: <20240709150410.34624-2-natalia.saiapova@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20240709150410.34624-1-natalia.saiapova@intel.com> References: <20240709150410.34624-1-natalia.saiapova@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-11.9 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~patchwork=sourceware.org@sourceware.org This is a refactoring. The logic in user_visible_resume_ptid is very similar to schedlock_applies, but uses `step` parameter instead of `tp->control.stepping_command`. Refactor schedlock_applies logic into the following two overloaded methods: bool schedlock_applies (thread_info *tp) and bool schedlock_applies (bool step) such that they share the logic. Update the call-sites accordingly, where we have only the thread, use the former, and where we have the bool step, use the latter. --- gdb/infrun.c | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/gdb/infrun.c b/gdb/infrun.c index 1f32a63ad54..2baffa9e9d8 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -107,7 +107,8 @@ static bool start_step_over (void); static bool step_over_info_valid_p (void); -static bool schedlock_applies (struct thread_info *tp); +static bool schedlock_applies (thread_info *tp); +static bool schedlock_applies (bool step); /* Asynchronous signal handler registered as event loop source for when we have pending events ready to be passed to the core. */ @@ -2392,20 +2393,12 @@ user_visible_resume_ptid (int step) individually. */ resume_ptid = inferior_ptid; } - else if ((scheduler_mode == schedlock_on) - || (scheduler_mode == schedlock_step && step)) + else if (schedlock_applies (step)) { /* User-settable 'scheduler' mode requires solo thread resume. */ resume_ptid = inferior_ptid; } - else if ((scheduler_mode == schedlock_replay) - && target_record_will_replay (minus_one_ptid, execution_direction)) - { - /* User-settable 'scheduler' mode requires solo thread resume in replay - mode. */ - resume_ptid = inferior_ptid; - } else if (inferior_ptid != null_ptid && inferior_thread ()->control.in_cond_eval) { @@ -3195,15 +3188,23 @@ thread_still_needs_step_over (struct thread_info *tp) return what; } +/* Returns true if scheduler locking applies to TP. */ + +static bool +schedlock_applies (thread_info *tp) +{ + bool step = (tp != nullptr) && tp->control.stepping_command; + return schedlock_applies (step); +} + /* Returns true if scheduler locking applies. STEP indicates whether - we're about to do a step/next-like command to a thread. */ + we're about to do a step/next-like command. */ static bool -schedlock_applies (struct thread_info *tp) +schedlock_applies (bool step) { return (scheduler_mode == schedlock_on - || (scheduler_mode == schedlock_step - && tp->control.stepping_command) + || (scheduler_mode == schedlock_step && step) || (scheduler_mode == schedlock_replay && target_record_will_replay (minus_one_ptid, execution_direction))); From patchwork Tue Jul 9 15:04:06 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Saiapova, Natalia" X-Patchwork-Id: 93598 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 56D01386C5B4 for ; Tue, 9 Jul 2024 15:06:11 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.15]) by sourceware.org (Postfix) with ESMTPS id E4955386D607 for ; Tue, 9 Jul 2024 15:05:33 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org E4955386D607 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=intel.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org E4955386D607 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=198.175.65.15 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537537; cv=none; b=fsxwouTVF6EjshA4PUc6bsWKJoo7Iv1ZN/7ZmUR4GnOyPkwbQIm2X6H8f3MOdk68NGryuJ2HYhTM7/B3ibV/QrlRbZ1cxrE7lPvpKGjX6sXe/7atGq4BP2ENNflmcmEOfMZNarxjMe+1b3g8gOBXwdrbQDHVvKsmuWMgXNe0JHU= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537537; c=relaxed/simple; bh=Fyg2CtqLPLSq7tlS2Np4B4bUlRHHNExKaltxEjVgsew=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=lfCfGuUPWFDvmCMefqUHX4b4OcYa6EaXZ9FCvLLcIHZMXVfsuXzzqlAT2tn7oBqa5aLN7FjdriWv8gP4Q8VZ1+Fvs34/AhIBnmXxzfF3hgLsV6TzeTBNYNxrUCrBazV8DzAl6IWg8M7SfnipLFKuHk+vPrazN8RQbhsJ/ER8H7w= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1720537534; x=1752073534; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=Fyg2CtqLPLSq7tlS2Np4B4bUlRHHNExKaltxEjVgsew=; b=O3uw7zsfPv3+adZHXLXOlu4Yfl7lgsqeHryO6GSqn8KywO+vnTYGy8nu Xj0ilFymG9RdyI0sRFjZ7XGj29jkRPqFt7OUJtSDlR51OufuJo1m400GS TeOYWRe0+/CnZ+q5daVjnnamXsmFlVebDZ7AgBaC3Dxa/JQUrVQ3YRuTl XAQ9GVH5S2aFyC9RqMmeXhOBWpD3fbbGY5QUWPfkzNHapduTFVfL51yNQ E3i7LoqSBdmuJQSOqhJStm4ZFJgPW8LRMbIRdRR8x7i4Up//Wf+Kk+VhI OFusfwFo9GiFPu1wac6kHGzSfIG07mdf98eZPrV7Cc2ExcRyvuNf+DmIq g==; X-CSE-ConnectionGUID: AgESBb+fTUCc6W7tjBl/pw== X-CSE-MsgGUID: +EQfdCKBQn2ODQv3y2fL9Q== X-IronPort-AV: E=McAfee;i="6700,10204,11128"; a="21567399" X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="21567399" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa107.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:05:33 -0700 X-CSE-ConnectionGUID: tK9GwPvFSEqaD3ULGvtFqg== X-CSE-MsgGUID: eAlTleFPTGOQHPamc4QZnQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="52184597" Received: from dut1061atsm.igk.intel.com (HELO localhost) ([10.211.177.242]) by fmviesa003-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:05:32 -0700 From: Natalia Saiapova To: gdb-patches@sourceware.org Subject: [PATCH v2 2/6] gdb, cli: remove left-over code from "set_logging_on". Date: Tue, 9 Jul 2024 15:04:06 +0000 Message-Id: <20240709150410.34624-3-natalia.saiapova@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20240709150410.34624-1-natalia.saiapova@intel.com> References: <20240709150410.34624-1-natalia.saiapova@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-11.9 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~patchwork=sourceware.org@sourceware.org This is a refactoring. Remove the left-over code, which rewrites the logging filename in "set logging on" command. The code became unused after the deprecation of "set logging (on|off)" command. Before the deprecation, the command could also take a file name and rewrite the logging file, e.g.: (gdb) set logging on lalala Copying output to lalala. Copying debug output to lalala. After the command was deprecated and reimplemented as an alias to "set logging enable on", additional input after "on" became invalid: (gdb) set logging on lalala Warning: 'set logging on', an alias for the command 'set logging enabled', is deprecated. Use 'set logging enabled on'. "on" or "off" expected. (gdb) set logging on lalala "on" or "off" expected. (gdb) set logging enable on lalala "on" or "off" expected. (gdb) set logging enable on Copying output to gdb.txt. Copying debug output to gdb.txt. Approved-By: Tom Tromey --- gdb/cli/cli-logging.c | 5 ----- 1 file changed, 5 deletions(-) diff --git a/gdb/cli/cli-logging.c b/gdb/cli/cli-logging.c index 2c54ceafb3e..4886bf2eed1 100644 --- a/gdb/cli/cli-logging.c +++ b/gdb/cli/cli-logging.c @@ -159,11 +159,6 @@ handle_redirections (int from_tty) static void set_logging_on (const char *args, int from_tty) { - const char *rest = args; - - if (rest && *rest) - logging_filename = rest; - handle_redirections (from_tty); } From patchwork Tue Jul 9 15:04:07 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Saiapova, Natalia" X-Patchwork-Id: 93599 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id E1B1438449CB for ; Tue, 9 Jul 2024 15:06:23 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.15]) by sourceware.org (Postfix) with ESMTPS id DE0EA38449CB for ; Tue, 9 Jul 2024 15:05:44 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org DE0EA38449CB Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=intel.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org DE0EA38449CB Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=198.175.65.15 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537547; cv=none; b=svHKbEBZ00JkLOunEQUU4HJxOqM7WZddXYd7wqhI4rSxb0t2bmQO8wWuuPrpUWaomcqdFdh2jhkjxjwZE1v1671njZ+m6tIJ9GaRjo2SjjK6V452M1VbJf8Yrw6d8C39JEy8AMlS399rvr81/H6soZI80x5kNKMfFdUe3IOE7JI= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537547; c=relaxed/simple; bh=0TJ3eKjRuE4eb47jemiR1Niq6OdkKLq+gCs/Q5/q60A=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=DPsXjEsmj9UZLRTGJgYvTEiMzmh/ZPpZRsXx3bRFOjrH5m0RLbk9FS4Z0AibgZw9qgJnQwXOO6kBgmg5MIHOuc/QZPA6LlDonPZLDSDPpNUfZqZ1Q8qYNK40N5WFwgDOAgtWGgVMbjke0DrYB1sNhNaAB/8j5TdscIs+fxRh9I0= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1720537545; x=1752073545; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=0TJ3eKjRuE4eb47jemiR1Niq6OdkKLq+gCs/Q5/q60A=; b=XkJqDXDNI6CaJgJiEmNT3Fyq5xGqs8rSZUE8VBIs2A8fVFkZLevbue1B mNTqy+9ugmYDup2QfqS+RQIvS66rfBF9mUN0oKHX4g+UZtqheEK6tXCqH NAFK8iM86KmqgyLMhZ4ZU5Vpa8YwMsGtPZNQqlvHuYjpeVkDO9vCAu5LV Eh4aCdYidW+B0BTduOUJVW5bXdO2to+Z2i6yE9qWZXTQ6U7495g29On2d tDR5oaVkocnkhUI0pJEVHfDt79TqJ21HLNwFeZkPvXo40GFCZ+s/zFGwj Ho1MeiWozemmpr7f+6mSSrothddZkVzT/L4wRqvQJBR6IFLcLvJpdY143 w==; X-CSE-ConnectionGUID: DJF2HRgOTA+8PRo0ERkPkQ== X-CSE-MsgGUID: vwD4Vum5TVGTYgKM3184Sw== X-IronPort-AV: E=McAfee;i="6700,10204,11128"; a="21567419" X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="21567419" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa107.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:05:43 -0700 X-CSE-ConnectionGUID: d9A6O9uCQtKtfYxm3dmhPg== X-CSE-MsgGUID: wFe0bo7qQb6BwTFuqsttQA== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="52184610" Received: from dut1061atsm.igk.intel.com (HELO localhost) ([10.211.177.242]) by fmviesa003-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:05:43 -0700 From: Natalia Saiapova To: gdb-patches@sourceware.org Subject: [PATCH v2 3/6] gdb, cli: pass the argument of a set command to its callback. Date: Tue, 9 Jul 2024 15:04:07 +0000 Message-Id: <20240709150410.34624-4-natalia.saiapova@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20240709150410.34624-1-natalia.saiapova@intel.com> References: <20240709150410.34624-1-natalia.saiapova@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-11.9 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~patchwork=sourceware.org@sourceware.org This might be useful, if some commands need to have a special case if run w/o arguments. I am going to use it in gdb: refine commands to control scheduler locking. to keep the old behaviour of the set scheduler-locking step which should set both set scheduler-locking step on set scheduler-locking replay step on To do this, the set-command needs to detect that it was issued without arguments and have a special handling for this. Without the special handling, the command set scheduler-locking step would set only set scheduler-locking step on --- gdb/cli/cli-setshow.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gdb/cli/cli-setshow.c b/gdb/cli/cli-setshow.c index bcc793b3148..9f3a294cca1 100644 --- a/gdb/cli/cli-setshow.c +++ b/gdb/cli/cli-setshow.c @@ -447,7 +447,7 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c) error (_("gdb internal error: bad var_type in do_setshow_command")); } - c->func (NULL, from_tty, c); + c->func (arg, from_tty, c); if (notify_command_param_changed_p (option_changed, c)) { From patchwork Tue Jul 9 15:04:08 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Saiapova, Natalia" X-Patchwork-Id: 93602 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id D4479386D623 for ; Tue, 9 Jul 2024 15:07:00 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.15]) by sourceware.org (Postfix) with ESMTPS id ABFE5386C5B4 for ; Tue, 9 Jul 2024 15:05:52 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org ABFE5386C5B4 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=intel.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org ABFE5386C5B4 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=198.175.65.15 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537555; cv=none; b=DNaHT5cWF+gkuQjPN7FutBny6kBYBOJM5CdMtqCdyYobb4z6FXCY28Q3UjgwwTk0JlguStVnAE1Comz1SB5dyhEe1rw1uIguRIv82MwasVxLDPx27x5slL6kGgSsaMtdgAxz1GlpQbBYx6Z4dhsW2sizVikwIc3D/k0DRZtBvLE= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537555; c=relaxed/simple; bh=IgKrwXQqddcN4n25DVCSTmPuXJQrM/vB2BqvptcyXHM=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=nes/tcfXxJpAQit+/mKZ40/eDJ0+zcd5XzGdv0mY0EYRAERXIvA4qM8mSSRU0b+9R/VAwg94/jwAvQ9aAbKoS23AkQP843E1H7++/PRIQrgbFTH6NOBg77KWQB16kcqEb04I5iABUhirJuuDSEvjxPcQkzHSIalh1tBp9IVEPSU= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1720537552; x=1752073552; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=IgKrwXQqddcN4n25DVCSTmPuXJQrM/vB2BqvptcyXHM=; b=GqX/yeLwcIvrT8zNNRcU5sUoD9Mx6sEaHnlzaPhCYCALM8M7S8ncs+5G PJZalsg2yDsYkJPmIKi8z+ThuCHr6IylFEx7QkjuzkWZHCuT6a7TcBmb4 sRzhb4AtlLs5rjLtX52OFxDPE7F2pnZB87iofnLB5u/HHNY/Zu9N8mM35 q5fvuTzyD1pgICX5SDARagVS4pvs9eE7NrBt0kqbYpbSxmJdGGnhpqt/B JjC0BVzmJ7VHZdUAbKv/r9klXhZjcoaModbJvX1f4RHSTit+uIsQ3QomP EryuovFYCLYDJkrnmGzsahqvfGbZJeehDI8k2OzGwxeYFZlC0wkmaCOVs g==; X-CSE-ConnectionGUID: I/e8gbGnSaa6au9LE/4taA== X-CSE-MsgGUID: 8pr4brBqQga6+foFwANZZQ== X-IronPort-AV: E=McAfee;i="6700,10204,11128"; a="21567438" X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="21567438" Received: from fmviesa003.fm.intel.com ([10.60.135.143]) by orvoesa107.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:05:52 -0700 X-CSE-ConnectionGUID: aEy3ytHQSyawkcxlGbkjzw== X-CSE-MsgGUID: azE31wtFTAi9mXp+4+Ea8Q== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="52184624" Received: from dut1061atsm.igk.intel.com (HELO localhost) ([10.211.177.242]) by fmviesa003-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:05:51 -0700 From: Natalia Saiapova To: gdb-patches@sourceware.org Subject: [PATCH v2 4/6] gdb: change the internal representation of scheduler locking. Date: Tue, 9 Jul 2024 15:04:08 +0000 Message-Id: <20240709150410.34624-5-natalia.saiapova@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20240709150410.34624-1-natalia.saiapova@intel.com> References: <20240709150410.34624-1-natalia.saiapova@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-12.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~patchwork=sourceware.org@sourceware.org Introduce a new structure to manage different options of the scheduler locking. The options can coexist together and be set individually. In the next patch gdb: refine commands to control scheduler locking. we introduce the commands to control these options. In this patch we do not introduce new commands and keep the previous API. New scheduler locking options are: replay non-step -- control non-stepping commands during replay mode. replay step -- control stepping commands during replay mode. non-step -- control non-stepping commands during normal exection. step -- control stepping commands during normal exection. Internally they hold a bool value, when true the locking is enabled. Mapping to the old settings Old Settings | New settings ----------------------------------- off | all are false | replay | non-step = false, step = false, | replay non-step = true, replay step = true | step | non-step = false, step = true, | replay non-step = false, replay step = true | on | all are true --- gdb/infrun.c | 142 +++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 125 insertions(+), 17 deletions(-) diff --git a/gdb/infrun.c b/gdb/infrun.c index 2baffa9e9d8..21b7b7c7806 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -107,8 +107,10 @@ static bool start_step_over (void); static bool step_over_info_valid_p (void); -static bool schedlock_applies (thread_info *tp); -static bool schedlock_applies (bool step); +struct schedlock_options; +static bool schedlock_applies (thread_info *); +static bool schedlock_applies (thread_info *, bool); +static bool schedlock_applies_to_opts (const schedlock_options &, bool); /* Asynchronous signal handler registered as event loop source for when we have pending events ready to be passed to the core. */ @@ -2323,7 +2325,69 @@ infrun_thread_ptid_changed (process_stratum_target *target, inferior_ptid = new_ptid; } - +/* A structure to hold scheduler locking settings for + a mode, replay or normal. */ +struct schedlock_options +{ + struct option { + const std::string name; + bool value; + + option () = delete; + option (std::string name, bool value) + : name (std::move (name)), value (value) + {} + + /* Forbid accidential copying. */ + option (const option &) = delete; + option operator= (const option &) = delete; + option (option &&) = default; + option &operator= (option &&) = default; + + operator bool () const { return value; } + const char *c_str () const { return value ? "on" : "off"; } + /* Set new value. Return true, if the value has changed. */ + bool set (bool new_value); + }; + + schedlock_options () = delete; + schedlock_options (option non_step , option step) + : non_step (std::move (non_step )), step (std::move (step)) + {} + + /* Forbid accidential copying. */ + schedlock_options (const schedlock_options &) = delete; + schedlock_options operator= (const schedlock_options &) = delete; + schedlock_options (schedlock_options &&) = default; + schedlock_options &operator= (schedlock_options &&) = default; + + /* If true, the scheduler is locked during non-stepping. */ + option non_step; + /* If true, the scheduler is locked during stepping. */ + option step; +}; + +bool +schedlock_options::option::set (bool new_value) +{ + if (value != new_value) + { + value = new_value; + return true; + } + + return false; +} + +struct schedlock +{ + schedlock (schedlock_options opt, schedlock_options replay_opt) + : normal (std::move (opt)), replay (std::move (replay_opt)) + {} + + schedlock_options normal; + schedlock_options replay; +}; static const char schedlock_off[] = "off"; static const char schedlock_on[] = "on"; @@ -2336,7 +2400,34 @@ static const char *const scheduler_enums[] = { schedlock_replay, nullptr }; + static const char *scheduler_mode = schedlock_replay; + +schedlock schedlock {{{"non-step", false}, {"step", false}}, + {{"replay non-step", true}, {"replay step", true}}}; + +/* A helper function to set scheduler locking shortcuts: + set scheduler-locking on: all options are on. + set scheduler-locking off: all options are off. + set scheduler-locking replay: only replay options are on. + set scheduler-locking step: only "step" and "replay step" are on. */ + +static void +set_schedlock_shortcut_option (const char *shortcut) +{ + bool is_on = (shortcut == schedlock_on); + bool is_step = (shortcut == schedlock_step); + bool is_replay = (shortcut == schedlock_replay); + bool is_off = (shortcut == schedlock_off); + /* Check that we got a valid shortcut option. */ + gdb_assert (is_on || is_step || is_replay || is_off); + + schedlock.normal.non_step.set (is_on); + schedlock.normal.step.set (is_on || is_step); + schedlock.replay.non_step.set (is_on || is_replay); + schedlock.replay.step.set (is_on || is_replay || is_step); +} + static void show_scheduler_mode (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) @@ -2353,9 +2444,13 @@ set_schedlock_func (const char *args, int from_tty, struct cmd_list_element *c) if (!target_can_lock_scheduler ()) { scheduler_mode = schedlock_off; + /* Set scheduler locking off. */ + set_schedlock_shortcut_option (schedlock_off); error (_("Target '%s' cannot support this command."), target_shortname ()); } + + set_schedlock_shortcut_option (scheduler_mode); } /* True if execution commands resume all threads of all processes by @@ -2386,6 +2481,10 @@ ptid_t user_visible_resume_ptid (int step) { ptid_t resume_ptid; + thread_info *tp = nullptr; + + if (inferior_ptid != null_ptid) + tp = inferior_thread (); if (non_stop) { @@ -2393,14 +2492,13 @@ user_visible_resume_ptid (int step) individually. */ resume_ptid = inferior_ptid; } - else if (schedlock_applies (step)) + else if (schedlock_applies (tp, step)) { /* User-settable 'scheduler' mode requires solo thread resume. */ resume_ptid = inferior_ptid; } - else if (inferior_ptid != null_ptid - && inferior_thread ()->control.in_cond_eval) + else if (tp != nullptr && tp->control.in_cond_eval) { /* The inferior thread is evaluating a BP condition. Other threads might be stopped or running and we do not want to change their @@ -3111,7 +3209,7 @@ clear_proceed_status (int step) This is a convenience feature to not require the user to explicitly stop replaying the other threads. We're assuming that the user's intent is to resume tracing the recorded process. */ - if (!non_stop && scheduler_mode == schedlock_replay + if (!non_stop && schedlock_applies_to_opts (schedlock.replay, step) && target_record_is_replaying (minus_one_ptid) && !target_record_will_replay (user_visible_resume_ptid (step), execution_direction)) @@ -3188,26 +3286,36 @@ thread_still_needs_step_over (struct thread_info *tp) return what; } +/* Return true if OPTS lock the scheduler. + STEP indicates whether a thread is about to step. + Note, this does not take into the account the mode (replay or + normal execution). */ + +static bool +schedlock_applies_to_opts (const schedlock_options &opts, bool step) +{ + return ((opts.non_step && !step) || (opts.step && step)); +} + /* Returns true if scheduler locking applies to TP. */ static bool schedlock_applies (thread_info *tp) { - bool step = (tp != nullptr) && tp->control.stepping_command; - return schedlock_applies (step); + bool step = tp->control.stepping_command; + return schedlock_applies (tp, step); } -/* Returns true if scheduler locking applies. STEP indicates whether - we're about to do a step/next-like command. */ +/* Returns true if scheduler locking applies to TP. + STEP indicates whether a thread is about to step. */ static bool -schedlock_applies (bool step) +schedlock_applies (thread_info *tp, bool step) { - return (scheduler_mode == schedlock_on - || (scheduler_mode == schedlock_step && step) - || (scheduler_mode == schedlock_replay - && target_record_will_replay (minus_one_ptid, - execution_direction))); + bool is_replay = target_record_will_replay (minus_one_ptid, + execution_direction); + schedlock_options &opts = is_replay ? schedlock.replay : schedlock.normal; + return schedlock_applies_to_opts (opts, step); } /* When FORCE_P is false, set process_stratum_target::COMMIT_RESUMED_STATE From patchwork Tue Jul 9 15:04:09 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Saiapova, Natalia" X-Patchwork-Id: 93600 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id A90B338432F5 for ; Tue, 9 Jul 2024 15:06:46 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.20]) by sourceware.org (Postfix) with ESMTPS id D1546386182A for ; Tue, 9 Jul 2024 15:06:05 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org D1546386182A Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=intel.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org D1546386182A Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=198.175.65.20 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537571; cv=none; b=B2e1wZBCWwsvQPC7eyRElR0oIBFkJ/V1LINnCi+mAzmhOaJFfgwIRTmdzivJOLoTAQRzRR8fXk6honuq6affvBoBxxFitLQLfMBd8XHsDSyvH93x7TWTLFYU9R6QRSvMbRI+w6MeoeDU2gTRXmA1BAIb9LmI4/U9XBb4IlTCmWc= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537571; c=relaxed/simple; bh=nhWivCpfyBzrrW3wOmA2ZQLgyzD/5im1zmo4uJR4bAs=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=L9UtvvR9XUoOWvPzAm6SG4KZYhZ/FKJFev7RGlUdvlMvrJfq/xhOdPK8cLD5xlSDXlBdJzQko81BqRxd4IxQ6ateksMuJAGuyx7UWpbKZLG3wYNfPRmRb1SaaAsBbsTEWrv1fN0GfDt/4MDWTHcVK4VBy0PrZdmYK4Xyj2pSuOU= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1720537566; x=1752073566; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=nhWivCpfyBzrrW3wOmA2ZQLgyzD/5im1zmo4uJR4bAs=; b=QmgwsDGngg6mIb/9icvr9P5PNOAqYydxxWaUHakB2ZlZp6ehyk/UVZZz JrILbZn3+TL6UHVOw8fNWsEYZLes+pVyy7kt3ocXxJ833OhMOrCsolA14 m7d3Ie87h4ns216bKfJdOFdP0/jl3gbTr8t9Kf4TlysIjx4VOv1S5nIz0 6WWI9ZgZ0ayOz/1njiECntsAMB2qLPxnZfQabMc1ZoUFFJzOuTps6OowN hSfojL9d7dP2ywQWHT09feUVX5pQfPWDQTg6k/H+sydSvTZwRSQwd/5Kl JYecOITCdWTmbMVTtwHkzlL5uOR1UBXT36RRfmNkgwheMfiDIYufSq9ah g==; X-CSE-ConnectionGUID: v/1cKEHsSK2HaV7Lao7/KQ== X-CSE-MsgGUID: 3BJPPyhtTsmXwr6p4LfJ9w== X-IronPort-AV: E=McAfee;i="6700,10204,11128"; a="17619694" X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="17619694" Received: from fmviesa009.fm.intel.com ([10.60.135.149]) by orvoesa112.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:06:05 -0700 X-CSE-ConnectionGUID: 09qCaT+kSuG2T3v+pktXlw== X-CSE-MsgGUID: iSNsRH01Qi2YRBBT3ryc2Q== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="47866226" Received: from dut1061atsm.igk.intel.com (HELO localhost) ([10.211.177.242]) by fmviesa009-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:06:03 -0700 From: Natalia Saiapova To: gdb-patches@sourceware.org Subject: [PATCH v2 5/6] gdb: refine commands to control scheduler locking. Date: Tue, 9 Jul 2024 15:04:09 +0000 Message-Id: <20240709150410.34624-6-natalia.saiapova@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20240709150410.34624-1-natalia.saiapova@intel.com> References: <20240709150410.34624-1-natalia.saiapova@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-11.9 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~patchwork=sourceware.org@sourceware.org In this patch, we introduce new command options for set/show scheduler locking. New options give the user a finer control over the scheduler. Introduce set scheduler-locking | step> show scheduler-locking For example, with these commands a user can get a combined scheduler locking for stepping commands during the normal execution and for all commands in replay mode. The existing scheduler-locking settings still exist and work as shortcuts. set scheduler-locking step is equivalent to set scheduler-locking non-step off set scheduler-locking replay non-step off set scheduler-locking replay step on set scheduler-locking step on set scheduler-locking on is equivalent to set scheduler-locking non-step on set scheduler-locking replay non-step on set scheduler-locking replay step on set scheduler-locking step on set scheduler-locking replay is equivalent to set scheduler-locking non-step off set scheduler-locking replay non-step on set scheduler-locking replay step on set scheduler-locking step off set scheduler-locking off is equivalent to set scheduler-locking non-step off set scheduler-locking replay non-step off set scheduler-locking replay step off set scheduler-locking step off This is bound to the structure we introduced in the previous commit: gdb: change the internal representation of scheduler locking. To introduce it under scheduler-locking I had to change the way the show command works. (gdb) show scheduler-locking scheduler-locking non-step: "off" Scheduler locking for non-stepping commands is "off" during normal execution. scheduler-locking replay non-step: "on" Scheduler locking for non-stepping commands is "on" during replay mode. scheduler-locking replay step: "on" Scheduler locking for stepping commands is "on" during replay mode. scheduler-locking step: "off" Scheduler locking for stepping commands is "off" during normal execution. (gdb) show scheduler-locking replay scheduler-locking replay non-step: "on" Scheduler locking for non-stepping commands is "on" during replay mode. scheduler-locking replay step: "on" Scheduler locking for stepping commands is "on" during replay mode. (gdb) show scheduler-locking replay step "on" Scheduler locking for stepping commands is "on" during replay mode. (gdb) show scheduler-locking non-step "off" Scheduler locking for non-stepping commands is "off" during normal execution. Note, there is a small inconsistency with the "set scheduler-locking step". If we did not keep the older way of setting the scheduler locking, command set scheduler-locking step would be the same as set scheduler-locking step on while to be backward compatible, we have it as set scheduler-locking step on set scheduler-locking replay step on Reviewed-By: Eli Zaretskii Reviewed-By: Eli Zaretskii --- gdb/NEWS | 20 ++ gdb/doc/gdb.texinfo | 70 +++++- gdb/infrun.c | 224 ++++++++++++++---- .../gdb.mi/user-selected-context-sync.exp | 22 +- .../gdb.threads/hand-call-in-threads.exp | 10 +- .../multiple-successive-infcall.exp | 6 +- gdb/testsuite/gdb.threads/schedlock.exp | 80 ++++++- gdb/testsuite/lib/gdb.exp | 70 ++++-- 8 files changed, 400 insertions(+), 102 deletions(-) diff --git a/gdb/NEWS b/gdb/NEWS index 47677cb773a..188596b20e7 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -58,6 +58,26 @@ list . lines. This makes it more obvious that there is no information, as opposed to implying there is no inferior loaded. +set scheduler-locking (on|off) +show scheduler-locking + where is one of the following: + non-step | replay non-step | replay step | step. + Extend the scheduler locking settings with a set of set/show + commands, which can be used individually to control the scheduler during + stepping and non-stepping commands. Stepping commands include step, stepi, next. + Non-stepping commands include continue, finish, until, jump, return. + 'non-step' -- when on, the scheduler is locked during non-stepping commands + in normal mode. + 'replay non-step' -- when on, the scheduler is locked during non-stepping + commands in replay mode. + 'replay step' -- when on, the scheduler is locked during stepping + commands in replay mode. + 'step' -- when on, the scheduler is locked during stepping commands + in normal mode. + The older scheduler locking settings can be used as shortcuts, their behavior + is preserved. + The output of "show scheduler-locking" has changed to support the new settings. + * New commands info missing-debug-handler diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index 86cd420832a..32e2703414d 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -7175,28 +7175,67 @@ On some OSes, you can modify @value{GDBN}'s default behavior by locking the OS scheduler to allow only a single thread to run. @table @code -@item set scheduler-locking @var{mode} @cindex scheduler-locking +@item set scheduler-locking @var{type} [@code{on}|@code{off}] +@cindex scheduler locking type +@cindex lock scheduler +Set the scheduler locking settings. It applies to normal execution, +record mode, and replay mode. You can configure scheduler locking separately +for stepping and non-stepping commands. Examples of stepping commands are: +@samp{step}, @samp{stepi}, @samp{next}. Examples of non-stepping commands are +@samp{continue}, @samp{finish}, @samp{jump}, @samp{until}, @samp{return} or +inferior function calls. + +The following @var{type}-settings are available: + +@table @code +@item non-step +When @code{on}, the scheduler is locked for non-stepping commands during +normal execution and record modes. For non-stepping commands other threads +may not preempt the current thread. This setting is @code{off} by default. + +@item replay non-step +When @code{on}, the scheduler is locked for non-stepping commands during +replay mode. For non-stepping commands other threads may not preempt +the current thread. This setting is @code{on} by default. + +@item replay step +When @code{on}, the scheduler is locked for stepping commands during replay +mode. While stepping, other threads may not preempt the current thread, +so that the focus of debugging does not change unexpectedly. This setting +is @code{on} by default. + +@item step +When @code{on}, the scheduler is locked for stepping commands during +normal execution and record modes. While stepping, other threads may not +preempt the current thread, so that the focus of debugging does not change +unexpectedly. This setting is @code{off} by default. + +@end table + +@item set scheduler-locking @var{shortcut-mode} @cindex scheduler locking mode @cindex lock scheduler -Set the scheduler locking mode. It applies to normal execution, -record mode, and replay mode. @var{mode} can be one of -the following: +Set the scheduler locking mode. It applies to normal execution, record mode, +and replay mode. @var{shortcut-mode} is a shortcut to set several scheduler +locking types at once and can be one of the following: @table @code @item off -There is no locking and any thread may run at any time. +There is no locking and any thread may run at any time. This is +equivalent to setting all type options to @code{off}. @item on -Only the current thread may run when the inferior is resumed. New -threads created by the resumed thread are held stopped at their entry -point, before they execute any instruction. +Only the current thread may run when the inferior is resumed. New threads +created by the resumed thread are held stopped at their entry point, before +they execute any instruction. This is equivalent to setting all type options +to @code{on}. @item step Behaves like @code{on} when stepping, and @code{off} otherwise. Threads other than the current never get a chance to run when you -step, and they are completely free to run when you use commands like -@samp{continue}, @samp{until}, or @samp{finish}. +step, and they are completely free to run when you use non-stepping +commands. This mode optimizes for single-stepping; it prevents other threads from preempting the current thread while you are stepping, so that the @@ -7205,9 +7244,18 @@ another thread hits a breakpoint during its timeslice, @value{GDBN} does not change the current thread away from the thread that you are debugging. +This is equivalent to set @samp{scheduler-locking step} and +@samp{scheduler-locking replay step} to @code{on}, while other settings +are @code{off}. + @item replay Behaves like @code{on} in replay mode, and @code{off} in either record mode or during normal execution. This is the default mode. + +This is equivalent to set @samp{scheduler-locking replay non-step} and +@samp{scheduler-locking replay step} to @code{on}, while other settings +are @code{off}. + @end table @item show scheduler-locking @@ -34171,7 +34219,7 @@ the end or beginning of a replay log if one is being used. @end itemize In all-stop mode (@pxref{All-Stop Mode}), may resume only one thread, or all threads, depending on the -value of the @samp{scheduler-locking} variable. If @samp{--all} is +value of the @samp{scheduler-locking} variables. If @samp{--all} is specified, all threads (in all inferiors) will be resumed. The @samp{--all} option is ignored in all-stop mode. If the @samp{--thread-group} options is specified, then all threads in that thread group are resumed. diff --git a/gdb/infrun.c b/gdb/infrun.c index 21b7b7c7806..b02966a8afa 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -77,6 +77,8 @@ #include "extension.h" #include "disasm.h" #include "interps.h" +#include "cli/cli-decode.h" +#include /* Prototypes for local functions */ @@ -112,6 +114,12 @@ static bool schedlock_applies (thread_info *); static bool schedlock_applies (thread_info *, bool); static bool schedlock_applies_to_opts (const schedlock_options &, bool); +/* Command lists for the scheduler locking. */ +static cmd_list_element *schedlock_set_cmdlist; +static cmd_list_element *schedlock_show_cmdlist; +static cmd_list_element *schedlock_set_replay_cmdlist; +static cmd_list_element *schedlock_show_replay_cmdlist; + /* Asynchronous signal handler registered as event loop source for when we have pending events ready to be passed to the core. */ static struct async_event_handler *infrun_async_inferior_event_token; @@ -2346,7 +2354,8 @@ struct schedlock_options operator bool () const { return value; } const char *c_str () const { return value ? "on" : "off"; } - /* Set new value. Return true, if the value has changed. */ + /* Set new value. Return true, if the value has changed. + Also notifies the observer, if the value has changed. */ bool set (bool new_value); }; @@ -2373,6 +2382,9 @@ schedlock_options::option::set (bool new_value) if (value != new_value) { value = new_value; + std::string param_name = "scheduler-locking " + name; + + interps_notify_param_changed (param_name.c_str (), c_str ()); return true; } @@ -2393,15 +2405,6 @@ static const char schedlock_off[] = "off"; static const char schedlock_on[] = "on"; static const char schedlock_step[] = "step"; static const char schedlock_replay[] = "replay"; -static const char *const scheduler_enums[] = { - schedlock_off, - schedlock_on, - schedlock_step, - schedlock_replay, - nullptr -}; - -static const char *scheduler_mode = schedlock_replay; schedlock schedlock {{{"non-step", false}, {"step", false}}, {{"replay non-step", true}, {"replay step", true}}}; @@ -2422,35 +2425,89 @@ set_schedlock_shortcut_option (const char *shortcut) /* Check that we got a valid shortcut option. */ gdb_assert (is_on || is_step || is_replay || is_off); - schedlock.normal.non_step.set (is_on); - schedlock.normal.step.set (is_on || is_step); - schedlock.replay.non_step.set (is_on || is_replay); - schedlock.replay.step.set (is_on || is_replay || is_step); + bool any_changed = schedlock.normal.non_step.set (is_on); + any_changed = schedlock.normal.step.set (is_on || is_step) || any_changed; + any_changed = schedlock.replay.non_step.set (is_on || is_replay) || any_changed; + any_changed = schedlock.replay.step.set (is_on || is_replay || is_step) + || any_changed; + + /* If at least one parameter has changed, notify the observer + in the old-fashioned way. */ + if (any_changed) + interps_notify_param_changed ("scheduler-locking", shortcut); } +/* Default callback for set methods of scheduler locking options. + Checks that the scheduler locking is supported. + If no, it reverts all options to "off" and throws an error. */ + static void -show_scheduler_mode (struct ui_file *file, int from_tty, - struct cmd_list_element *c, const char *value) +set_schedlock_callback (const char *args, int from_tty, cmd_list_element *c) { - gdb_printf (file, - _("Mode for locking scheduler " - "during execution is \"%s\".\n"), - value); + if (target_can_lock_scheduler ()) + return; + + /* Set scheduler locking off and error out. */ + set_schedlock_shortcut_option (schedlock_off); + error (_("Target '%s' cannot support this command."), target_shortname ()); } +/* Support for shortcut schedlock options: "on", "off", "step", "replay". */ + static void -set_schedlock_func (const char *args, int from_tty, struct cmd_list_element *c) +set_schedlock_step (const char *args, int from_tty, cmd_list_element *c) { - if (!target_can_lock_scheduler ()) - { - scheduler_mode = schedlock_off; - /* Set scheduler locking off. */ - set_schedlock_shortcut_option (schedlock_off); - error (_("Target '%s' cannot support this command."), - target_shortname ()); - } + if (!args || !*args) + set_schedlock_shortcut_option (schedlock_step); + set_schedlock_callback (args, from_tty, nullptr); +} - set_schedlock_shortcut_option (scheduler_mode); +static void +set_schedlock_replay (const char *args, int from_tty) +{ + set_schedlock_shortcut_option (schedlock_replay); + set_schedlock_callback (args, from_tty, nullptr); +} + +static void +set_schedlock_on (const char *args, int from_tty) +{ + set_schedlock_shortcut_option (schedlock_on); + set_schedlock_callback (args, from_tty, nullptr); +} + +static void +set_schedlock_off (const char *args, int from_tty) +{ + set_schedlock_shortcut_option (schedlock_off); + set_schedlock_callback (args, from_tty, nullptr); +} + +/* Default method to show a single option of scheduler locking. */ + +static void +show_schedlock_option (ui_file *file, int from_tty, + cmd_list_element *c, const char *value) +{ + gdb_assert (c->prefix != nullptr); + const char *mode; + if (strcmp (c->prefix->name, "replay") == 0) + mode = "replay mode"; + else if (strcmp (c->prefix->name, "scheduler-locking") == 0) + mode = "normal execution"; + else + gdb_assert_not_reached ("Unexpected command prefix."); + + const char *type; + if (strcmp (c->name, "step") == 0) + type = "stepping commands"; + else if (strcmp (c->name, "non-step") == 0) + type = "non-stepping commands"; + else + gdb_assert_not_reached ("Unexpected command name."); + + gdb_printf (file, _("\"%s\" Scheduler locking for %s is " + "\"%s\" during the %s.\n"), value, type, value, mode); } /* True if execution commands resume all threads of all processes by @@ -8466,15 +8523,7 @@ switch_back_to_stepped_thread (struct execution_control_state *ecs) return true; } - /* If scheduler locking applies even if not stepping, there's no - need to walk over threads. Above we've checked whether the - current thread is stepping. If some other thread not the - event thread is stepping, then it must be that scheduler - locking is not in effect. */ - if (schedlock_applies (ecs->event_thread)) - return false; - - /* Otherwise, we no longer expect a trap in the current thread. + /* We no longer expect a trap in the current thread. Clear the trap_expected flag before switching back -- this is what keep_going does as well, if we call it. */ ecs->event_thread->control.trap_expected = 0; @@ -10771,21 +10820,92 @@ By default, the debugger will use the same inferior."), show_follow_exec_mode_string, &setlist, &showlist); - add_setshow_enum_cmd ("scheduler-locking", class_run, - scheduler_enums, &scheduler_mode, _("\ -Set mode for locking scheduler during execution."), _("\ -Show mode for locking scheduler during execution."), _("\ -off == no locking (threads may preempt at any time)\n\ -on == full locking (no thread except the current thread may run)\n\ - This applies to both normal execution and replay mode.\n\ -step == scheduler locked during stepping commands (step, next, stepi, nexti).\n\ - In this mode, other threads may run during other commands.\n\ - This applies to both normal execution and replay mode.\n\ -replay == scheduler locked in replay mode and unlocked during normal execution."), - set_schedlock_func, /* traps on target vector */ - show_scheduler_mode, + /* Commands for set/show scheduler-locking. */ + + add_setshow_prefix_cmd ("scheduler-locking", class_run, _("\ +Scheduler locking settings.\n\ +Configure scheduler locking settings in various conditions."), _("\ +Show scheduler locking settings in various conditions."), + &schedlock_set_cmdlist, + &schedlock_show_cmdlist, &setlist, &showlist); + add_setshow_boolean_cmd ("non-step", class_run, &schedlock.normal.non_step.value, _("\ +Scheduler locking for non-stepping commands during normal execution."), _("\ +Show scheduler locking for non-stepping commands during normal execution."), + _("\ +Controls scheduler locking for non-stepping commands during normal execution.\n\ +Commands include continue, until, finish. The setting does not affect \ +stepping."), + set_schedlock_callback, + show_schedlock_option, + &schedlock_set_cmdlist, + &schedlock_show_cmdlist); + + add_setshow_boolean_cmd ("step", class_run, &schedlock.normal.step.value, _("\ +Scheduler locking for stepping commands. W/o arguments locks the scheduler \ +for stepping."), _("\ +Show scheduler locking for stepping commands during normal execution."), _("\ +If argument \"on\" or \"off\", sets scheduler locking behavior for stepping\n\ +commands only during normal execution.\n\ +Commands include step, next, stepi, nexti."), + set_schedlock_step, + show_schedlock_option, + &schedlock_set_cmdlist, + &schedlock_show_cmdlist); + + /* Commands for set/show scheduler-locking in replay mode. + The base command adds support for the shortcut + set scheduler-locking replay + command. */ + + add_setshow_prefix_cmd ("replay", class_run, _("\ +Scheduler locking settings for replay mode.\n\ +Configure scheduler locking in various conditions such as during continuing\n\ +or stepping."), +("Show scheduler locking in replay mode."), + &schedlock_set_replay_cmdlist, + &schedlock_show_replay_cmdlist, + &schedlock_set_cmdlist, + &schedlock_show_cmdlist); + add_prefix_cmd ("replay", class_run, set_schedlock_replay, _("\ +Scheduler locking settings for replay mode. \ +W/o arguments completely locks the scheduler in replay mode."), + &schedlock_set_replay_cmdlist, + 0, &schedlock_set_cmdlist); + + add_setshow_boolean_cmd ("non-step", class_run, &schedlock.replay.non_step.value, _("\ +Set scheduler locking for non-stepping commands in replay mode."), _("\ +Show scheduler locking for non-stepping commands in replay mode."), _("\ +Controls scheduler locking for non-stepping commands in replay mode.\n\ +Commands include continue, until, finish. The setting does not affect \ +stepping."), + set_schedlock_callback, + show_schedlock_option, + &schedlock_set_replay_cmdlist, + &schedlock_show_replay_cmdlist); + + add_setshow_boolean_cmd ("step", class_run, &schedlock.replay.step.value, _("\ +Set scheduler locking for stepping commands in replay mode."), _("\ +Show scheduler locking for stepping commands in replay mode."), _("\ +Controls scheduler locking for stepping commands in replay mode.\n\ +Commands include step, next, stepi, nexti."), + set_schedlock_callback, + show_schedlock_option, + &schedlock_set_replay_cmdlist, + &schedlock_show_replay_cmdlist); + +/* Commands "set scheduler-locking on" and "set scheduler-locking off" + are provided for backward compatibility. */ + c = add_cmd ("on", class_run, set_schedlock_on, _("\ +[Shortcut] Full locking (no thread except the current thread may run).\n\ +This applies to both normal execution and replay mode."), + &schedlock_set_cmdlist); + + c = add_cmd ("off", class_run, set_schedlock_off, _("\ +[Shortcut] No locking (threads may preempt at any time)."), + &schedlock_set_cmdlist); + add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\ Set mode for resuming threads of all processes."), _("\ Show mode for resuming threads of all processes."), _("\ diff --git a/gdb/testsuite/gdb.mi/user-selected-context-sync.exp b/gdb/testsuite/gdb.mi/user-selected-context-sync.exp index 93b91b42f92..c21748def9d 100644 --- a/gdb/testsuite/gdb.mi/user-selected-context-sync.exp +++ b/gdb/testsuite/gdb.mi/user-selected-context-sync.exp @@ -255,17 +255,12 @@ proc make_cli_in_mi_re { command cli_in_mi_mode mode event inf cli_thread # Return the current value of the "scheduler-locking" parameter. proc show_scheduler_locking { } { - global gdb_prompt - global expect_out - - set any "\[^\r\n\]*" - set test "show scheduler-locking" - gdb_test_multiple $test $test { - -re ".*Mode for locking scheduler during execution is \"(${any})\".\r\n$gdb_prompt " { - pass $test - return $expect_out(1,string) - } + set schedlock [get_scheduler_locking $test] + + if {$schedlock ne "unknown"} { + pass $test + return $schedlock } error "Couldn't get current scheduler-locking value." @@ -311,7 +306,7 @@ proc test_continue_to_start { mode inf } { } if { $mode == "all-stop" } { - set previous_schedlock_val [show_scheduler_locking] + set previous_schedlock [show_scheduler_locking] # Set scheduler-locking on, so that we can control threads # independently. @@ -342,7 +337,10 @@ proc test_continue_to_start { mode inf } { } # Restore scheduler-locking to its original value. - gdb_test_no_output "set scheduler-locking $previous_schedlock_val" + foreach opt {"non-step" "replay non-step" "replay step" "step"} { + gdb_test_no_output \ + "set scheduler-locking $opt [dict get $previous_schedlock $opt]" + } } else { # $mode == "non-stop" # Put a thread-specific breakpoint for thread 2 of the current # inferior. We don't put a breakpoint for thread 3, since we diff --git a/gdb/testsuite/gdb.threads/hand-call-in-threads.exp b/gdb/testsuite/gdb.threads/hand-call-in-threads.exp index cde2b2d98ac..36c839990e2 100644 --- a/gdb/testsuite/gdb.threads/hand-call-in-threads.exp +++ b/gdb/testsuite/gdb.threads/hand-call-in-threads.exp @@ -68,7 +68,10 @@ gdb_test "continue" \ # Before we start making hand function calls, turn on scheduler locking. gdb_test_no_output "set scheduler-locking on" "enable scheduler locking" -gdb_test "show scheduler-locking" ".* locking scheduler .* is \"on\"." "show scheduler locking on" +set test "show scheduler-locking on" +gdb_assert {[get_scheduler_locking $test \ + [dict create "non-step" "on" "replay non-step" "on" \ + "replay step" "on" "step" "on"]] ne "unknown"} $test # Now hand-call a function in each thread, having the function # stop without returning. @@ -139,7 +142,10 @@ gdb_test_multiple "maint print dummy-frames" "all dummies popped" { # Before we resume the full program, turn off scheduler locking. gdb_test_no_output "set scheduler-locking off" "disable scheduler locking" -gdb_test "show scheduler-locking" ".* locking scheduler .* is \"off\"." "show scheduler locking off" +set test "show scheduler-locking off" +gdb_assert {[get_scheduler_locking $test \ + [dict create "non-step" "off" "replay non-step" "off" \ + "replay step" "off" "step" "off"]] ne "unknown"} $test # Continue one last time, the program should exit normally. # diff --git a/gdb/testsuite/gdb.threads/multiple-successive-infcall.exp b/gdb/testsuite/gdb.threads/multiple-successive-infcall.exp index 4a97179a5b4..c0f786e6389 100644 --- a/gdb/testsuite/gdb.threads/multiple-successive-infcall.exp +++ b/gdb/testsuite/gdb.threads/multiple-successive-infcall.exp @@ -49,8 +49,10 @@ foreach_with_prefix thread {5 4 3} { gdb_breakpoint [gdb_get_line_number "testmarker01"] gdb_continue_to_breakpoint "testmarker01" gdb_test_no_output "set scheduler-locking on" -gdb_test "show scheduler-locking" \ - "Mode for locking scheduler during execution is \"on\"." +set test "show scheduler-locking" +gdb_assert {[get_scheduler_locking $test \ + [dict create "non-step" "on" "replay non-step" "on" \ + "replay step" "on" "step" "on"]] ne "unknown"} $test foreach_with_prefix thread {5 4 3 2 1} { gdb_test "thread ${thread}" "Switching to .*" diff --git a/gdb/testsuite/gdb.threads/schedlock.exp b/gdb/testsuite/gdb.threads/schedlock.exp index bd5d5d2cff3..b81cb8a9907 100644 --- a/gdb/testsuite/gdb.threads/schedlock.exp +++ b/gdb/testsuite/gdb.threads/schedlock.exp @@ -94,7 +94,8 @@ proc get_current_thread { description } { # Make sure we're stopped in the loop, in one of the non-main threads. proc goto_loop { msg } { - gdb_breakpoint [concat [gdb_get_line_number "schedlock.exp: main loop"] " if arg != 0"] + global srcfile + gdb_breakpoint [concat "$srcfile:" [gdb_get_line_number "schedlock.exp: main loop"] " if arg != 0"] set test "return to loop" if {$msg != ""} { @@ -264,16 +265,21 @@ with_test_prefix "schedlock=on: cmd=continue" { } # Test stepping/nexting with different modes of scheduler locking. -proc test_step { schedlock cmd call_function } { +# Do scheduler-locking off setting before the test if PRESET_SCHEDLOCK_OFF is 1. +# LOCKED defines whether we expect the thread to be locked. If -1, then +# determine it first. +proc test_step { schedlock cmd call_function { preset_schedlock_off 1 } { locked -1 } } { global NUM - gdb_test_no_output "set scheduler-locking off" + if {$preset_schedlock_off} { + gdb_test_no_output "set scheduler-locking off" + } goto_loop "" set curthread [get_current_thread "before"] # No need to set to off again. This avoids a duplicate message. - if {$schedlock != "off"} { + if {$preset_schedlock_off && $schedlock != "off"} { gdb_test_no_output "set scheduler-locking $schedlock" } @@ -284,16 +290,18 @@ proc test_step { schedlock cmd call_function } { step_ten_loops $cmd - if { $schedlock == "on" || $schedlock == "step" } { - set locked 1 - } else { - set locked 0 + if { $locked == -1 } { + if { $schedlock == "on" || $schedlock == "step"} { + set locked 1 + } else { + set locked 0 + } } check_result $cmd $curthread $before_args $locked } -# Test stepping/nexting with different modes of scheduler locking. +# Test stepping/nexting with different shortcut modes of scheduler locking. foreach schedlock {"off" "step" "on"} { with_test_prefix "schedlock=$schedlock" { with_test_prefix "cmd=step" { @@ -312,3 +320,57 @@ foreach schedlock {"off" "step" "on"} { } } } + +proc test_schedlock_opts {non_step step} { + set test "show scheduler-locking" + if {[get_scheduler_locking $test \ + [dict create "non-step" $non_step "replay non-step" "off" \ + "replay step" "off" "step" $step]] eq "unknown"} { + fail $test + } else { + pass $test + } + + set locked 0 + if {$step eq "on"} { + set locked 1 + } + + # Stepping tests. + with_test_prefix "cmd=step" { + test_step "" "step" 0 0 $locked + } + with_test_prefix "cmd=next" { + foreach call_function {0 1} { + with_test_prefix "call_function=$call_function" { + test_step "" "next" $call_function 0 $locked + } + } + } + + # Continuing tests. + set locked 0 + if {$non_step eq "on"} { + set locked 1 + } + with_test_prefix "cmd=continue" { + # Use whichever we stopped in. + set curthread [get_current_thread "before"] + set cont_args [get_args "before"] + my_continue "continue" + check_result "continue" $curthread $cont_args $locked + } +} + +gdb_test_no_output "set scheduler-locking off" + +# Test different options of scheduler locking. +foreach non_step {"off" "on"} { + foreach step {"off" "on"} { + with_test_prefix "non-step=$non_step step=$step" { + gdb_test_no_output "set scheduler-locking non-step $non_step" + gdb_test_no_output "set scheduler-locking step $step" + test_schedlock_opts $non_step $step + } + } +} diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp index dfe19c9410d..6d313c2a9a1 100644 --- a/gdb/testsuite/lib/gdb.exp +++ b/gdb/testsuite/lib/gdb.exp @@ -8966,6 +8966,52 @@ gdb_caching_proc gdb_target_symbol_prefix {} { return $prefix } +# Return a dictionary of scheduler locking settings with keys: +# non-step, replay non-step, replay step, step. +# TEST is an optional test name. +# EXPECTED is a dictionary of expected values for scheduler locking with +# the same keys. If EXPECTED has less elements than scheduler locking +# settings, that means that both on and off can be expected for missing +# settings. +proc get_scheduler_locking {{test ""} {expected ""}} { + global gdb_prompt + if {$test eq ""} { + set test "reading current scheduler-locking mode" + } + + set opts {"non-step" "replay non-step" "replay step" "step"} + + # Fill the missing entries in EXPECTED list. + foreach opt $opts { + if {![dict exists $expected $opt]} { + dict set expected $opt "\(?:on|off\)" + } + } + + set any "\[^\r\n\]+" + set schedlock_regex "" + foreach opt $opts { + set opt_regex \ + "${any}$opt: +\"\([dict get $expected $opt]\)\"${any}" + set schedlock_regex "$schedlock_regex\[\r\n\]+$opt_regex" + } + + set current_schedlock_mode "unknown" + gdb_test_multiple "show scheduler-locking" $test { + -re -wrap $schedlock_regex { + set current_schedlock_mode [dict create] + set i 1 + foreach opt $opts { + dict set current_schedlock_mode $opt $expect_out($i,string) + incr $i + } + } + -re -wrap "" {} + timeout {} + } + return $current_schedlock_mode +} + # Return 1 if target supports scheduler locking, otherwise return 0. gdb_caching_proc target_supports_scheduler_locking {} { @@ -8984,28 +9030,24 @@ gdb_caching_proc target_supports_scheduler_locking {} { } set supports_schedule_locking -1 - set current_schedule_locking_mode "" set test "reading current scheduler-locking mode" - gdb_test_multiple "show scheduler-locking" $test { - -re "Mode for locking scheduler during execution is \"(\[\^\"\]*)\".*$gdb_prompt" { - set current_schedule_locking_mode $expect_out(1,string) - } - -re "$gdb_prompt $" { - set supports_schedule_locking 0 - } - timeout { - set supports_schedule_locking 0 - } + set current_schedlock [get_scheduler_locking $test] + if { $current_schedlock eq "unknown" } { + set supports_schedule_locking 0 } if { $supports_schedule_locking == -1 } { set test "checking for scheduler-locking support" - gdb_test_multiple "set scheduler-locking $current_schedule_locking_mode" $test { - -re "Target '\[^'\]+' cannot support this command\..*$gdb_prompt $" { + set regex_schedlock \ + "set scheduler-locking step [dict get current_schedlock step]" + + # Try to set scheduler-locking run. + gdb_test_multiple $regex_schedlock $test { + -re -wrap "Target '\[^'\]+' cannot support this command\..*" { set supports_schedule_locking 0 } - -re "$gdb_prompt $" { + -re -wrap "" { set supports_schedule_locking 1 } timeout { From patchwork Tue Jul 9 15:04:10 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Saiapova, Natalia" X-Patchwork-Id: 93601 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id C10B13841FE1 for ; Tue, 9 Jul 2024 15:06:50 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.20]) by sourceware.org (Postfix) with ESMTPS id ADB0338449CA for ; Tue, 9 Jul 2024 15:06:13 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org ADB0338449CA Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=intel.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=intel.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org ADB0338449CA Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=198.175.65.20 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537580; cv=none; b=krpy/hgaKVTYoYqpNnbVRg+hcYIZ2W8vyMB6NUOxs34uMH1ZO8pOOUk7tycA3HG6aJQsx3dgbhHgizn9RkHygyIRJwr1vdJUCJZhz+bakRLyaTdbmQt+AJcEOpJbydYC7nNH5pIPn6PS/mbbpqD4xDB8ON81g5QzW7/AJRpbj1E= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1720537580; c=relaxed/simple; bh=xtHubKZKsPuXNuglWdDlqIywABjZ/Q5HsOo84PRG94M=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=JoZREHWFZt7lWgqQZ2a5Aj1FDvoi3s5/P6vVTUG7s8xOCwwv9Pd+FMvoq+p1blbNrKLIixP67uE/QuKv1M/HabxWLDoRZhUwMO+pYFdekGTAV+zW3cpT14hHJOKv6gjP3kxWrT/AldQ2SsYWbhSTZxyXCD/TLWDxVtI/nsDH8dQ= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1720537574; x=1752073574; h=from:to:subject:date:message-id:in-reply-to:references: mime-version:content-transfer-encoding; bh=xtHubKZKsPuXNuglWdDlqIywABjZ/Q5HsOo84PRG94M=; b=HqSEpMM4s9hJ263Yc6fhqkFkhYvqyZLry+dGvM917kHKp5M1hSDe2Gom yPwIohhM7OzuWinTBNPaAUKyeG953s3Eyy38lNu622Y7pFup4zT5FX1lX bBe2LMlCmvY15jeD5gXxsJbzV0HDk81sEmNEXZ5KNpGqhoyPDKycWNXDc nmwu6jAaVKl33Xa2gWTT/J8gKESLdxOVqTbtUbNo/Mkjvluy72lzMPAtV 4B2d5Yxz/p02CkFCRMyIcLH7PPS6k3T+lhVUNoLgXKDvDfiBKcLxuMQmO mAadivylY+JZKodVemJH/SlvXyuHjflcSw0BNKZBrjDXw1K4E5dbw85Pf Q==; X-CSE-ConnectionGUID: /WcYMURTTDiFfmgqBTcaGg== X-CSE-MsgGUID: qwSlC1tgSPu1BM8zl9XWww== X-IronPort-AV: E=McAfee;i="6700,10204,11128"; a="17619765" X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="17619765" Received: from fmviesa009.fm.intel.com ([10.60.135.149]) by orvoesa112.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:06:14 -0700 X-CSE-ConnectionGUID: 6fhpEeleQNmPjHTD3tj/6g== X-CSE-MsgGUID: R4+rgjHLQBO+Rka2IBWhjQ== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.09,195,1716274800"; d="scan'208";a="47866304" Received: from dut1061atsm.igk.intel.com (HELO localhost) ([10.211.177.242]) by fmviesa009-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jul 2024 08:06:12 -0700 From: Natalia Saiapova To: gdb-patches@sourceware.org Subject: [PATCH v2 6/6] gdb: add eval option to lock the scheduler during infcalls. Date: Tue, 9 Jul 2024 15:04:10 +0000 Message-Id: <20240709150410.34624-7-natalia.saiapova@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20240709150410.34624-1-natalia.saiapova@intel.com> References: <20240709150410.34624-1-natalia.saiapova@intel.com> MIME-Version: 1.0 X-Spam-Status: No, score=-12.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces~patchwork=sourceware.org@sourceware.org This patch replaces the "non-step" scheduler locking setting with two settings: "continue" and "eval". "continue" handles continuing commands, such as continue, until, return, finish, jump. "eval" handles inferior calls. Show scheduler locking: (gdb) show scheduler-locking scheduler-locking continue: "off" Scheduler locking for continuing commands is "off" during normal execution. scheduler-locking eval: "off" Scheduler locking for function calls is "off" during normal execution. scheduler-locking replay continue: "on" Scheduler locking for continuing commands is "on" during replay mode. scheduler-locking replay eval: "on" Scheduler locking for function calls is "on" during replay mode. scheduler-locking replay step: "on" Scheduler locking for stepping commands is "on" during replay mode. scheduler-locking step: "off" Scheduler locking for stepping commands is "off" during normal execution. Reviewed-By: Eli Zaretskii Reviewed-By: Eli Zaretskii --- gdb/NEWS | 19 +-- gdb/doc/gdb.texinfo | 42 ++++--- gdb/infrun.c | 110 ++++++++++++------ .../gdb.mi/user-selected-context-sync.exp | 3 +- .../gdb.threads/hand-call-in-threads.exp | 6 +- .../multiple-successive-infcall.exp | 3 +- gdb/testsuite/gdb.threads/schedlock.exp | 45 +++++-- gdb/testsuite/lib/gdb.exp | 3 +- 8 files changed, 159 insertions(+), 72 deletions(-) diff --git a/gdb/NEWS b/gdb/NEWS index 188596b20e7..739b2ec4b9b 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -61,15 +61,20 @@ list . set scheduler-locking (on|off) show scheduler-locking where is one of the following: - non-step | replay non-step | replay step | step. - Extend the scheduler locking settings with a set of set/show - commands, which can be used individually to control the scheduler during - stepping and non-stepping commands. Stepping commands include step, stepi, next. - Non-stepping commands include continue, finish, until, jump, return. - 'non-step' -- when on, the scheduler is locked during non-stepping commands + continue | eval | replay continue | replay eval | replay step | step + Extend the scheduler locking settings with a set of set/show commands, + which can be used individually to control the scheduler during stepping, + continuing and evaluating commands. Stepping commands include step, stepi, + next. Continuing commands include continue, finish, until, jump, return. + The evaluating commands are those which invoke inferior calls. + 'continue' -- when on, the scheduler is locked during continuing commands in normal mode. - 'replay non-step' -- when on, the scheduler is locked during non-stepping + 'eval' -- when on, the scheduler is locked during inferior calls in + normal mode. + 'replay continue' -- when on, the scheduler is locked during continuing commands in replay mode. + 'replay eval' -- when on, the scheduler is locked during inferior calls + in replay mode. 'replay step' -- when on, the scheduler is locked during stepping commands in replay mode. 'step' -- when on, the scheduler is locked during stepping commands diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index 32e2703414d..2598834d578 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -7181,35 +7181,47 @@ locking the OS scheduler to allow only a single thread to run. @cindex lock scheduler Set the scheduler locking settings. It applies to normal execution, record mode, and replay mode. You can configure scheduler locking separately -for stepping and non-stepping commands. Examples of stepping commands are: -@samp{step}, @samp{stepi}, @samp{next}. Examples of non-stepping commands are -@samp{continue}, @samp{finish}, @samp{jump}, @samp{until}, @samp{return} or -inferior function calls. +for continuing and stepping commands, as well as function calls. +Examples of stepping commands are: @samp{step}, @samp{stepi}, @samp{next}. +Examples of continuing commands are @samp{continue}, @samp{finish}, +@samp{jump}, @samp{until}, @samp{return}. The following @var{type}-settings are available: @table @code -@item non-step -When @code{on}, the scheduler is locked for non-stepping commands during -normal execution and record modes. For non-stepping commands other threads +@item continue +When @code{on}, the scheduler is locked for continuing commands during +normal execution and record modes. For continuing commands other threads may not preempt the current thread. This setting is @code{off} by default. -@item replay non-step -When @code{on}, the scheduler is locked for non-stepping commands during -replay mode. For non-stepping commands other threads may not preempt +@item eval +When @code{on}, the scheduler is locked for function calls during normal +execution and record modes, such that other threads may not preempt +the current thread during the inferior call. This setting is @code{off} +by default. + +@item replay continue +When @code{on}, the scheduler is locked for continuing commands during +replay mode. For continuing commands other threads may not preempt the current thread. This setting is @code{on} by default. +@item replay eval +When @code{on}, the scheduler is locked for function calls during replay +mode, such that other threads may not preempt the current thread during +the inferior call. This setting is @code{on} by default. + @item replay step When @code{on}, the scheduler is locked for stepping commands during replay mode. While stepping, other threads may not preempt the current thread, so that the focus of debugging does not change unexpectedly. This setting -is @code{on} by default. +is @code{on} by default. This setting is @code{on} by default. @item step When @code{on}, the scheduler is locked for stepping commands during normal execution and record modes. While stepping, other threads may not preempt the current thread, so that the focus of debugging does not change -unexpectedly. This setting is @code{off} by default. +unexpectedly. This setting is @code{off} by default. This setting is +@code{off} by default. @end table @@ -7252,9 +7264,9 @@ are @code{off}. Behaves like @code{on} in replay mode, and @code{off} in either record mode or during normal execution. This is the default mode. -This is equivalent to set @samp{scheduler-locking replay non-step} and -@samp{scheduler-locking replay step} to @code{on}, while other settings -are @code{off}. +This is equivalent to set @samp{scheduler-locking replay continue}, +@samp{scheduler-locking replay eval} and @samp{scheduler-locking replay step} +to @code{on}, while other settings are @code{off}. @end table diff --git a/gdb/infrun.c b/gdb/infrun.c index b02966a8afa..5544a3ece73 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -111,8 +111,9 @@ static bool step_over_info_valid_p (void); struct schedlock_options; static bool schedlock_applies (thread_info *); -static bool schedlock_applies (thread_info *, bool); -static bool schedlock_applies_to_opts (const schedlock_options &, bool); +static bool schedlock_applies (bool, thread_info *tp = nullptr); +static bool schedlock_applies_to_opts (const schedlock_options &, bool, + thread_info *tp = nullptr); /* Command lists for the scheduler locking. */ static cmd_list_element *schedlock_set_cmdlist; @@ -2360,8 +2361,8 @@ struct schedlock_options }; schedlock_options () = delete; - schedlock_options (option non_step , option step) - : non_step (std::move (non_step )), step (std::move (step)) + schedlock_options (option eval, option cont, option step) + : eval (std::move (eval)), cont (std::move (cont)), step (std::move (step)) {} /* Forbid accidential copying. */ @@ -2370,8 +2371,10 @@ struct schedlock_options schedlock_options (schedlock_options &&) = default; schedlock_options &operator= (schedlock_options &&) = default; - /* If true, the scheduler is locked during non-stepping. */ - option non_step; + /* If true, the scheduler is locked during inferior calls. */ + option eval; + /* If true, the scheduler is locked during continuing. */ + option cont; /* If true, the scheduler is locked during stepping. */ option step; }; @@ -2406,8 +2409,18 @@ static const char schedlock_on[] = "on"; static const char schedlock_step[] = "step"; static const char schedlock_replay[] = "replay"; -schedlock schedlock {{{"non-step", false}, {"step", false}}, - {{"replay non-step", true}, {"replay step", true}}}; +schedlock schedlock { + { + {"eval", false}, + {"cont", false}, + {"step", false} + }, + { + {"replay eval", true}, + {"replay cont", true}, + {"replay step", true} + } +}; /* A helper function to set scheduler locking shortcuts: set scheduler-locking on: all options are on. @@ -2425,11 +2438,13 @@ set_schedlock_shortcut_option (const char *shortcut) /* Check that we got a valid shortcut option. */ gdb_assert (is_on || is_step || is_replay || is_off); - bool any_changed = schedlock.normal.non_step.set (is_on); + bool any_changed = schedlock.normal.cont.set (is_on); any_changed = schedlock.normal.step.set (is_on || is_step) || any_changed; - any_changed = schedlock.replay.non_step.set (is_on || is_replay) || any_changed; + any_changed = schedlock.normal.eval.set (is_on) || any_changed; + any_changed = schedlock.replay.cont.set (is_on || is_replay) || any_changed; any_changed = schedlock.replay.step.set (is_on || is_replay || is_step) || any_changed; + any_changed = schedlock.replay.eval.set (is_on || is_replay) || any_changed; /* If at least one parameter has changed, notify the observer in the old-fashioned way. */ @@ -2501,8 +2516,10 @@ show_schedlock_option (ui_file *file, int from_tty, const char *type; if (strcmp (c->name, "step") == 0) type = "stepping commands"; - else if (strcmp (c->name, "non-step") == 0) - type = "non-stepping commands"; + else if (strcmp (c->name, "continue") == 0) + type = "continuing commands"; + else if (strcmp (c->name, "eval") == 0) + type = "expression evaluation"; else gdb_assert_not_reached ("Unexpected command name."); @@ -2549,7 +2566,7 @@ user_visible_resume_ptid (int step) individually. */ resume_ptid = inferior_ptid; } - else if (schedlock_applies (tp, step)) + else if (schedlock_applies (step, tp)) { /* User-settable 'scheduler' mode requires solo thread resume. */ @@ -3345,13 +3362,20 @@ thread_still_needs_step_over (struct thread_info *tp) /* Return true if OPTS lock the scheduler. STEP indicates whether a thread is about to step. + While the stepping info we take from STEP argument, the inferior call + state we get from the thread TP. Note, this does not take into the account the mode (replay or normal execution). */ static bool -schedlock_applies_to_opts (const schedlock_options &opts, bool step) +schedlock_applies_to_opts (const schedlock_options &opts, bool step, + thread_info *tp) { - return ((opts.non_step && !step) || (opts.step && step)); + bool in_infcall = (tp != nullptr) && tp->control.in_infcall; + + return ((opts.cont && !step && !in_infcall) + || (opts.step && step) + || (opts.eval && in_infcall)); } /* Returns true if scheduler locking applies to TP. */ @@ -3359,20 +3383,20 @@ schedlock_applies_to_opts (const schedlock_options &opts, bool step) static bool schedlock_applies (thread_info *tp) { - bool step = tp->control.stepping_command; - return schedlock_applies (tp, step); + bool step = (tp != nullptr) && tp->control.stepping_command; + return schedlock_applies (step, tp); } -/* Returns true if scheduler locking applies to TP. - STEP indicates whether a thread is about to step. */ +/* Returns true if scheduler locking applies to thread TP. + STEP indicates whether we're about to do a step/next-like command. */ static bool -schedlock_applies (thread_info *tp, bool step) +schedlock_applies (bool step, thread_info *tp) { bool is_replay = target_record_will_replay (minus_one_ptid, execution_direction); schedlock_options &opts = is_replay ? schedlock.replay : schedlock.normal; - return schedlock_applies_to_opts (opts, step); + return schedlock_applies_to_opts (opts, step, tp); } /* When FORCE_P is false, set process_stratum_target::COMMIT_RESUMED_STATE @@ -10830,13 +10854,12 @@ Show scheduler locking settings in various conditions."), &schedlock_show_cmdlist, &setlist, &showlist); - add_setshow_boolean_cmd ("non-step", class_run, &schedlock.normal.non_step.value, _("\ -Scheduler locking for non-stepping commands during normal execution."), _("\ -Show scheduler locking for non-stepping commands during normal execution."), - _("\ -Controls scheduler locking for non-stepping commands during normal execution.\n\ -Commands include continue, until, finish. The setting does not affect \ -stepping."), + add_setshow_boolean_cmd ("continue", class_run, &schedlock.normal.cont.value, _("\ +Scheduler locking for continuing commands during normal execution."), _("\ +Show scheduler locking for continuing commands during normal execution."), _("\ +Controls scheduler locking for continuing commands during normal execution.\n\ +Commands include continue, until, finish. The setting does not affect\n\ +stepping and function calls."), set_schedlock_callback, show_schedlock_option, &schedlock_set_cmdlist, @@ -10854,6 +10877,16 @@ Commands include step, next, stepi, nexti."), &schedlock_set_cmdlist, &schedlock_show_cmdlist); + add_setshow_boolean_cmd ("eval", class_run, &schedlock.normal.eval.value, _("\ +Scheduler locking for function calls during normal execution."), _("\ +Show scheduler locking for function calls during normal execution."), + _("\ +Controls scheduler locking for function calls during normal execution."), + set_schedlock_callback, + show_schedlock_option, + &schedlock_set_cmdlist, + &schedlock_show_cmdlist); + /* Commands for set/show scheduler-locking in replay mode. The base command adds support for the shortcut set scheduler-locking replay @@ -10874,12 +10907,12 @@ W/o arguments completely locks the scheduler in replay mode."), &schedlock_set_replay_cmdlist, 0, &schedlock_set_cmdlist); - add_setshow_boolean_cmd ("non-step", class_run, &schedlock.replay.non_step.value, _("\ -Set scheduler locking for non-stepping commands in replay mode."), _("\ -Show scheduler locking for non-stepping commands in replay mode."), _("\ -Controls scheduler locking for non-stepping commands in replay mode.\n\ -Commands include continue, until, finish. The setting does not affect \ -stepping."), + add_setshow_boolean_cmd ("continue", class_run, &schedlock.replay.cont.value, _("\ +Set scheduler locking for continuing commands in replay mode."), _("\ +Show scheduler locking for continuing commands in replay mode."), _("\ +Controls scheduler locking for continuing commands in replay mode.\n\ +Commands include continue, until, finish. The setting does not affect\n\ +stepping and function calls."), set_schedlock_callback, show_schedlock_option, &schedlock_set_replay_cmdlist, @@ -10895,6 +10928,15 @@ Commands include step, next, stepi, nexti."), &schedlock_set_replay_cmdlist, &schedlock_show_replay_cmdlist); + add_setshow_boolean_cmd ("eval", class_run, &schedlock.replay.eval.value, _("\ +Set scheduler locking for function calls in replay mode."), _("\ +Show scheduler locking for function calls in replay mode."), _("\ +Controls scheduler locking for function calls in replay mode."), + set_schedlock_callback, + show_schedlock_option, + &schedlock_set_replay_cmdlist, + &schedlock_show_replay_cmdlist); + /* Commands "set scheduler-locking on" and "set scheduler-locking off" are provided for backward compatibility. */ c = add_cmd ("on", class_run, set_schedlock_on, _("\ diff --git a/gdb/testsuite/gdb.mi/user-selected-context-sync.exp b/gdb/testsuite/gdb.mi/user-selected-context-sync.exp index c21748def9d..ee457fd0b85 100644 --- a/gdb/testsuite/gdb.mi/user-selected-context-sync.exp +++ b/gdb/testsuite/gdb.mi/user-selected-context-sync.exp @@ -337,7 +337,8 @@ proc test_continue_to_start { mode inf } { } # Restore scheduler-locking to its original value. - foreach opt {"non-step" "replay non-step" "replay step" "step"} { + foreach opt {"continue" "eval" "replay continue" \ + "replay eval" "replay step" "step"} { gdb_test_no_output \ "set scheduler-locking $opt [dict get $previous_schedlock $opt]" } diff --git a/gdb/testsuite/gdb.threads/hand-call-in-threads.exp b/gdb/testsuite/gdb.threads/hand-call-in-threads.exp index 36c839990e2..17223971d14 100644 --- a/gdb/testsuite/gdb.threads/hand-call-in-threads.exp +++ b/gdb/testsuite/gdb.threads/hand-call-in-threads.exp @@ -70,7 +70,8 @@ gdb_test "continue" \ gdb_test_no_output "set scheduler-locking on" "enable scheduler locking" set test "show scheduler-locking on" gdb_assert {[get_scheduler_locking $test \ - [dict create "non-step" "on" "replay non-step" "on" \ + [dict create "continue" "on" "eval" "on" \ + "replay continue" "on" "replay eval" "on" \ "replay step" "on" "step" "on"]] ne "unknown"} $test # Now hand-call a function in each thread, having the function @@ -144,7 +145,8 @@ gdb_test_multiple "maint print dummy-frames" "all dummies popped" { gdb_test_no_output "set scheduler-locking off" "disable scheduler locking" set test "show scheduler-locking off" gdb_assert {[get_scheduler_locking $test \ - [dict create "non-step" "off" "replay non-step" "off" \ + [dict create "continue" "off" "eval" "off" \ + "replay continue" "off" "replay eval" "off" \ "replay step" "off" "step" "off"]] ne "unknown"} $test # Continue one last time, the program should exit normally. diff --git a/gdb/testsuite/gdb.threads/multiple-successive-infcall.exp b/gdb/testsuite/gdb.threads/multiple-successive-infcall.exp index c0f786e6389..b24b112d94a 100644 --- a/gdb/testsuite/gdb.threads/multiple-successive-infcall.exp +++ b/gdb/testsuite/gdb.threads/multiple-successive-infcall.exp @@ -51,7 +51,8 @@ gdb_continue_to_breakpoint "testmarker01" gdb_test_no_output "set scheduler-locking on" set test "show scheduler-locking" gdb_assert {[get_scheduler_locking $test \ - [dict create "non-step" "on" "replay non-step" "on" \ + [dict create "continue" "on" "eval" "on" \ + "replay continue" "on" "replay eval" "on" \ "replay step" "on" "step" "on"]] ne "unknown"} $test foreach_with_prefix thread {5 4 3 2 1} { diff --git a/gdb/testsuite/gdb.threads/schedlock.exp b/gdb/testsuite/gdb.threads/schedlock.exp index b81cb8a9907..00041c6cf34 100644 --- a/gdb/testsuite/gdb.threads/schedlock.exp +++ b/gdb/testsuite/gdb.threads/schedlock.exp @@ -228,7 +228,7 @@ proc check_result { cmd before_thread before_args locked } { set num_other_threads 0 for {set i 0} {$i < $NUM} {incr i} { if {[lindex $before_args $i] == [lindex $after_args $i]} { - if {$i == $before_thread} { + if {$i == $before_thread && $cmd ne "infcall"} { fail "$test (didn't run)" } } else { @@ -321,11 +321,12 @@ foreach schedlock {"off" "step" "on"} { } } -proc test_schedlock_opts {non_step step} { +proc test_schedlock_opts {cont eval step} { set test "show scheduler-locking" if {[get_scheduler_locking $test \ - [dict create "non-step" $non_step "replay non-step" "off" \ - "replay step" "off" "step" $step]] eq "unknown"} { + [dict create "continue" $cont "eval" $eval \ + "replay continue" "off" "replay eval" "off" \ + "replay step" "off" "step" $step]] eq "unknown"} { fail $test } else { pass $test @@ -350,7 +351,7 @@ proc test_schedlock_opts {non_step step} { # Continuing tests. set locked 0 - if {$non_step eq "on"} { + if {$cont eq "on"} { set locked 1 } with_test_prefix "cmd=continue" { @@ -360,17 +361,39 @@ proc test_schedlock_opts {non_step step} { my_continue "continue" check_result "continue" $curthread $cont_args $locked } + + # Infcall tests. + set locked 0 + if {$eval eq "on"} { + set locked 1 + } + with_test_prefix "cmd=infcall" { + # Use whichever we stopped in. + set curthread [get_current_thread "before-infcall"] + set cont_args [get_args "before-infcall"] + + for {set i 0} {[expr $i < 10]} {set i [expr $i + 1]} { + with_test_prefix "infcall #$i" { + gdb_test "print some_function()" ".*" + } + } + + check_result "infcall" $curthread $cont_args $locked + } } gdb_test_no_output "set scheduler-locking off" # Test different options of scheduler locking. -foreach non_step {"off" "on"} { - foreach step {"off" "on"} { - with_test_prefix "non-step=$non_step step=$step" { - gdb_test_no_output "set scheduler-locking non-step $non_step" - gdb_test_no_output "set scheduler-locking step $step" - test_schedlock_opts $non_step $step +foreach cont {"off" "on"} { + foreach eval {"off" "on"} { + foreach step {"off" "on"} { + with_test_prefix "continue=$cont eval=$eval step=$step" { + gdb_test_no_output "set scheduler-locking continue $cont" + gdb_test_no_output "set scheduler-locking eval $eval" + gdb_test_no_output "set scheduler-locking step $step" + test_schedlock_opts $cont $eval $step + } } } } diff --git a/gdb/testsuite/lib/gdb.exp b/gdb/testsuite/lib/gdb.exp index 6d313c2a9a1..bea7851193d 100644 --- a/gdb/testsuite/lib/gdb.exp +++ b/gdb/testsuite/lib/gdb.exp @@ -8979,7 +8979,8 @@ proc get_scheduler_locking {{test ""} {expected ""}} { set test "reading current scheduler-locking mode" } - set opts {"non-step" "replay non-step" "replay step" "step"} + set opts {"continue" "eval" "replay continue" "replay eval" \ + "replay step" "step"} # Fill the missing entries in EXPECTED list. foreach opt $opts {