From patchwork Mon Jun 9 15:24:12 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Gary Benson X-Patchwork-Id: 1379 Received: (qmail 13518 invoked by alias); 9 Jun 2014 15:24:21 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 13499 invoked by uid 89); 9 Jun 2014 15:24:19 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.4 required=5.0 tests=AWL, BAYES_00, RP_MATCHES_RCVD, SPF_HELO_PASS, SPF_PASS autolearn=ham version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 09 Jun 2014 15:24:18 +0000 Received: from int-mx12.intmail.prod.int.phx2.redhat.com (int-mx12.intmail.prod.int.phx2.redhat.com [10.5.11.25]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id s59FOEVD008501 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Mon, 9 Jun 2014 11:24:14 -0400 Received: from blade.nx (ovpn-116-92.ams2.redhat.com [10.36.116.92]) by int-mx12.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id s59FOCSS032603; Mon, 9 Jun 2014 11:24:13 -0400 Received: by blade.nx (Postfix, from userid 1000) id 900D726243C; Mon, 9 Jun 2014 16:24:12 +0100 (BST) Date: Mon, 9 Jun 2014 16:24:12 +0100 From: Gary Benson To: gdb-patches@sourceware.org Cc: Andrew Burgess , Doug Evans , Eli Zaretskii , Florian Weimer , Mark Kettenis , Pedro Alves , Tom Tromey Subject: [PATCH 2/3 v5] Refactor and expose core-dumping functionality Message-ID: <20140609152412.GC27494@blade.nx> References: <20140609152229.GA27494@blade.nx> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20140609152229.GA27494@blade.nx> X-IsSubscribed: yes This patch exposes the functions that dump core outside utils.c. can_dump_core gains a new parameter, "limit_kind", to allow either the soft or hard limit to be checked, and its printing has separated into the new function warn_cant_dump_core. The new function can_dump_core_warn does what can_dump_core previously did (print and warn). gdb/ 2014-06-09 Gary Benson * utils.h (resource_limit_kind): New enum. (can_dump_core): New declaration. (warn_cant_dump_core): Likewise. (dump_core): Likewise. * utils.c (dump_core): Made nonstatic. Added new parameter "limit_kind". (can_dump_core): Made nonstatic. Moved printing code to... (warn_cant_dump_core): New function. (can_dump_core_warn): Likewise. (internal_vproblem): Replace calls to can_dump_core with calls to can_dump_core_warn. Supply new argument to each. diff --git a/gdb/utils.h b/gdb/utils.h index 0ba7879..a6115c1 100644 --- a/gdb/utils.h +++ b/gdb/utils.h @@ -374,4 +374,28 @@ extern ULONGEST align_down (ULONGEST v, int n); extern LONGEST gdb_sign_extend (LONGEST value, int bit); +/* Resource limits used by getrlimit and setrlimit. */ + +enum resource_limit_kind + { + LIMIT_CUR, + LIMIT_MAX + }; + +/* Check whether GDB will be able to dump core using the dump_core + function. Returns zero if GDB cannot or should not dump core. + If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected. + If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */ + +extern int can_dump_core (enum resource_limit_kind limit_kind); + +/* Print a warning that we cannot dump core. */ + +extern void warn_cant_dump_core (const char *reason); + +/* Dump core trying to increase the core soft limit to hard limit + first. */ + +extern void dump_core (void); + #endif /* UTILS_H */ diff --git a/gdb/utils.c b/gdb/utils.c index a72f3bd..0f25436 100644 --- a/gdb/utils.c +++ b/gdb/utils.c @@ -600,7 +600,7 @@ error_stream (struct ui_file *stream) /* Dump core trying to increase the core soft limit to hard limit first. */ -static void +void dump_core (void) { #ifdef HAVE_SETRLIMIT @@ -613,10 +613,12 @@ dump_core (void) } /* Check whether GDB will be able to dump core using the dump_core - function. */ + function. Returns zero if GDB cannot or should not dump core. + If LIMIT_KIND is LIMIT_CUR the user's soft limit will be respected. + If LIMIT_KIND is LIMIT_MAX only the hard limit will be respected. */ -static int -can_dump_core (const char *reason) +int +can_dump_core (enum resource_limit_kind limit_kind) { #ifdef HAVE_GETRLIMIT struct rlimit rlim; @@ -625,19 +627,47 @@ can_dump_core (const char *reason) if (getrlimit (RLIMIT_CORE, &rlim) != 0) return 1; - if (rlim.rlim_max == 0) + switch (limit_kind) { - fprintf_unfiltered (gdb_stderr, - _("%s\nUnable to dump core, use `ulimit -c" - " unlimited' before executing GDB next time.\n"), - reason); - return 0; + case LIMIT_CUR: + if (rlim.rlim_cur == 0) + return 0; + + case LIMIT_MAX: + if (rlim.rlim_max == 0) + return 0; } #endif /* HAVE_GETRLIMIT */ return 1; } +/* Print a warning that we cannot dump core. */ + +void +warn_cant_dump_core (const char *reason) +{ + fprintf_unfiltered (gdb_stderr, + _("%s\nUnable to dump core, use `ulimit -c" + " unlimited' before executing GDB next time.\n"), + reason); +} + +/* Check whether GDB will be able to dump core using the dump_core + function, and print a warning if we cannot. */ + +static int +can_dump_core_warn (enum resource_limit_kind limit_kind, + const char *reason) +{ + int core_dump_allowed = can_dump_core (limit_kind); + + if (!core_dump_allowed) + warn_cant_dump_core (reason); + + return core_dump_allowed; +} + /* Allow the user to configure the debugger behavior with respect to what to do when an internal problem is detected. */ @@ -756,7 +786,7 @@ internal_vproblem (struct internal_problem *problem, if (problem->should_dump_core == internal_problem_ask) { - if (!can_dump_core (reason)) + if (!can_dump_core_warn (LIMIT_MAX, reason)) dump_core_p = 0; else { @@ -767,7 +797,7 @@ internal_vproblem (struct internal_problem *problem, } } else if (problem->should_dump_core == internal_problem_yes) - dump_core_p = can_dump_core (reason); + dump_core_p = can_dump_core_warn (LIMIT_MAX, reason); else if (problem->should_dump_core == internal_problem_no) dump_core_p = 0; else