From patchwork Thu Jul 18 18:27:24 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Kisel X-Patchwork-Id: 13736636 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 22136C3DA61 for ; Thu, 18 Jul 2024 18:27:59 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id A0C756B0085; Thu, 18 Jul 2024 14:27:58 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 995D66B0089; Thu, 18 Jul 2024 14:27:58 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 81CDA6B008C; Thu, 18 Jul 2024 14:27:58 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0013.hostedemail.com [216.40.44.13]) by kanga.kvack.org (Postfix) with ESMTP id 68C6F6B0085 for ; Thu, 18 Jul 2024 14:27:58 -0400 (EDT) Received: from smtpin03.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay05.hostedemail.com (Postfix) with ESMTP id 0A89E401AF for ; Thu, 18 Jul 2024 18:27:58 +0000 (UTC) X-FDA: 82353707436.03.403BF76 Received: from linux.microsoft.com (linux.microsoft.com [13.77.154.182]) by imf14.hostedemail.com (Postfix) with ESMTP id 4A9BA100012 for ; Thu, 18 Jul 2024 18:27:55 +0000 (UTC) Authentication-Results: imf14.hostedemail.com; dkim=pass header.d=linux.microsoft.com header.s=default header.b=SXd9PvAG; dmarc=pass (policy=none) header.from=linux.microsoft.com; spf=pass (imf14.hostedemail.com: domain of romank@linux.microsoft.com designates 13.77.154.182 as permitted sender) smtp.mailfrom=romank@linux.microsoft.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1721327229; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=GnOQJH6coKfJJds1hTuGDPjeAO6p0g0oj+N+wSCFGtg=; b=2sC5/qjeCMs99AlZEO2gVLY2LvoXwweHZUMBn5dL/kEcEYTJCrewjDPOnv5mulZ7TGBGOx E1zHvZlGw9f60c1TP3KqKVw/7IOdvgVp3SxGb6ZiZobVuTJrycxlVOhN3cErT1LwW1Y2qE PlgFs0nsi6S7p6+T4t+GRLot8cw4mqU= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1721327229; a=rsa-sha256; cv=none; b=4ktfvZQwTUlFpvOiaLo65VauJKmC8dUpIl5ZyGXwXLnJNFUrRshleGdkv9qQmrc0uJwPaC 98NRiF/DTVHl00Vs4W930mRpWPSJEeimjCdXBk3ivnORf/4S0FmmtvpnzVtNjzeq1W1EMt LthcgzrOqFtcqGiqFBn1/JGq3TD6kv0= ARC-Authentication-Results: i=1; imf14.hostedemail.com; dkim=pass header.d=linux.microsoft.com header.s=default header.b=SXd9PvAG; dmarc=pass (policy=none) header.from=linux.microsoft.com; spf=pass (imf14.hostedemail.com: domain of romank@linux.microsoft.com designates 13.77.154.182 as permitted sender) smtp.mailfrom=romank@linux.microsoft.com Received: from xps-8930.corp.microsoft.com (unknown [131.107.160.48]) by linux.microsoft.com (Postfix) with ESMTPSA id CA41520B7177; Thu, 18 Jul 2024 11:27:53 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.11.0 linux.microsoft.com CA41520B7177 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.microsoft.com; s=default; t=1721327273; bh=GnOQJH6coKfJJds1hTuGDPjeAO6p0g0oj+N+wSCFGtg=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=SXd9PvAGvsqXeqsEtaFnGlNW3LLr2x2Avdeqb1hqf8LG+RUfsgWYbdhtQ/xUkEQ7W VvKfpeAMZiTZ0PbjElW3ytMtBT6dyKkilUkNwJb8XgxAiSILm92KagJ2OayHQ7/WnH +2pJtCwKuJ9IxBoo+MAivQN2RIDd5y4qrhNjtcDM= From: Roman Kisel To: akpm@linux-foundation.org, apais@linux.microsoft.com, ardb@kernel.org, bigeasy@linutronix.de, brauner@kernel.org, ebiederm@xmission.com, jack@suse.cz, keescook@chromium.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, nagvijay@microsoft.com, oleg@redhat.com, tandersen@netflix.com, vincent.whitchurch@axis.com, viro@zeniv.linux.org.uk Cc: apais@microsoft.com, benhill@microsoft.com, ssengar@microsoft.com, sunilmut@microsoft.com, vdso@hexbites.dev Subject: [PATCH v3 1/2] coredump: Standartize and fix logging Date: Thu, 18 Jul 2024 11:27:24 -0700 Message-ID: <20240718182743.1959160-2-romank@linux.microsoft.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240718182743.1959160-1-romank@linux.microsoft.com> References: <20240718182743.1959160-1-romank@linux.microsoft.com> MIME-Version: 1.0 X-Rspamd-Server: rspam07 X-Rspamd-Queue-Id: 4A9BA100012 X-Stat-Signature: oq6pkgprud9nmn6izztxu476aca4hgx8 X-Rspam-User: X-HE-Tag: 1721327275-475544 X-HE-Meta: U2FsdGVkX19Dn+97gwMztwx5XrVtCWjA6OBm2xX9ngi+U8xRsq3oflbZgnwkD3EHZFA4ot2vk50c/sDO/zvcverm3qa5MF1PqVpFY1AQz2LX1l1Pp/S5aYFZMeeD+OjoMY+tELSrj5FSwLhI4PBFcU2tORlWR5GbtXuWBRLz5rvhIsuV3UB2IY82yPRrizelsd+TjuvW6otI/IlPDsdgQgHUR0KPxlOg5XXsoXREssadUYYeLU2mzR/yYEY0ANCyG43/kSwUdtfXyKOEoWM9L0xdtCIhBtgocYIG93Y+F/aO6pvvWZ3JBrj0Ol8yn673u0VYxW5CrmCx/KDgvYnjgQ0lcQp+segMQew5N/rME4ItQV8iNgsyijBDl20FrFZ7ruGcluWsr9pcdaHhdrIIgEvwszlhaWiRFlarS5+nLRUZmTHPOymanZsHA9oEL8EHNzDq+PEspCCesdbOxViyBcQuupYhnDKuM7ldzp9d81fHDQb+uTIt/5L3HWu03m44RNqx7m7bhN0xUSTBfxf53sNWI+621loiYYLrdH6yq/O7Rh7hQw53+AM7m6rYV8EDY33NM2xbn22F1p21nFb1GhRiGZf0ZJC5as6OgBkXTi2OQZLn5ocDdnqb12OQOnqV5anapMLnt0TrhLAf3EABXUZLQvJzzDLAIEbDS7gciZgtPq8WHGzCB6OjcWfJPDxhXPrj0zNaPUFnLKgyFCejIFlyKROqYUzdJQFCOCTef5pReQOf1f9AFGkY9ZLG/8PkmSFY1zFvZPlTxspXzqc+xGf1j/71KqzM9aOQMYdxLNTm+TVz+15wYl1PwchDbGUJuzmIk+uFP03dYMReQPgIkdREkLhadD/4LjoPZ4KCDY0zFBi8gk9L9+j3AXeFiLHN5m2PLMdJKxT/e+HslvN9mbCPyXrTg5vGvOiA5g51pv3KbGNxzqh960kuOtg0ZezkXmJXitPEP2MAn9pxJ8V LZo4S/lU bIKzSJyH6HvLOXxB/qDtS/Dq7WP+xmJR61oogLV8Trr0E1ss5H+kdRJPPjskIWo497WHCJnPwWobDFtUEhZ+4ibkYUjEP8rFrxAWV8lLm+RzgC2C/wAgP1zI+1HfMWVDEnC0Hgfm/HQRwBVQ4d+odwaMdjYWKftHT4GyMBuXFk2hEWtO60IJSqsPtFy45kB48NQEzijs70Veqw4qjcC6Ve5Eg5VQw96dWix/vPmxI9ooD8bWsh4t8O5H+jQAUDsPrLwwMKHzOfTOuMc8= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: The coredump code does not log the process ID and the comm consistently, logs unescaped comm when it does log it, and does not always use the ratelimited logging. That makes it harder to analyze logs and puts the system at the risk of spamming the system log incase something crashes many times over and over again. Fix that by logging TGID and comm (escaped) consistently and using the ratelimited logging always. Signed-off-by: Roman Kisel Tested-by: Allen Pais > --- fs/coredump.c | 43 +++++++++++++++------------------------- include/linux/coredump.h | 22 ++++++++++++++++++++ 2 files changed, 38 insertions(+), 27 deletions(-) diff --git a/fs/coredump.c b/fs/coredump.c index a57a06b80f57..19d3343b93c6 100644 --- a/fs/coredump.c +++ b/fs/coredump.c @@ -586,8 +586,7 @@ void do_coredump(const kernel_siginfo_t *siginfo) struct subprocess_info *sub_info; if (ispipe < 0) { - printk(KERN_WARNING "format_corename failed\n"); - printk(KERN_WARNING "Aborting core\n"); + coredump_report_failure("format_corename failed, aborting core"); goto fail_unlock; } @@ -607,27 +606,21 @@ void do_coredump(const kernel_siginfo_t *siginfo) * right pid if a thread in a multi-threaded * core_pattern process dies. */ - printk(KERN_WARNING - "Process %d(%s) has RLIMIT_CORE set to 1\n", - task_tgid_vnr(current), current->comm); - printk(KERN_WARNING "Aborting core\n"); + coredump_report_failure("RLIMIT_CORE is set to 1, aborting core"); goto fail_unlock; } cprm.limit = RLIM_INFINITY; dump_count = atomic_inc_return(&core_dump_count); if (core_pipe_limit && (core_pipe_limit < dump_count)) { - printk(KERN_WARNING "Pid %d(%s) over core_pipe_limit\n", - task_tgid_vnr(current), current->comm); - printk(KERN_WARNING "Skipping core dump\n"); + coredump_report_failure("over core_pipe_limit, skipping core dump"); goto fail_dropcount; } helper_argv = kmalloc_array(argc + 1, sizeof(*helper_argv), GFP_KERNEL); if (!helper_argv) { - printk(KERN_WARNING "%s failed to allocate memory\n", - __func__); + coredump_report_failure("%s failed to allocate memory", __func__); goto fail_dropcount; } for (argi = 0; argi < argc; argi++) @@ -644,8 +637,7 @@ void do_coredump(const kernel_siginfo_t *siginfo) kfree(helper_argv); if (retval) { - printk(KERN_INFO "Core dump to |%s pipe failed\n", - cn.corename); + coredump_report_failure("|%s pipe failed", cn.corename); goto close_fail; } } else { @@ -658,10 +650,8 @@ void do_coredump(const kernel_siginfo_t *siginfo) goto fail_unlock; if (need_suid_safe && cn.corename[0] != '/') { - printk(KERN_WARNING "Pid %d(%s) can only dump core "\ - "to fully qualified path!\n", - task_tgid_vnr(current), current->comm); - printk(KERN_WARNING "Skipping core dump\n"); + coredump_report_failure( + "this process can only dump core to a fully qualified path, skipping core dump"); goto fail_unlock; } @@ -730,13 +720,13 @@ void do_coredump(const kernel_siginfo_t *siginfo) idmap = file_mnt_idmap(cprm.file); if (!vfsuid_eq_kuid(i_uid_into_vfsuid(idmap, inode), current_fsuid())) { - pr_info_ratelimited("Core dump to %s aborted: cannot preserve file owner\n", - cn.corename); + coredump_report_failure("Core dump to %s aborted: " + "cannot preserve file owner", cn.corename); goto close_fail; } if ((inode->i_mode & 0677) != 0600) { - pr_info_ratelimited("Core dump to %s aborted: cannot preserve file permissions\n", - cn.corename); + coredump_report_failure("Core dump to %s aborted: " + "cannot preserve file permissions", cn.corename); goto close_fail; } if (!(cprm.file->f_mode & FMODE_CAN_WRITE)) @@ -757,7 +747,7 @@ void do_coredump(const kernel_siginfo_t *siginfo) * have this set to NULL. */ if (!cprm.file) { - pr_info("Core dump to |%s disabled\n", cn.corename); + coredump_report_failure("Core dump to |%s disabled", cn.corename); goto close_fail; } if (!dump_vma_snapshot(&cprm)) @@ -983,11 +973,10 @@ void validate_coredump_safety(void) { if (suid_dumpable == SUID_DUMP_ROOT && core_pattern[0] != '/' && core_pattern[0] != '|') { - pr_warn( -"Unsafe core_pattern used with fs.suid_dumpable=2.\n" -"Pipe handler or fully qualified core dump path required.\n" -"Set kernel.core_pattern before fs.suid_dumpable.\n" - ); + + coredump_report_failure("Unsafe core_pattern used with fs.suid_dumpable=2: " + "pipe handler or fully qualified core dump path required. " + "Set kernel.core_pattern before fs.suid_dumpable."); } } diff --git a/include/linux/coredump.h b/include/linux/coredump.h index 0904ba010341..45e598fe3476 100644 --- a/include/linux/coredump.h +++ b/include/linux/coredump.h @@ -43,8 +43,30 @@ extern int dump_align(struct coredump_params *cprm, int align); int dump_user_range(struct coredump_params *cprm, unsigned long start, unsigned long len); extern void do_coredump(const kernel_siginfo_t *siginfo); + +/* + * Logging for the coredump code, ratelimited. + * The TGID and comm fields are added to the message. + */ + +#define __COREDUMP_PRINTK(Level, Format, ...) \ + do { \ + char comm[TASK_COMM_LEN]; \ + \ + get_task_comm(comm, current); \ + printk_ratelimited(Level "coredump: %d(%*pE): " Format "\n", \ + task_tgid_vnr(current), (int)strlen(comm), comm, ##__VA_ARGS__); \ + } while (0) \ + +#define coredump_report(fmt, ...) __COREDUMP_PRINTK(KERN_INFO, fmt, ##__VA_ARGS__) +#define coredump_report_failure(fmt, ...) __COREDUMP_PRINTK(KERN_WARNING, fmt, ##__VA_ARGS__) + #else static inline void do_coredump(const kernel_siginfo_t *siginfo) {} + +#define coredump_report(...) +#define coredump_report_failure(...) + #endif #if defined(CONFIG_COREDUMP) && defined(CONFIG_SYSCTL) From patchwork Thu Jul 18 18:27:25 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Kisel X-Patchwork-Id: 13736637 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 47970C3DA49 for ; Thu, 18 Jul 2024 18:28:01 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id E7AF66B0088; Thu, 18 Jul 2024 14:27:58 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id DDCF96B008C; Thu, 18 Jul 2024 14:27:58 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id AB5546B0088; Thu, 18 Jul 2024 14:27:58 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id 7CBA66B0088 for ; Thu, 18 Jul 2024 14:27:58 -0400 (EDT) Received: from smtpin15.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id 30A79C01C7 for ; Thu, 18 Jul 2024 18:27:58 +0000 (UTC) X-FDA: 82353707436.15.D8C680F Received: from linux.microsoft.com (linux.microsoft.com [13.77.154.182]) by imf12.hostedemail.com (Postfix) with ESMTP id 6B50040010 for ; Thu, 18 Jul 2024 18:27:55 +0000 (UTC) Authentication-Results: imf12.hostedemail.com; dkim=pass header.d=linux.microsoft.com header.s=default header.b=GboBFozA; spf=pass (imf12.hostedemail.com: domain of romank@linux.microsoft.com designates 13.77.154.182 as permitted sender) smtp.mailfrom=romank@linux.microsoft.com; dmarc=pass (policy=none) header.from=linux.microsoft.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1721327234; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=1e3l8AB/5X9bCXqJTK5ycCS5UCYJGifmUe4sbQWGhvk=; b=UjHgb8OKPeucOxtS+AParvV/Wv+38I9FDoMethMnl7fYji29mptdhPjB7o5xeL/TI/jXNh jRBANOjdRwV40r+N8HxCf5Xu8RiOSVVQItCQ9vZ28ND+ZdKpI+Yn27BBbbMY1e4jKVUhux CBngUZ6/NY4xpOKhDCKO5SS9AQu3ij0= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1721327234; a=rsa-sha256; cv=none; b=4dWyAw+2mn8/hOAkxx3eQycHV8LiBOxQ6KUCjc6HhJQh6nwb/zlqH6NwgFXmSsuCMQ2zVz Uo1E2bR/XLM5vJDcSSV5COGELEzLXITXQ3iVGZNhCdOAZuDdRN+oOA8gQI1OcjHPb1yKfC /BgLRoYe/Z3lYyeZ939+Q5W9T+8vwEk= ARC-Authentication-Results: i=1; imf12.hostedemail.com; dkim=pass header.d=linux.microsoft.com header.s=default header.b=GboBFozA; spf=pass (imf12.hostedemail.com: domain of romank@linux.microsoft.com designates 13.77.154.182 as permitted sender) smtp.mailfrom=romank@linux.microsoft.com; dmarc=pass (policy=none) header.from=linux.microsoft.com Received: from xps-8930.corp.microsoft.com (unknown [131.107.160.48]) by linux.microsoft.com (Postfix) with ESMTPSA id 140B520B7123; Thu, 18 Jul 2024 11:27:54 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.11.0 linux.microsoft.com 140B520B7123 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.microsoft.com; s=default; t=1721327274; bh=1e3l8AB/5X9bCXqJTK5ycCS5UCYJGifmUe4sbQWGhvk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=GboBFozAYYNkWlkFoo0d95FXYjmn9e/+UpjDfGiZUT4lD5VfIL/dxOXsx8oXJkvO3 x/McV4pwA0/1uRhR5SZVGSI3hCC/U63msyCONOqWBLnWeVoCyUUDky2Nmqw8/nKaWO lw0PgFlbnVlUQSTMcs20tsmyobA48kqUCt/t6mJ0= From: Roman Kisel To: akpm@linux-foundation.org, apais@linux.microsoft.com, ardb@kernel.org, bigeasy@linutronix.de, brauner@kernel.org, ebiederm@xmission.com, jack@suse.cz, keescook@chromium.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, nagvijay@microsoft.com, oleg@redhat.com, tandersen@netflix.com, vincent.whitchurch@axis.com, viro@zeniv.linux.org.uk Cc: apais@microsoft.com, benhill@microsoft.com, ssengar@microsoft.com, sunilmut@microsoft.com, vdso@hexbites.dev Subject: [PATCH v3 2/2] binfmt_elf, coredump: Log the reason of the failed core dumps Date: Thu, 18 Jul 2024 11:27:25 -0700 Message-ID: <20240718182743.1959160-3-romank@linux.microsoft.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240718182743.1959160-1-romank@linux.microsoft.com> References: <20240718182743.1959160-1-romank@linux.microsoft.com> MIME-Version: 1.0 X-Stat-Signature: sbrjgrh1h454ykgbupzudetdtgusaie6 X-Rspamd-Queue-Id: 6B50040010 X-Rspam-User: X-Rspamd-Server: rspam08 X-HE-Tag: 1721327275-846025 X-HE-Meta: U2FsdGVkX1/WZqK24qeQJSwmNltLA6aslO5ylECQR4N04K/LSHvqwGcXpi+DyFCsc6aHggn3rKpCcEQeN+LVKvN5o7RIWHKCNNgl4BHRmxqwy4p8H1Rb1Nq/tBhfkHU9gU4qg993IyiTZDGH+FXYI5XkrN68ewtbE68X6u5HxHy7PGLBVtPPrqjUEsJY9HAK5Y3x9mF59hUu3QIYHQCpR0t1rh5b6j9RRMsza3Wi8qf6dWr3n3o73+dV57htxkPA/5tutKCQA/IkZhmnjT2NzHf3h/MN/zZljr7V73Bzqg6+/LGRpKu+7LD+MvJ8H1kf/DRNDH02acyc8VCTNvwilFcAUcDxXXveSpNH5K9IN/DbsPd/OS8SbCw421FMe0BYxK5t+r96uFlKTyPGXue4hTIc2u7/t816HdChUX+pJdj7+LcibTHrro0ksBDkt8iygzpK2i8MeIZu1c0M24etyLXEY1OnY37xCjglGmNe4TdIW74Ku6si7c24kuW6l3QphlXPZ6EUp8jGG/hKfXdBHplg2SmeT1J/2976PYdVfvCUQlZhYw+LV1UgaHn13J9PP8NGvvo4hyELAWBm+QQUlG25rntmP+N4qqkIJvXZ86wRnafZPpsSu5GvDmqe3OXmk53IvqbQ/eHi7B9Kc7Zm3hKgHuxQAdHsBp1pUy0OpMA0p+yrQebFvXoay55WVQcFlEeLfGDJ+SvJ9nfFyFFKy+Y8hVq9W1ltgok+L76RyTa5euAYI/UypDV7eVVuzrzXuyP+ZCxRSmHoIlKp8YYrJ+tmW7Jpyw4wzqJhiq9+4WFr28ppswecyCEOwWu2YxlmdGZJ5TvYeF87GWLuVMllUPYU35Y6lB4xAyplxKd1Eqj4sSCNRv0byEw5sxTc044rBa0lF8zHFxFgXXNxSa6oHVX9OMk5niLt7ITv3kb/lbP/hH3J53L0RDAsS85EIZrCk6cWoU9vL78aDBwDAED q3REAKnZ p1pfTTkpBImwnyrDlhIjHmwqeQk/ryCpXDS6CM2JwZDiSTVVA8FliegmfLbSDsVb+O/SqedUGx6xlPHUH1KJPY0r9XQenhUhokS2ZhvdmGflyPewN/1ZMuXYL1BR1P2ytRebRPASFvUATFZWLzoEiUELJ/N0V80IL59jFVKvvmFnJVUq96xTqedyeJhs2IYmWJ5LPUygN0XvBV+t0mUGdyucGaGxXxWdNQdGwOCKzQwvLDOoF1kIgFCcD6KIRll8+JsAurQ3VABvwN4xnZZXi8/xhSqOMna4qcLIJGT6eqDFkSFTMf8eglzyQn/gbyfuTy7e4 X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: Missing, failed, or corrupted core dumps might impede crash investigations. To improve reliability of that process and consequently the programs themselves, one needs to trace the path from producing a core dumpfile to analyzing it. That path starts from the core dump file written to the disk by the kernel or to the standard input of a user mode helper program to which the kernel streams the coredump contents. There are cases where the kernel will interrupt writing the core out or produce a truncated/not-well-formed core dump without leaving a note. Add logging for the core dump collection failure paths to be able to reason what has gone wrong when the core dump is malformed or missing. Report the size of the data written to aid in diagnosing the user mode helper. Signed-off-by: Roman Kisel --- fs/binfmt_elf.c | 48 +++++++++++++----- fs/coredump.c | 107 ++++++++++++++++++++++++++++++++------- include/linux/coredump.h | 8 ++- kernel/signal.c | 21 +++++++- 4 files changed, 150 insertions(+), 34 deletions(-) diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c index a43897b03ce9..0fa5a8af247e 100644 --- a/fs/binfmt_elf.c +++ b/fs/binfmt_elf.c @@ -1994,8 +1994,10 @@ static int elf_core_dump(struct coredump_params *cprm) * Collect all the non-memory information about the process for the * notes. This also sets up the file header. */ - if (!fill_note_info(&elf, e_phnum, &info, cprm)) + if (!fill_note_info(&elf, e_phnum, &info, cprm)) { + coredump_report_failure("Error collecting note info"); goto end_coredump; + } has_dumped = 1; @@ -2010,8 +2012,10 @@ static int elf_core_dump(struct coredump_params *cprm) sz += elf_coredump_extra_notes_size(); phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL); - if (!phdr4note) + if (!phdr4note) { + coredump_report_failure("Error allocating program headers note entry"); goto end_coredump; + } fill_elf_note_phdr(phdr4note, sz, offset); offset += sz; @@ -2025,18 +2029,24 @@ static int elf_core_dump(struct coredump_params *cprm) if (e_phnum == PN_XNUM) { shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL); - if (!shdr4extnum) + if (!shdr4extnum) { + coredump_report_failure("Error allocating extra program headers"); goto end_coredump; + } fill_extnum_info(&elf, shdr4extnum, e_shoff, segs); } offset = dataoff; - if (!dump_emit(cprm, &elf, sizeof(elf))) + if (!dump_emit(cprm, &elf, sizeof(elf))) { + coredump_report_failure("Error emitting the ELF headers"); goto end_coredump; + } - if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note))) + if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note))) { + coredump_report_failure("Error emitting the program header for notes"); goto end_coredump; + } /* Write program headers for segments dump */ for (i = 0; i < cprm->vma_count; i++) { @@ -2059,20 +2069,28 @@ static int elf_core_dump(struct coredump_params *cprm) phdr.p_flags |= PF_X; phdr.p_align = ELF_EXEC_PAGESIZE; - if (!dump_emit(cprm, &phdr, sizeof(phdr))) + if (!dump_emit(cprm, &phdr, sizeof(phdr))) { + coredump_report_failure("Error emitting program headers"); goto end_coredump; + } } - if (!elf_core_write_extra_phdrs(cprm, offset)) + if (!elf_core_write_extra_phdrs(cprm, offset)) { + coredump_report_failure("Error writing out extra program headers"); goto end_coredump; + } /* write out the notes section */ - if (!write_note_info(&info, cprm)) + if (!write_note_info(&info, cprm)) { + coredump_report_failure("Error writing out notes"); goto end_coredump; + } /* For cell spufs */ - if (elf_coredump_extra_notes_write(cprm)) + if (elf_coredump_extra_notes_write(cprm)) { + coredump_report_failure("Error writing out extra notes"); goto end_coredump; + } /* Align to page */ dump_skip_to(cprm, dataoff); @@ -2080,16 +2098,22 @@ static int elf_core_dump(struct coredump_params *cprm) for (i = 0; i < cprm->vma_count; i++) { struct core_vma_metadata *meta = cprm->vma_meta + i; - if (!dump_user_range(cprm, meta->start, meta->dump_size)) + if (!dump_user_range(cprm, meta->start, meta->dump_size)) { + coredump_report_failure("Error writing out the process memory"); goto end_coredump; + } } - if (!elf_core_write_extra_data(cprm)) + if (!elf_core_write_extra_data(cprm)) { + coredump_report_failure("Error writing out extra data"); goto end_coredump; + } if (e_phnum == PN_XNUM) { - if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum))) + if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum))) { + coredump_report_failure("Error emitting extra program headers"); goto end_coredump; + } } end_coredump: diff --git a/fs/coredump.c b/fs/coredump.c index 19d3343b93c6..8c8f6748efac 100644 --- a/fs/coredump.c +++ b/fs/coredump.c @@ -464,7 +464,17 @@ static bool dump_interrupted(void) * but then we need to teach dump_write() to restart and clear * TIF_SIGPENDING. */ - return fatal_signal_pending(current) || freezing(current); + if (fatal_signal_pending(current)) { + coredump_report_failure("interrupted: fatal signal pending"); + return true; + } + + if (freezing(current)) { + coredump_report_failure("interrupted: freezing"); + return true; + } + + return false; } static void wait_for_dump_helpers(struct file *file) @@ -519,7 +529,7 @@ static int umh_pipe_setup(struct subprocess_info *info, struct cred *new) return err; } -void do_coredump(const kernel_siginfo_t *siginfo) +int do_coredump(const kernel_siginfo_t *siginfo) { struct core_state core_state; struct core_name cn; @@ -527,7 +537,7 @@ void do_coredump(const kernel_siginfo_t *siginfo) struct linux_binfmt * binfmt; const struct cred *old_cred; struct cred *cred; - int retval = 0; + int retval; int ispipe; size_t *argv = NULL; int argc = 0; @@ -551,14 +561,20 @@ void do_coredump(const kernel_siginfo_t *siginfo) audit_core_dumps(siginfo->si_signo); binfmt = mm->binfmt; - if (!binfmt || !binfmt->core_dump) + if (!binfmt || !binfmt->core_dump) { + retval = -ENOEXEC; goto fail; - if (!__get_dumpable(cprm.mm_flags)) + } + if (!__get_dumpable(cprm.mm_flags)) { + retval = -EACCES; goto fail; + } cred = prepare_creds(); - if (!cred) + if (!cred) { + retval = -EPERM; goto fail; + } /* * We cannot trust fsuid as being the "true" uid of the process * nor do we know its entire history. We only know it was tainted @@ -587,6 +603,7 @@ void do_coredump(const kernel_siginfo_t *siginfo) if (ispipe < 0) { coredump_report_failure("format_corename failed, aborting core"); + retval = ispipe; goto fail_unlock; } @@ -607,6 +624,7 @@ void do_coredump(const kernel_siginfo_t *siginfo) * core_pattern process dies. */ coredump_report_failure("RLIMIT_CORE is set to 1, aborting core"); + retval = -EPERM; goto fail_unlock; } cprm.limit = RLIM_INFINITY; @@ -614,6 +632,7 @@ void do_coredump(const kernel_siginfo_t *siginfo) dump_count = atomic_inc_return(&core_dump_count); if (core_pipe_limit && (core_pipe_limit < dump_count)) { coredump_report_failure("over core_pipe_limit, skipping core dump"); + retval = -E2BIG; goto fail_dropcount; } @@ -621,6 +640,7 @@ void do_coredump(const kernel_siginfo_t *siginfo) GFP_KERNEL); if (!helper_argv) { coredump_report_failure("%s failed to allocate memory", __func__); + retval = -ENOMEM; goto fail_dropcount; } for (argi = 0; argi < argc; argi++) @@ -646,12 +666,16 @@ void do_coredump(const kernel_siginfo_t *siginfo) int open_flags = O_CREAT | O_WRONLY | O_NOFOLLOW | O_LARGEFILE | O_EXCL; - if (cprm.limit < binfmt->min_coredump) + if (cprm.limit < binfmt->min_coredump) { + coredump_report_failure("over coredump resource limit, skipping core dump"); + retval = -E2BIG; goto fail_unlock; + } if (need_suid_safe && cn.corename[0] != '/') { coredump_report_failure( "this process can only dump core to a fully qualified path, skipping core dump"); + retval = -EPERM; goto fail_unlock; } @@ -697,20 +721,28 @@ void do_coredump(const kernel_siginfo_t *siginfo) } else { cprm.file = filp_open(cn.corename, open_flags, 0600); } - if (IS_ERR(cprm.file)) + if (IS_ERR(cprm.file)) { + retval = PTR_ERR(cprm.file); goto fail_unlock; + } inode = file_inode(cprm.file); - if (inode->i_nlink > 1) + if (inode->i_nlink > 1) { + retval = -EMLINK; goto close_fail; - if (d_unhashed(cprm.file->f_path.dentry)) + } + if (d_unhashed(cprm.file->f_path.dentry)) { + retval = -EEXIST; goto close_fail; + } /* * AK: actually i see no reason to not allow this for named * pipes etc, but keep the previous behaviour for now. */ - if (!S_ISREG(inode->i_mode)) + if (!S_ISREG(inode->i_mode)) { + retval = -EISDIR; goto close_fail; + } /* * Don't dump core if the filesystem changed owner or mode * of the file during file creation. This is an issue when @@ -722,17 +754,22 @@ void do_coredump(const kernel_siginfo_t *siginfo) current_fsuid())) { coredump_report_failure("Core dump to %s aborted: " "cannot preserve file owner", cn.corename); + retval = -EPERM; goto close_fail; } if ((inode->i_mode & 0677) != 0600) { coredump_report_failure("Core dump to %s aborted: " "cannot preserve file permissions", cn.corename); + retval = -EPERM; goto close_fail; } - if (!(cprm.file->f_mode & FMODE_CAN_WRITE)) + if (!(cprm.file->f_mode & FMODE_CAN_WRITE)) { + retval = -EACCES; goto close_fail; - if (do_truncate(idmap, cprm.file->f_path.dentry, - 0, 0, cprm.file)) + } + retval = do_truncate(idmap, cprm.file->f_path.dentry, + 0, 0, cprm.file); + if (retval) goto close_fail; } @@ -748,10 +785,15 @@ void do_coredump(const kernel_siginfo_t *siginfo) */ if (!cprm.file) { coredump_report_failure("Core dump to |%s disabled", cn.corename); + retval = -EPERM; goto close_fail; } - if (!dump_vma_snapshot(&cprm)) + if (!dump_vma_snapshot(&cprm)) { + coredump_report_failure("Can't get VMA snapshot for core dump |%s", + cn.corename); + retval = -EACCES; goto close_fail; + } file_start_write(cprm.file); core_dumped = binfmt->core_dump(&cprm); @@ -767,9 +809,21 @@ void do_coredump(const kernel_siginfo_t *siginfo) } file_end_write(cprm.file); free_vma_snapshot(&cprm); + } else { + coredump_report_failure("Core dump to %s%s has been interrupted", + ispipe ? "|" : "", cn.corename); + retval = -EAGAIN; + goto fail; } + coredump_report( + "written to %s%s: VMAs: %d, size %zu; core: %lld bytes, pos %lld", + ispipe ? "|" : "", cn.corename, + cprm.vma_count, cprm.vma_data_size, cprm.written, cprm.pos); if (ispipe && core_pipe_limit) wait_for_dump_helpers(cprm.file); + + retval = 0; + close_fail: if (cprm.file) filp_close(cprm.file, NULL); @@ -784,7 +838,7 @@ void do_coredump(const kernel_siginfo_t *siginfo) fail_creds: put_cred(cred); fail: - return; + return retval; } /* @@ -804,8 +858,16 @@ static int __dump_emit(struct coredump_params *cprm, const void *addr, int nr) if (dump_interrupted()) return 0; n = __kernel_write(file, addr, nr, &pos); - if (n != nr) + if (n != nr) { + if (n < 0) + coredump_report_failure("failed when writing out, error %zd", n); + else + coredump_report_failure( + "partially written out, only %zd(of %d) bytes written", + n, nr); + return 0; + } file->f_pos = pos; cprm->written += n; cprm->pos += n; @@ -818,9 +880,16 @@ static int __dump_skip(struct coredump_params *cprm, size_t nr) static char zeroes[PAGE_SIZE]; struct file *file = cprm->file; if (file->f_mode & FMODE_LSEEK) { - if (dump_interrupted() || - vfs_llseek(file, nr, SEEK_CUR) < 0) + int ret; + + if (dump_interrupted()) return 0; + + ret = vfs_llseek(file, nr, SEEK_CUR); + if (ret < 0) { + coredump_report_failure("failed when seeking, error %d", ret); + return 0; + } cprm->pos += nr; return 1; } else { diff --git a/include/linux/coredump.h b/include/linux/coredump.h index 45e598fe3476..edeb8532ce0f 100644 --- a/include/linux/coredump.h +++ b/include/linux/coredump.h @@ -42,7 +42,7 @@ extern int dump_emit(struct coredump_params *cprm, const void *addr, int nr); extern int dump_align(struct coredump_params *cprm, int align); int dump_user_range(struct coredump_params *cprm, unsigned long start, unsigned long len); -extern void do_coredump(const kernel_siginfo_t *siginfo); +extern int do_coredump(const kernel_siginfo_t *siginfo); /* * Logging for the coredump code, ratelimited. @@ -62,7 +62,11 @@ extern void do_coredump(const kernel_siginfo_t *siginfo); #define coredump_report_failure(fmt, ...) __COREDUMP_PRINTK(KERN_WARNING, fmt, ##__VA_ARGS__) #else -static inline void do_coredump(const kernel_siginfo_t *siginfo) {} +static inline int do_coredump(const kernel_siginfo_t *siginfo) +{ + /* Coredump support is not available, can't fail. */ + return 0; +} #define coredump_report(...) #define coredump_report_failure(...) diff --git a/kernel/signal.c b/kernel/signal.c index 1f9dd41c04be..4d1ed397b175 100644 --- a/kernel/signal.c +++ b/kernel/signal.c @@ -2880,6 +2880,8 @@ bool get_signal(struct ksignal *ksig) current->flags |= PF_SIGNALED; if (sig_kernel_coredump(signr)) { + int ret; + if (print_fatal_signals) print_fatal_signal(signr); proc_coredump_connector(current); @@ -2891,7 +2893,24 @@ bool get_signal(struct ksignal *ksig) * first and our do_group_exit call below will use * that value and ignore the one we pass it. */ - do_coredump(&ksig->info); + ret = do_coredump(&ksig->info); + if (ret) + coredump_report_failure("coredump has not been created, error %d", + ret); + else if (!IS_ENABLED(CONFIG_COREDUMP)) { + /* + * Coredumps are not available, can't fail collecting + * the coredump. + * + * Leave a note though that the coredump is going to be + * not created. This is not an error or a warning as disabling + * support in the kernel for coredumps isn't commonplace, and + * the user must've built the kernel with the custom config so + * let them know all works as desired. + */ + coredump_report("no coredump collected as " + "that is disabled in the kernel configuration"); + } } /*