From nobody Fri Nov 14 16:53:57 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4C96C13B797 for ; Fri, 2 May 2025 01:13:01 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148383; cv=none; b=hx4sLAep5r3NMy7BihPH8XuLWJe+4Zbk0u8tbSX0zBPaubz9PYHW7FhAjoy8Y2V1KCrmHhBLzdsFgaS+RXdT07wvrGnJ2DUZSp8s8xu/Qal8NFFCCnUXIttJ9zffiFpG8bRQFf6ThA3dKwstmTibMinqNY+bFtUljdyIkPanLfo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148383; c=relaxed/simple; bh=kw86nuPVLkYCohDpduaq9Vfb25L0SaYqGcPejOtVH8M=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Gxgy2P1r9TiCvl82qx8Pq/P9He4yYwO87FO9p0ylIqGYp9DpFZHHRrSAGCNXAnuLtIuMi/C68gilWUCFkIiUCN6UjKHng8o4O+FuQ1w2E52zNKbVqlR7ODfnst6sPu01eDK5w72qZDLWSbIlNwbnfkOee1tnf9HzczT7lokUcOw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=V6PGMwWD; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="V6PGMwWD" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1746148381; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=K2neMnZN51HiDqW//ekE5B1aNMq6DXqgdqUvcAEfrC4=; b=V6PGMwWDEWWF2ivGH+gXWDj//aO9k02m0I6KhzXSucpXFd2k4136ZDNyYYaqaqaow0eA5R Xm5BzoH7lYCuVT2Y9abaBh1AiUjOUWcnjM7lA/fcZuxF//KOxb3wunsc0RU4WHL7ONGN42 L7nEUbYq4UsgRYcSGqVSL7jeHbpFDgA= Received: from mail-pl1-f200.google.com (mail-pl1-f200.google.com [209.85.214.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-574-MaTdyJGqNNuArexKMph1ww-1; Thu, 01 May 2025 21:12:59 -0400 X-MC-Unique: MaTdyJGqNNuArexKMph1ww-1 X-Mimecast-MFC-AGG-ID: MaTdyJGqNNuArexKMph1ww_1746148379 Received: by mail-pl1-f200.google.com with SMTP id d9443c01a7336-22647ff3cf5so11931035ad.0 for ; Thu, 01 May 2025 18:12:59 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746148379; x=1746753179; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=K2neMnZN51HiDqW//ekE5B1aNMq6DXqgdqUvcAEfrC4=; b=DX3abjzdgIyTXEcF6yEd9uXApKfw75nmGgc8lciz3cJkzfPatHA+oBWgXb8czMjMnr OqgPW+oh5xWJtzNnWt9lIkt1Nnvr4mD2+L8Hfk8pFuXZzWbVXR//5OzznbjL4qUXC3nO F9AP+GwEWUwpn7YifeoimP+2dZKSH5cPQgHARVZeMgcLHfZSgvg3jF11wH9khcf/FTFn dSDRjTZ4VWrTNGwgjbcftjmgy8Y9oddLUvUJWq0IP5ey3Yk3vj1SFef5SyKwrbY5RTSG M4Hsy8p2E+rY4137DRVfu318Xui1poJdF2EiKj1s92d44MDc/852PyEiOizaVQhAsoZn Cucw== X-Forwarded-Encrypted: i=1; AJvYcCUaihRid/jbAxzfbnHh0ZoQrzNEFnJtRKgqUfCANO5+ZLP6bQXeH/ryyEM04WxuhJnW99JJQXxtG8A3lls=@vger.kernel.org X-Gm-Message-State: AOJu0YwJwuT7KYg7cmYwJ14VbNMiz9tuMt3HSIIntRRac8vOBQ3iEKCM 7n3VmZr2IfNOnOD9OniWsTnaN2bfCV+dDB3Hj+E5pvZaXIG69FLQjDhMbPw4QLxQYo8qhuIhV+J 8Jd3U9t+ZpW1MlXw4haUss+GWo0cK8mXfLSnk7dAjmOwVcyQCWGwT+WKgMpld0Q== X-Gm-Gg: ASbGnct6ucCtIcZsYGFKVD8byTgpXUEIBmwyrbVRHBFdTnMRVhUl2NiN/FbkXRp4e8g f2eFSDLVQ5so8s65ZRLpsifCsdhr0yV7qVNPJyIz1jYzPKAgJzagxrFglCzXMCysARVH1uslr6z nqSD7UqD98Dm9icg6u0J3cXEo3B9gXuDrm0ckN25nJ79BDWU7yibq+zvCEQjvMAkoSqwZLW8NAB U+f9wio4IvlKYvnG9W+wAAkLU4TThure5CSkQ/aQUpqNmKarPQUJ0QzBEyb73SDxdYrk9c2OPUG Csc= X-Received: by 2002:a17:903:f8b:b0:220:cd9f:a180 with SMTP id d9443c01a7336-22e103891c7mr18287445ad.53.1746148378900; Thu, 01 May 2025 18:12:58 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFS7W4ycz826xBQg/pNwjqNo/5dTFfvPHK3ONMEajh9YlmAw8XidmhLF5f/05azjEItTlWoxg== X-Received: by 2002:a17:903:f8b:b0:220:cd9f:a180 with SMTP id d9443c01a7336-22e103891c7mr18287085ad.53.1746148378557; Thu, 01 May 2025 18:12:58 -0700 (PDT) Received: from localhost ([209.132.188.88]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-22e1085aeb9sm2895405ad.60.2025.05.01.18.12.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 May 2025 18:12:58 -0700 (PDT) From: Coiby Xu To: kexec@lists.infradead.org Cc: Ondrej Kozina , Milan Broz , Thomas Staudt , =?UTF-8?q?Daniel=20P=20=2E=20Berrang=C3=A9?= , Kairui Song , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Arnaud Lefebvre , Jan Pazdziora , Andrew Morton Subject: [PATCH v9 1/8] kexec_file: allow to place kexec_buf randomly Date: Fri, 2 May 2025 09:12:35 +0800 Message-ID: <20250502011246.99238-2-coxu@redhat.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250502011246.99238-1-coxu@redhat.com> References: <20250502011246.99238-1-coxu@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Currently, kexec_buf is placed in order which means for the same machine, the info in the kexec_buf is always located at the same position each time the machine is booted. This may cause a risk for sensitive information like LUKS volume key. Now struct kexec_buf has a new field random which indicates it's supposed to be placed in a random position. Note this feature is enabled only when CONFIG_CRASH_DUMP is enabled. So it only takes effect for kdump and won't impact kexec reboot. Suggested-by: Jan Pazdziora Signed-off-by: Coiby Xu Acked-by: Baoquan He --- include/linux/kexec.h | 30 ++++++++++++++++++++++++++++++ kernel/kexec_file.c | 3 +++ 2 files changed, 33 insertions(+) diff --git a/include/linux/kexec.h b/include/linux/kexec.h index c8971861521a..1871eaa95432 100644 --- a/include/linux/kexec.h +++ b/include/linux/kexec.h @@ -25,6 +25,10 @@ =20 extern note_buf_t __percpu *crash_notes; =20 +#ifdef CONFIG_CRASH_DUMP +#include +#endif + #ifdef CONFIG_KEXEC_CORE #include #include @@ -169,6 +173,7 @@ int kexec_image_post_load_cleanup_default(struct kimage= *image); * @buf_min: The buffer can't be placed below this address. * @buf_max: The buffer can't be placed above this address. * @top_down: Allocate from top of memory. + * @random: Place the buffer at a random position. */ struct kexec_buf { struct kimage *image; @@ -180,8 +185,33 @@ struct kexec_buf { unsigned long buf_min; unsigned long buf_max; bool top_down; +#ifdef CONFIG_CRASH_DUMP + bool random; +#endif }; =20 + +#ifdef CONFIG_CRASH_DUMP +static inline void kexec_random_range_start(unsigned long start, + unsigned long end, + struct kexec_buf *kbuf, + unsigned long *temp_start) +{ + unsigned short i; + + if (kbuf->random) { + get_random_bytes(&i, sizeof(unsigned short)); + *temp_start =3D start + (end - start) / USHRT_MAX * i; + } +} +#else +static inline void kexec_random_range_start(unsigned long start, + unsigned long end, + struct kexec_buf *kbuf, + unsigned long *temp_start) +{} +#endif + int kexec_load_purgatory(struct kimage *image, struct kexec_buf *kbuf); int kexec_purgatory_get_set_symbol(struct kimage *image, const char *name, void *buf, unsigned int size, diff --git a/kernel/kexec_file.c b/kernel/kexec_file.c index fba686487e3b..1180c0aa73f6 100644 --- a/kernel/kexec_file.c +++ b/kernel/kexec_file.c @@ -445,6 +445,7 @@ static int locate_mem_hole_top_down(unsigned long start= , unsigned long end, =20 temp_end =3D min(end, kbuf->buf_max); temp_start =3D temp_end - kbuf->memsz + 1; + kexec_random_range_start(temp_start, temp_end, kbuf, &temp_start); =20 do { /* align down start */ @@ -489,6 +490,8 @@ static int locate_mem_hole_bottom_up(unsigned long star= t, unsigned long end, =20 temp_start =3D max(start, kbuf->buf_min); =20 + kexec_random_range_start(temp_start, end, kbuf, &temp_start); + do { temp_start =3D ALIGN(temp_start, kbuf->buf_align); temp_end =3D temp_start + kbuf->memsz - 1; --=20 2.49.0 From nobody Fri Nov 14 16:53:57 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C974C2B9A4 for ; Fri, 2 May 2025 01:13:09 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148392; cv=none; b=S55ORvMkqoDxi7z7CYTLYKTNsELdaFukqLAPn5rRH/Uyo2JlZLdF7qltsLtSeJXnbT7PRN0pTZNQNg8DfqNhcRc4THq1/OjAexazZ9tpuQ2/l69OcFNoX+d4K69UlGQfOburdHmQcSd7wWQfWPtluuDnljWOhomodW2xbljULsY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148392; c=relaxed/simple; bh=ea9mZ0fMYc8H3dNJtS8bA7Qklp+AW/Cq46IXI50ntpU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=oJqadBZlXavagos6Olck9PvMtPAbKvTo7P9udCTWJ1TqN2EGl+0+xadk9xIT1DwUdrlJpQtRY7CsbqOOvPEgO5K/Z2rxXcA8ifTjN9X5okWCDjuSjOmJi5bs3b0RXIEbhXOLeu0WdAmD4u/09/THwXqNelS+NgrY5kKXX9z7vFw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=aMtxLCT5; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="aMtxLCT5" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1746148387; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=vw3CvT79Q3cOVUn1o5X1aSl+i2HC2zO/yQ3kCtIdex0=; b=aMtxLCT5UCh7TA2VFHLx1vMWb0WNjHsvY3SuXL8HDoNs+8BxDlQtRVjYWaAtpHspI5tIYf KU/lpD/lTCBXbbo//PJisoaYv7vVxq03W+kH9YLbl2mKUt8S9FNfEN+oXf/7BZRQ90Iab6 Z7Khh9+Ylpa2r8tQH6uospwaHrN93tM= Received: from mail-pf1-f199.google.com (mail-pf1-f199.google.com [209.85.210.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-156-3JDyA1NbMCKjfcozmMtBxg-1; Thu, 01 May 2025 21:13:05 -0400 X-MC-Unique: 3JDyA1NbMCKjfcozmMtBxg-1 X-Mimecast-MFC-AGG-ID: 3JDyA1NbMCKjfcozmMtBxg_1746148383 Received: by mail-pf1-f199.google.com with SMTP id d2e1a72fcca58-73e0094706bso2250049b3a.3 for ; Thu, 01 May 2025 18:13:04 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746148383; x=1746753183; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=vw3CvT79Q3cOVUn1o5X1aSl+i2HC2zO/yQ3kCtIdex0=; b=fAkOUDktJr2FODDg9atkrLZGsWhDwNyHBsIP9O0FOf5lN96+dsJN5gqEKGH5lPEkbO bXX2043E9JKu9IwLoy3I/u50Bkn9MxcHbkXg8/yHFRlcxQZPGDAKIJqgtQNqQ3ULceTr TitQcsTo+XGOrN6svQbaBilG5Op3dzIhdRIuEuIkHScwmFOsmHyoMXpNymB+suo3k4pl toX6YLLCICikxu3CiB8ibHUyIsQugTgCA2r8JYkB8Djkp4FUkX5iO1zY3RZNTc9I67db tUvM8Lg2DqnvIsaf4l2bapfdourQzjMGb/RqvM/po2esWwDg/IhBGls99YJO4utYuSGS 5Q1A== X-Forwarded-Encrypted: i=1; AJvYcCX/RMkjNtSVADKIb+X7sK7bmeNMnJVIr+K5hiK130yiKTFskLwtLkDzK02vpFDrIMhhYuN1E3LMdBKzmxE=@vger.kernel.org X-Gm-Message-State: AOJu0Yxl58LEVAbfxHR2ErE/ZKfqeHOCiPMYBHrF9UUhcw8aSlBItOPj 0CVvJ4mxHxR3gI7DztYcV+ym2EVVi0/imSum6qDDcvfFK6sm5utiNjCMhi7K3GfWIg4sYLSMcWH UJPEA0Q3/bH/igivez2WN73vyuIA3QC/hvXCYTGFcrgILkabnOXQYi8TlZefsdw== X-Gm-Gg: ASbGncsG1rmYB+P2rGKCnlFOrdLTzUe1deaas/+9EQv/5z3GWlBIhkFB7QU4kQyB3oL kgy5LtDFjjULHoQsmv+Zstr0Q/W8TE4kPU1zFLyAuuOXAkePMkfsA/HjkLQ3VSmoljn9vF8camt d3dDjE2epgWYtwCHzk6hEYQd2lEyrEFhsKK8Y9U83d5/MJ8+O/MrvcSXweXHPPze7A0pR9yJ2ui 6dZM+nrjVJPQsAZbfQgITqUYX10SaDEY3l6qb0cNlgDzh3boLugkqddPAIObZ923BiQ/T+WzG9a TXw= X-Received: by 2002:a05:6a00:4098:b0:737:6e1f:29da with SMTP id d2e1a72fcca58-74058b1fd7dmr1448485b3a.21.1746148383166; Thu, 01 May 2025 18:13:03 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHuA9DqPILPKQxZdcEH9QQNdT7mY4hktCyGDXZmoD7ZwVzoWJjEAELCZGpGm7+EPHwHStwhEA== X-Received: by 2002:a05:6a00:4098:b0:737:6e1f:29da with SMTP id d2e1a72fcca58-74058b1fd7dmr1448445b3a.21.1746148382793; Thu, 01 May 2025 18:13:02 -0700 (PDT) Received: from localhost ([209.132.188.88]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-74058deb363sm342932b3a.73.2025.05.01.18.13.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 May 2025 18:13:02 -0700 (PDT) From: Coiby Xu To: kexec@lists.infradead.org Cc: Ondrej Kozina , Milan Broz , Thomas Staudt , =?UTF-8?q?Daniel=20P=20=2E=20Berrang=C3=A9?= , Kairui Song , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Arnaud Lefebvre , Andrew Morton , Vivek Goyal , Jonathan Corbet , linux-doc@vger.kernel.org (open list:DOCUMENTATION) Subject: [PATCH v9 2/8] crash_dump: make dm crypt keys persist for the kdump kernel Date: Fri, 2 May 2025 09:12:36 +0800 Message-ID: <20250502011246.99238-3-coxu@redhat.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250502011246.99238-1-coxu@redhat.com> References: <20250502011246.99238-1-coxu@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable A configfs /sys/kernel/config/crash_dm_crypt_keys is provided for user space to make the dm crypt keys persist for the kdump kernel. Take the case of dumping to a LUKS-encrypted target as an example, here is the life cycle of the kdump copies of LUKS volume keys, 1. After the 1st kernel loads the initramfs during boot, systemd uses an user-input passphrase to de-crypt the LUKS volume keys or simply TPM-sealed volume keys and then save the volume keys to specified keyring (using the --link-vk-to-keyring API) and the keys will expire within specified time. 2. A user space tool (kdump initramfs loader like kdump-utils) create key items inside /sys/kernel/config/crash_dm_crypt_keys to inform the 1st kernel which keys are needed. 3. When the kdump initramfs is loaded by the kexec_file_load syscall, the 1st kernel will iterate created key items, save the keys to kdump reserved memory. 4. When the 1st kernel crashes and the kdump initramfs is booted, the kdump initramfs asks the kdump kernel to create a user key using the key stored in kdump reserved memory by writing yes to /sys/kernel/crash_dm_crypt_keys/restore. Then the LUKS encrypted device is unlocked with libcryptsetup's --volume-key-keyring API. 5. The system gets rebooted to the 1st kernel after dumping vmcore to the LUKS encrypted device is finished Eventually the keys have to stay in the kdump reserved memory for the kdump kernel to unlock encrypted volumes. During this process, some measures like letting the keys expire within specified time are desirable to reduce security risk. This patch assumes, 1) there are 128 LUKS devices at maximum to be unlocked thus MAX_KEY_NUM=3D128. 2) a key description won't exceed 128 bytes thus KEY_DESC_MAX_LEN=3D128. And here is a demo on how to interact with /sys/kernel/config/crash_dm_crypt_keys, # Add key #1 mkdir /sys/kernel/config/crash_dm_crypt_keys/7d26b7b4-e342-4d2d-b660-74= 26b0996720 # Add key #1's description echo cryptsetup:7d26b7b4-e342-4d2d-b660-7426b0996720 > /sys/kernel/conf= ig/crash_dm_crypt_keys/description # how many keys do we have now? cat /sys/kernel/config/crash_dm_crypt_keys/count 1 # Add key# 2 in the same way # how many keys do we have now? cat /sys/kernel/config/crash_dm_crypt_keys/count 2 # the tree structure of /crash_dm_crypt_keys configfs tree /sys/kernel/config/crash_dm_crypt_keys/ /sys/kernel/config/crash_dm_crypt_keys/ =E2=94=9C=E2=94=80=E2=94=80 7d26b7b4-e342-4d2d-b660-7426b0996720 =E2=94=82=C2=A0=C2=A0 =E2=94=94=E2=94=80=E2=94=80 description =E2=94=9C=E2=94=80=E2=94=80 count =E2=94=9C=E2=94=80=E2=94=80 fce2cd38-4d59-4317-8ce2-1fd24d52c46a =E2=94=82=C2=A0=C2=A0 =E2=94=94=E2=94=80=E2=94=80 description Signed-off-by: Coiby Xu Acked-by: Baoquan He --- Documentation/admin-guide/kdump/kdump.rst | 28 ++++ kernel/Kconfig.kexec | 11 ++ kernel/Makefile | 1 + kernel/crash_dump_dm_crypt.c | 154 ++++++++++++++++++++++ 4 files changed, 194 insertions(+) create mode 100644 kernel/crash_dump_dm_crypt.c diff --git a/Documentation/admin-guide/kdump/kdump.rst b/Documentation/admi= n-guide/kdump/kdump.rst index 1f7f14c6e184..b74d3bed8fff 100644 --- a/Documentation/admin-guide/kdump/kdump.rst +++ b/Documentation/admin-guide/kdump/kdump.rst @@ -547,6 +547,34 @@ from within add_taint() whenever the value set in this= bitmask matches with the bit flag being set by add_taint(). This will cause a kdump to occur at the add_taint()->panic() call. =20 +Write the dump file to encrypted disk volume +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + +CONFIG_CRASH_DM_CRYPT can be enabled to support saving the dump file to an +encrypted disk volume. User space can interact with +/sys/kernel/config/crash_dm_crypt_keys for setup, + +1. Tell the first kernel what logon keys are needed to unlock the disk vol= umes, + # Add key #1 + mkdir /sys/kernel/config/crash_dm_crypt_keys/7d26b7b4-e342-4d2d-b660-7= 426b0996720 + # Add key #1's description + echo cryptsetup:7d26b7b4-e342-4d2d-b660-7426b0996720 > /sys/kernel/con= fig/crash_dm_crypt_keys/description + + # how many keys do we have now? + cat /sys/kernel/config/crash_dm_crypt_keys/count + 1 + + # Add key #2 in the same way + + # how many keys do we have now? + cat /sys/kernel/config/crash_dm_crypt_keys/count + 2 + +2. Load the dump-capture kernel + +3. After the dump-capture kerne get booted, restore the keys to user keyri= ng + echo yes > /sys/kernel/crash_dm_crypt_keys/restore + Contact =3D=3D=3D=3D=3D=3D=3D =20 diff --git a/kernel/Kconfig.kexec b/kernel/Kconfig.kexec index 4d111f871951..0a8fafd247d1 100644 --- a/kernel/Kconfig.kexec +++ b/kernel/Kconfig.kexec @@ -116,6 +116,17 @@ config CRASH_DUMP For s390, this option also enables zfcpdump. See also =20 +config CRASH_DM_CRYPT + bool "Support saving crash dump to dm-crypt encrypted volume" + depends on KEXEC_FILE + depends on CRASH_DUMP + depends on DM_CRYPT + depends on CONFIGFS_FS + help + With this option enabled, user space can intereact with + /sys/kernel/config/crash_dm_crypt_keys to make the dm crypt keys + persistent for the dump-capture kernel. + config CRASH_HOTPLUG bool "Update the crash elfcorehdr on system configuration changes" default y diff --git a/kernel/Makefile b/kernel/Makefile index 434929de17ef..c7d3793107e5 100644 --- a/kernel/Makefile +++ b/kernel/Makefile @@ -77,6 +77,7 @@ obj-$(CONFIG_VMCORE_INFO) +=3D vmcore_info.o elfcorehdr.o obj-$(CONFIG_CRASH_RESERVE) +=3D crash_reserve.o obj-$(CONFIG_KEXEC_CORE) +=3D kexec_core.o obj-$(CONFIG_CRASH_DUMP) +=3D crash_core.o +obj-$(CONFIG_CRASH_DM_CRYPT) +=3D crash_dump_dm_crypt.o obj-$(CONFIG_KEXEC) +=3D kexec.o obj-$(CONFIG_KEXEC_FILE) +=3D kexec_file.o obj-$(CONFIG_KEXEC_ELF) +=3D kexec_elf.o diff --git a/kernel/crash_dump_dm_crypt.c b/kernel/crash_dump_dm_crypt.c new file mode 100644 index 000000000000..62a3c47d8b3b --- /dev/null +++ b/kernel/crash_dump_dm_crypt.c @@ -0,0 +1,154 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include +#include +#include +#include + +#define KEY_NUM_MAX 128 /* maximum dm crypt keys */ +#define KEY_DESC_MAX_LEN 128 /* maximum dm crypt key description size */ + +static unsigned int key_count; + +struct config_key { + struct config_item item; + const char *description; +}; + +static inline struct config_key *to_config_key(struct config_item *item) +{ + return container_of(item, struct config_key, item); +} + +static ssize_t config_key_description_show(struct config_item *item, char = *page) +{ + return sprintf(page, "%s\n", to_config_key(item)->description); +} + +static ssize_t config_key_description_store(struct config_item *item, + const char *page, size_t count) +{ + struct config_key *config_key =3D to_config_key(item); + size_t len; + int ret; + + ret =3D -EINVAL; + len =3D strcspn(page, "\n"); + + if (len > KEY_DESC_MAX_LEN) { + pr_err("The key description shouldn't exceed %u characters", KEY_DESC_MA= X_LEN); + return ret; + } + + if (!len) + return ret; + + kfree(config_key->description); + ret =3D -ENOMEM; + config_key->description =3D kmemdup_nul(page, len, GFP_KERNEL); + if (!config_key->description) + return ret; + + return count; +} + +CONFIGFS_ATTR(config_key_, description); + +static struct configfs_attribute *config_key_attrs[] =3D { + &config_key_attr_description, + NULL, +}; + +static void config_key_release(struct config_item *item) +{ + kfree(to_config_key(item)); + key_count--; +} + +static struct configfs_item_operations config_key_item_ops =3D { + .release =3D config_key_release, +}; + +static const struct config_item_type config_key_type =3D { + .ct_item_ops =3D &config_key_item_ops, + .ct_attrs =3D config_key_attrs, + .ct_owner =3D THIS_MODULE, +}; + +static struct config_item *config_keys_make_item(struct config_group *grou= p, + const char *name) +{ + struct config_key *config_key; + + if (key_count > KEY_NUM_MAX) { + pr_err("Only %u keys at maximum to be created\n", KEY_NUM_MAX); + return ERR_PTR(-EINVAL); + } + + config_key =3D kzalloc(sizeof(struct config_key), GFP_KERNEL); + if (!config_key) + return ERR_PTR(-ENOMEM); + + config_item_init_type_name(&config_key->item, name, &config_key_type); + + key_count++; + + return &config_key->item; +} + +static ssize_t config_keys_count_show(struct config_item *item, char *page) +{ + return sprintf(page, "%d\n", key_count); +} + +CONFIGFS_ATTR_RO(config_keys_, count); + +static struct configfs_attribute *config_keys_attrs[] =3D { + &config_keys_attr_count, + NULL, +}; + +/* + * Note that, since no extra work is required on ->drop_item(), + * no ->drop_item() is provided. + */ +static struct configfs_group_operations config_keys_group_ops =3D { + .make_item =3D config_keys_make_item, +}; + +static const struct config_item_type config_keys_type =3D { + .ct_group_ops =3D &config_keys_group_ops, + .ct_attrs =3D config_keys_attrs, + .ct_owner =3D THIS_MODULE, +}; + +static struct configfs_subsystem config_keys_subsys =3D { + .su_group =3D { + .cg_item =3D { + .ci_namebuf =3D "crash_dm_crypt_keys", + .ci_type =3D &config_keys_type, + }, + }, +}; + +static int __init configfs_dmcrypt_keys_init(void) +{ + int ret; + + config_group_init(&config_keys_subsys.su_group); + mutex_init(&config_keys_subsys.su_mutex); + ret =3D configfs_register_subsystem(&config_keys_subsys); + if (ret) { + pr_err("Error %d while registering subsystem %s\n", ret, + config_keys_subsys.su_group.cg_item.ci_namebuf); + goto out_unregister; + } + + return 0; + +out_unregister: + configfs_unregister_subsystem(&config_keys_subsys); + + return ret; +} + +module_init(configfs_dmcrypt_keys_init); --=20 2.49.0 From nobody Fri Nov 14 16:53:57 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8508F85260 for ; Fri, 2 May 2025 01:13:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148392; cv=none; b=IzWm3PhTqXqy33/zL2l8/qmdMpSlDxAqRWNh7Bed1cYa5yS4RaweV6BLrG2hTzUtcl2MdAJuhYlxYmhbVixcglQnYodbdQtE7mgJhvlEn8xqTywMpumBeJ66aWH7z2ZL4KxkNpZw6qenaqJ7FmfDs4xpa93sXapZloxVYEq/7uI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148392; c=relaxed/simple; bh=xGq6E1Xm4xowTjcw7xDmWLNzTZI63dDxQ9UmgG7Pajo=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=iGH5OCer6k1OgmZAVA014zjsHaM/zkmztOlDO+sF5et9dRzFkL4ToukxRnM7wEhaHc0GGjL4LIeSInjX3fA2g66KbHK5pdJGViP/9gm/x7m8KTX7/ol8mvv0BXyhBECMMDiFIcrOSVrK952hiY3RCmEy5JyB7xqQQn3eL+E95EI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=M5sl8szr; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="M5sl8szr" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1746148389; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=GBWfvLJxb5OXrN8DqbQaSB09FpR8x5OxSi6J4jIJ0dk=; b=M5sl8szrEI6/3OSPB7u1VP8ZGaYYKm82KJW3olBWhxIK8MljSdO/X8vVJ+cxFNLzMjqXtX KCl92QNEcxPtyzYDiM7xr6tRFIbsK1xETikRiQuGJrUTAM7G4pegNSVJOKpvXVcFIJU5xl p3W3UxeFNaukSZlt1oHmZAYvX7k5/ts= Received: from mail-pf1-f197.google.com (mail-pf1-f197.google.com [209.85.210.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-324-RlH0gVQePBywBflkDsBluQ-1; Thu, 01 May 2025 21:13:08 -0400 X-MC-Unique: RlH0gVQePBywBflkDsBluQ-1 X-Mimecast-MFC-AGG-ID: RlH0gVQePBywBflkDsBluQ_1746148387 Received: by mail-pf1-f197.google.com with SMTP id d2e1a72fcca58-73c205898aaso1134435b3a.2 for ; Thu, 01 May 2025 18:13:08 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746148387; x=1746753187; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=GBWfvLJxb5OXrN8DqbQaSB09FpR8x5OxSi6J4jIJ0dk=; b=ldgjmMF1XoEcKV+LGNyBdwsz8AP8BTnNLz0mqw8f/7BFcXaMVCFIQkhw7L8UqLlkXP 9OKF+eb0XYaEfdX9vOwTP/jfEbWPsrbgBtP9sixioBx5PnD6huC8lzxwmX7HQ8cMqMjK 8zxY8QPrkLRGCDcw4p/dw+Sb2l4q6U4OxkvMFNZxzBkyJLbceFOxmoCZbpvLNj2jxGri jJYwZdw7K8mVh+I2HMGb1Kucn6KArgrvsB8PcKD921vfNgV+1MhIEbsozYAwoHlhKkHZ P27QWm9Zg4k7aX7YfoGXhWsenRM9K+6FV+fKxmmw5jJ1pZ7sub8N/1oQQdFHnNqEsIn2 6pFw== X-Forwarded-Encrypted: i=1; AJvYcCVIyUwvqFxG2rYlbVnre4RHcmlj5lpHIo8Fq6MEi/f09QVfJF9FH6qxEvzEulou7fDH2Qv8+HNu+dCbeK0=@vger.kernel.org X-Gm-Message-State: AOJu0Yye+NggbFh2ITLOMbfXtjyr2sGPFTOOnfXtjhgpQkU9MwiWsdDc VoLnV0VO98KzPUQ+x2nV3EaAxSqpb0KMUw5IB7EntGA0Gm3qjBqY6xVVGKG+m+7EL2EXJncY2aY 8oEg0nfk78Fu4MgPK9/tRIUP3IW4HJxvtNC+Qo6Gr5pm045IfDy9eK5XoSv6CUw== X-Gm-Gg: ASbGncv5TAkN9OSpMVNf/n7TFRaP3NodwMHvHiw/mOqiJXfqQPVK9mDoIcprtSzPHbr QKSSU3AwnDyjEru8Ahind3Fil8crF3X3KqY1x8pkA67X3dszCCySNcpI651HgzfgjAYFu5VsM6c d8zn2UteLVw/9262iliKjjO4ee6Sv/g4TUNK1CCqV7LWhIdFLpRiDiKxZEjesQvBUZg2L57ebbi bgIS5NgQ8CeojcoKnYnClAlq9TUuGq3Iyll2FuH4Kv405Z5IAME6C9cjyEoov7Bp5ZM06aeyDqj 3sM= X-Received: by 2002:a05:6a00:ab01:b0:730:9801:d3e2 with SMTP id d2e1a72fcca58-74058a1af41mr1713815b3a.8.1746148387364; Thu, 01 May 2025 18:13:07 -0700 (PDT) X-Google-Smtp-Source: AGHT+IEWrlVfaGnH2bAuy9TSvG0bRVxSTF2k5lzCQyD8yusIUmdWs3IYHq0T9Uk0I4GD24HMDP8szQ== X-Received: by 2002:a05:6a00:ab01:b0:730:9801:d3e2 with SMTP id d2e1a72fcca58-74058a1af41mr1713773b3a.8.1746148387017; Thu, 01 May 2025 18:13:07 -0700 (PDT) Received: from localhost ([209.132.188.88]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-74058d7adc9sm347612b3a.30.2025.05.01.18.13.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 May 2025 18:13:06 -0700 (PDT) From: Coiby Xu To: kexec@lists.infradead.org Cc: Ondrej Kozina , Milan Broz , Thomas Staudt , =?UTF-8?q?Daniel=20P=20=2E=20Berrang=C3=A9?= , Kairui Song , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Arnaud Lefebvre , Andrew Morton , Vivek Goyal , Kees Cook , "Gustavo A. R. Silva" , linux-hardening@vger.kernel.org (open list:KERNEL HARDENING (not covered by other areas):Keyword:\b__counted_by(_le|_be)?\b) Subject: [PATCH v9 3/8] crash_dump: store dm crypt keys in kdump reserved memory Date: Fri, 2 May 2025 09:12:37 +0800 Message-ID: <20250502011246.99238-4-coxu@redhat.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250502011246.99238-1-coxu@redhat.com> References: <20250502011246.99238-1-coxu@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" When the kdump kernel image and initrd are loaded, the dm crypts keys will be read from keyring and then stored in kdump reserved memory. Assume a key won't exceed 256 bytes thus MAX_KEY_SIZE=3D256 according to "cryptsetup benchmark". Signed-off-by: Coiby Xu Acked-by: Baoquan He --- include/linux/crash_core.h | 6 +- include/linux/kexec.h | 4 ++ kernel/crash_dump_dm_crypt.c | 133 +++++++++++++++++++++++++++++++++++ 3 files changed, 142 insertions(+), 1 deletion(-) diff --git a/include/linux/crash_core.h b/include/linux/crash_core.h index 44305336314e..2e6782239034 100644 --- a/include/linux/crash_core.h +++ b/include/linux/crash_core.h @@ -34,7 +34,11 @@ static inline void arch_kexec_protect_crashkres(void) { } static inline void arch_kexec_unprotect_crashkres(void) { } #endif =20 - +#ifdef CONFIG_CRASH_DM_CRYPT +int crash_load_dm_crypt_keys(struct kimage *image); +#else +static inline int crash_load_dm_crypt_keys(struct kimage *image) {return 0= ; } +#endif =20 #ifndef arch_crash_handle_hotplug_event static inline void arch_crash_handle_hotplug_event(struct kimage *image, v= oid *arg) { } diff --git a/include/linux/kexec.h b/include/linux/kexec.h index 1871eaa95432..6e688c5d8e4d 100644 --- a/include/linux/kexec.h +++ b/include/linux/kexec.h @@ -405,6 +405,10 @@ struct kimage { void *elf_headers; unsigned long elf_headers_sz; unsigned long elf_load_addr; + + /* dm crypt keys buffer */ + unsigned long dm_crypt_keys_addr; + unsigned long dm_crypt_keys_sz; }; =20 /* kexec interface functions */ diff --git a/kernel/crash_dump_dm_crypt.c b/kernel/crash_dump_dm_crypt.c index 62a3c47d8b3b..fb25f55f1512 100644 --- a/kernel/crash_dump_dm_crypt.c +++ b/kernel/crash_dump_dm_crypt.c @@ -1,14 +1,62 @@ // SPDX-License-Identifier: GPL-2.0-only +#include +#include #include #include #include #include =20 #define KEY_NUM_MAX 128 /* maximum dm crypt keys */ +#define KEY_SIZE_MAX 256 /* maximum dm crypt key size */ #define KEY_DESC_MAX_LEN 128 /* maximum dm crypt key description size */ =20 static unsigned int key_count; =20 +struct dm_crypt_key { + unsigned int key_size; + char key_desc[KEY_DESC_MAX_LEN]; + u8 data[KEY_SIZE_MAX]; +}; + +static struct keys_header { + unsigned int total_keys; + struct dm_crypt_key keys[] __counted_by(total_keys); +} *keys_header; + +static size_t get_keys_header_size(size_t total_keys) +{ + return struct_size(keys_header, keys, total_keys); +} + +static int read_key_from_user_keying(struct dm_crypt_key *dm_key) +{ + const struct user_key_payload *ukp; + struct key *key; + + kexec_dprintk("Requesting logon key %s", dm_key->key_desc); + key =3D request_key(&key_type_logon, dm_key->key_desc, NULL); + + if (IS_ERR(key)) { + pr_warn("No such logon key %s\n", dm_key->key_desc); + return PTR_ERR(key); + } + + ukp =3D user_key_payload_locked(key); + if (!ukp) + return -EKEYREVOKED; + + if (ukp->datalen > KEY_SIZE_MAX) { + pr_err("Key size %u exceeds maximum (%u)\n", ukp->datalen, KEY_SIZE_MAX); + return -EINVAL; + } + + memcpy(dm_key->data, ukp->data, ukp->datalen); + dm_key->key_size =3D ukp->datalen; + kexec_dprintk("Get dm crypt key (size=3D%u) %s: %8ph\n", dm_key->key_size, + dm_key->key_desc, dm_key->data); + return 0; +} + struct config_key { struct config_item item; const char *description; @@ -130,6 +178,91 @@ static struct configfs_subsystem config_keys_subsys = =3D { }, }; =20 +static int build_keys_header(void) +{ + struct config_item *item =3D NULL; + struct config_key *key; + int i, r; + + if (keys_header !=3D NULL) + kvfree(keys_header); + + keys_header =3D kzalloc(get_keys_header_size(key_count), GFP_KERNEL); + if (!keys_header) + return -ENOMEM; + + keys_header->total_keys =3D key_count; + + i =3D 0; + list_for_each_entry(item, &config_keys_subsys.su_group.cg_children, + ci_entry) { + if (item->ci_type !=3D &config_key_type) + continue; + + key =3D to_config_key(item); + + if (!key->description) { + pr_warn("No key description for key %s\n", item->ci_name); + return -EINVAL; + } + + strscpy(keys_header->keys[i].key_desc, key->description, + KEY_DESC_MAX_LEN); + r =3D read_key_from_user_keying(&keys_header->keys[i]); + if (r !=3D 0) { + kexec_dprintk("Failed to read key %s\n", + keys_header->keys[i].key_desc); + return r; + } + i++; + kexec_dprintk("Found key: %s\n", item->ci_name); + } + + return 0; +} + +int crash_load_dm_crypt_keys(struct kimage *image) +{ + struct kexec_buf kbuf =3D { + .image =3D image, + .buf_min =3D 0, + .buf_max =3D ULONG_MAX, + .top_down =3D false, + .random =3D true, + }; + int r; + + + if (key_count <=3D 0) { + kexec_dprintk("No dm-crypt keys\n"); + return -ENOENT; + } + + image->dm_crypt_keys_addr =3D 0; + r =3D build_keys_header(); + if (r) + return r; + + kbuf.buffer =3D keys_header; + kbuf.bufsz =3D get_keys_header_size(key_count); + + kbuf.memsz =3D kbuf.bufsz; + kbuf.buf_align =3D ELF_CORE_HEADER_ALIGN; + kbuf.mem =3D KEXEC_BUF_MEM_UNKNOWN; + r =3D kexec_add_buffer(&kbuf); + if (r) { + kvfree((void *)kbuf.buffer); + return r; + } + image->dm_crypt_keys_addr =3D kbuf.mem; + image->dm_crypt_keys_sz =3D kbuf.bufsz; + kexec_dprintk( + "Loaded dm crypt keys to kexec_buffer bufsz=3D0x%lx memsz=3D0x%lx\n", + kbuf.bufsz, kbuf.memsz); + + return r; +} + static int __init configfs_dmcrypt_keys_init(void) { int ret; --=20 2.49.0 From nobody Fri Nov 14 16:53:57 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A4CFC18BC2F for ; Fri, 2 May 2025 01:13:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148396; cv=none; b=CD6lbgh/neRA9KHB8/p6ZWD8qZzuH5f3vAWg4D4XqKUxql5gg1HwOtMO04QAqbnxZIuEEV3gc70lys61LNV80HiDcAi2BmZJmoI6n2mWsLEH88e3mWdDCl7Rwn2kocMLTeNQx3zJwAzP7omrmwM/JvC3uv+qTwljsVpyby4AEPk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148396; c=relaxed/simple; bh=+qVcrmIApyLmaXNuQTglnXxrm8JItDdXgdFkfg6wUnw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=q5RzMesdekuvcrE9ab+UoHrs851GRrGxXs+5lKNrxTDcZEcRksXQioIeYqcl/PdbxEneHaO/XtUgp5NUgiTrQLpnAybFJxiJsDFiu+EPoDShHqLnTXU0uJ9bVphUcjLzTX+b1eK2vVVOQG4x6KgKr03TzQ4P5zSG+Nh4McNQXvU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=WRigVIHQ; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="WRigVIHQ" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1746148393; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=FI+GXrx5MXDfidTwssNH3+yBW/jsE3sUkCXkCFCf894=; b=WRigVIHQYyeasMSzklXfXB8huWdULL9F1XQ7SQWxCcHx1SsW30cjxcA44hO8Wr6j5X7d3X cnwyQrHctfIkla827u/HN6zV/qRVZnwQSV6eUKTFGzcBL+4GAHU2OQXYFXMlanaCgqaYPQ A7llfGny0ugRtw/cM0KU3waBKWEITHc= Received: from mail-pg1-f200.google.com (mail-pg1-f200.google.com [209.85.215.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-248-uK_WRF4_NvedvDtsc6NFtA-1; Thu, 01 May 2025 21:13:12 -0400 X-MC-Unique: uK_WRF4_NvedvDtsc6NFtA-1 X-Mimecast-MFC-AGG-ID: uK_WRF4_NvedvDtsc6NFtA_1746148391 Received: by mail-pg1-f200.google.com with SMTP id 41be03b00d2f7-af59547f55bso909316a12.0 for ; Thu, 01 May 2025 18:13:12 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746148391; x=1746753191; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=FI+GXrx5MXDfidTwssNH3+yBW/jsE3sUkCXkCFCf894=; b=HZJahQLLykIxYudvrWldifcoUGQ5KmtWwoaIrlKcL5fGxUWvKeIzz8xELcgQAlJF5b nBesHCzRl94ZQjeaOC7T4RYoblaJlFr/kIiXoQnYiHYnuBLs1i/usQsVOnbtonILpMbw fdzaXRJ9F8oPChvulMnv32UpaPBAI7EvigIRzmI5vu79U29jHT4p0D/vGFP+um4mEX7n TC6x8YeVZhX6FUO7Y6lqCbwLjYfYtBlnlezBfmfZW0t8cPlDsOnfcoy2btyHOB//hMKH D3JUJfEAbVmaKxQRUXCvfD37vW/8CCvGIg57iVLxjvI3Wi0fPJGt8oJI0zUGVOrANAtQ Um9w== X-Forwarded-Encrypted: i=1; AJvYcCVXl2BVCGJK7crhtKESB7jumTv669dFw9+IcnAdAFZeY4iWOPvo82NKJKoxPRFAwl5Z9dbZJhscS5LgRzk=@vger.kernel.org X-Gm-Message-State: AOJu0YwOUkPqHE0HMlh7f3JvuPqGfUqCu+lxtpf3G18ivZtGysmZ7Te3 j7nHmlSG1+wxZ8nmgEAUOR5GXQiNVqOlv+V2jIpfePlpIGZGY8t0d7zJM0gEwP9uM/aDKhuViy8 oeWnsT0Iul2SZ7I/zdmCCFZxV2taTWqCGFjjpTd+YsaOky/BcgfzXMOVuvZRSig== X-Gm-Gg: ASbGncvWCOZpV/XNixfI2bd/Ts+HJITc45HJi7y/h4c5zfydggzMx2rspQXe81MinkK 5h0k7Rlt1vYqzKsHHK1Jhs71ieaCP3FSWaR9KV+c93EIz1gcXqtp0K/YhIiUapWBhakrr4N5EsZ 1ZY7KSCZVmUTXQUBIMjcmysQSKd29s/YDnfRcyPD/vG6+WxKu7yNJ6HD093G/rSpBZ1A7oTFxwE HNI8kNbzmsZczFasufc7i8Zu0IuYoBWSHTHhfrDs+HvnFmBAKa7SxxVYy4nzM85qZgqRUfWcBCa q20= X-Received: by 2002:a05:6a20:d485:b0:1f5:72eb:8b3f with SMTP id adf61e73a8af0-20cdef3dd0bmr1473399637.24.1746148391424; Thu, 01 May 2025 18:13:11 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFedydzy7eFeNpzLzqKKw1fQGI2Jm/XlzKlKPwhgkEdBGZDZTrtlVKsxZROLBUauHe6nb4G+w== X-Received: by 2002:a05:6a20:d485:b0:1f5:72eb:8b3f with SMTP id adf61e73a8af0-20cdef3dd0bmr1473355637.24.1746148391066; Thu, 01 May 2025 18:13:11 -0700 (PDT) Received: from localhost ([209.132.188.88]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b1fa82b68c1sm222557a12.37.2025.05.01.18.13.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 May 2025 18:13:10 -0700 (PDT) From: Coiby Xu To: kexec@lists.infradead.org Cc: Ondrej Kozina , Milan Broz , Thomas Staudt , =?UTF-8?q?Daniel=20P=20=2E=20Berrang=C3=A9?= , Kairui Song , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Arnaud Lefebvre , Andrew Morton , Vivek Goyal , Jonathan Corbet , linux-doc@vger.kernel.org (open list:DOCUMENTATION) Subject: [PATCH v9 4/8] crash_dump: reuse saved dm crypt keys for CPU/memory hot-plugging Date: Fri, 2 May 2025 09:12:38 +0800 Message-ID: <20250502011246.99238-5-coxu@redhat.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250502011246.99238-1-coxu@redhat.com> References: <20250502011246.99238-1-coxu@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" When there are CPU and memory hot un/plugs, the dm crypt keys may need to be reloaded again depending on the solution for crash hotplug support. Currently, there are two solutions. One is to utilizes udev to instruct user space to reload the kdump kernel image and initrd, elfcorehdr and etc again. The other is to only update the elfcorehdr segment introduced in commit 247262756121 ("crash: add generic infrastructure for crash hotplug support"). For the 1st solution, the dm crypt keys need to be reloaded again. The user space can write true to /sys/kernel/config/crash_dm_crypt_key/reuse so the stored keys can be re-used. For the 2nd solution, the dm crypt keys don't need to be reloaded. Currently, only x86 supports the 2nd solution. If the 2nd solution gets extended to all arches, this patch can be dropped. Signed-off-by: Coiby Xu Acked-by: Baoquan He --- Documentation/admin-guide/kdump/kdump.rst | 4 ++ kernel/crash_dump_dm_crypt.c | 52 +++++++++++++++++++++-- 2 files changed, 52 insertions(+), 4 deletions(-) diff --git a/Documentation/admin-guide/kdump/kdump.rst b/Documentation/admi= n-guide/kdump/kdump.rst index b74d3bed8fff..e25edaa8e533 100644 --- a/Documentation/admin-guide/kdump/kdump.rst +++ b/Documentation/admin-guide/kdump/kdump.rst @@ -570,6 +570,10 @@ encrypted disk volume. User space can interact with cat /sys/kernel/config/crash_dm_crypt_keys/count 2 =20 + # To support CPU/memory hot-plugging, re-use keys already saved to res= erved + # memory + echo true > /sys/kernel/config/crash_dm_crypt_key/reuse + 2. Load the dump-capture kernel =20 3. After the dump-capture kerne get booted, restore the keys to user keyri= ng diff --git a/kernel/crash_dump_dm_crypt.c b/kernel/crash_dump_dm_crypt.c index fb25f55f1512..5f4a62389150 100644 --- a/kernel/crash_dump_dm_crypt.c +++ b/kernel/crash_dump_dm_crypt.c @@ -28,6 +28,20 @@ static size_t get_keys_header_size(size_t total_keys) return struct_size(keys_header, keys, total_keys); } =20 +static void get_keys_from_kdump_reserved_memory(void) +{ + struct keys_header *keys_header_loaded; + + arch_kexec_unprotect_crashkres(); + + keys_header_loaded =3D kmap_local_page(pfn_to_page( + kexec_crash_image->dm_crypt_keys_addr >> PAGE_SHIFT)); + + memcpy(keys_header, keys_header_loaded, get_keys_header_size(key_count)); + kunmap_local(keys_header_loaded); + arch_kexec_protect_crashkres(); +} + static int read_key_from_user_keying(struct dm_crypt_key *dm_key) { const struct user_key_payload *ukp; @@ -150,8 +164,36 @@ static ssize_t config_keys_count_show(struct config_it= em *item, char *page) =20 CONFIGFS_ATTR_RO(config_keys_, count); =20 +static bool is_dm_key_reused; + +static ssize_t config_keys_reuse_show(struct config_item *item, char *page) +{ + return sprintf(page, "%d\n", is_dm_key_reused); +} + +static ssize_t config_keys_reuse_store(struct config_item *item, + const char *page, size_t count) +{ + if (!kexec_crash_image || !kexec_crash_image->dm_crypt_keys_addr) { + kexec_dprintk( + "dm-crypt keys haven't be saved to crash-reserved memory\n"); + return -EINVAL; + } + + if (kstrtobool(page, &is_dm_key_reused)) + return -EINVAL; + + if (is_dm_key_reused) + get_keys_from_kdump_reserved_memory(); + + return count; +} + +CONFIGFS_ATTR(config_keys_, reuse); + static struct configfs_attribute *config_keys_attrs[] =3D { &config_keys_attr_count, + &config_keys_attr_reuse, NULL, }; =20 @@ -238,10 +280,12 @@ int crash_load_dm_crypt_keys(struct kimage *image) return -ENOENT; } =20 - image->dm_crypt_keys_addr =3D 0; - r =3D build_keys_header(); - if (r) - return r; + if (!is_dm_key_reused) { + image->dm_crypt_keys_addr =3D 0; + r =3D build_keys_header(); + if (r) + return r; + } =20 kbuf.buffer =3D keys_header; kbuf.bufsz =3D get_keys_header_size(key_count); --=20 2.49.0 From nobody Fri Nov 14 16:53:57 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5F7CA19DF41 for ; Fri, 2 May 2025 01:13:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148401; cv=none; b=fUFLnAYgl4fUNYJs4UpK1eW5LS4+U1Rlj6G13ICnARILQfUHYdeZ5FBUHh1QVBgD50Qh/MkguFKyJxcC7FeFxsd+TAh4TEA+jqUR/YbUReryUm2t4XeuLrwbvaN7EqfhN7I4pjFfbU662wBBErjBOt/QAOgStAyJxh3ZRt9Jlbg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148401; c=relaxed/simple; bh=dOZvp6u+kyYhS9ZUG/GSP3M5qxYsSBxf5L2SkRc5vR8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=UsV+drR7HhWg4d9ry0JemsU2bp0a5M42Dec/sFPy4+CBz6SbPqwt8Ovm+2XyzYSH/JfyHEPioSAw8DbHxxeWoWOHoZPF0TNDjpeZRlKz195Hai2IWdz80kn2boGACe6C1nzzcaA0BnrGuD76pmfx7/j9tOf4zOpFz6XRZ6uuYjc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=T1JIioQn; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="T1JIioQn" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1746148398; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=1MajVo0eN+bOY/uhsAvuKiRsP8lMRdWSlIoFJzdsFWA=; b=T1JIioQnk2M+7ps3ZHN16j9K4LzG4jzUdXIXOz2BOOAOgwPCLxiueP15pIXFI3o7pKNfTU 4+/cGIpTxT00qWjNxYVBlFrBOf3hcpqrusIBSk9QBs132ZsDHy6sQLaulyDoDIe6r584Df 350zBxS1jsReU+pTwR6xjYjr/DKOUZE= Received: from mail-pf1-f198.google.com (mail-pf1-f198.google.com [209.85.210.198]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-68-DKVi9EH7NpOVYtjnEocxRg-1; Thu, 01 May 2025 21:13:17 -0400 X-MC-Unique: DKVi9EH7NpOVYtjnEocxRg-1 X-Mimecast-MFC-AGG-ID: DKVi9EH7NpOVYtjnEocxRg_1746148396 Received: by mail-pf1-f198.google.com with SMTP id d2e1a72fcca58-7369c5ed395so1827240b3a.0 for ; Thu, 01 May 2025 18:13:17 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746148395; x=1746753195; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=1MajVo0eN+bOY/uhsAvuKiRsP8lMRdWSlIoFJzdsFWA=; b=IUuZ6XRSA/ZmkBNRscL2egdAcF614YHOIkdCKBlqpNI71tMsibGwuUc2IO4y14P1UR Kdf+cJdXJLrZ/f5j4QVVgO3VRTqmunpG4IiwvZOJJVuOuOnpPQI1xdwgw0N6OJwQhGO1 kdWsiiKKCwKSXYk4H+W0NlwY7RwnuHiRuEKTqXS5s4KuGn5kOSvdlD5VELvG1gJ4HwFF XINwL6WTCWEOYb0NOLgHEQIVaQDaO7MHHA0QSmOH6tWQIINCSK7qCFGQR0/x72G9xUpG JXJNXJL6EyPKHELy8bm2RI0BqC+GlIAnHhKSboxK3qcmDhO9mYkJKPFJP27Gmyxtn1zz +hxg== X-Forwarded-Encrypted: i=1; AJvYcCVnJ40Ns+TgqJrBXnw+HWIv5hhFpvkwI5ZCl32WViCfXDB2HHoKwZdnPweqAJ0hrrhdgjaKJmCmaaENMRY=@vger.kernel.org X-Gm-Message-State: AOJu0Yykml2FJWZ/Am2wZhEOqv/MCZrEaqUxYSpWZNbL4DEtCRsEKc/u DMn5R2mpcNdnG2rwjayCQGwGexe61BGvJmRv9RFhsL84dOuCeUq4DM76wD0InUkMf6X9TKM8rLO QcWtiVTeQ9vr6tHOPybVbjUB40Z49k3LxCumjNXhwCtf5ZFhnFP/8nHhEEBJh/Q== X-Gm-Gg: ASbGnctXQdE1mMb9csOS64U7/0LKFf8N32LAOmdVnFP74+QGdPgGBfCbV3YeauQV8CA 3KaqVnJl38jWTGwtXAq6GPo9POn3OIextU5IQ7oRmIYeIWiYzfqf5JHhP3VxpsJ9LuAP/c45+T8 gRoA2wYYYWzGF7ng4lsAXfUFGTOHozVqbkTuvbEeRDeEsOwObCC2o6VBVlRV5ORk6mduQCvJDQ0 uykCux8YB2wcISjABLVao7RRWT9NXsJVzWbmAh8y5EkAtzzfpZDzHLkKeXqeNGFCB3UQZg7kpDd CTU= X-Received: by 2002:a05:6a21:9996:b0:1f5:5614:18d3 with SMTP id adf61e73a8af0-20cde374c45mr1332899637.8.1746148395570; Thu, 01 May 2025 18:13:15 -0700 (PDT) X-Google-Smtp-Source: AGHT+IE4p97v8it9sU5P5Sp05N+A9sBa8f61f+FHOAD5ZIDeBPK7a45C8c4sAtjySQ38fIl40uqCOQ== X-Received: by 2002:a05:6a21:9996:b0:1f5:5614:18d3 with SMTP id adf61e73a8af0-20cde374c45mr1332865637.8.1746148395168; Thu, 01 May 2025 18:13:15 -0700 (PDT) Received: from localhost ([209.132.188.88]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b1fa8609193sm298494a12.72.2025.05.01.18.13.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 May 2025 18:13:14 -0700 (PDT) From: Coiby Xu To: kexec@lists.infradead.org Cc: Ondrej Kozina , Milan Broz , Thomas Staudt , =?UTF-8?q?Daniel=20P=20=2E=20Berrang=C3=A9?= , Kairui Song , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Arnaud Lefebvre , Andrew Morton , Vivek Goyal Subject: [PATCH v9 5/8] crash_dump: retrieve dm crypt keys in kdump kernel Date: Fri, 2 May 2025 09:12:39 +0800 Message-ID: <20250502011246.99238-6-coxu@redhat.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250502011246.99238-1-coxu@redhat.com> References: <20250502011246.99238-1-coxu@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Crash kernel will retrieve the dm crypt keys based on the dmcryptkeys command line parameter. When user space writes the key description to /sys/kernel/config/crash_dm_crypt_key/restore, the crash kernel will save the encryption keys to the user keyring. Then user space e.g. cryptsetup's --volume-key-keyring API can use it to unlock the encrypted device. Signed-off-by: Coiby Xu Acked-by: Baoquan He --- include/linux/crash_core.h | 1 + include/linux/crash_dump.h | 2 + kernel/crash_dump_dm_crypt.c | 133 +++++++++++++++++++++++++++++++++++ 3 files changed, 136 insertions(+) diff --git a/include/linux/crash_core.h b/include/linux/crash_core.h index 2e6782239034..d35726d6a415 100644 --- a/include/linux/crash_core.h +++ b/include/linux/crash_core.h @@ -36,6 +36,7 @@ static inline void arch_kexec_unprotect_crashkres(void) {= } =20 #ifdef CONFIG_CRASH_DM_CRYPT int crash_load_dm_crypt_keys(struct kimage *image); +ssize_t dm_crypt_keys_read(char *buf, size_t count, u64 *ppos); #else static inline int crash_load_dm_crypt_keys(struct kimage *image) {return 0= ; } #endif diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h index 2f2555e6407c..dd6fc3b2133b 100644 --- a/include/linux/crash_dump.h +++ b/include/linux/crash_dump.h @@ -15,6 +15,8 @@ extern unsigned long long elfcorehdr_addr; extern unsigned long long elfcorehdr_size; =20 +extern unsigned long long dm_crypt_keys_addr; + #ifdef CONFIG_CRASH_DUMP extern int elfcorehdr_alloc(unsigned long long *addr, unsigned long long *= size); extern void elfcorehdr_free(unsigned long long addr); diff --git a/kernel/crash_dump_dm_crypt.c b/kernel/crash_dump_dm_crypt.c index 5f4a62389150..401423ba477d 100644 --- a/kernel/crash_dump_dm_crypt.c +++ b/kernel/crash_dump_dm_crypt.c @@ -3,6 +3,7 @@ #include #include #include +#include #include #include =20 @@ -28,6 +29,61 @@ static size_t get_keys_header_size(size_t total_keys) return struct_size(keys_header, keys, total_keys); } =20 +unsigned long long dm_crypt_keys_addr; +EXPORT_SYMBOL_GPL(dm_crypt_keys_addr); + +static int __init setup_dmcryptkeys(char *arg) +{ + char *end; + + if (!arg) + return -EINVAL; + dm_crypt_keys_addr =3D memparse(arg, &end); + if (end > arg) + return 0; + + dm_crypt_keys_addr =3D 0; + return -EINVAL; +} + +early_param("dmcryptkeys", setup_dmcryptkeys); + +/* + * Architectures may override this function to read dm crypt keys + */ +ssize_t __weak dm_crypt_keys_read(char *buf, size_t count, u64 *ppos) +{ + struct kvec kvec =3D { .iov_base =3D buf, .iov_len =3D count }; + struct iov_iter iter; + + iov_iter_kvec(&iter, READ, &kvec, 1, count); + return read_from_oldmem(&iter, count, ppos, cc_platform_has(CC_ATTR_MEM_E= NCRYPT)); +} + +static int add_key_to_keyring(struct dm_crypt_key *dm_key, + key_ref_t keyring_ref) +{ + key_ref_t key_ref; + int r; + + /* create or update the requested key and add it to the target keyring */ + key_ref =3D key_create_or_update(keyring_ref, "user", dm_key->key_desc, + dm_key->data, dm_key->key_size, + KEY_USR_ALL, KEY_ALLOC_IN_QUOTA); + + if (!IS_ERR(key_ref)) { + r =3D key_ref_to_ptr(key_ref)->serial; + key_ref_put(key_ref); + kexec_dprintk("Success adding key %s", dm_key->key_desc); + } else { + r =3D PTR_ERR(key_ref); + kexec_dprintk("Error when adding key"); + } + + key_ref_put(keyring_ref); + return r; +} + static void get_keys_from_kdump_reserved_memory(void) { struct keys_header *keys_header_loaded; @@ -42,6 +98,47 @@ static void get_keys_from_kdump_reserved_memory(void) arch_kexec_protect_crashkres(); } =20 +static int restore_dm_crypt_keys_to_thread_keyring(void) +{ + struct dm_crypt_key *key; + size_t keys_header_size; + key_ref_t keyring_ref; + u64 addr; + + /* find the target keyring (which must be writable) */ + keyring_ref =3D + lookup_user_key(KEY_SPEC_USER_KEYRING, 0x01, KEY_NEED_WRITE); + if (IS_ERR(keyring_ref)) { + kexec_dprintk("Failed to get the user keyring\n"); + return PTR_ERR(keyring_ref); + } + + addr =3D dm_crypt_keys_addr; + dm_crypt_keys_read((char *)&key_count, sizeof(key_count), &addr); + if (key_count < 0 || key_count > KEY_NUM_MAX) { + kexec_dprintk("Failed to read the number of dm-crypt keys\n"); + return -1; + } + + kexec_dprintk("There are %u keys\n", key_count); + addr =3D dm_crypt_keys_addr; + + keys_header_size =3D get_keys_header_size(key_count); + keys_header =3D kzalloc(keys_header_size, GFP_KERNEL); + if (!keys_header) + return -ENOMEM; + + dm_crypt_keys_read((char *)keys_header, keys_header_size, &addr); + + for (int i =3D 0; i < keys_header->total_keys; i++) { + key =3D &keys_header->keys[i]; + kexec_dprintk("Get key (size=3D%u)\n", key->key_size); + add_key_to_keyring(key, keyring_ref); + } + + return 0; +} + static int read_key_from_user_keying(struct dm_crypt_key *dm_key) { const struct user_key_payload *ukp; @@ -211,6 +308,37 @@ static const struct config_item_type config_keys_type = =3D { .ct_owner =3D THIS_MODULE, }; =20 +static bool restore; + +static ssize_t config_keys_restore_show(struct config_item *item, char *pa= ge) +{ + return sprintf(page, "%d\n", restore); +} + +static ssize_t config_keys_restore_store(struct config_item *item, + const char *page, size_t count) +{ + if (!restore) + restore_dm_crypt_keys_to_thread_keyring(); + + if (kstrtobool(page, &restore)) + return -EINVAL; + + return count; +} + +CONFIGFS_ATTR(config_keys_, restore); + +static struct configfs_attribute *kdump_config_keys_attrs[] =3D { + &config_keys_attr_restore, + NULL, +}; + +static const struct config_item_type kdump_config_keys_type =3D { + .ct_attrs =3D kdump_config_keys_attrs, + .ct_owner =3D THIS_MODULE, +}; + static struct configfs_subsystem config_keys_subsys =3D { .su_group =3D { .cg_item =3D { @@ -311,6 +439,11 @@ static int __init configfs_dmcrypt_keys_init(void) { int ret; =20 + if (is_kdump_kernel()) { + config_keys_subsys.su_group.cg_item.ci_type =3D + &kdump_config_keys_type; + } + config_group_init(&config_keys_subsys.su_group); mutex_init(&config_keys_subsys.su_mutex); ret =3D configfs_register_subsystem(&config_keys_subsys); --=20 2.49.0 From nobody Fri Nov 14 16:53:57 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A38D51474DA for ; Fri, 2 May 2025 01:13:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148404; cv=none; b=r0MGfCBhS/aprxGYf8eiMAhiR917vNba3864cdF4XZ5BR4jfit8hqZbb6SmvEQYnOZPX8ukBOEbvsYv1exJsK7EAJX7hVkByJNRlh69kQnxlwgE/3MClb6+y6KHgOyzmX+tG0paP0DGGfGkPHTPEQ9KRUPkNAr31Ey+keiz8qnE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148404; c=relaxed/simple; bh=Jqq98g57QRABGkpXrp1TbFP8bp6n/2CUamgLHY/0u64=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=rqS0hmRGMRwq/U8AiDXPgV5JLhEWQRENB60pJCVSOGNdM5OKRfhiYl/nOuNF0EOoxiulLfYqP+wPgdbCNS7kt/PsfJQDMlaD4L90UYYCjyByaOptXbbEqeFR4M952WyYxKddmWKgc28vHfkjlRP7HWE/ng50tmcottgF+USauFc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=F/hHc4Pc; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="F/hHc4Pc" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1746148401; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=3Pn26aT5bRv7h7/lzXPUF6z8FjJ6lnc7HN2JWKay0EY=; b=F/hHc4Pc02Gqw9efptQHg3/FbaIp6ryRK9ThHZulSy/mSghZJIh80nK7R6sRm29IXly7Wg 8KRmEahvpSBdS99+2NefRvmZrkGKdLzZGN3RiNjwZGtkIa7PJI20VTDguQ6t5WY3GAqVPn lxXbT6xDlg2d3VHHfXCgkjiFWto834c= Received: from mail-pg1-f199.google.com (mail-pg1-f199.google.com [209.85.215.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-286-Rs-9airLMSyn31EFa5uSdA-1; Thu, 01 May 2025 21:13:20 -0400 X-MC-Unique: Rs-9airLMSyn31EFa5uSdA-1 X-Mimecast-MFC-AGG-ID: Rs-9airLMSyn31EFa5uSdA_1746148399 Received: by mail-pg1-f199.google.com with SMTP id 41be03b00d2f7-b0f807421c9so946551a12.0 for ; Thu, 01 May 2025 18:13:20 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746148399; x=1746753199; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=3Pn26aT5bRv7h7/lzXPUF6z8FjJ6lnc7HN2JWKay0EY=; b=iF6OPYw6FVkthPEm7TATf5aSMMp4dx7HMbL64Goptx8zp9IzACYoDJTxn3cOvUnwDM eBEZAL9iTRhsstiVb8hLk9lgm04F9h0VX8uN1aQhOxffbnRcpfH42ZqGaj6KasapZvr8 Z9AdR5Ur/qkRfDyttF5WvRCi6NDphEVoxJGJWvOgLcFHBDs1xdT0tJzRKBfi+UMTQWxr PjeCxx/IakV+qOWzSfH65y/KirHGGnssL2q3c+fwRDPfbxFO+EUEykknER/Adu722JyN be1umnZeQOLNU/1j0+Od48RQHmHuS5fz8ZrNqhGzUuGCyzJMrNcUKbIbqNmQ9t+TeL4n tgWA== X-Forwarded-Encrypted: i=1; AJvYcCXS4v7CSKQdZN+EchFmQ+mXIckOPoqSe4PA8EBAF6F/BXijv1y1E+gJSx2+Ok6NQTyWsYeWCc30y3dGZxg=@vger.kernel.org X-Gm-Message-State: AOJu0Yx7RfGfjdFyvRxsPc+Ha5K2tm7wrQZrbkNT16eavtUSvS3S4JpR 18ryiaDFwNXabN52gZL73qadkmdc4yr27lF61s3XQu+hguu7ZHeqD7iWoEnju3YvdEMb7wgmDUP cKz6lnBx2bBLMadB8sI9853rODAHPH6heIGwHUnRhswo3GPyh/gYlu+ANZLNsPw== X-Gm-Gg: ASbGnctB1YcXrv1gX78jwIkLg6uCCxjaLTp1pr8e4Y2a6Nz5oRxUxOc7TgiyHSnjwZO gMZtOVyJyBRFAV49+q0qysbFk+DTY1NIb1HqQ3S9731rNk8dkqJHBH1Sv5QnuuPfqVaMvsdbMLb SksomoWBgynsHgojz03CDy4huxC0Etvb/oAKtsHD9gjfep7ulHOfVvsImOvkNq4fYi3UBedTQVc 1JOinkyOLTABKR/9gMyewaqKWpALkpiJ99zBYDlFzS4X+6uHX3A1GMVJx1K9L4sHe6YCMXmQxj3 n5U= X-Received: by 2002:a05:6a20:9f90:b0:1f5:7c6f:6c8a with SMTP id adf61e73a8af0-20ce03eda59mr1482243637.35.1746148399417; Thu, 01 May 2025 18:13:19 -0700 (PDT) X-Google-Smtp-Source: AGHT+IG5/p3+2eDOQ1WtTewaJNj1PvUOiUHyS/8lpdnWABtDfZb0/NmxZiqOwhxRTW3nf4iHj2YNpQ== X-Received: by 2002:a05:6a20:9f90:b0:1f5:7c6f:6c8a with SMTP id adf61e73a8af0-20ce03eda59mr1482208637.35.1746148399137; Thu, 01 May 2025 18:13:19 -0700 (PDT) Received: from localhost ([209.132.188.88]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b1fa82422ebsm309280a12.10.2025.05.01.18.13.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 May 2025 18:13:18 -0700 (PDT) From: Coiby Xu To: kexec@lists.infradead.org Cc: Ondrej Kozina , Milan Broz , Thomas Staudt , =?UTF-8?q?Daniel=20P=20=2E=20Berrang=C3=A9?= , Kairui Song , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Arnaud Lefebvre , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Dave Hansen , "H. Peter Anvin" , Andy Lutomirski , Peter Zijlstra Subject: [PATCH v9 6/8] Revert "x86/mm: Remove unused __set_memory_prot()" Date: Fri, 2 May 2025 09:12:40 +0800 Message-ID: <20250502011246.99238-7-coxu@redhat.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250502011246.99238-1-coxu@redhat.com> References: <20250502011246.99238-1-coxu@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This reverts commit 693bbf2a50447353c6a47961e6a7240a823ace02 as kdump LUKS support (CONFIG_CRASH_DM_CRYPT) depends on __set_memory_prot. Signed-off-by: Coiby Xu --- arch/x86/include/asm/set_memory.h | 1 + arch/x86/mm/pat/set_memory.c | 13 +++++++++++++ 2 files changed, 14 insertions(+) diff --git a/arch/x86/include/asm/set_memory.h b/arch/x86/include/asm/set_m= emory.h index 8d9f1c9aaa4c..023994fe6115 100644 --- a/arch/x86/include/asm/set_memory.h +++ b/arch/x86/include/asm/set_memory.h @@ -37,6 +37,7 @@ int set_memory_rox(unsigned long addr, int numpages); * The caller is required to take care of these. */ =20 +int __set_memory_prot(unsigned long addr, int numpages, pgprot_t prot); int _set_memory_uc(unsigned long addr, int numpages); int _set_memory_wc(unsigned long addr, int numpages); int _set_memory_wt(unsigned long addr, int numpages); diff --git a/arch/x86/mm/pat/set_memory.c b/arch/x86/mm/pat/set_memory.c index def3d9284254..df7502ad165c 100644 --- a/arch/x86/mm/pat/set_memory.c +++ b/arch/x86/mm/pat/set_memory.c @@ -2148,6 +2148,19 @@ static inline int cpa_clear_pages_array(struct page = **pages, int numpages, CPA_PAGES_ARRAY, pages); } =20 +/* + * __set_memory_prot is an internal helper for callers that have been pass= ed + * a pgprot_t value from upper layers and a reservation has already been t= aken. + * If you want to set the pgprot to a specific page protocol, use the + * set_memory_xx() functions. + */ +int __set_memory_prot(unsigned long addr, int numpages, pgprot_t prot) +{ + return change_page_attr_set_clr(&addr, numpages, prot, + __pgprot(~pgprot_val(prot)), 0, 0, + NULL); +} + int _set_memory_uc(unsigned long addr, int numpages) { /* --=20 2.49.0 From nobody Fri Nov 14 16:53:57 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F21291A257D for ; Fri, 2 May 2025 01:13:26 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148408; cv=none; b=Ruwi/GNU77L9eVK37xg4yQSgVqZAgQJRspS3/Har0SoTVygv9qbbrDBFBE8KwZUJxDCVswvjGe7pSslzB0340qhRqkFWFnsLfkqV2HcvUSqsZ2bYuMZZpfX2aOP1vC4bv4MgCxhNkmDjQ0GX5y6dJxr2o0HPj8CcAXx0iqbBlts= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148408; c=relaxed/simple; bh=358HTmulVlruFMpacpjHwFNBa3gAqASZ7gNoN8s6OoA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=QPLuyVKmu4w28DU0AcUnZ9ybnbNDl5vJwkKk4aMy/C/kt4aQZiFHV4noGp02jWjL3wf/SGq8R1D49ghY0csb7cjWYPm3QSd4TE7dL9spcicSVerefgfvZUQWg3KktFPZGpHEGcfeqdfXQyQR865gweboqQCcI4/sIOCOYsyrBks= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=h22l++I0; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="h22l++I0" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1746148405; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=/EXCS7YZfoYbLHPYyFkucRV4RaFlxZolah51T9bD/WA=; b=h22l++I0BOKVDgfZZ9iqNyLdq/reU7sMwsRjjtBiKkvaLJ1uBBAANce94p6J2g+Ty2UcK9 aBaza88vEBqxe4lE5oCKfPaJ8LUhFT/yUt3HUmigmnrs5CDgx/s4PbVGqCWTemwPt8QsJe d4UQRGxhSVoJSZ+IylLA52WoXypBrGU= Received: from mail-pf1-f200.google.com (mail-pf1-f200.google.com [209.85.210.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-82-KjGPY1OgOyq93GbgGBMAVg-1; Thu, 01 May 2025 21:13:25 -0400 X-MC-Unique: KjGPY1OgOyq93GbgGBMAVg-1 X-Mimecast-MFC-AGG-ID: KjGPY1OgOyq93GbgGBMAVg_1746148404 Received: by mail-pf1-f200.google.com with SMTP id d2e1a72fcca58-73c205898aaso1134656b3a.2 for ; Thu, 01 May 2025 18:13:24 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746148404; x=1746753204; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=/EXCS7YZfoYbLHPYyFkucRV4RaFlxZolah51T9bD/WA=; b=uMcxj/D8pI4w3Bu5Qr33PPUUN9H45pgqLWwFdhBoiEoXsj0Fw7fc5uYpMUzC4ct7+B YFhLCz+csq+GADRcbauqmTRTJ87CY9nA2WHE5dl4bKRTufX8E94ZqUGD/vX9AYTPw2TF hXIuZKDJyDi6CAK3GMY/0saI58eTBHJDkSZ8bTzZfhF639VbDbXaYaW7MZLDXpzrplSL klAvQVY8d5F0DnNSPIRvZbYzRaJZwRPVsU4zIAUA9+r3u1qdbErbZet0zzhC1pT6tzAk v1/8hQXajdOsnBB+yzZgMiRKQo0jTKA7lA9Rh+5BTGS/+kh4rY8ACR90ky/hw5mHcdfW XQYg== X-Forwarded-Encrypted: i=1; AJvYcCVmu9zJ4YM3RUNfKBJACcIfriACU31ViRd5glS+M4oVHVC/UM1vfdAfYSw1C77zDGUDYXJZzuPAfrrFg/c=@vger.kernel.org X-Gm-Message-State: AOJu0YzdaLybRhobwVil+dNDnFK6SQhwj3/ggmDgpJhJvXMyiG9/5ZAA K8XHxaIr/o5BqyScPKmgWBFn/c2KUXHP4d3emzFF1K1dhzrMsP1eVXIS1mtylrGldOLbzqgcEGt VDQNivvDTMbBIVWuud94Vw+rn18QZZREOJVSfqa4BhxdG+1FUwQSqi74Ye1I2+w== X-Gm-Gg: ASbGncuppbWJN+3vCh/91mEfpOHATdVrZxhV2ROtIibJYhYNWcZ7qb+rY2K2BlHOO/h 4vJr2s8j8E7K4zAni0nxbpColRBa+VHvl43uXyPvUMaX75w1kbcp/x1NKspemw5rmQtqCyVySP3 uleyE6HRGlZdciUx3p40OJcUJedf3l8l9hpg00p/KrRd/mrHqFxFO2gjRZ8sJ2YOk0pQVe1EaVt P8Pb0UNUzNGPaz5Zn7LVu7F97lGBZ7yw0M1WV1OrYQyvhAvDY4CrsyTA0tD617nHnSMaQ981qjT +kI= X-Received: by 2002:a05:6a21:78c:b0:1f5:6b36:f574 with SMTP id adf61e73a8af0-20ce02e7da0mr1498446637.38.1746148403591; Thu, 01 May 2025 18:13:23 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFU0R9cOfxCknV2YN3iEnSYLPTc4nx8JnX2KM70AD+jCoO7YKr4yHDcrBlPC1IzEWkqBT/rQg== X-Received: by 2002:a05:6a21:78c:b0:1f5:6b36:f574 with SMTP id adf61e73a8af0-20ce02e7da0mr1498402637.38.1746148403254; Thu, 01 May 2025 18:13:23 -0700 (PDT) Received: from localhost ([209.132.188.88]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-74058d7a3b1sm357910b3a.15.2025.05.01.18.13.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 May 2025 18:13:23 -0700 (PDT) From: Coiby Xu To: kexec@lists.infradead.org Cc: Ondrej Kozina , Milan Broz , Thomas Staudt , =?UTF-8?q?Daniel=20P=20=2E=20Berrang=C3=A9?= , Kairui Song , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Arnaud Lefebvre , Andrew Morton , Vivek Goyal , Jonathan Corbet , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Dave Hansen , "H. Peter Anvin" , linux-doc@vger.kernel.org (open list:DOCUMENTATION) Subject: [PATCH v9 7/8] x86/crash: pass dm crypt keys to kdump kernel Date: Fri, 2 May 2025 09:12:41 +0800 Message-ID: <20250502011246.99238-8-coxu@redhat.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250502011246.99238-1-coxu@redhat.com> References: <20250502011246.99238-1-coxu@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" 1st kernel will build up the kernel command parameter dmcryptkeys as similar to elfcorehdr to pass the memory address of the stored info of dm crypt key to kdump kernel. Signed-off-by: Coiby Xu Acked-by: Baoquan He --- Documentation/admin-guide/kdump/kdump.rst | 4 ++-- arch/x86/kernel/crash.c | 26 +++++++++++++++++++++-- arch/x86/kernel/kexec-bzimage64.c | 21 ++++++++++++++++++ 3 files changed, 47 insertions(+), 4 deletions(-) diff --git a/Documentation/admin-guide/kdump/kdump.rst b/Documentation/admi= n-guide/kdump/kdump.rst index e25edaa8e533..20fabdf6567e 100644 --- a/Documentation/admin-guide/kdump/kdump.rst +++ b/Documentation/admin-guide/kdump/kdump.rst @@ -551,8 +551,8 @@ Write the dump file to encrypted disk volume =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D =20 CONFIG_CRASH_DM_CRYPT can be enabled to support saving the dump file to an -encrypted disk volume. User space can interact with -/sys/kernel/config/crash_dm_crypt_keys for setup, +encrypted disk volume (only x86_64 supported for now). User space can inte= ract +with /sys/kernel/config/crash_dm_crypt_keys for setup, =20 1. Tell the first kernel what logon keys are needed to unlock the disk vol= umes, # Add key #1 diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c index 0be61c45400c..bcb534688dfe 100644 --- a/arch/x86/kernel/crash.c +++ b/arch/x86/kernel/crash.c @@ -278,6 +278,7 @@ static int memmap_exclude_ranges(struct kimage *image, = struct crash_mem *cmem, unsigned long long mend) { unsigned long start, end; + int ret; =20 cmem->ranges[0].start =3D mstart; cmem->ranges[0].end =3D mend; @@ -286,22 +287,43 @@ static int memmap_exclude_ranges(struct kimage *image= , struct crash_mem *cmem, /* Exclude elf header region */ start =3D image->elf_load_addr; end =3D start + image->elf_headers_sz - 1; - return crash_exclude_mem_range(cmem, start, end); + ret =3D crash_exclude_mem_range(cmem, start, end); + + if (ret) + return ret; + + /* Exclude dm crypt keys region */ + if (image->dm_crypt_keys_addr) { + start =3D image->dm_crypt_keys_addr; + end =3D start + image->dm_crypt_keys_sz - 1; + return crash_exclude_mem_range(cmem, start, end); + } + + return ret; } =20 /* Prepare memory map for crash dump kernel */ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *p= arams) { + unsigned int nr_ranges =3D 0; int i, ret =3D 0; unsigned long flags; struct e820_entry ei; struct crash_memmap_data cmd; struct crash_mem *cmem; =20 - cmem =3D vzalloc(struct_size(cmem, ranges, 1)); + /* + * Using random kexec_buf for passing dm crypt keys may cause a range + * split. So use two slots here. + */ + nr_ranges =3D 2; + cmem =3D vzalloc(struct_size(cmem, ranges, nr_ranges)); if (!cmem) return -ENOMEM; =20 + cmem->max_nr_ranges =3D nr_ranges; + cmem->nr_ranges =3D 0; + memset(&cmd, 0, sizeof(struct crash_memmap_data)); cmd.params =3D params; =20 diff --git a/arch/x86/kernel/kexec-bzimage64.c b/arch/x86/kernel/kexec-bzim= age64.c index 68530fad05f7..c71cdd8e425a 100644 --- a/arch/x86/kernel/kexec-bzimage64.c +++ b/arch/x86/kernel/kexec-bzimage64.c @@ -27,6 +27,8 @@ #include =20 #define MAX_ELFCOREHDR_STR_LEN 30 /* elfcorehdr=3D0x<64bit-value> */ +#define MAX_DMCRYPTKEYS_STR_LEN 31 /* dmcryptkeys=3D0x<64bit-value> */ + =20 /* * Defines lowest physical address for various segments. Not sure where @@ -76,6 +78,10 @@ static int setup_cmdline(struct kimage *image, struct bo= ot_params *params, if (image->type =3D=3D KEXEC_TYPE_CRASH) { len =3D sprintf(cmdline_ptr, "elfcorehdr=3D0x%lx ", image->elf_load_addr); + + if (image->dm_crypt_keys_addr !=3D 0) + len +=3D sprintf(cmdline_ptr + len, + "dmcryptkeys=3D0x%lx ", image->dm_crypt_keys_addr); } memcpy(cmdline_ptr + len, cmdline, cmdline_len); cmdline_len +=3D len; @@ -441,6 +447,19 @@ static void *bzImage64_load(struct kimage *image, char= *kernel, ret =3D crash_load_segments(image); if (ret) return ERR_PTR(ret); + ret =3D crash_load_dm_crypt_keys(image); + if (ret =3D=3D -ENOENT) { + kexec_dprintk("No dm crypt key to load\n"); + } else if (ret) { + pr_err("Failed to load dm crypt keys\n"); + return ERR_PTR(ret); + } + if (image->dm_crypt_keys_addr && + cmdline_len + MAX_ELFCOREHDR_STR_LEN + MAX_DMCRYPTKEYS_STR_LEN > + header->cmdline_size) { + pr_err("Appending dmcryptkeys=3D to command line exceeds maximum = allowed length\n"); + return ERR_PTR(-EINVAL); + } } #endif =20 @@ -468,6 +487,8 @@ static void *bzImage64_load(struct kimage *image, char = *kernel, efi_map_sz =3D efi_get_runtime_map_size(); params_cmdline_sz =3D sizeof(struct boot_params) + cmdline_len + MAX_ELFCOREHDR_STR_LEN; + if (image->dm_crypt_keys_addr) + params_cmdline_sz +=3D MAX_DMCRYPTKEYS_STR_LEN; params_cmdline_sz =3D ALIGN(params_cmdline_sz, 16); kbuf.bufsz =3D params_cmdline_sz + ALIGN(efi_map_sz, 16) + sizeof(struct setup_data) + --=20 2.49.0 From nobody Fri Nov 14 16:53:57 2025 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9BD1C15575C for ; Fri, 2 May 2025 01:13:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148415; cv=none; b=vGdWVdQUDZmqp9EY8DMPaX8RAZm7sS75meZsCA7w7k3GA38Hems0UCXAvQjsh9TET/o7tnVC4JaDAEdLh8MkWTKZTmipPrqutEEDdRqlzRxxyuN9PPThh1Oe+bnD/LJx5wls3dchoDzeER6IY2ITioWw0uSQfjp9MVyRZQlQIGA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1746148415; c=relaxed/simple; bh=CrhcQhwg624hK8uwQNcRZuxl/btjRZnhBZDQK3Zqb2U=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=l5LjqZ1bBz6fcpsqnKIHrQ2ZjGYWINJN137GzFzNKGYcqEFgq3G48P4Q2ooQGKvyJUiDqvMC040RAYXE8Y17aSuXnOHT+pDSdPWO+DP4Cu/sPeHIkusm7qf4QE34FRKvgdY+wIjyuhvoZA40sd9aRfinLKASTlmEDF3+wt2olfU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com; spf=pass smtp.mailfrom=redhat.com; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b=U9Y+dJIL; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=redhat.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=redhat.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="U9Y+dJIL" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1746148411; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=1fPDWAlkRpZFD9IGtL8ncnibi+0RTZDXokax1ZHMC4M=; b=U9Y+dJILhyResWUPLqGipx6zVMmzA98QBf+iTcrrZlkeNVFOKC1QXndS/lV3ctJzIWtJn5 iR3kQwJlvtgbp5PjRNh2465d2prnpzIOKEb8dBRzszqvqDaDS1eU/dfUCltGJWqlCBufPg QYaZsLxtEpVSZEbqcltiYLRKodhikgM= Received: from mail-pl1-f197.google.com (mail-pl1-f197.google.com [209.85.214.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-358-5NKHAGurNiaANyb-f93lrw-1; Thu, 01 May 2025 21:13:29 -0400 X-MC-Unique: 5NKHAGurNiaANyb-f93lrw-1 X-Mimecast-MFC-AGG-ID: 5NKHAGurNiaANyb-f93lrw_1746148407 Received: by mail-pl1-f197.google.com with SMTP id d9443c01a7336-225505d1ca5so14262125ad.2 for ; Thu, 01 May 2025 18:13:28 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1746148407; x=1746753207; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=1fPDWAlkRpZFD9IGtL8ncnibi+0RTZDXokax1ZHMC4M=; b=EN3Gg7KYmV7J+m5MK1UQuwcEKLLn4RxDT755+KzZBJNjFoXXkVZhWpLH9dU38m/q+L g3Rcxl/nDZW1N7L1qXE58Lkc8sP7bFjpbXTxmUl3GvDVK0VKQESHcMyJd6v85aGmnjJ8 9RZGcxX9jiub7SqI0mHtuIwVRJNH4FFb79r/wahW7nFP8tLq80ib4LYOE5F8zOS4uE2n /S18cNvD4xonczZPQh9upvRQNDRPCmZPdYqlmsCEnT04nXaZjpy5yV/c78W0gUY5PL44 3UXemekWorU7fEL0g0qoPJikhJKycdKDL/E/LYsM++VOsWNqbo99aA1a1k3sm4wi2L2s RWxQ== X-Forwarded-Encrypted: i=1; AJvYcCXdFedCkI/nrupsOzNfIXFtX5cU9sE7jspfcRfdfkA6r3Q4rEmVU9XXdx/f4h4CdB5byqnBoNMh6yZcWLo=@vger.kernel.org X-Gm-Message-State: AOJu0YxGuOU9rbuCKPhld9/0XXBTmHUS56M+XdRLUsbWfXEYhYC/P5eX 9ldppAIfkAAdyTdsY7DVXkMy4/RsKWj5BS9UuBM1q/mMXPHrQ9YRN1qWniK0esoM1e2S5jdlDvr qIzC2ktlwuglUvQHafn496vE8rGdfxUUOFY1+lo+Vi3bt8rbCO/Tq7ejbcrzG6A== X-Gm-Gg: ASbGncs5hbh6bnSYlQk3WgGucOe50LMvZidSDSSHIWKKXp2xefDiCLjs1lGZgJ3ieX3 iBBmna0X9oIQJ41gBb5vlnEsOUd2/wOC1/cDSsMhi2HHVp8rmKLnHoCKe1Ms0ugIZoF7vDTnnwG H//vwg+OjYIPQjjUJBbC6dZbIbwqlYjsxV1g8duHEd0AMDoIk9LzAzhH0xCEBEA+xRmW/QpjEsU GHgCoDAMdiHoxhxuKyqr3Ctf3Q5GZooNC6o4VKS2+aH9IhXsDk6XrGMv1sluXnbld/0dh4te4vo AN8= X-Received: by 2002:a17:903:1aa3:b0:224:76f:9e4a with SMTP id d9443c01a7336-22e102d01ebmr17984495ad.14.1746148407413; Thu, 01 May 2025 18:13:27 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGvqxKF7gk97Lr8Vh32QR8SR5Scmsb6rcwbgFjb7HlkZaRVa8Vb6z2gCQMwaiziz7TBRlXfgw== X-Received: by 2002:a17:903:1aa3:b0:224:76f:9e4a with SMTP id d9443c01a7336-22e102d01ebmr17984105ad.14.1746148407121; Thu, 01 May 2025 18:13:27 -0700 (PDT) Received: from localhost ([209.132.188.88]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-30a476267e0sm1603716a91.39.2025.05.01.18.13.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 May 2025 18:13:26 -0700 (PDT) From: Coiby Xu To: kexec@lists.infradead.org Cc: Ondrej Kozina , Milan Broz , Thomas Staudt , =?UTF-8?q?Daniel=20P=20=2E=20Berrang=C3=A9?= , Kairui Song , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Arnaud Lefebvre , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Dave Hansen , "H. Peter Anvin" Subject: [PATCH v9 8/8] x86/crash: make the page that stores the dm crypt keys inaccessible Date: Fri, 2 May 2025 09:12:42 +0800 Message-ID: <20250502011246.99238-9-coxu@redhat.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250502011246.99238-1-coxu@redhat.com> References: <20250502011246.99238-1-coxu@redhat.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" This adds an addition layer of protection for the saved copy of dm crypt key. Trying to access the saved copy will cause page fault. Suggested-by: Pingfan Liu Signed-off-by: Coiby Xu Acked-by: Baoquan He --- arch/x86/kernel/machine_kexec_64.c | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/arch/x86/kernel/machine_kexec_64.c b/arch/x86/kernel/machine_k= exec_64.c index a68f5a0a9f37..f615fcb6d35d 100644 --- a/arch/x86/kernel/machine_kexec_64.c +++ b/arch/x86/kernel/machine_kexec_64.c @@ -598,13 +598,35 @@ static void kexec_mark_crashkres(bool protect) kexec_mark_range(control, crashk_res.end, protect); } =20 +/* make the memory storing dm crypt keys in/accessible */ +static void kexec_mark_dm_crypt_keys(bool protect) +{ + unsigned long start_paddr, end_paddr; + unsigned int nr_pages; + + if (kexec_crash_image->dm_crypt_keys_addr) { + start_paddr =3D kexec_crash_image->dm_crypt_keys_addr; + end_paddr =3D start_paddr + kexec_crash_image->dm_crypt_keys_sz - 1; + nr_pages =3D (PAGE_ALIGN(end_paddr) - PAGE_ALIGN_DOWN(start_paddr))/PAGE= _SIZE; + if (protect) + set_memory_np((unsigned long)phys_to_virt(start_paddr), nr_pages); + else + __set_memory_prot( + (unsigned long)phys_to_virt(start_paddr), + nr_pages, + __pgprot(_PAGE_PRESENT | _PAGE_NX | _PAGE_RW)); + } +} + void arch_kexec_protect_crashkres(void) { kexec_mark_crashkres(true); + kexec_mark_dm_crypt_keys(true); } =20 void arch_kexec_unprotect_crashkres(void) { + kexec_mark_dm_crypt_keys(false); kexec_mark_crashkres(false); } #endif --=20 2.49.0