From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id A7462D5B87A for ; Tue, 29 Oct 2024 05:52:48 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=WYTfc9B9bMTk+fwFn0u04MfonJzU7OYun33a/zOYIL4=; b=kjJMumSOOAi9ns gw/3G4URg+yNWqA5wNzPmIf6FSQKFKcprmh0tlSKIpJaayZ86FoeOjSCsv/fLgoq1T/EtV08AG9yV Ul5PhpfNTInmFzg9gJeliE7lX4w03A2Gnt3LJEFUwK2gpP9hJuI7hyxDjVFhIV3SFcjvrQ84z43Ea XRANCDSVMshvW4N9pagGlsZM18Gcq4kk+omeWzCmEgjp+o04BRGMKSs7BZ5w/F5uCYJAnMCP05dNd Z/6fgej+dapltkOw2utM6p7fFiBfL8JaJsFTf1D6tYXizoa3TeHpVUasIJnIB7T8uMWIO0RHB3RbK 87uILhrDKIjl35BEV/BQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98 #2 (Red Hat Linux)) id 1t5f9s-0000000DI5j-1amn; Tue, 29 Oct 2024 05:52:48 +0000 Received: from us-smtp-delivery-124.mimecast.com ([170.10.133.124]) by bombadil.infradead.org with esmtps (Exim 4.98 #2 (Red Hat Linux)) id 1t5f9p-0000000DI3D-0u4h for kexec@lists.infradead.org; Tue, 29 Oct 2024 05:52:46 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1730181164; 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=zu6hE/UbIftfaQR7QgBZda/S19K5fTxOQ48ZhHGy+/E=; b=Vf9L8+HMombJODuda8JWFFwJKLQCsorBCORiA3GcR6G8sb+kQcfoRqPX5ycYSWb3aL5nqu LImjjxvVJilLYPEpQMtFBJkyEfLmM+zCJPi3ja4eUbdJ0mwmSV7HWIaCzdnUHI84hd6XWM dIh95x5X/FI2VCGt2+OPWvU24yxmOH0= Received: from mail-oo1-f70.google.com (mail-oo1-f70.google.com [209.85.161.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-518-sH1FZNpIMNmS6cI59KuzqQ-1; Tue, 29 Oct 2024 01:52:42 -0400 X-MC-Unique: sH1FZNpIMNmS6cI59KuzqQ-1 Received: by mail-oo1-f70.google.com with SMTP id 006d021491bc7-5ebb90bcb4eso4440855eaf.2 for ; Mon, 28 Oct 2024 22:52:42 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1730181161; x=1730785961; 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=zu6hE/UbIftfaQR7QgBZda/S19K5fTxOQ48ZhHGy+/E=; b=BhR5eag5Zc1SU4d0otAm6C3WCg152A9e0d90X473ZrPFiE5WHYJDNHqTze/CKl7SD1 +T/lAQ3HESi7RRf/uu/p5+JigNZcr+S8s4AS3aT3ATKEwwQvbjILcO2rezcmZ0XeuaL1 E35GoDaSEX/dhWDEAk5SgsF+8BiqluDR9XH4Qje8M8XqPq37czVgWSfbyXI4EqBZMjJ+ YARLY97KPszYUgz+tBg442EXDlZ71KHS7R8OjiracRjt465+3tfAovMwU1Mc1UHez4p6 V5wnVYD+FpqISyH2U3acKWRLIhaAuGWfh3YV4YvLAXb3owqigBNfSls3UQ/fT8owM9qg 1YDQ== X-Gm-Message-State: AOJu0YxhNSo1wq0/1Px48wNP03RLmrN0athiyOnPus+1JBiDpRZK6//1 hk1WT3URzTaskEdyEFUXP1tgwpx54sz+HQ7Thsys8rNLEcVmpEbTis6FHbJ9sJTS4heAf0Rz3OW Gc24K8I2cE8Nqf8U/5yPsKwoRNTElNtnsEIHA0NAJezHwmuAgGYQwkGRvm5YuAZVHG+fejtFLw5 H7y6oU8n9fCGydXp9/2MdEuaq21PBH2zlyCtsslxqP5RMU X-Received: by 2002:a05:6358:70e:b0:1c3:d56f:75d5 with SMTP id e5c5f4694b2df-1c3f9ebd7bamr405153455d.12.1730181161240; Mon, 28 Oct 2024 22:52:41 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFIeyDZ4qibE0q70t5rCmLQFuJDwF14hYHZlaTWK1aizOjK1w3KufvbIODFSuq+EGJJ77esMg== X-Received: by 2002:a05:6358:70e:b0:1c3:d56f:75d5 with SMTP id e5c5f4694b2df-1c3f9ebd7bamr405151255d.12.1730181158544; Mon, 28 Oct 2024 22:52:38 -0700 (PDT) Received: from localhost ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-7edc8679ce9sm6759853a12.29.2024.10.28.22.52.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 28 Oct 2024 22:52:38 -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 , Jan Pazdziora , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Greg KH , Vivek Goyal Subject: [PATCH v6 2/7] crash_dump: make dm crypt keys persist for the kdump kernel Date: Tue, 29 Oct 2024 13:52:15 +0800 Message-ID: <20241029055223.210039-3-coxu@redhat.com> X-Mailer: git-send-email 2.47.0 In-Reply-To: <20241029055223.210039-1-coxu@redhat.com> References: <20241029055223.210039-1-coxu@redhat.com> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20241028_225245_357276_16EAABDB X-CRM114-Status: GOOD ( 24.66 ) X-BeenThere: kexec@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "kexec" Errors-To: kexec-bounces+kexec=archiver.kernel.org@lists.infradead.org QSBjb25maWdmcyAvc3lzL2tlcm5lbC9jb25maWcvY3Jhc2hfZG1fY3J5cHRfa2V5cyBpcyBwcm92 aWRlZCBmb3IgdXNlcgpzcGFjZSB0byBtYWtlIHRoZSBkbSBjcnlwdCBrZXlzIHBlcnNpc3QgZm9y IHRoZSBrZHVtcCBrZXJuZWwuIFRha2UgdGhlCmNhc2Ugb2YgZHVtcGluZyB0byBhIExVS1MtZW5j cnlwdGVkIHRhcmdldCBhcyBhbiBleGFtcGxlLCBoZXJlIGlzIHRoZQpsaWZlIGN5Y2xlIG9mIHRo ZSBrZHVtcCBjb3BpZXMgb2YgTFVLUyB2b2x1bWUga2V5cywKCiAxLiBBZnRlciB0aGUgMXN0IGtl cm5lbCBsb2FkcyB0aGUgaW5pdHJhbWZzIGR1cmluZyBib290LCBzeXN0ZW1kIHVzZXMKICAgIGFu IHVzZXItaW5wdXQgcGFzc3BocmFzZSB0byBkZS1jcnlwdCB0aGUgTFVLUyB2b2x1bWUga2V5cyBv ciBzaW1wbHkKICAgIFRQTS1zZWFsZWQgdm9sdW1lIGtleXMgYW5kIHRoZW4gc2F2ZSB0aGUgdm9s dW1lIGtleXMgdG8gc3BlY2lmaWVkCiAgICBrZXlyaW5nICh1c2luZyB0aGUgLS1saW5rLXZrLXRv LWtleXJpbmcgQVBJKSBhbmQgdGhlIGtleXMgd2lsbCBleHBpcmUKICAgIHdpdGhpbiBzcGVjaWZp ZWQgdGltZS4KCiAyLiBBIHVzZXIgc3BhY2UgdG9vbCAoa2R1bXAgaW5pdHJhbWZzIGxvYWRlciBs aWtlIGtkdW1wLXV0aWxzKSBjcmVhdGUKICAgIGtleSBpdGVtcyBpbnNpZGUgL3N5cy9rZXJuZWwv Y29uZmlnL2NyYXNoX2RtX2NyeXB0X2tleXMgdG8gaW5mb3JtCiAgICB0aGUgMXN0IGtlcm5lbCB3 aGljaCBrZXlzIGFyZSBuZWVkZWQuCgogMy4gV2hlbiB0aGUga2R1bXAgaW5pdHJhbWZzIGlzIGxv YWRlZCBieSB0aGUga2V4ZWNfZmlsZV9sb2FkCiAgICBzeXNjYWxsLCB0aGUgMXN0IGtlcm5lbCB3 aWxsIGl0ZXJhdGUgY3JlYXRlZCBrZXkgaXRlbXMsIHNhdmUgdGhlCiAgICBrZXlzIHRvIGtkdW1w IHJlc2VydmVkIG1lbW9yeS4KCiA0LiBXaGVuIHRoZSAxc3Qga2VybmVsIGNyYXNoZXMgYW5kIHRo ZSBrZHVtcCBpbml0cmFtZnMgaXMgYm9vdGVkLCB0aGUKICAgIGtkdW1wIGluaXRyYW1mcyBhc2tz IHRoZSBrZHVtcCBrZXJuZWwgdG8gY3JlYXRlIGEgdXNlciBrZXkgdXNpbmcgdGhlCiAgICBrZXkg c3RvcmVkIGluIGtkdW1wIHJlc2VydmVkIG1lbW9yeSBieSB3cml0aW5nIHllcyB0bwogICAgL3N5 cy9rZXJuZWwvY3Jhc2hfZG1fY3J5cHRfa2V5cy9yZXN0b3JlLiBUaGVuIHRoZSBMVUtTIGVuY3J5 cHRlZAogICAgZGV2aWNlIGlzIHVubG9ja2VkIHdpdGggbGliY3J5cHRzZXR1cCdzIC0tdm9sdW1l LWtleS1rZXlyaW5nIEFQSS4KCiA1LiBUaGUgc3lzdGVtIGdldHMgcmVib290ZWQgdG8gdGhlIDFz dCBrZXJuZWwgYWZ0ZXIgZHVtcGluZyB2bWNvcmUgdG8KICAgIHRoZSBMVUtTIGVuY3J5cHRlZCBk ZXZpY2UgaXMgZmluaXNoZWQKCkV2ZW50dWFsbHkgdGhlIGtleXMgaGF2ZSB0byBzdGF5IGluIHRo ZSBrZHVtcCByZXNlcnZlZCBtZW1vcnkgZm9yIHRoZQprZHVtcCBrZXJuZWwgdG8gdW5sb2NrIGVu Y3J5cHRlZCB2b2x1bWVzLiBEdXJpbmcgdGhpcyBwcm9jZXNzLCBzb21lCm1lYXN1cmVzIGxpa2Ug bGV0dGluZyB0aGUga2V5cyBleHBpcmUgd2l0aGluZyBzcGVjaWZpZWQgdGltZSBhcmUKZGVzaXJh YmxlIHRvIHJlZHVjZSBzZWN1cml0eSByaXNrLgoKVGhpcyBwYXRjaCBhc3N1bWVzLAoxKSB0aGVy ZSBhcmUgMTI4IExVS1MgZGV2aWNlcyBhdCBtYXhpbXVtIHRvIGJlIHVubG9ja2VkIHRodXMgTUFY X0tFWV9OVU09MTI4LgoyKSBhIGtleSBkZXNjcmlwdGlvbiB3b24ndCBleGNlZWQgMTI4IGJ5dGVz IHRodXMgS0VZX0RFU0NfTUFYX0xFTj0xMjguCgpBbmQgaGVyZSBpcyBhIGRlbW8gb24gaG93IHRv IGludGVyYWN0IHdpdGgKL3N5cy9rZXJuZWwvY29uZmlnL2NyYXNoX2RtX2NyeXB0X2tleXMsCgog ICAgIyBBZGQga2V5ICMxCiAgICBta2RpciAvc3lzL2tlcm5lbC9jb25maWcvY3Jhc2hfZG1fY3J5 cHRfa2V5cy83ZDI2YjdiNC1lMzQyLTRkMmQtYjY2MC03NDI2YjA5OTY3MjAKICAgICMgQWRkIGtl eSAjMSdzIGRlc2NyaXB0aW9uCiAgICBlY2hvIGNyeXB0c2V0dXA6N2QyNmI3YjQtZTM0Mi00ZDJk LWI2NjAtNzQyNmIwOTk2NzIwID4gL3N5cy9rZXJuZWwvY29uZmlnL2NyYXNoX2RtX2NyeXB0X2tl eXMvZGVzY3JpcHRpb24KCiAgICAjIGhvdyBtYW55IGtleXMgZG8gd2UgaGF2ZSBub3c/CiAgICBj YXQgL3N5cy9rZXJuZWwvY29uZmlnL2NyYXNoX2RtX2NyeXB0X2tleXMvY291bnQKICAgIDEKCiAg ICAjIEFkZCBrZXkjMiBpbiB0aGUgc2FtZSB3YXkKCiAgICAjIGhvdyBtYW55IGtleXMgZG8gd2Ug aGF2ZSBub3c/CiAgICBjYXQgL3N5cy9rZXJuZWwvY29uZmlnL2NyYXNoX2RtX2NyeXB0X2tleXMv Y291bnQKICAgIDIKCiAgICAjIHRoZSB0cmVlIHN0cnVjdHVyZSBvZiAvY3Jhc2hfZG1fY3J5cHRf a2V5cyBjb25maWdmcwogICAgdHJlZSAvc3lzL2tlcm5lbC9jb25maWcvY3Jhc2hfZG1fY3J5cHRf a2V5cy8KICAgIC9zeXMva2VybmVsL2NvbmZpZy9jcmFzaF9kbV9jcnlwdF9rZXlzLwogICAg4pSc 4pSA4pSAIDdkMjZiN2I0LWUzNDItNGQyZC1iNjYwLTc0MjZiMDk5NjcyMAogICAg4pSCwqDCoCDi lJTilIDilIAgZGVzY3JpcHRpb24KICAgIOKUnOKUgOKUgCBjb3VudAogICAg4pSc4pSA4pSAIGZj ZTJjZDM4LTRkNTktNDMxNy04Y2UyLTFmZDI0ZDUyYzQ2YQogICAg4pSCwqDCoCDilJTilIDilIAg ZGVzY3JpcHRpb24KClNpZ25lZC1vZmYtYnk6IENvaWJ5IFh1IDxjb3h1QHJlZGhhdC5jb20+Ci0t LQoga2VybmVsL0tjb25maWcua2V4ZWMgICAgICAgICB8ICAgOSArKwoga2VybmVsL01ha2VmaWxl ICAgICAgICAgICAgICB8ICAgMSArCiBrZXJuZWwvY3Jhc2hfZHVtcF9kbV9jcnlwdC5jIHwgMTU0 ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDE2 NCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQga2VybmVsL2NyYXNoX2R1bXBfZG1f Y3J5cHQuYwoKZGlmZiAtLWdpdCBhL2tlcm5lbC9LY29uZmlnLmtleGVjIGIva2VybmVsL0tjb25m aWcua2V4ZWMKaW5kZXggNmMzNGU2M2M4OGZmLi4xMzQ5ODc4ZDY1NjUgMTAwNjQ0Ci0tLSBhL2tl cm5lbC9LY29uZmlnLmtleGVjCisrKyBiL2tlcm5lbC9LY29uZmlnLmtleGVjCkBAIC0xMTYsNiAr MTE2LDE1IEBAIGNvbmZpZyBDUkFTSF9EVU1QCiAJICBGb3IgczM5MCwgdGhpcyBvcHRpb24gYWxz byBlbmFibGVzIHpmY3BkdW1wLgogCSAgU2VlIGFsc28gPGZpbGU6RG9jdW1lbnRhdGlvbi9hcmNo L3MzOTAvemZjcGR1bXAucnN0PgogCitjb25maWcgQ1JBU0hfRE1fQ1JZUFQKKwlib29sICJTdXBw b3J0IHNhdmluZyBjcmFzaCBkdW1wIHRvIGRtLWNyeXB0IGVuY3J5cHRlZCB2b2x1bWUiCisJZGVw ZW5kcyBvbiBDUkFTSF9EVU1QCisJZGVwZW5kcyBvbiBETV9DUllQVAorCWhlbHAKKwkgIFdpdGgg dGhpcyBvcHRpb24gZW5hYmxlZCwgdXNlciBzcGFjZSBjYW4gaW50ZXJlYWN0IHdpdGgKKwkgIC9z eXMva2VybmVsL2NvbmZpZy9jcmFzaF9kbV9jcnlwdF9rZXlzIHRvIG1ha2UgdGhlIGRtIGNyeXB0 IGtleXMKKwkgIHBlcnNpc3RlbnQgZm9yIHRoZSBjcmFzaCBkdW1wIGtlcm5lbC4KKwogY29uZmln IENSQVNIX0hPVFBMVUcKIAlib29sICJVcGRhdGUgdGhlIGNyYXNoIGVsZmNvcmVoZHIgb24gc3lz dGVtIGNvbmZpZ3VyYXRpb24gY2hhbmdlcyIKIAlkZWZhdWx0IHkKZGlmZiAtLWdpdCBhL2tlcm5l bC9NYWtlZmlsZSBiL2tlcm5lbC9NYWtlZmlsZQppbmRleCA4Nzg2NmIwMzdmYmUuLjlkMWNhYmYx ZWM0NiAxMDA2NDQKLS0tIGEva2VybmVsL01ha2VmaWxlCisrKyBiL2tlcm5lbC9NYWtlZmlsZQpA QCAtNzIsNiArNzIsNyBAQCBvYmotJChDT05GSUdfVk1DT1JFX0lORk8pICs9IHZtY29yZV9pbmZv Lm8gZWxmY29yZWhkci5vCiBvYmotJChDT05GSUdfQ1JBU0hfUkVTRVJWRSkgKz0gY3Jhc2hfcmVz ZXJ2ZS5vCiBvYmotJChDT05GSUdfS0VYRUNfQ09SRSkgKz0ga2V4ZWNfY29yZS5vCiBvYmotJChD T05GSUdfQ1JBU0hfRFVNUCkgKz0gY3Jhc2hfY29yZS5vCitvYmotJChDT05GSUdfQ1JBU0hfRE1f Q1JZUFQpICs9IGNyYXNoX2R1bXBfZG1fY3J5cHQubwogb2JqLSQoQ09ORklHX0tFWEVDKSArPSBr ZXhlYy5vCiBvYmotJChDT05GSUdfS0VYRUNfRklMRSkgKz0ga2V4ZWNfZmlsZS5vCiBvYmotJChD T05GSUdfS0VYRUNfRUxGKSArPSBrZXhlY19lbGYubwpkaWZmIC0tZ2l0IGEva2VybmVsL2NyYXNo X2R1bXBfZG1fY3J5cHQuYyBiL2tlcm5lbC9jcmFzaF9kdW1wX2RtX2NyeXB0LmMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi42MmEzYzQ3ZDhiM2IKLS0tIC9kZXYvbnVs bAorKysgYi9rZXJuZWwvY3Jhc2hfZHVtcF9kbV9jcnlwdC5jCkBAIC0wLDAgKzEsMTU0IEBACisv LyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CisjaW5jbHVkZSA8a2V5cy91 c2VyLXR5cGUuaD4KKyNpbmNsdWRlIDxsaW51eC9jcmFzaF9kdW1wLmg+CisjaW5jbHVkZSA8bGlu dXgvY29uZmlnZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKworI2RlZmluZSBLRVlf TlVNX01BWCAxMjgJLyogbWF4aW11bSBkbSBjcnlwdCBrZXlzICovCisjZGVmaW5lIEtFWV9ERVND X01BWF9MRU4gMTI4CS8qIG1heGltdW0gZG0gY3J5cHQga2V5IGRlc2NyaXB0aW9uIHNpemUgKi8K Kworc3RhdGljIHVuc2lnbmVkIGludCBrZXlfY291bnQ7CisKK3N0cnVjdCBjb25maWdfa2V5IHsK KwlzdHJ1Y3QgY29uZmlnX2l0ZW0gaXRlbTsKKwljb25zdCBjaGFyICpkZXNjcmlwdGlvbjsKK307 CisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IGNvbmZpZ19rZXkgKnRvX2NvbmZpZ19rZXkoc3RydWN0 IGNvbmZpZ19pdGVtICppdGVtKQoreworCXJldHVybiBjb250YWluZXJfb2YoaXRlbSwgc3RydWN0 IGNvbmZpZ19rZXksIGl0ZW0pOworfQorCitzdGF0aWMgc3NpemVfdCBjb25maWdfa2V5X2Rlc2Ny aXB0aW9uX3Nob3coc3RydWN0IGNvbmZpZ19pdGVtICppdGVtLCBjaGFyICpwYWdlKQoreworCXJl dHVybiBzcHJpbnRmKHBhZ2UsICIlc1xuIiwgdG9fY29uZmlnX2tleShpdGVtKS0+ZGVzY3JpcHRp b24pOworfQorCitzdGF0aWMgc3NpemVfdCBjb25maWdfa2V5X2Rlc2NyaXB0aW9uX3N0b3JlKHN0 cnVjdCBjb25maWdfaXRlbSAqaXRlbSwKKwkJCQkJICAgIGNvbnN0IGNoYXIgKnBhZ2UsIHNpemVf dCBjb3VudCkKK3sKKwlzdHJ1Y3QgY29uZmlnX2tleSAqY29uZmlnX2tleSA9IHRvX2NvbmZpZ19r ZXkoaXRlbSk7CisJc2l6ZV90IGxlbjsKKwlpbnQgcmV0OworCisJcmV0ID0gLUVJTlZBTDsKKwls ZW4gPSBzdHJjc3BuKHBhZ2UsICJcbiIpOworCisJaWYgKGxlbiA+IEtFWV9ERVNDX01BWF9MRU4p IHsKKwkJcHJfZXJyKCJUaGUga2V5IGRlc2NyaXB0aW9uIHNob3VsZG4ndCBleGNlZWQgJXUgY2hh cmFjdGVycyIsIEtFWV9ERVNDX01BWF9MRU4pOworCQlyZXR1cm4gcmV0OworCX0KKworCWlmICgh bGVuKQorCQlyZXR1cm4gcmV0OworCisJa2ZyZWUoY29uZmlnX2tleS0+ZGVzY3JpcHRpb24pOwor CXJldCA9IC1FTk9NRU07CisJY29uZmlnX2tleS0+ZGVzY3JpcHRpb24gPSBrbWVtZHVwX251bChw YWdlLCBsZW4sIEdGUF9LRVJORUwpOworCWlmICghY29uZmlnX2tleS0+ZGVzY3JpcHRpb24pCisJ CXJldHVybiByZXQ7CisKKwlyZXR1cm4gY291bnQ7Cit9CisKK0NPTkZJR0ZTX0FUVFIoY29uZmln X2tleV8sIGRlc2NyaXB0aW9uKTsKKworc3RhdGljIHN0cnVjdCBjb25maWdmc19hdHRyaWJ1dGUg KmNvbmZpZ19rZXlfYXR0cnNbXSA9IHsKKwkmY29uZmlnX2tleV9hdHRyX2Rlc2NyaXB0aW9uLAor CU5VTEwsCit9OworCitzdGF0aWMgdm9pZCBjb25maWdfa2V5X3JlbGVhc2Uoc3RydWN0IGNvbmZp Z19pdGVtICppdGVtKQoreworCWtmcmVlKHRvX2NvbmZpZ19rZXkoaXRlbSkpOworCWtleV9jb3Vu dC0tOworfQorCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX2l0ZW1fb3BlcmF0aW9ucyBjb25maWdf a2V5X2l0ZW1fb3BzID0geworCS5yZWxlYXNlID0gY29uZmlnX2tleV9yZWxlYXNlLAorfTsKKwor c3RhdGljIGNvbnN0IHN0cnVjdCBjb25maWdfaXRlbV90eXBlIGNvbmZpZ19rZXlfdHlwZSA9IHsK KwkuY3RfaXRlbV9vcHMgPSAmY29uZmlnX2tleV9pdGVtX29wcywKKwkuY3RfYXR0cnMgPSBjb25m aWdfa2V5X2F0dHJzLAorCS5jdF9vd25lciA9IFRISVNfTU9EVUxFLAorfTsKKworc3RhdGljIHN0 cnVjdCBjb25maWdfaXRlbSAqY29uZmlnX2tleXNfbWFrZV9pdGVtKHN0cnVjdCBjb25maWdfZ3Jv dXAgKmdyb3VwLAorCQkJCQkJIGNvbnN0IGNoYXIgKm5hbWUpCit7CisJc3RydWN0IGNvbmZpZ19r ZXkgKmNvbmZpZ19rZXk7CisKKwlpZiAoa2V5X2NvdW50ID4gS0VZX05VTV9NQVgpIHsKKwkJcHJf ZXJyKCJPbmx5ICV1IGtleXMgYXQgbWF4aW11bSB0byBiZSBjcmVhdGVkXG4iLCBLRVlfTlVNX01B WCk7CisJCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworCX0KKworCWNvbmZpZ19rZXkgPSBremFs bG9jKHNpemVvZihzdHJ1Y3QgY29uZmlnX2tleSksIEdGUF9LRVJORUwpOworCWlmICghY29uZmln X2tleSkKKwkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisKKwljb25maWdfaXRlbV9pbml0X3R5 cGVfbmFtZSgmY29uZmlnX2tleS0+aXRlbSwgbmFtZSwgJmNvbmZpZ19rZXlfdHlwZSk7CisKKwlr ZXlfY291bnQrKzsKKworCXJldHVybiAmY29uZmlnX2tleS0+aXRlbTsKK30KKworc3RhdGljIHNz aXplX3QgY29uZmlnX2tleXNfY291bnRfc2hvdyhzdHJ1Y3QgY29uZmlnX2l0ZW0gKml0ZW0sIGNo YXIgKnBhZ2UpCit7CisJcmV0dXJuIHNwcmludGYocGFnZSwgIiVkXG4iLCBrZXlfY291bnQpOwor fQorCitDT05GSUdGU19BVFRSX1JPKGNvbmZpZ19rZXlzXywgY291bnQpOworCitzdGF0aWMgc3Ry dWN0IGNvbmZpZ2ZzX2F0dHJpYnV0ZSAqY29uZmlnX2tleXNfYXR0cnNbXSA9IHsKKwkmY29uZmln X2tleXNfYXR0cl9jb3VudCwKKwlOVUxMLAorfTsKKworLyoKKyAqIE5vdGUgdGhhdCwgc2luY2Ug bm8gZXh0cmEgd29yayBpcyByZXF1aXJlZCBvbiAtPmRyb3BfaXRlbSgpLAorICogbm8gLT5kcm9w X2l0ZW0oKSBpcyBwcm92aWRlZC4KKyAqLworc3RhdGljIHN0cnVjdCBjb25maWdmc19ncm91cF9v cGVyYXRpb25zIGNvbmZpZ19rZXlzX2dyb3VwX29wcyA9IHsKKwkubWFrZV9pdGVtID0gY29uZmln X2tleXNfbWFrZV9pdGVtLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBjb25maWdfaXRlbV90 eXBlIGNvbmZpZ19rZXlzX3R5cGUgPSB7CisJLmN0X2dyb3VwX29wcyA9ICZjb25maWdfa2V5c19n cm91cF9vcHMsCisJLmN0X2F0dHJzID0gY29uZmlnX2tleXNfYXR0cnMsCisJLmN0X293bmVyID0g VEhJU19NT0RVTEUsCit9OworCitzdGF0aWMgc3RydWN0IGNvbmZpZ2ZzX3N1YnN5c3RlbSBjb25m aWdfa2V5c19zdWJzeXMgPSB7CisJLnN1X2dyb3VwID0geworCQkuY2dfaXRlbSA9IHsKKwkJCS5j aV9uYW1lYnVmID0gImNyYXNoX2RtX2NyeXB0X2tleXMiLAorCQkJLmNpX3R5cGUgPSAmY29uZmln X2tleXNfdHlwZSwKKwkJfSwKKwl9LAorfTsKKworc3RhdGljIGludCBfX2luaXQgY29uZmlnZnNf ZG1jcnlwdF9rZXlzX2luaXQodm9pZCkKK3sKKwlpbnQgcmV0OworCisJY29uZmlnX2dyb3VwX2lu aXQoJmNvbmZpZ19rZXlzX3N1YnN5cy5zdV9ncm91cCk7CisJbXV0ZXhfaW5pdCgmY29uZmlnX2tl eXNfc3Vic3lzLnN1X211dGV4KTsKKwlyZXQgPSBjb25maWdmc19yZWdpc3Rlcl9zdWJzeXN0ZW0o JmNvbmZpZ19rZXlzX3N1YnN5cyk7CisJaWYgKHJldCkgeworCQlwcl9lcnIoIkVycm9yICVkIHdo aWxlIHJlZ2lzdGVyaW5nIHN1YnN5c3RlbSAlc1xuIiwgcmV0LAorCQkgICAgICAgY29uZmlnX2tl eXNfc3Vic3lzLnN1X2dyb3VwLmNnX2l0ZW0uY2lfbmFtZWJ1Zik7CisJCWdvdG8gb3V0X3VucmVn aXN0ZXI7CisJfQorCisJcmV0dXJuIDA7CisKK291dF91bnJlZ2lzdGVyOgorCWNvbmZpZ2ZzX3Vu cmVnaXN0ZXJfc3Vic3lzdGVtKCZjb25maWdfa2V5c19zdWJzeXMpOworCisJcmV0dXJuIHJldDsK K30KKworbW9kdWxlX2luaXQoY29uZmlnZnNfZG1jcnlwdF9rZXlzX2luaXQpOwotLSAKMi40Ny4w CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18Ka2V4ZWMg bWFpbGluZyBsaXN0CmtleGVjQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJh ZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9rZXhlYwo= From mboxrd@z Thu Jan 1 00:00:00 1970 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 B9D5F20101C for ; Tue, 29 Oct 2024 05:52:47 +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=1730181170; cv=none; b=A/SDifYuTvm+44sBVgx1h3oHUPFUj2j7/5bilKLRjbHNxnOza4GU3LgdsChsGlpDAAikKEI951eCcWncoLelTzmod+2FECHbg2WclBBeVwWcqRi5HRINJJcfOpjOZCZGMkaUvvd0DTGbafBpRAilq5nQMODus9F0GJY7Lit4PnA= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730181170; c=relaxed/simple; bh=PvqoVwtrQdEEGP9Jzyf0mJOhNlqbvegQzqnz0S/J1CU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=fXbAHQMQdtplLo4akprLYbW22Rw1e1ZtjXySb2drW3cSsDCs9v74Su55MEiX/rwzmkA6Noedcw8UqKNRZF1N4VtlyHq0Qz8EwM0XT4C9KkUIiBkjlGfiJ56jp6fXkfxrHnOjhJhhQ6w5e13iTvU3gOXk63XdagLTD3oM285+iPU= 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=ilByqf1z; 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="ilByqf1z" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1730181166; 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=zu6hE/UbIftfaQR7QgBZda/S19K5fTxOQ48ZhHGy+/E=; b=ilByqf1zdCoe9483CEoyMufMrHSov4QEyHAF+smkCRaVGYDNxS/KxbbPlme0odbouSZlde KYyN4N41WJo36zctdQSXfkVgtmHxZGDayOfcme5HKGs+t1iCZ9ZQtYEJ9xaLroHH03EV43 BgOAPns8SjDL7Dyn15LUA07kPgXfbXU= Received: from mail-oo1-f70.google.com (mail-oo1-f70.google.com [209.85.161.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-691-0gRLHU5cMLioA0eCLKv0lw-1; Tue, 29 Oct 2024 01:52:39 -0400 X-MC-Unique: 0gRLHU5cMLioA0eCLKv0lw-1 Received: by mail-oo1-f70.google.com with SMTP id 006d021491bc7-5ebb90bcb4eso4440833eaf.2 for ; Mon, 28 Oct 2024 22:52:39 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1730181159; x=1730785959; 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=zu6hE/UbIftfaQR7QgBZda/S19K5fTxOQ48ZhHGy+/E=; b=YTF0o9NHDg4hkzZO0WOioFFmeInIlDc7iGFyV2w9SRlvU18qdtNeIGRixeyCvlqNPq UNBrbuwmBFAERC4GiSIqCIT+i/SBQmNDYyV3O5q91PDjQyDIYThyo9clzJpxAXmeFCsS cOwUJKv2zN4yvJ9bDJIt1gUk+zFZuOFTLd4WQRbxDeCa+XjzASWuQHIB3jA1GNsGK3n+ Zke9zWbTP8BG7XJVxmvRY4r/KMuDmnpdy6Ri1C7LfZIZD5KrylN362FO91C9MuJaRlZM /Rbb4ct5+X2lJUF55BonAmX4Ssmc9gWA+qtejCmPxU6urEPDKT73qEdk4gGXx23KQylT ONQA== X-Forwarded-Encrypted: i=1; AJvYcCUEPUVgN0EmYrP1J8wgfNkduy/q/WfxsMEXEwTT5ubEFOfrJXgqfF0nfTBvEZoeyZcLzmkNWnOhAmK8684=@vger.kernel.org X-Gm-Message-State: AOJu0YzVYK+RI+Tz8Kp7dMBO8Y2z4DEKQz7vmdClmmYw8pKbB/CqSPl5 n7mu0X8hRYk3s6CLtlPhgUWfHdOYhAPtAEv6TIk4d5ohKTllaT3Xqz5IR2r2hr1r0SscusrTfLc l+FNLO7UbBrkXtY4tv6wdH2j24YQ9NkQhKW4uFpgI4ERNtuUT88UyO8YTxkxm/w== X-Received: by 2002:a05:6358:70e:b0:1c3:d56f:75d5 with SMTP id e5c5f4694b2df-1c3f9ebd7bamr405152255d.12.1730181158955; Mon, 28 Oct 2024 22:52:38 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFIeyDZ4qibE0q70t5rCmLQFuJDwF14hYHZlaTWK1aizOjK1w3KufvbIODFSuq+EGJJ77esMg== X-Received: by 2002:a05:6358:70e:b0:1c3:d56f:75d5 with SMTP id e5c5f4694b2df-1c3f9ebd7bamr405151255d.12.1730181158544; Mon, 28 Oct 2024 22:52:38 -0700 (PDT) Received: from localhost ([43.228.180.230]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-7edc8679ce9sm6759853a12.29.2024.10.28.22.52.35 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 28 Oct 2024 22:52:38 -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 , Jan Pazdziora , Pingfan Liu , Baoquan He , Dave Young , linux-kernel@vger.kernel.org, x86@kernel.org, Dave Hansen , Vitaly Kuznetsov , Greg KH , Vivek Goyal Subject: [PATCH v6 2/7] crash_dump: make dm crypt keys persist for the kdump kernel Date: Tue, 29 Oct 2024 13:52:15 +0800 Message-ID: <20241029055223.210039-3-coxu@redhat.com> X-Mailer: git-send-email 2.47.0 In-Reply-To: <20241029055223.210039-1-coxu@redhat.com> References: <20241029055223.210039-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: 8bit 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 withing 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=128. 2) a key description won't exceed 128 bytes thus KEY_DESC_MAX_LEN=128. 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-7426b0996720 # Add key #1's description echo cryptsetup:7d26b7b4-e342-4d2d-b660-7426b0996720 > /sys/kernel/config/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/ ├── 7d26b7b4-e342-4d2d-b660-7426b0996720 │   └── description ├── count ├── fce2cd38-4d59-4317-8ce2-1fd24d52c46a │   └── description Signed-off-by: Coiby Xu --- kernel/Kconfig.kexec | 9 ++ kernel/Makefile | 1 + kernel/crash_dump_dm_crypt.c | 154 +++++++++++++++++++++++++++++++++++ 3 files changed, 164 insertions(+) create mode 100644 kernel/crash_dump_dm_crypt.c diff --git a/kernel/Kconfig.kexec b/kernel/Kconfig.kexec index 6c34e63c88ff..1349878d6565 100644 --- a/kernel/Kconfig.kexec +++ b/kernel/Kconfig.kexec @@ -116,6 +116,15 @@ config CRASH_DUMP For s390, this option also enables zfcpdump. See also +config CRASH_DM_CRYPT + bool "Support saving crash dump to dm-crypt encrypted volume" + 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 crash dump 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) += vmcore_info.o elfcorehdr.o obj-$(CONFIG_CRASH_RESERVE) += crash_reserve.o obj-$(CONFIG_KEXEC_CORE) += kexec_core.o obj-$(CONFIG_CRASH_DUMP) += crash_core.o +obj-$(CONFIG_CRASH_DM_CRYPT) += crash_dump_dm_crypt.o obj-$(CONFIG_KEXEC) += kexec.o obj-$(CONFIG_KEXEC_FILE) += kexec_file.o obj-$(CONFIG_KEXEC_ELF) += 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 = to_config_key(item); + size_t len; + int ret; + + ret = -EINVAL; + len = strcspn(page, "\n"); + + if (len > KEY_DESC_MAX_LEN) { + pr_err("The key description shouldn't exceed %u characters", KEY_DESC_MAX_LEN); + return ret; + } + + if (!len) + return ret; + + kfree(config_key->description); + ret = -ENOMEM; + config_key->description = 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[] = { + &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 = { + .release = config_key_release, +}; + +static const struct config_item_type config_key_type = { + .ct_item_ops = &config_key_item_ops, + .ct_attrs = config_key_attrs, + .ct_owner = THIS_MODULE, +}; + +static struct config_item *config_keys_make_item(struct config_group *group, + 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 = 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[] = { + &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 = { + .make_item = config_keys_make_item, +}; + +static const struct config_item_type config_keys_type = { + .ct_group_ops = &config_keys_group_ops, + .ct_attrs = config_keys_attrs, + .ct_owner = THIS_MODULE, +}; + +static struct configfs_subsystem config_keys_subsys = { + .su_group = { + .cg_item = { + .ci_namebuf = "crash_dm_crypt_keys", + .ci_type = &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 = 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); -- 2.47.0