From nobody Sat Feb 7 10:15:01 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.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 0F9F61A7264 for ; Fri, 7 Feb 2025 08:08:29 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915711; cv=none; b=cD8F/7tGBovqfwHDRBhv7TefwjTqs2Ys35XxxQYXFHzgP60VEMMRBU6qVPLPelSU4dgxH8mJy8nwQELUQpHln2pKSPvM69BiZSpD3vvvQBwy3D/095D61RmeGG0sBBAKCu1yP4osDx9pHOjqy3gk05NtMSGq3QeJzZXtGdl5YSE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915711; c=relaxed/simple; bh=3Ni9gW+FdstqIfkEUVX03cP14F/28Bv2HPB9KvpyesU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=WuwVHJMP0D9U00LEn9qhGqtN5qMUO/0rc7BXx96uU5kjgmT5AegvuOXTeEsSt4nQpBzJAucGutUJpqEsMH5OOrxg5tLYm2j8/RS1XaFq604C/+iYyaavsrkRlUmoNkDI3/vScA6KZjboZQQwR8x6xlIco/hl9usqyuc+GZOznEM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none 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=a7vRQOZc; arc=none smtp.client-ip=170.10.129.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none 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="a7vRQOZc" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1738915709; 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=SAfH8CaZcdNlX6bGu3s15qKUzaN5EneIuMEhM/Mtjyc=; b=a7vRQOZcstJFfpfwxpjtbAYbEDHyk78WODbXxJdFL6yqaxcIEG5OSJj5gIKPRCy+C0NQGz ZL9E5nGPAvjS5hykVQ78plo+k6EnHZbvQvGdUWhiY6quF+01VZGCVBNcQkJOwEeKCBAA74 T5wjcQPd+DOpM3vDTYQuZfGpF0r40fA= 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-665-QiMOdp6tMbCUcj7I7-ACRg-1; Fri, 07 Feb 2025 03:08:27 -0500 X-MC-Unique: QiMOdp6tMbCUcj7I7-ACRg-1 X-Mimecast-MFC-AGG-ID: QiMOdp6tMbCUcj7I7-ACRg Received: by mail-pl1-f197.google.com with SMTP id d9443c01a7336-21f444af89fso18545055ad.1 for ; Fri, 07 Feb 2025 00:08:27 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738915706; x=1739520506; 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=SAfH8CaZcdNlX6bGu3s15qKUzaN5EneIuMEhM/Mtjyc=; b=mN5xAwJ20MV5fUt1SKxh2+0LQSWjsp8F4A6fJ+w7t6wUumDwBvkjiBMFnPnPg9hcxC Ni3u7zC4w3uGzzBhnnnnK7Emvnf2SWxMi54pqsJuW9BrGvFIm8J76Ol0W8AuPPrEUx9M sLEULAHhLSxYlSb3hmWu/lKIeRjpz/iEf1E3lsBZHpv9kETfmOKOFQ5BlkhDRWrjgrzc knJqBdcD3l/y2uasgU3IoaKT8WzjVcMZ26PxuNB++ThVUFZ+/8itjSU6ubl5s4BsEXFI UfWCBmcQ5wV9MMxj0AuEPv4EHo8gwoxdt9YNlP0aPryseCPlxWmFCIf870f1AqQ+2RD2 Supg== X-Forwarded-Encrypted: i=1; AJvYcCXXBhxMYsU4o1OnVKfcGY54NVqN2Du+gkgjHgUveKxWG3ZOSJpPMGRH/ABzvLfHvByojUKqHSwoucNwOJc=@vger.kernel.org X-Gm-Message-State: AOJu0YzMcBzyGfLoV4/5cDVn7z5mzaWL/FABIdowWrLCEICC/XSzrWFo acXHIdMH552VQ0C+MjgTv0fWM7jyVnBWzWewPlI6L2sUMUnqJhH5mUMmgCcvJVoQFfppce9/QKS heeiuNT6QUpFmv2YevzOjY2b4vE285lBwOkpJYg+y2LwtIvVjDhD2lx/8JGpvyQ== X-Gm-Gg: ASbGncuM3A4XmED6t34xYJ8t7zg0S7STU2oy9SMEey/eB6Sa58Had8YrVVSPwyTaX1G q3urluXuM5uYwMK1Jdk/Bcig/ESyrSwLzJCA2pn7hl0ncG3qaoCpP0s7tmjE1GYfOFETyl/8oqO lmP8uPHnPyanWnJ96SwkqtVwFLc9gaH+wDikTZcpI6kO+vn5HTHzq65sYQirr9vSnvxCzfY695s w+Ygoqb1t19HcT1zyYlWU4N1KILJ4puy1pUMzjyqMdOPOgCuXgeWjnYNyy8yfbmUwqlbRy+ X-Received: by 2002:a17:902:ef51:b0:215:6995:1ef3 with SMTP id d9443c01a7336-21f4e6a1125mr40433545ad.3.1738915706427; Fri, 07 Feb 2025 00:08:26 -0800 (PST) X-Google-Smtp-Source: AGHT+IEPE/gqMkWPnB/djnJNY/obb5cFGvAP4LjWDnm8O0PsSmswh+uBBdXKftkoZyy8le1irXB8Pg== X-Received: by 2002:a17:902:ef51:b0:215:6995:1ef3 with SMTP id d9443c01a7336-21f4e6a1125mr40433315ad.3.1738915706122; Fri, 07 Feb 2025 00:08:26 -0800 (PST) Received: from localhost ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-21f3650ce21sm24790205ad.26.2025.02.07.00.08.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 00:08:25 -0800 (PST) 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 , Jan Pazdziora , Eric Biederman Subject: [PATCH v8 1/7] kexec_file: allow to place kexec_buf randomly Date: Fri, 7 Feb 2025 16:08:09 +0800 Message-ID: <20250207080818.129165-2-coxu@redhat.com> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250207080818.129165-1-coxu@redhat.com> References: <20250207080818.129165-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 f0e9f8eda7a3..61269e97502a 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 @@ -171,6 +175,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; @@ -182,8 +187,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 3eedb8c226ad..875fe108cc83 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 */ @@ -483,6 +484,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.48.1 From nobody Sat Feb 7 10:15:01 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.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 689501B0421 for ; Fri, 7 Feb 2025 08:08:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915716; cv=none; b=t5eIP2fLUO4hVyxALUkOZaNejF7LDSO+7goUCBRuN97Uqcik6eeqaidNRA7ehAjQnMpd7G8bW4cyU18oDAV2yM6eXxQFIYn2ETJQ5vAWZw3Kay9u/TjK7Yk3RZiAlrWKkNesjA+xENfSxPCqquOttVU83HSZ+/Zi+s7Eaf+PXs0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915716; c=relaxed/simple; bh=NyKzY0K0Ma12vUJu1+XLB5k9FElHY2Np8fadJc87zXc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=fMpYUIvCDB3fF87M4LpoD5b72l7q9CkA2d433jgB5yqF5yEO4cOw+QgKZrN05+xbZoBbSbjQu9fOc/ILwzWCvgOLSsa7J33OaelmzY5T0X60Fa2dPHADn6/drAtBujpWs45NACc01Yue/sod3TblYLMY+wCBiAtOqKcopH10Kdo= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none 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=Iucv3ZQy; arc=none smtp.client-ip=170.10.129.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none 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="Iucv3ZQy" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1738915713; 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=uNvqfRY/p43Kh27tUfS4izlyaUMw4mc0s7iE7l5Z3Sk=; b=Iucv3ZQyWrCGFiNGqTFK3soV4vh1m02Pm/ViMZBU8ICNngdNo7RC3Ge/hlCZHTSgA5+CB8 qZpKyjAzJIdnKG9MAFXx/mr3HMrWBFzcsSf/Typ2QbYFwMUQAayR59TeQ7RHehyEDpB2nt HVXSLTKAEniEyxVMOsmuhsvvooKoJ9E= Received: from mail-pl1-f198.google.com (mail-pl1-f198.google.com [209.85.214.198]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-683-MSf-8Qf2OhivOFqP_G9Icw-1; Fri, 07 Feb 2025 03:08:31 -0500 X-MC-Unique: MSf-8Qf2OhivOFqP_G9Icw-1 X-Mimecast-MFC-AGG-ID: MSf-8Qf2OhivOFqP_G9Icw Received: by mail-pl1-f198.google.com with SMTP id d9443c01a7336-21f022fc6a3so40105225ad.1 for ; Fri, 07 Feb 2025 00:08:31 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738915711; x=1739520511; 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=uNvqfRY/p43Kh27tUfS4izlyaUMw4mc0s7iE7l5Z3Sk=; b=ZZYLM0BiZIPhebjvVc9DXCExx4tq1IscOMEgu7I0g400xid8v1XvXovQ6JsoO+Nj35 RXWeStK6STcjc20WBwWW4n7dysfUim1Dhg6l5KkfLw/GJRjFxFRoemfo755iNg9/D8yA 93Dj3xpXE5p/3eIDxsI2yKeSXMRGjlhkmUNIpT+mgNwekwmpxlirmubBVtU51bLaCVhx JlBG3p4WmlJ3Mak8DGXRrThSKZNQQICJFV5wi+c4lnTobSSe2LCpnqkfXaETTnCioZ0/ la+e7NyS4vhiZwvy5mHp/9OtAl+mX0XQAlNedl5SCbsJyJlkzHz7HzTwwnnVv9exCK7z RkcA== X-Forwarded-Encrypted: i=1; AJvYcCVmg6XPStVyL4m4VpouMX0Y3PaFOOOPc+gmmF77oaQADPdOo87MQjaQJ/g4KVqcuK8TxeuXJcMg+NU6F7w=@vger.kernel.org X-Gm-Message-State: AOJu0YxXZX1yMauWuDOiusSkecPyX65kM1w5pmMQTVXhjI7EFvJ5l8+8 YOmZGTriZlcFyZZiBkSVzYO3MxUZYBBF9I1Y3dseBExzOjQK4ktZFSKMNYSQX0nX/sCubT0iA8R UJXHsDNSClfQe1EqJ7QukxvwT8FbhZ6bFnL1utLHlRE6sITnq6mgy8OiUnCDe3w== X-Gm-Gg: ASbGncvxQ/J+Hw9wf6CMTFoitS9a9iMGyMA/YevpSFESNy0OFqiMZ0DtWuHxFozCg2t N13h9VrPIU21m2CECA2Ec+yEG9EFL2wqifszwuZrKVDvfQJ7X9lXEGGwXK2Hyg0P7fe3sdNjFeg +LvwpK6neAkUWAAbdrawyivtE4nXcNNJ5Cw0PfCPPFxLZ/gLU5WkkhVjokFs4E/N4VNsZwxJXb4 y/gNEq0GFhC76QchXWfKH5hgX5SQhqpzHbP+sP+z3o+vl6u5QfoXcPvlz5QcVxSmfqJLr4D X-Received: by 2002:a17:902:f60f:b0:215:6c5f:d142 with SMTP id d9443c01a7336-21f4f7a257fmr37890105ad.20.1738915710615; Fri, 07 Feb 2025 00:08:30 -0800 (PST) X-Google-Smtp-Source: AGHT+IHs60RhVNrgryoHKynyiSh2tPFd7Ldxk7PRowHjlbIPWF1HtpbSpHjjlk+tvWfekAFaJaB6cg== X-Received: by 2002:a17:902:f60f:b0:215:6c5f:d142 with SMTP id d9443c01a7336-21f4f7a257fmr37889855ad.20.1738915710241; Fri, 07 Feb 2025 00:08:30 -0800 (PST) Received: from localhost ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-21f3653afa7sm24407295ad.66.2025.02.07.00.08.28 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 00:08:29 -0800 (PST) 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 , Vivek Goyal , Jonathan Corbet , linux-doc@vger.kernel.org (open list:DOCUMENTATION) Subject: [PATCH v8 2/7] crash_dump: make dm crypt keys persist for the kdump kernel Date: Fri, 7 Feb 2025 16:08:10 +0800 Message-ID: <20250207080818.129165-3-coxu@redhat.com> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250207080818.129165-1-coxu@redhat.com> References: <20250207080818.129165-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 | 10 ++ kernel/Makefile | 1 + kernel/crash_dump_dm_crypt.c | 154 ++++++++++++++++++++++ 4 files changed, 193 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 5376890adbeb..83d422d761b6 100644 --- a/Documentation/admin-guide/kdump/kdump.rst +++ b/Documentation/admin-guide/kdump/kdump.rst @@ -551,6 +551,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 keys are needed to unlock the disk volumes, + # 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..5226775fd4c6 100644 --- a/kernel/Kconfig.kexec +++ b/kernel/Kconfig.kexec @@ -116,6 +116,16 @@ 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 + 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 87866b037fbe..9d1cabf1ec46 100644 --- a/kernel/Makefile +++ b/kernel/Makefile @@ -72,6 +72,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.48.1 From nobody Sat Feb 7 10:15:01 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.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 963631A83EE for ; Fri, 7 Feb 2025 08:08:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915724; cv=none; b=PL1MPnI3t0nU6Dv1d4erDEn1iaqKend+S9QjSSzDJbLrFre5ufUsATNvw41gjZAJNTTC2UQX4zFPKiGH+DnDkLSKHhfTzOK0S1HL7KHJ9o/6J+NnFBtW2tL6UWn52Le5w3dZ8xVnP25xKSLwLfQv65L5nPxN3bkz0/zeT2ysWUM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915724; c=relaxed/simple; bh=wGo8awM55P1fixHWH0T9+mtru3yxo+FWs1KGiEg7kzU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=hYMxWN1NEXj+cU9airmZUkuJVLdEg5Tai9ZLPNyX39kecMH3OszVckcgFeZtxbpY7/dKQCdFCukIYkSnzIYA1g0XWIkd14IkUDPgrFUi2ftFQb1910hPamIrxklGcq9a5C9Y1Ld+XX5wNOlfBoWtvA80GJF8XuUXsb/0m+dDq6g= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none 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=Ff8Dlq1h; arc=none smtp.client-ip=170.10.129.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none 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="Ff8Dlq1h" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1738915721; 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=wiArPs1+avBHMZbi2nWrtxJACPoRgCcLG1Yosqozl6w=; b=Ff8Dlq1hOudSjVMSUdLRumVtv/hv8oG0vmbkm1yHAS/co+Zc1rrzdhhld0h2pyvVxJDoWq IJhJO4Suf+UDDDqfUT2xQ53XSiy/56e+lV9KIikBuK8K/3rIXLVXLNuSLzBVGshFrr3hZh mGwiRkqjXj85zBxjxovcX7CdXv7Bmuk= Received: from mail-pl1-f199.google.com (mail-pl1-f199.google.com [209.85.214.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-45-83xlJHViPgSBR5uUmx-bHw-1; Fri, 07 Feb 2025 03:08:40 -0500 X-MC-Unique: 83xlJHViPgSBR5uUmx-bHw-1 X-Mimecast-MFC-AGG-ID: 83xlJHViPgSBR5uUmx-bHw Received: by mail-pl1-f199.google.com with SMTP id d9443c01a7336-21f0d8b7647so55058115ad.0 for ; Fri, 07 Feb 2025 00:08:40 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738915714; x=1739520514; 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=wiArPs1+avBHMZbi2nWrtxJACPoRgCcLG1Yosqozl6w=; b=MA7PI4qEWJthwxAkbRoiEaK+IkvE81xV7/oyYuk6D5zJRM+sceRP6MtnhaZzPA6isd TmwsMEvi3lnJ4HmggQjgro43e+4zgLiT2QvQQHQd68Gmebd1mtdxZ905tLLJj/DfIp1w 5ZC0hbEZQLPA3dozfUhwjLErku/Cs8+VJBWiqc9LdVElROxjxMPfc1KWXsWvTt9vLrcb M02EUUX6RSm3o6x0jlcXDYFOfieWva0JNQ/XirqgNuTIIYqIGTzJAMbuR+AwZWYpBbxn nhqPAoUxMfQj4C245mGjN6PF+IaPzOFzCLVfMAwSnjmuR9IA7uNxaKrHftvjj9yZbppf AOrg== X-Forwarded-Encrypted: i=1; AJvYcCW1DZgMNOb1tJA1KzhpmGvpDyvpzQTpm9+Zj0y6wpKdGG2/qiSKaytZJbMTFgHesT1OOEkzs9seX9Dx95A=@vger.kernel.org X-Gm-Message-State: AOJu0Yzrw0gD5xbBGWOYQrZl1St91hIT5m6rolf4j3r0AQ/vDL4OZqC7 xJek7d3j5jxRvGns4NdQSCd1YPYC4WdlIugMuEuGEsHwl3uHi3w2VZhtGgMLbyNFOVQJs0bY8l4 rOknYB51ukhxDzJpowmk2jP93Tf7wAXpnAhaZo0Pj56EFIlqWSjx+YFTcm56uEA== X-Gm-Gg: ASbGncv6Illyu6pfTjrioPrH3HalRtXkBPpZHc8Hpwz9/gtMEb8L62HIIKQ+Rm+dQ/Z 76GAFIy3u+dL34aFVxdv5ywdfnFduZmaTy/rnJ1Ym7buxY6x+FIdOYaYl89mihO1DTKfuTm8EhS pyc4ys7n1X1l/JfFbDLIr6fq7r+wWTpf6b+5BKMh6AP9yUzQg5adGFP5P6oe49baRubgZ6dlmg9 eLBHAnmOWe/nRf3KVLuZEM8fROihVMW6evSUTiGki6vG6g74yVTiqfhb13MkM7QsuzbxoqJ X-Received: by 2002:a17:902:e552:b0:219:cdf1:a0b8 with SMTP id d9443c01a7336-21f4e70becemr33812685ad.30.1738915714416; Fri, 07 Feb 2025 00:08:34 -0800 (PST) X-Google-Smtp-Source: AGHT+IEOy2GKcmqR9hVKPcRIgrcrNltxpouvX9yK078gbyYuEyZ9aHqEHHcHMDTXf7Funzs6C/FVgQ== X-Received: by 2002:a17:902:e552:b0:219:cdf1:a0b8 with SMTP id d9443c01a7336-21f4e70becemr33812455ad.30.1738915714085; Fri, 07 Feb 2025 00:08:34 -0800 (PST) Received: from localhost ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-21f3650cd10sm24776065ad.31.2025.02.07.00.08.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 00:08:33 -0800 (PST) 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 , Vivek Goyal , Eric Biederman , 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 v8 3/7] crash_dump: store dm crypt keys in kdump reserved memory Date: Fri, 7 Feb 2025 16:08:11 +0800 Message-ID: <20250207080818.129165-4-coxu@redhat.com> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250207080818.129165-1-coxu@redhat.com> References: <20250207080818.129165-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 | 128 +++++++++++++++++++++++++++++++++++ 3 files changed, 137 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 61269e97502a..ec7504ba80e9 100644 --- a/include/linux/kexec.h +++ b/include/linux/kexec.h @@ -398,6 +398,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..00dc6a3f71ca 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 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 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,86 @@ 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); + + 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.48.1 From nobody Sat Feb 7 10:15:01 2026 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 963041A4F2D for ; Fri, 7 Feb 2025 08:08:42 +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=1738915724; cv=none; b=n+i3fk9R4KRH2lFI64pr4nC5DQFmMo+Zm0EpjvuZnvpuVj0Iamd8aijM74TtBsjJHJY3M0dfwRsOUqXN6W94lp6kJegVKvPuyJjIuhaFCtY5mdDwMVYAduk3OmZQYNP7px4Lqk/jZIlUefx+CHuUbGg9H+bEzPmpI20PVqy6Q6s= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915724; c=relaxed/simple; bh=ooq2LTWco/Q5VgSj/ws9UJuLfY+jbL51jd44eN8UAD0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=mc2A/2rMLF2LdBSHKwxiCttkZFBel8bR8AwbnXB+pGVseAVK0HxT/UWECgQh1Agih1Y4S2GlPyVpDWEB0tVl7r506nhXPNJRetOU2pK9BytU0ynYwaB+IBpHnd7GJs/ARV2RBCux6nAaATOmw0F48tmrzxNgUDRKHFYPNP6sGL0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none 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=cmFUIBLT; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none 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="cmFUIBLT" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1738915721; 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=vs/fEt8187919W7bAsJ6ILZH4C6hECupt8Iw6rDvcR8=; b=cmFUIBLT/kuugijcRVSUdMNs4bkLAg5sJxOraJPhsKzAwrxP3wNe3HNa9NjSR31Rf5x8EV smHKzPohLZP6tNNZmodEU2oNbvg9szjbmyfPWLOXHUcMAfY+LwykSj5AAfaUH2udOVjZr8 xu77N23KEDzUIqIqKzqpR3kvVnQh+jM= Received: from mail-pl1-f199.google.com (mail-pl1-f199.google.com [209.85.214.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-684-MNVd5ghvOeC3AGG-U8xkUw-1; Fri, 07 Feb 2025 03:08:40 -0500 X-MC-Unique: MNVd5ghvOeC3AGG-U8xkUw-1 X-Mimecast-MFC-AGG-ID: MNVd5ghvOeC3AGG-U8xkUw Received: by mail-pl1-f199.google.com with SMTP id d9443c01a7336-21f5060ef10so25201655ad.2 for ; Fri, 07 Feb 2025 00:08:40 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738915719; x=1739520519; 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=vs/fEt8187919W7bAsJ6ILZH4C6hECupt8Iw6rDvcR8=; b=YVc4Je1wzIdXzB3iQ3AYoT653mWaYV4D1P/OfWcUr/zDe1i4SxTaWn8S13YIPLDMLb HSg7L52TaRtLENcBGTj3rFhdJm8PztWs7CsMlJsw7KiSkXWeVL0+JQncOJrLQNmYxeE6 QLptaschHv94YSXBdG1IpD6IlNF0T8o8XleeU7Uwn3f5kkRH0Sb5yNPe0oJFp4VH0PM/ 231w6zXn3mj0GnJpalxF5YV++JiRr8h6WlcCwF75Z+LPEt5QK6oOa66bsZqfQSkaQqBX FTHJudaFWL2Qt5KXcuJao/svtrJLdd0vp5xgTwniEXD5el4UXxJoREhL56p34icgerYH fjpw== X-Forwarded-Encrypted: i=1; AJvYcCWMWdwLmzO4kRLwM9kudfkxlP0bTX2JRogpX+yhI9YziFySqW6O1GyQRe1lM0vSeDZzzVqWXNDHfl16g/U=@vger.kernel.org X-Gm-Message-State: AOJu0YyCLRlnxS5rdgf2+RLdAReXBFkzM5T6pNZXIz8rKaZg3db0e831 v0BUg2tVeEt2TpYnFkidmN/lE42Z4Er+ULIkwgMUEA0TfurGN5AhSfWfyoP0UQ2NDBx3dujAjFe EsNAj0aOPM3rgTFZW8/O4qeW6rD3hKsgdDz8zUcVpir+1JFIz230vtffl9MR2TA== X-Gm-Gg: ASbGnctBDmty9/5UkQuuoShNdU4YZ4RKgie4T7ihcUnBEqa/Hx8JmAHjo7Rd0652oCU 8nm2DxDv+gZrYpeDSHLGMCkMV6HORFlgpMP08BqKW9dSW4ZILfnNo8fNMRMOAbuL1Ub3K6vifaJ xiHHRSDp48Q5dL5iaIGZdFHjhMy2xH2DrocWRf7mWZ80OZm3R6YL0hxuzaZSOLLqiNR40Fv8BJU urP3Ockl1kFb04B0nc325wuC0AJ1Fd4wOd943v03f3IEl1lnsnlMx2wAoImvbBQYl2OikMy X-Received: by 2002:a17:902:f542:b0:21e:ff31:526 with SMTP id d9443c01a7336-21f4e77b902mr43522045ad.43.1738915719228; Fri, 07 Feb 2025 00:08:39 -0800 (PST) X-Google-Smtp-Source: AGHT+IFDtGAWMniDa7kdL3sNgA7bh1GCtIrQ4jLjUrxyTT7Lx6LA9FXZwINkgBT1U4ESkAYbK9t2sg== X-Received: by 2002:a17:902:f542:b0:21e:ff31:526 with SMTP id d9443c01a7336-21f4e77b902mr43521655ad.43.1738915718900; Fri, 07 Feb 2025 00:08:38 -0800 (PST) Received: from localhost ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-21f365616ecsm24825295ad.100.2025.02.07.00.08.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 00:08:37 -0800 (PST) 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 , Vivek Goyal , Jonathan Corbet , linux-doc@vger.kernel.org (open list:DOCUMENTATION) Subject: [PATCH v8 4/7] crash_dump: reuse saved dm crypt keys for CPU/memory hot-plugging Date: Fri, 7 Feb 2025 16:08:12 +0800 Message-ID: <20250207080818.129165-5-coxu@redhat.com> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250207080818.129165-1-coxu@redhat.com> References: <20250207080818.129165-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 83d422d761b6..1283f0244614 100644 --- a/Documentation/admin-guide/kdump/kdump.rst +++ b/Documentation/admin-guide/kdump/kdump.rst @@ -574,6 +574,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 00dc6a3f71ca..e4e0cc1c3399 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 @@ -233,10 +275,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.48.1 From nobody Sat Feb 7 10:15:01 2026 Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.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 0620F235C0B for ; Fri, 7 Feb 2025 08:08:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915732; cv=none; b=tOGOKfglPocGWcyEBiLiZ1rbqSOeM4bhTBHx6qirVCNSGARpfEjEIogb5Z22pDYVtn32kC6tTW4Jz9hngVCbI6LuqFI8ogwwzjwbLdUB7qFn7WKuLRu9LptWjeeHZNlGZefFjEOpJ41jxoLudPyDuKYr6Oe+ft/0OLEDD7NvxLY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915732; c=relaxed/simple; bh=qYgiaxK7DTCswsumKXpFE8Gz/6JnFk7H5/sd6l23VF8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=gHf8LKKvyB3kO/BHEMv9KDn+E7KwwwCQsMG/ZfBFNZDqAoqf6I7GAzTdKAK9IM9SQjiIKoKTPUx522WTsbXOGGXqglr0ZxlIjXPPzULV+Wrtoeoy1OZUwNY9Oc3BzD6PhwtVl2HaWBQ5hxHspoxrNpQrXJtJwySb1itlkPSVxiU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none 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=RVZnCOgx; arc=none smtp.client-ip=170.10.129.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none 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="RVZnCOgx" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1738915730; 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=K4HLB2l94cxI2U1OdfZtSwsiylrY7VkACKgIHY5nsyc=; b=RVZnCOgxyFfxBHAz0RquP52KqPe5OuQip5dzWQeSFtuV6OJ4fSRXw875RFyKHL1iaJ6EfJ JQAPeJjsejRkx6MW5M8t0r3erH2B0KMr56yKbCtrWXb4M1FIl10P6oONoyGGizJncnJvFv Wu/7pIrHiuwW1pAaGMuG8tWrHRHr/hQ= Received: from mail-pl1-f199.google.com (mail-pl1-f199.google.com [209.85.214.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-47-oTHE66I8P1229Y-QLvhDSg-1; Fri, 07 Feb 2025 03:08:48 -0500 X-MC-Unique: oTHE66I8P1229Y-QLvhDSg-1 X-Mimecast-MFC-AGG-ID: oTHE66I8P1229Y-QLvhDSg Received: by mail-pl1-f199.google.com with SMTP id d9443c01a7336-21f4f0570e2so18158715ad.2 for ; Fri, 07 Feb 2025 00:08:48 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738915723; x=1739520523; 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=K4HLB2l94cxI2U1OdfZtSwsiylrY7VkACKgIHY5nsyc=; b=rFmImsr4P8SxiLfS5vd7Jic+pW+32Vyt4EENMWRziqRCT9wWfmlTAH483GDk2kpt31 juH02pdIuwncoEjYFYOgsLJxQHMSxrjJxedQ1cdVUnUtcrpRls3yZlVPrbHoR//jg6HI 20B0k1QSrHTT2sO3fktHyxDl6F3PEUfB0lKq8AjuGPOPPnMjPYZdfJOyd6HLLxnsZVA2 fq9vPPujiV8/G2gVE3XOFsJ2f+RNbFhb0k5pJfsN4/jYCc22HGkkvIo+pXXAq9nnHV6T PJFtQAx4lwDmVRDGJqaZ6JXlcAEqV/5h7NvUSB6MolCCgAERDy5VzfvAe75UBX3kaf4l lOug== X-Forwarded-Encrypted: i=1; AJvYcCXtHaCEu8KvDk+1Ao5WxX/jsN1CIgbRpMFZzy2eBALrOzQvu8d4JC0dI+KAc8kGTCcnw1xYftlx817PT1Y=@vger.kernel.org X-Gm-Message-State: AOJu0YwCZsY2hgjJeE6w9i21p6MyZolo0RBIMgrg/HuveZN/yKYJe/AE rI/rBRkgAoknVZ2H3+1CT9AcN21o6/PNDxQJSC0Dtd1S5fbg+SSbunDTdJFQFHQlR3abdPfvRtb irmwOej+tNpwrqHA0+EG0x7L07lctPMsVnJixteJ19pt9XeM4kOQ8zYqfZDUNLQ== X-Gm-Gg: ASbGncu/tf+mFXomUjOmQ1yr/XLzOzcLRewitgtF9UlYeO4yg/qSg8ehcoqW9gTy0gT rG7jNra3lZj7OjN56oyKiEVyzhrdHIfN8uE3puYmSASLEIYWneyUUKMY9FCnJnlhiGkVZ03xKMV cy1GS1e+zRzdPp7jXOvTjq/op59TWD49E5zT+O7oBjRJ34xsCuEEIi73FzACnkwtvV+PClfBeVZ KNuFk0Fci08ryukB1UaGIMrWiqkiU8rr9rZik2Zi3zgi8UdJm8VyKC5UZlql+jj7oCiRRwL X-Received: by 2002:a17:903:28d:b0:211:ce91:63ea with SMTP id d9443c01a7336-21f4e6f449amr40652875ad.15.1738915723420; Fri, 07 Feb 2025 00:08:43 -0800 (PST) X-Google-Smtp-Source: AGHT+IEG/Nl/sdNxE3d9AYSZmlVVB64Sgy2HwYPMVzmQGwxFjzAN+7LrOpduVERhXyu9f9J9OA/vpQ== X-Received: by 2002:a17:903:28d:b0:211:ce91:63ea with SMTP id d9443c01a7336-21f4e6f449amr40652485ad.15.1738915723069; Fri, 07 Feb 2025 00:08:43 -0800 (PST) Received: from localhost ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2fa09a184cdsm2738670a91.13.2025.02.07.00.08.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 00:08:42 -0800 (PST) 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 , Vivek Goyal Subject: [PATCH v8 5/7] crash_dump: retrieve dm crypt keys in kdump kernel Date: Fri, 7 Feb 2025 16:08:13 +0800 Message-ID: <20250207080818.129165-6-coxu@redhat.com> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250207080818.129165-1-coxu@redhat.com> References: <20250207080818.129165-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 e4e0cc1c3399..993d9e08d774 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 { @@ -306,6 +434,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.48.1 From nobody Sat Feb 7 10:15:01 2026 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 41F8E23642C for ; Fri, 7 Feb 2025 08:08:52 +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=1738915734; cv=none; b=ClHMwHdQ7TH98UuEdkgVHhunuB9PhupBgeK8JEqCRSPzqfp8dgQCWhtcYPmrA5h6lubnDXRLrNr885YljVK9ZDM8d0fVDL5zwsnH8Dl2Jy5skdrpw/3ADfh2Yu5MjF36+GiDEXW0/xZTWpjmdV3PB7m5eCyRW+LlNt6pG5OfRU4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738915734; c=relaxed/simple; bh=x0p6hIaW4+aySJw17dpuvGeRp0+lJ/1YYST0D6RoFPE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=liDfZ6K86QmFVU9o3+8B2SsQqe9YwlcP2XsdBnb/ctpm0po3OQhmaZRjg9ZwAMPj+lGOjXR5NOjQkjzNSnjkT4f+9IJQ/ebNn/Iky/rnHO7xtqfbtafrkzpO9Tf2QEkm+lIA/39s04ZZOD0GzWK7TWZ5si9UyD771y3dP8d74UA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none 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=Keg42iZD; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none 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="Keg42iZD" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1738915731; 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=aL14X0leHlIaXriDDuvzj+jBkNI10p+NUwdo4iMYdVY=; b=Keg42iZDDx8/Xvd0pt86n8F9h83cqcWC4jZcq+KrU58lmbGcr4ewPgcqeb3uNOHbryQX7a a5e8wyqRN0NcZxZI5laBtcj/LXVcsXa9ciOLkX609zeUwdIvYFX6UpNtFtUTkAN8eKYwIu QDn5YpgfClCcvy/ZlyLj2QLlMlkyHNM= Received: from mail-pj1-f70.google.com (mail-pj1-f70.google.com [209.85.216.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-332-HPs2Iko0MVSPs_e8OmZtWg-1; Fri, 07 Feb 2025 03:08:49 -0500 X-MC-Unique: HPs2Iko0MVSPs_e8OmZtWg-1 X-Mimecast-MFC-AGG-ID: HPs2Iko0MVSPs_e8OmZtWg Received: by mail-pj1-f70.google.com with SMTP id 98e67ed59e1d1-2fa2e61c187so441243a91.0 for ; Fri, 07 Feb 2025 00:08:49 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738915729; x=1739520529; 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=aL14X0leHlIaXriDDuvzj+jBkNI10p+NUwdo4iMYdVY=; b=OgsvUcTbmNEnIreTgwMPa7iun6qNQNtmWfw7cooPRZULgKGwv8ABblk1QdD+909eId 6HFgR9BpRRkI6Cm/y1X2j4mlSJ46lEPMYURIqecnW+e/FLsMHiFTHVL7TWULDLgkJenm Yk5g6MMscQAf27vdT8pM2GMQiAv6PdrrMwDEBxGAMm366i/Zj8TL4/CIBQIz/ypmpg56 jfFZC24LUjEspUJOLdQW26f2Suvp3NHpTGm8aCAa3N1KeVjHfNSwI/aduk2HPEpHozrL Tg/SUrB0IwaMU3dRFZW0JqzoLki1Rfzp3gx8Qi4qaS0VmZk9dWhAIlLKSFfhYrvw9w1H p/vg== X-Forwarded-Encrypted: i=1; AJvYcCUek+GzHHlE1CdeERj+4z4OKp+eiXGIdGn9DkyEfWAtWjjeoR4VsDS3jhHFYHtzJdzozgzH5Mm8rbBvrzs=@vger.kernel.org X-Gm-Message-State: AOJu0YxdfdpmjAJiRTpHJ9JKoYvifZilsyqnJKQC1pqKEKldeJgo+AJA ivfIlRkgz6MzqpgthBPmn/b0UEidqNB056ycS+Oh7NficuNp3ApkwXXmRYD+XzsANNC/fiRQsox nzH+ie6jRibe6SfDWpmaeMiakTbWP118YpOGlaU9iIojuXuYts6xQsfk9XwvuZA== X-Gm-Gg: ASbGncsrO0y8NUNDoCQqMsUC7WcsWezIgEV5p6RJUzP5w6eiiEz5NnnwVZgjzPjOeU5 t6rU+/vKhMdXwfVjolqYUhzPWjF/aIS3teM3GjRGcrE9A+Oy+2MD2xFyzxtRggUvoEVxfNK/ycI opuQAnz0ii1nJiuSCFJ2MygOXFgPBVWW1QE3xddAPCusYUS+WwEA47vbfxy2h+vswIGxbFc3I7k T/2O3XoG+dOI5cB14VFIh5jsUPqsvvg4GVEpyvGeE/H8rr9FyYqw1uWws7Z5xJCjDinncnd X-Received: by 2002:a17:90b:4b83:b0:2fa:3174:e344 with SMTP id 98e67ed59e1d1-2fa3174e3camr490272a91.14.1738915728702; Fri, 07 Feb 2025 00:08:48 -0800 (PST) X-Google-Smtp-Source: AGHT+IGForNSQZIeWtJV5QgUb8FCeJOL+p2N2wYN66XEWld0+A3AqNwNbyWXDtNkREAyMmDul4JNQQ== X-Received: by 2002:a17:90b:4b83:b0:2fa:3174:e344 with SMTP id 98e67ed59e1d1-2fa3174e3camr490228a91.14.1738915728354; Fri, 07 Feb 2025 00:08:48 -0800 (PST) Received: from localhost ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-2f9e1d77b73sm5465432a91.12.2025.02.07.00.08.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 00:08:46 -0800 (PST) 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 , 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 v8 6/7] x86/crash: pass dm crypt keys to kdump kernel Date: Fri, 7 Feb 2025 16:08:14 +0800 Message-ID: <20250207080818.129165-7-coxu@redhat.com> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250207080818.129165-1-coxu@redhat.com> References: <20250207080818.129165-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 | 11 ++++++++++ 3 files changed, 37 insertions(+), 4 deletions(-) diff --git a/Documentation/admin-guide/kdump/kdump.rst b/Documentation/admi= n-guide/kdump/kdump.rst index 1283f0244614..2209caf36d79 100644 --- a/Documentation/admin-guide/kdump/kdump.rst +++ b/Documentation/admin-guide/kdump/kdump.rst @@ -555,8 +555,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 keys are needed to unlock the disk volumes, # Add key #1 diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c index 340af8155658..a525ee639b63 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..5604a5109858 100644 --- a/arch/x86/kernel/kexec-bzimage64.c +++ b/arch/x86/kernel/kexec-bzimage64.c @@ -76,6 +76,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 +445,13 @@ 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); + } } #endif =20 --=20 2.48.1 From nobody Sat Feb 7 10:15:01 2026 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 5B59A199254 for ; Fri, 7 Feb 2025 08:14:06 +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=1738916048; cv=none; b=hxuJcLuE/iG83JN4sLH5UX/Tnx5i0hNAJ1GpnJpltNYVnJxkYbck3DX5b4SnG12qB9S+DTelYBxr+CkIpcZF9mg87vSdACWEmTWx63cuMsPguf4v2s93WXvpCduz/eM5awu0rxWE7KDyTIHIPxJVFUT5USTROuyca7Z34yg+4to= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738916048; c=relaxed/simple; bh=h7ENOft2SY09K8gYYNgwcT/3gUzWbpo8/Oe79D/1UmY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=qLUbNrWSxMlVM6N82u8wyzbQRieFs/TlKdrq6kLns2FLqbRLQX0kG3W08kbAK/XTi+HgppZazIcsD0Ctd+enPLrW7iRvo4/06uRHMKgCopOa704Mu7lTBSmKHAGQzjG/NfwCCs6fGyPLEEHqxVXTeIkd6XtYUl1fCefJwAjQILE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none 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=RLObjaHV; arc=none smtp.client-ip=170.10.133.124 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none 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="RLObjaHV" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1738916044; 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=B+vuW6U48iDvPQRM7yyRLxHLzZYL+ucqowEQ4SiSdz8=; b=RLObjaHVZXgmnlqXvHFSYeXW3fIJpIHP8nfKXaDYHruHG0Hjerp037paB9BIqSyyiJ9/iE Mj+wY58WqxkBjJhK/HKQqQKPbYH/EE/Ev7+E4XBL1ayhSAduE8ayvKKYvtC8fgqWDq49UF 8xQFwtAq2rn8solJZG9EZ9e5NqXxPV8= 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-632-yjIuPE0UO8umdut7PvOqxw-1; Fri, 07 Feb 2025 03:14:03 -0500 X-MC-Unique: yjIuPE0UO8umdut7PvOqxw-1 X-Mimecast-MFC-AGG-ID: yjIuPE0UO8umdut7PvOqxw Received: by mail-pl1-f197.google.com with SMTP id d9443c01a7336-21f49f0bd8fso16401835ad.2 for ; Fri, 07 Feb 2025 00:14:03 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1738916042; x=1739520842; 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=B+vuW6U48iDvPQRM7yyRLxHLzZYL+ucqowEQ4SiSdz8=; b=xDc73f7NePIXQnaVGPxxCKq4xGn5+RCTCF/jDoALliRgwlJ5OTSOXGnGXDyfsiiDZ0 150dPzq9yaTZLb1DKXoyVihxbriPz/ATaA+u9i8Eb9EHCDdDIbjP0fd597tED/oceS+r 1qAbYaknJmk0jlFD8pLhSnZSExrPwmD9XsFi+soymSLzm8fnbJ64vWR+e9O+ZyjI1Mii 38nfYhQE/TSfVO3luGkAFczWBgieMLqcj8Wc+MZEiO9iuEiirzzFfbcvoKeIOD5yy5/e YtF0VbDD6vYQIqYFlZtr7BvPlz+uqSxlUmlDp6DbdvaVy+wUbK7ksKJdUGGTPu/ZwzA+ uS4w== X-Forwarded-Encrypted: i=1; AJvYcCXilIH2t0YrEHNG1b1cCqddfeZT9ZXORlfa7+l8emep4TU0tSiWXX6+D9KxRNoJL0p+wS1B3zTduHmTLc0=@vger.kernel.org X-Gm-Message-State: AOJu0YxyZLyY5QwAeVLcT+Ogxl8geCCwEJSQmV7UphzORu5OE2L88e+X OB1//q9ASwTyCVIMtFvjdN/JQpvK8lhbK4W5TA/T187s7qnWmIos81rYlhV4HQztIrPvyiBcKNP WpNGVIcNx4amflAt5nwcxSHmzZ8rx7plhShoW/ti1fHgTI7E6i57Zqs2TrEKI7g== X-Gm-Gg: ASbGncuRw+38f08IeHwNqymr6WxZBDcWQESEjiE7ihZdwXTJlFFnRpjnCl5op2/7F/A CYLK7VLAAOj+oDYDcFP54khuob6YDnbFBHAwMlerRu0rlzCt2w3BS32ov5kOnkZqr7/iUlU1Nud sx1Zw6DA0cvYEqrOKAtwHSrS/ejUHh6dZV6kRpBbv8UHSXJoQdDJFdmicnZyq5OUXGP2W7PIzsX uGk5tEr41vHvHaTtmu1cHm61WMC94P/uKgJ9zG6rWcRNt9qGYdjBUSsdQDzHn1vXVtFeiUo X-Received: by 2002:a17:903:2309:b0:215:a04a:89d5 with SMTP id d9443c01a7336-21f4e1cf038mr40201335ad.2.1738916042446; Fri, 07 Feb 2025 00:14:02 -0800 (PST) X-Google-Smtp-Source: AGHT+IEgk9M0daWYVa2Ek7u8oS/CFLYtRBIoNw24mfM3TS73uCeiCwSamNzyIev1riImUKcHHz726g== X-Received: by 2002:a17:903:2309:b0:215:a04a:89d5 with SMTP id d9443c01a7336-21f4e1cf038mr40201145ad.2.1738916042195; Fri, 07 Feb 2025 00:14:02 -0800 (PST) Received: from localhost ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-21f3683d8bdsm24540065ad.151.2025.02.07.00.14.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 07 Feb 2025 00:14:01 -0800 (PST) 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 , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Dave Hansen , "H. Peter Anvin" Subject: [PATCH v8 7/7] x86/crash: make the page that stores the dm crypt keys inaccessible Date: Fri, 7 Feb 2025 16:13:58 +0800 Message-ID: <20250207081358.129794-1-coxu@redhat.com> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20250207080818.129165-1-coxu@redhat.com> References: <20250207080818.129165-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.48.1