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 4412EC0032E for ; Fri, 20 Oct 2023 20:33:37 +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-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:From:References:Cc:To:Subject: MIME-Version:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=4jMTz9fxO74kUKiFE8a1KjwiayG6/neT//sS0Eh+Uew=; b=XrHz8LP5sVeGl4 SjM/sEHPTTqMMh4wCdlR6seD954U2gT/l5c2sNHARWA4hduDlcHqaV8PbTVWrXPfgaPHnCdquIi+0 +WJkHFYwS+jtqR2UnOQGAOmd7Mu0A3k22ipVdu+uCGuLEOPjHEE1F+ci1xNUSjc38E7qzprOohtvJ gmmJ756JvwrU3fsgpABaICnF7j0Bxa80QQbAV7VVHqsHW8ja9D6fsN7FABkalMmNKLEluam8+NrNM bTTlL/DEm2ncdgWsSavM2OPQsMR+z3qN9Hs2Hm9LJziKde160mQm/z+QZ6JpT6eiBFm1JyEbfMNqS xpvvdPmtSC+lS4MwZznw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qtwBZ-002z7u-0F; Fri, 20 Oct 2023 20:33:33 +0000 Received: from linux.microsoft.com ([13.77.154.182]) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qtwBV-002z7Y-2H for kexec@lists.infradead.org; Fri, 20 Oct 2023 20:33:31 +0000 Received: from [192.168.86.69] (unknown [50.46.228.62]) by linux.microsoft.com (Postfix) with ESMTPSA id 31AB820B74C0; Fri, 20 Oct 2023 13:33:26 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.11.0 linux.microsoft.com 31AB820B74C0 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.microsoft.com; s=default; t=1697834006; bh=5lwU68ggTpUd5Qazc3xwkaQiQeOdLttE6W0CAK60Opo=; h=Date:Subject:To:Cc:References:From:In-Reply-To:From; b=Uw1kKEqnN37zRIpncu4lwRIdRueUZYkLp77nUFbjbvzJr97szt6cv1Sdwv4lsDKlY YsC9ELPDr1/XEENEtLLAltrNFNgb6K7ZEUJRt/o+zJXTHNOIS7+yBW8OBMQPLlYk1z zTieTV4KjJDtoseVTX1TGqHV+kmDXZcE1EYHNjRE= Message-ID: <9b227c0a-ddb3-b1c3-4ed0-e3e740db7788@linux.microsoft.com> Date: Fri, 20 Oct 2023 13:33:25 -0700 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.15.1 Subject: Re: [PATCH v2 1/7] ima: refactor ima_dump_measurement_list to move memory allocation to a separate function Content-Language: en-US To: Stefan Berger , zohar@linux.ibm.com, ebiederm@xmission.com, noodles@fb.com, bauermann@kolabnow.com, kexec@lists.infradead.org, linux-integrity@vger.kernel.org Cc: code@tyhicks.com, nramas@linux.microsoft.com, paul@paul-moore.com References: <20231005182602.634615-1-tusharsu@linux.microsoft.com> <20231005182602.634615-2-tusharsu@linux.microsoft.com> <2c06f9c5-6f3a-b163-20ca-24178d7cba4e@linux.ibm.com> From: Tushar Sugandhi In-Reply-To: <2c06f9c5-6f3a-b163-20ca-24178d7cba4e@linux.ibm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231020_133329_867062_466B228D X-CRM114-Status: GOOD ( 41.31 ) 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-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "kexec" Errors-To: kexec-bounces+kexec=archiver.kernel.org@lists.infradead.org VGhhbmtzIGEgbG90IFN0ZWZhbiBmb3IgcmV2aWV3aW5nIHRoaXMgc2VyaWVzLgpSZWFsbHkgYXBw cmVjaWF0ZSBpdC4KCk9uIDEwLzEyLzIzIDE3OjI4LCBTdGVmYW4gQmVyZ2VyIHdyb3RlOgo+IAo+ IE9uIDEwLzUvMjMgMTQ6MjUsIFR1c2hhciBTdWdhbmRoaSB3cm90ZToKPj4gSU1BIGFsbG9jYXRl cyBtZW1vcnkgYW5kIGR1bXBzIHRoZSBtZWFzdXJlbWVudCBkdXJpbmcga2V4ZWMgc29mdCByZWJv b3QKPj4gYXMgYSBzaW5nbGUgZnVuY3Rpb24gY2FsbCBpbWFfZHVtcF9tZWFzdXJlbWVudF9saXN0 KCkuwqAgSXQgZ2V0cyBjYWxsZWQKPj4gZHVyaW5nIGtleGVjICdsb2FkJyBvcGVyYXRpb24uwqAg SXQgcmVzdWx0cyBpbiB0aGUgSU1BIG1lYXN1cmVtZW50cwo+PiBiZXR3ZWVuIHRoZSB3aW5kb3cg b2Yga2V4ZWMgJ2xvYWQnIGFuZCAnZXhlY3V0ZScgZ2V0dGluZyBkcm9wcGVkIHdoZW4gdGhlCj4+ IHN5c3RlbSBib290cyBpbnRvIHRoZSBuZXcgS2VybmVsLsKgIE9uZSBvZiB0aGUga2V4ZWMgcmVx dWlyZW1lbnRzIGlzIHRoZQo+PiBzZWdtZW50IHNpemUgY2Fubm90IGNoYW5nZSBiZXR3ZWVuIHRo ZSAnbG9hZCcgYW5kIHRoZSAnZXhlY3V0ZScuCj4+IFRoZXJlZm9yZSwgdG8gYWRkcmVzcyB0aGlz IHByb2JsZW0sIGltYV9kdW1wX21lYXN1cmVtZW50X2xpc3QoKSBuZWVkcwo+PiB0byBiZSByZWZh Y3RvcmVkIHRvIGFsbG9jYXRlIHRoZSBtZW1vcnkgYXQga2V4ZWMgJ2xvYWQnLCBhbmQgZHVtcCB0 aGUKPj4gbWVhc3VyZW1lbnRzIGF0IGtleGVjICdleGVjdXRlJy7CoCBUaGUgZnVuY3Rpb24gdGhh dCBhbGxvY2F0ZXMgdGhlIG1lbW9yeQo+PiBzaG91bGQgaGFuZGxlIHRoZSBzY2VuYXJpbyB3aGVy ZSB0aGUga2V4ZWMgbG9hZCBpcyBjYWxsZWQgbXVsdGlwbGUgdGltZXMuCj4+Cj4+IFJlZmFjdG9y IGltYV9kdW1wX21lYXN1cmVtZW50X2xpc3QoKSB0byBtb3ZlIHRoZSBtZW1vcnkgYWxsb2NhdGlv biBwYXJ0Cj4+IHRvIGEgc2VwYXJhdGUgZnVuY3Rpb24gaW1hX2FsbG9jX2tleGVjX2J1ZigpIHRv IGFsbG9jYXRlIGJ1ZmZlciBvZiBzaXplCj4+ICdrZXhlY19zZWdtZW50X3NpemUnIGF0IGtleGVj ICdsb2FkJy7CoCBNYWtlIHRoZSBsb2NhbCB2YXJpYWJsZXMgaW4KPj4gZnVuY3Rpb24gaW1hX2R1 bXBfbWVhc3VyZW1lbnRfbGlzdCgpIGdsb2JhbCwgc28gdGhhdCB0aGV5IGNhbiBiZSBhY2Nlc3Nl ZAo+PiBmcm9tIGltYV9hbGxvY19rZXhlY19idWYoKS7CoCBNYWtlIG5lY2Vzc2FyeSBjaGFuZ2Vz IHRvIHRoZSBmdW5jdGlvbgo+PiBpbWFfYWRkX2tleGVjX2J1ZmZlcigpIHRvIGNhbGwgdGhlIGFi b3ZlIHR3byBmdW5jdGlvbnMuCj4+Cj4+IFNpZ25lZC1vZmYtYnk6IFR1c2hhciBTdWdhbmRoaTx0 dXNoYXJzdUBsaW51eC5taWNyb3NvZnQuY29tPgo+PiAtLS0KPj4gwqAgc2VjdXJpdHkvaW50ZWdy aXR5L2ltYS9pbWFfa2V4ZWMuYyB8IDEyNiArKysrKysrKysrKysrKysrKysrKystLS0tLS0tLQo+ PiDCoCAxIGZpbGUgY2hhbmdlZCwgOTMgaW5zZXJ0aW9ucygrKSwgMzMgZGVsZXRpb25zKC0pCj4+ Cj4+IGRpZmYgLS1naXQgYS9zZWN1cml0eS9pbnRlZ3JpdHkvaW1hL2ltYV9rZXhlYy5jIAo+PiBi L3NlY3VyaXR5L2ludGVncml0eS9pbWEvaW1hX2tleGVjLmMKPj4gaW5kZXggNDE5ZGM0MDVjODMx Li4zMDdlMDc5OTE4NjUgMTAwNjQ0Cj4+IC0tLSBhL3NlY3VyaXR5L2ludGVncml0eS9pbWEvaW1h X2tleGVjLmMKPj4gKysrIGIvc2VjdXJpdHkvaW50ZWdyaXR5L2ltYS9pbWFfa2V4ZWMuYwo+PiBA QCAtMTUsNjEgKzE1LDExNCBAQAo+PiDCoCAjaW5jbHVkZSAiaW1hLmgiCj4+IMKgICNpZmRlZiBD T05GSUdfSU1BX0tFWEVDCj4+ICtzdHJ1Y3Qgc2VxX2ZpbGUgaW1hX2tleGVjX2ZpbGU7Cj4+ICtz dHJ1Y3QgaW1hX2tleGVjX2hkciBpbWFfa2hkcjsKPiAKPiBTaW5jZSB5b3UgYXJlIG9ubHkgcG9w dWxhdGluZyB0aGUgYnVmZmVyIGF0IGtleGVjICdleGVjdXRlJyB0aW1lLCB5b3UgCj4gc2hvdWxk IGJlIGFibGUgdG8gbW92ZSB0aGlzIGhlYWRlciBpbnRvIHRoZSBmdW5jdGlvbiB3aGVyZSBpdCBp cyBuZWVkZWQuCj4gCll1cCwgaW1hX2toZHIgZG9lc24ndCBuZWVkIHRvIGJlIHN0YXRpYy4gV2ls bCBmaXguCj4gCj4+ICsKPj4gK3ZvaWQgaW1hX2NsZWFyX2tleGVjX2ZpbGUodm9pZCkKPj4gK3sK Pj4gK8KgwqDCoCB2ZnJlZShpbWFfa2V4ZWNfZmlsZS5idWYpOwo+IEkgd291bGQgcGFzcyB0aGUg aW1hX2tleGVjX2ZpbGUgb250byB0aGlzIGZ1bmN0aW9uIGhlcmUgYXMgYSBwYXJhbWV0ZXIgCj4g cmF0aGVyIHRoYW4gYWNjZXNzaW5nIHRoZSBmaWxlLXN0YXRpYyB2YXJpYWJsZS4gSSBmaW5kIHRo aXMgYmV0dGVyIHRvIAo+IHJlYWQgb25jZSB5b3UgbG9vayBhdCBpbWFfY2xlYXJfa2V4ZWNfZmls ZSgpIGZ1cnRoZXIgYmVsb3cgYW5kIHdvbmRlciAKPiB3aHkgaXQgZG9lc24ndCB0YWtlIGEgcGFy YW1ldGVyLgpBZ3JlZWQuIFRoaXMgd2lsbCBtYWtlIHRoZSBjb2RlIG1vcmUgcmVhZGFibGUuCgo+ PiArwqDCoMKgIGltYV9rZXhlY19maWxlLmJ1ZiA9IE5VTEw7Cj4+ICvCoMKgwqAgaW1hX2tleGVj X2ZpbGUuc2l6ZSA9IDA7Cj4+ICvCoMKgwqAgaW1hX2tleGVjX2ZpbGUucmVhZF9wb3MgPSAwOwo+ PiArwqDCoMKgIGltYV9rZXhlY19maWxlLmNvdW50ID0gMDsKPj4gK30KPj4gKwo+PiArc3RhdGlj IGludCBpbWFfYWxsb2Nfa2V4ZWNfYnVmKHNpemVfdCBrZXhlY19zZWdtZW50X3NpemUpCj4gCj4g Q2FsbCBpdCBzZWdtZW50IHNpemUgdG8gYXZvaWQgdGhlIGxhdGVyIGtleGVjX3NlZ21lbnRfc2l6 ZSBzdGF0aWMgCj4gdmFyaWFibGUgaW4gdGhpcyBmaWxlLgo+IAo+IApXaWxsIGRvLgo+PiArewo+ PiArwqDCoMKgIGlmICgoa2V4ZWNfc2VnbWVudF9zaXplID09IDApIHx8Cj4+ICvCoMKgwqDCoMKg wqDCoCAoa2V4ZWNfc2VnbWVudF9zaXplID09IFVMT05HX01BWCkgfHwKPj4gK8KgwqDCoMKgwqDC oMKgICgoa2V4ZWNfc2VnbWVudF9zaXplID4+IFBBR0VfU0hJRlQpID4gdG90YWxyYW1fcGFnZXMo KSAvIDIpKSB7Cj4gCj4gVGhlc2UgdGVzdHMgYXJlIGFscmVhZHkgZG9uZSBiZWZvcmUgaW1hX2Fs bG9jYV9rZXhlY19idWYoKSBpcyBjYWxsZWQuIAo+IEFsc28sIGtleGVjX3NlZ21lbnRfc2l6ZSBj YW5ub3QgYmUgMC4KPiAKPiAKSSB3YXMgYmVpbmcgZXh0cmEgY2F1dGlvdXMgaGVyZS4gSWYgaW1h X2FsbG9jX2tleGVjX2J1ZigpIGdldHMgY2FsbGVkCmZyb20gc29tZSBvdGhlciBwbGFjZSwgdGhl biB0aGlzIGNoZWNrIHdvdWxkIGJlIGhhbmR5LiBCZWluZyBzYWlkIHRoYXQsCm1heWJlIHRoaXMg ZnVuY3Rpb24gaXMgYSBiZXR0ZXIgcGxhY2UgdG8gaGF2ZSB0aGlzIGNoZWNrLiBJIHdpbGwgc2Vl CndoYXQgSSBjYW4gZG8gaGVyZSB0byBzaW1wbGlmeSB0aGluZ3MuIFRoYW5rcyBmb3IgdGhlIGZl ZWRiYWNrLgoKPj4gK8KgwqDCoMKgwqDCoMKgIHByX2VycigiJXM6IEludmFsaWQgc2VnbWVudCBz aXplIGZvciBrZXhlYzogJXp1XG4iLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBfX2Z1bmNf Xywga2V4ZWNfc2VnbWVudF9zaXplKTsKPj4gK8KgwqDCoMKgwqDCoMKgIHJldHVybiAtRUlOVkFM Owo+PiArwqDCoMKgIH0KPj4gKwo+PiArwqDCoMKgIC8qCj4+ICvCoMKgwqDCoCAqIElmIGtleGVj IGxvYWQgd2FzIGNhbGxlZCBiZWZvcmUsIGNsZWFyIHRoZSBleGlzdGluZyBidWZmZXIKPj4gK8Kg wqDCoMKgICogYmVmb3JlIGFsbG9jYXRpbmcgYSBuZXcgb25lCj4+ICvCoMKgwqDCoCAqLwo+PiAr wqDCoMKgIGlmIChpbWFfa2V4ZWNfZmlsZS5idWYpCj4+ICvCoMKgwqDCoMKgwqDCoCBpbWFfY2xl YXJfa2V4ZWNfZmlsZSgpOwo+PiArCj4gCj4gaW1hX2NsZWFyX2ZpbGUoJmltYV9rZXhlY19maWxl KTsKPiAKPiAKQWdyZWVkLiBXaWxsIGRvLgoKPj4gK8KgwqDCoCAvKiBzZWdtZW50IHNpemUgY2Fu J3QgY2hhbmdlIGJldHdlZW4ga2V4ZWMgbG9hZCBhbmQgZXhlY3V0ZSAqLwo+PiArwqDCoMKgIGlt YV9rZXhlY19maWxlLmJ1ZiA9IHZtYWxsb2Moa2V4ZWNfc2VnbWVudF9zaXplKTsKPj4gK8KgwqDC oCBpZiAoIWltYV9rZXhlY19maWxlLmJ1Zikgewo+PiArwqDCoMKgwqDCoMKgwqAgcHJfZXJyKCIl czogTm8gbWVtb3J5IGZvciBpbWEga2V4ZWMgbWVhc3VyZW1lbnQgYnVmZmVyXG4iLAo+PiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCBfX2Z1bmNfXyk7Cj4+ICvCoMKgwqDCoMKgwqDCoCByZXR1cm4g LUVOT01FTTsKPj4gK8KgwqDCoCB9Cj4+ICsKPj4gK8KgwqDCoCBpbWFfa2V4ZWNfZmlsZS5zaXpl ID0ga2V4ZWNfc2VnbWVudF9zaXplOwo+PiArwqDCoMKgIGltYV9rZXhlY19maWxlLnJlYWRfcG9z ID0gMDsKPj4gK8KgwqDCoCBpbWFfa2V4ZWNfZmlsZS5jb3VudCA9IHNpemVvZihpbWFfa2hkcik7 wqDCoMKgIC8qIHJlc2VydmVkIHNwYWNlICovCj4+ICsKPj4gK8KgwqDCoCBtZW1zZXQoJmltYV9r aGRyLCAwLCBzaXplb2YoaW1hX2toZHIpKTsKPj4gK8KgwqDCoCBpbWFfa2hkci52ZXJzaW9uID0g MTsKPiAKPiBNb3ZlIHRoaXMgaW50byBpbWFfZHVtcF9tZWFzdXJlbWVudF9saXN0KCkgc2luY2Ug aXQncyBvbmx5IHVzZWQgdGhlcmUgCj4gb25jZSBhbmQgZ2V0dGluZyByaWQgb2YgdGhpcyBmaWxl LXN0YXRpYyB2YXJpYWJsZSBpcyBhIHBsdXMuCj4gCj4gClllcy4gVGhpcyB3aWxsIGdldCByaWQg b2YgYW4gZXh0cmEgc3RhdGljIHZhcmlhYmxlLgoKPj4gKwo+PiArwqDCoMKgIHJldHVybiAwOwo+ PiArfQo+PiArCj4+IMKgIHN0YXRpYyBpbnQgaW1hX2R1bXBfbWVhc3VyZW1lbnRfbGlzdCh1bnNp Z25lZCBsb25nICpidWZmZXJfc2l6ZSwgCj4+IHZvaWQgKipidWZmZXIsCj4+IMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHVuc2lnbmVkIGxvbmcgc2VnbWVudF9z aXplKQo+PiDCoCB7Cj4+IMKgwqDCoMKgwqAgc3RydWN0IGltYV9xdWV1ZV9lbnRyeSAqcWU7Cj4+ IC3CoMKgwqAgc3RydWN0IHNlcV9maWxlIGZpbGU7Cj4+IC3CoMKgwqAgc3RydWN0IGltYV9rZXhl Y19oZHIga2hkcjsKPiBEb24ndCByZW1vdmUgaXQgZnJvbSBoZXJlLgpBZ3JlZWQuIGtoZHIgZG9l c24ndCBuZWVkIHRvIGJlIHN0YXRpYy4KCj4+IMKgwqDCoMKgwqAgaW50IHJldCA9IDA7Cj4+IC3C oMKgwqAgLyogc2VnbWVudCBzaXplIGNhbid0IGNoYW5nZSBiZXR3ZWVuIGtleGVjIGxvYWQgYW5k IGV4ZWN1dGUgKi8KPj4gLcKgwqDCoCBmaWxlLmJ1ZiA9IHZtYWxsb2Moc2VnbWVudF9zaXplKTsK Pj4gLcKgwqDCoCBpZiAoIWZpbGUuYnVmKSB7Cj4+IC3CoMKgwqDCoMKgwqDCoCByZXQgPSAtRU5P TUVNOwo+PiAtwqDCoMKgwqDCoMKgwqAgZ290byBvdXQ7Cj4+ICvCoMKgwqAgaWYgKCFpbWFfa2V4 ZWNfZmlsZS5idWYpIHsKPj4gK8KgwqDCoMKgwqDCoMKgIHByX2VycigiJXM6IEtleGVjIGZpbGUg YnVmIG5vdCBhbGxvY2F0ZWRcbiIsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIF9fZnVuY19f KTsKPj4gK8KgwqDCoMKgwqDCoMKgIHJldHVybiAtRUlOVkFMOwo+PiDCoMKgwqDCoMKgIH0KPj4g LcKgwqDCoCBmaWxlLnNpemUgPSBzZWdtZW50X3NpemU7Cj4+IC3CoMKgwqAgZmlsZS5yZWFkX3Bv cyA9IDA7Cj4+IC3CoMKgwqAgZmlsZS5jb3VudCA9IHNpemVvZihraGRyKTvCoMKgwqAgLyogcmVz ZXJ2ZWQgc3BhY2UgKi8KPj4gK8KgwqDCoCAvKgo+PiArwqDCoMKgwqAgKiBFbnN1cmUgdGhlIGtl eGVjIGJ1ZmZlciBpcyBsYXJnZSBlbm91Z2ggdG8gaG9sZCBpbWFfa2hkcgo+PiArwqDCoMKgwqAg Ki8KPj4gK8KgwqDCoCBpZiAoaW1hX2tleGVjX2ZpbGUuc2l6ZSA8IHNpemVvZihpbWFfa2hkcikp IHsKPj4gK8KgwqDCoMKgwqDCoMKgIHByX2VycigiJXM6IEtleGVjIGJ1ZmZlciBzaXplIHRvbyBs b3cgdG8gaG9sZCBpbWFfa2hkclxuIiwKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAgX19mdW5j X18pOwo+PiArwqDCoMKgwqDCoMKgwqAgaW1hX2NsZWFyX2tleGVjX2ZpbGUoKTsKPj4gK8KgwqDC oMKgwqDCoMKgIHJldHVybiAtRU5PTUVNOwo+PiArwqDCoMKgIH0KPj4gLcKgwqDCoCBtZW1zZXQo JmtoZHIsIDAsIHNpemVvZihraGRyKSk7Cj4+IC3CoMKgwqAga2hkci52ZXJzaW9uID0gMTsKPj4g K8KgwqDCoCAvKgo+PiArwqDCoMKgwqAgKiBJZiB3ZSByZWFjaCBoZXJlLCB0aGVuIHRoZXJlIGlz IGVub3VnaCBtZW1vcnkKPj4gK8KgwqDCoMKgICogb2Ygc2l6ZSBrZXhlY19zZWdtZW50X3NpemUg aW4gaW1hX2tleGVjX2ZpbGUuYnVmCj4+ICvCoMKgwqDCoCAqIHRvIGNvcHkgYXQgbGVhc3QgcGFy dGlhbCBJTUEgbG9nLgo+PiArwqDCoMKgwqAgKiBNYWtlIGJlc3QgZWZmb3J0IHRvIGNvcHkgYXMg bWFueSBJTUEgbWVhc3VyZW1lbnRzCj4+ICvCoMKgwqDCoCAqIGFzIHBvc3NpYmxlLgo+IFlvdSBj YW4gcmVmb3JtYXQgdGhlc2UgY29tbWVudHMgdG8gKGF0IGxlYXN0KSA4MCBjb2x1bW5zLgo+IApT dXJlIHRoaW5nLgo+PiArwqDCoMKgwqAgKi8KPj4gwqDCoMKgwqDCoCBsaXN0X2Zvcl9lYWNoX2Vu dHJ5X3JjdShxZSwgJmltYV9tZWFzdXJlbWVudHMsIGxhdGVyKSB7Cj4+IC3CoMKgwqDCoMKgwqDC oCBpZiAoZmlsZS5jb3VudCA8IGZpbGUuc2l6ZSkgewo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBraGRyLmNvdW50Kys7Cj4+IC3CoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGltYV9tZWFzdXJlbWVu dHNfc2hvdygmZmlsZSwgcWUpOwo+PiArwqDCoMKgwqDCoMKgwqAgaWYgKGltYV9rZXhlY19maWxl LmNvdW50IDwgaW1hX2tleGVjX2ZpbGUuc2l6ZSkgewo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCBpbWFfa2hkci5jb3VudCsrOwo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbWFfbWVhc3Vy ZW1lbnRzX3Nob3coJmltYV9rZXhlY19maWxlLCBxZSk7Cj4+IMKgwqDCoMKgwqDCoMKgwqDCoCB9 IGVsc2Ugewo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXQgPSAtRUlOVkFMOwo+PiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCByZXQgPSBFRkJJRzsKPiAKPiBIbSwgeW91IGFyZSBub3QgbG9v a2luZyBmb3IgRUZCSUcgYWZ0ZXIgY2FsbGluZyB0aGlzIGZ1bmN0aW9uIGFuZCB0aGUgCj4gb3Zl cnJ1biBjb3VsZCBhY3R1YWxseSBhbHNvIGhhcHBlbiBpbiB0aGUgaW1hX21lYXN1cmVtZW50X3No b3coKSBhYm92ZSAKPiBhbmQgZ28gdW5yZXBvcnRlZCBpZiB0aGlzIGlzIHRoZSBsYXN0IGVsZW1l bnQuCj4gCj4gaWYgKGltYV9rZXhlY19maWxlLmNvdW50IDwgaW1hX2tleGVjX2ZpbGUuc2l6ZSkg ewo+ICDCoMKgwqDCoGltYV9raGRyLmNvdW50Kys7Cj4gIMKgwqDCoMKgaW1hX21lYXN1cmVtZW50 c19zaG93KCZpbWFfa2V4ZWNfZmlsZSwgcWUpOwo+IH0KPiAKPiBpZiAoaW1hX2tleGVjX2ZpbGUu Y291bnQgPj0gaW1hX2tleGVjX2ZpbGUuc2l6ZSkgewo+ICDCoMKgwqDCoC8qIGxlYXZlIHJldCA9 IDA7IGNhbGxlciBkb2Vzbid0IG5lZWQgdG8gd29ycnkgYWJvdXQgdW5kZXJzaXplZCAKPiBidWZm ZXIgKi8KPiAgwqDCoMKgwqBwcl9lcnIoIiVzOiBJTUEgbG9nIGZpbGUgaXMgdG9vIGJpZyBmb3Ig S2V4ZWMgYnVmXG4iLAo+ICDCoMKgwqDCoMKgwqDCoCBfX2Z1bmNfXyk7Cj4gIMKgwqDCoMKgYnJl YWs7Cj4gfQo+IApUaGlzIG1ha2VzIGl0IG1vcmUgY2xlYW4uIFRoYW5rcy4gV2lsbCBkby4KCn5U dXNoYXIKCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHByX2VycigiJXM6IElNQSBsb2cgZmls ZSBpcyB0b28gYmlnIGZvciBLZXhlYyBidWZcbiIsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgX19mdW5jX18pOwo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBicmVhazsK Pj4gwqDCoMKgwqDCoMKgwqDCoMKgIH0KPj4gwqDCoMKgwqDCoCB9Cj4+IC3CoMKgwqAgaWYgKHJl dCA8IDApCj4+IC3CoMKgwqDCoMKgwqDCoCBnb3RvIG91dDsKPj4gLQo+PiDCoMKgwqDCoMKgIC8q Cj4+IMKgwqDCoMKgwqDCoCAqIGZpbGwgaW4gcmVzZXJ2ZWQgc3BhY2Ugd2l0aCBzb21lIGJ1ZmZl ciBkZXRhaWxzCj4+IMKgwqDCoMKgwqDCoCAqIChlZy4gdmVyc2lvbiwgYnVmZmVyIHNpemUsIG51 bWJlciBvZiBtZWFzdXJlbWVudHMpCj4+IMKgwqDCoMKgwqDCoCAqLwo+PiAtwqDCoMKgIGtoZHIu YnVmZmVyX3NpemUgPSBmaWxlLmNvdW50Owo+PiArwqDCoMKgIGltYV9raGRyLmJ1ZmZlcl9zaXpl ID0gaW1hX2tleGVjX2ZpbGUuY291bnQ7Cj4+IMKgwqDCoMKgwqAgaWYgKGltYV9jYW5vbmljYWxf Zm10KSB7Cj4+IC3CoMKgwqDCoMKgwqDCoCBraGRyLnZlcnNpb24gPSBjcHVfdG9fbGUxNihraGRy LnZlcnNpb24pOwo+PiAtwqDCoMKgwqDCoMKgwqAga2hkci5jb3VudCA9IGNwdV90b19sZTY0KGto ZHIuY291bnQpOwo+PiAtwqDCoMKgwqDCoMKgwqAga2hkci5idWZmZXJfc2l6ZSA9IGNwdV90b19s ZTY0KGtoZHIuYnVmZmVyX3NpemUpOwo+PiArwqDCoMKgwqDCoMKgwqAgaW1hX2toZHIudmVyc2lv biA9IGNwdV90b19sZTE2KGltYV9raGRyLnZlcnNpb24pOwo+PiArwqDCoMKgwqDCoMKgwqAgaW1h X2toZHIuY291bnQgPSBjcHVfdG9fbGU2NChpbWFfa2hkci5jb3VudCk7Cj4+ICvCoMKgwqDCoMKg wqDCoCBpbWFfa2hkci5idWZmZXJfc2l6ZSA9IGNwdV90b19sZTY0KGltYV9raGRyLmJ1ZmZlcl9z aXplKTsKPj4gwqDCoMKgwqDCoCB9Cj4+IC3CoMKgwqAgbWVtY3B5KGZpbGUuYnVmLCAma2hkciwg c2l6ZW9mKGtoZHIpKTsKPj4gK8KgwqDCoCBtZW1jcHkoaW1hX2tleGVjX2ZpbGUuYnVmLCAmaW1h X2toZHIsIHNpemVvZihpbWFfa2hkcikpOwo+PiDCoMKgwqDCoMKgIHByaW50X2hleF9kdW1wX2Rl YnVnKCJpbWEgZHVtcDogIiwgRFVNUF9QUkVGSVhfTk9ORSwgMTYsIDEsCj4+IC3CoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBmaWxlLmJ1ZiwgZmlsZS5jb3VudCA8IDEwMCA/IGZpbGUu Y291bnQgOiAxMDAsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbWFfa2V4 ZWNfZmlsZS5idWYsIGltYV9rZXhlY19maWxlLmNvdW50IDwgMTAwID8KPj4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIGltYV9rZXhlY19maWxlLmNvdW50IDogMTAwLAo+PiDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdHJ1ZSk7Cj4+IC3CoMKgwqAgKmJ1ZmZl cl9zaXplID0gZmlsZS5jb3VudDsKPj4gLcKgwqDCoCAqYnVmZmVyID0gZmlsZS5idWY7Cj4+IC1v dXQ6Cj4+IC3CoMKgwqAgaWYgKHJldCA9PSAtRUlOVkFMKQo+PiAtwqDCoMKgwqDCoMKgwqAgdmZy ZWUoZmlsZS5idWYpOwo+PiArwqDCoMKgICpidWZmZXJfc2l6ZSA9IGltYV9rZXhlY19maWxlLmNv dW50Owo+PiArwqDCoMKgICpidWZmZXIgPSBpbWFfa2V4ZWNfZmlsZS5idWY7Cj4+ICsKPj4gwqDC oMKgwqDCoCByZXR1cm4gcmV0Owo+PiDCoCB9Cj4+IEBAIC0xMDgsMTMgKzE2MSwyMCBAQCB2b2lk IGltYV9hZGRfa2V4ZWNfYnVmZmVyKHN0cnVjdCBraW1hZ2UgKmltYWdlKQo+PiDCoMKgwqDCoMKg wqDCoMKgwqAgcmV0dXJuOwo+PiDCoMKgwqDCoMKgIH0KPj4gLcKgwqDCoCBpbWFfZHVtcF9tZWFz dXJlbWVudF9saXN0KCZrZXhlY19idWZmZXJfc2l6ZSwgJmtleGVjX2J1ZmZlciwKPj4gLcKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAga2V4ZWNfc2VnbWVudF9zaXplKTsKPj4gLcKg wqDCoCBpZiAoIWtleGVjX2J1ZmZlcikgewo+PiArwqDCoMKgIHJldCA9IGltYV9hbGxvY19rZXhl Y19idWYoa2V4ZWNfc2VnbWVudF9zaXplKTsKPj4gK8KgwqDCoCBpZiAocmV0IDwgMCkgewo+PiDC oMKgwqDCoMKgwqDCoMKgwqAgcHJfZXJyKCJOb3QgZW5vdWdoIG1lbW9yeSBmb3IgdGhlIGtleGVj IG1lYXN1cmVtZW50IAo+PiBidWZmZXIuXG4iKTsKPj4gwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVy bjsKPj4gwqDCoMKgwqDCoCB9Cj4+ICvCoMKgwqAgcmV0ID0gaW1hX2R1bXBfbWVhc3VyZW1lbnRf bGlzdCgma2V4ZWNfYnVmZmVyX3NpemUsICZrZXhlY19idWZmZXIsCj4+ICvCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBrZXhlY19zZWdtZW50X3NpemUpOwo+PiArwqDCoMKg IGlmIChyZXQgPCAwKSB7Cj4+ICvCoMKgwqDCoMKgwqDCoCBwcl9lcnIoIiVzOiBGYWlsZWQgdG8g ZHVtcCBJTUEgbWVhc3VyZW1lbnRzLiBFcnJvcjolZC5cbiIsCj4+ICvCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgIF9fZnVuY19fLCByZXQpOwo+PiArwqDCoMKgwqDCoMKgwqAgcmV0dXJuOwo+ PiArwqDCoMKgIH0KPj4gKwo+PiDCoMKgwqDCoMKgIGtidWYuYnVmZmVyID0ga2V4ZWNfYnVmZmVy Owo+PiDCoMKgwqDCoMKgIGtidWYuYnVmc3ogPSBrZXhlY19idWZmZXJfc2l6ZTsKPj4gwqDCoMKg wqDCoCBrYnVmLm1lbXN6ID0ga2V4ZWNfc2VnbWVudF9zaXplOwoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18Ka2V4ZWMgbWFpbGluZyBsaXN0CmtleGVjQGxp c3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0 aW5mby9rZXhlYwo= 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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6E101C004C0 for ; Fri, 20 Oct 2023 20:33:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229554AbjJTUda (ORCPT ); Fri, 20 Oct 2023 16:33:30 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:55210 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229704AbjJTUd3 (ORCPT ); Fri, 20 Oct 2023 16:33:29 -0400 Received: from linux.microsoft.com (linux.microsoft.com [13.77.154.182]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 44F06C0 for ; Fri, 20 Oct 2023 13:33:27 -0700 (PDT) Received: from [192.168.86.69] (unknown [50.46.228.62]) by linux.microsoft.com (Postfix) with ESMTPSA id 31AB820B74C0; Fri, 20 Oct 2023 13:33:26 -0700 (PDT) DKIM-Filter: OpenDKIM Filter v2.11.0 linux.microsoft.com 31AB820B74C0 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.microsoft.com; s=default; t=1697834006; bh=5lwU68ggTpUd5Qazc3xwkaQiQeOdLttE6W0CAK60Opo=; h=Date:Subject:To:Cc:References:From:In-Reply-To:From; b=Uw1kKEqnN37zRIpncu4lwRIdRueUZYkLp77nUFbjbvzJr97szt6cv1Sdwv4lsDKlY YsC9ELPDr1/XEENEtLLAltrNFNgb6K7ZEUJRt/o+zJXTHNOIS7+yBW8OBMQPLlYk1z zTieTV4KjJDtoseVTX1TGqHV+kmDXZcE1EYHNjRE= Message-ID: <9b227c0a-ddb3-b1c3-4ed0-e3e740db7788@linux.microsoft.com> Date: Fri, 20 Oct 2023 13:33:25 -0700 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.15.1 Subject: Re: [PATCH v2 1/7] ima: refactor ima_dump_measurement_list to move memory allocation to a separate function Content-Language: en-US To: Stefan Berger , zohar@linux.ibm.com, ebiederm@xmission.com, noodles@fb.com, bauermann@kolabnow.com, kexec@lists.infradead.org, linux-integrity@vger.kernel.org Cc: code@tyhicks.com, nramas@linux.microsoft.com, paul@paul-moore.com References: <20231005182602.634615-1-tusharsu@linux.microsoft.com> <20231005182602.634615-2-tusharsu@linux.microsoft.com> <2c06f9c5-6f3a-b163-20ca-24178d7cba4e@linux.ibm.com> From: Tushar Sugandhi In-Reply-To: <2c06f9c5-6f3a-b163-20ca-24178d7cba4e@linux.ibm.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-integrity@vger.kernel.org Thanks a lot Stefan for reviewing this series. Really appreciate it. On 10/12/23 17:28, Stefan Berger wrote: > > On 10/5/23 14:25, Tushar Sugandhi wrote: >> IMA allocates memory and dumps the measurement during kexec soft reboot >> as a single function call ima_dump_measurement_list().  It gets called >> during kexec 'load' operation.  It results in the IMA measurements >> between the window of kexec 'load' and 'execute' getting dropped when the >> system boots into the new Kernel.  One of the kexec requirements is the >> segment size cannot change between the 'load' and the 'execute'. >> Therefore, to address this problem, ima_dump_measurement_list() needs >> to be refactored to allocate the memory at kexec 'load', and dump the >> measurements at kexec 'execute'.  The function that allocates the memory >> should handle the scenario where the kexec load is called multiple times. >> >> Refactor ima_dump_measurement_list() to move the memory allocation part >> to a separate function ima_alloc_kexec_buf() to allocate buffer of size >> 'kexec_segment_size' at kexec 'load'.  Make the local variables in >> function ima_dump_measurement_list() global, so that they can be accessed >> from ima_alloc_kexec_buf().  Make necessary changes to the function >> ima_add_kexec_buffer() to call the above two functions. >> >> Signed-off-by: Tushar Sugandhi >> --- >>   security/integrity/ima/ima_kexec.c | 126 +++++++++++++++++++++-------- >>   1 file changed, 93 insertions(+), 33 deletions(-) >> >> diff --git a/security/integrity/ima/ima_kexec.c >> b/security/integrity/ima/ima_kexec.c >> index 419dc405c831..307e07991865 100644 >> --- a/security/integrity/ima/ima_kexec.c >> +++ b/security/integrity/ima/ima_kexec.c >> @@ -15,61 +15,114 @@ >>   #include "ima.h" >>   #ifdef CONFIG_IMA_KEXEC >> +struct seq_file ima_kexec_file; >> +struct ima_kexec_hdr ima_khdr; > > Since you are only populating the buffer at kexec 'execute' time, you > should be able to move this header into the function where it is needed. > Yup, ima_khdr doesn't need to be static. Will fix. > >> + >> +void ima_clear_kexec_file(void) >> +{ >> +    vfree(ima_kexec_file.buf); > I would pass the ima_kexec_file onto this function here as a parameter > rather than accessing the file-static variable. I find this better to > read once you look at ima_clear_kexec_file() further below and wonder > why it doesn't take a parameter. Agreed. This will make the code more readable. >> +    ima_kexec_file.buf = NULL; >> +    ima_kexec_file.size = 0; >> +    ima_kexec_file.read_pos = 0; >> +    ima_kexec_file.count = 0; >> +} >> + >> +static int ima_alloc_kexec_buf(size_t kexec_segment_size) > > Call it segment size to avoid the later kexec_segment_size static > variable in this file. > > Will do. >> +{ >> +    if ((kexec_segment_size == 0) || >> +        (kexec_segment_size == ULONG_MAX) || >> +        ((kexec_segment_size >> PAGE_SHIFT) > totalram_pages() / 2)) { > > These tests are already done before ima_alloca_kexec_buf() is called. > Also, kexec_segment_size cannot be 0. > > I was being extra cautious here. If ima_alloc_kexec_buf() gets called from some other place, then this check would be handy. Being said that, maybe this function is a better place to have this check. I will see what I can do here to simplify things. Thanks for the feedback. >> +        pr_err("%s: Invalid segment size for kexec: %zu\n", >> +            __func__, kexec_segment_size); >> +        return -EINVAL; >> +    } >> + >> +    /* >> +     * If kexec load was called before, clear the existing buffer >> +     * before allocating a new one >> +     */ >> +    if (ima_kexec_file.buf) >> +        ima_clear_kexec_file(); >> + > > ima_clear_file(&ima_kexec_file); > > Agreed. Will do. >> +    /* segment size can't change between kexec load and execute */ >> +    ima_kexec_file.buf = vmalloc(kexec_segment_size); >> +    if (!ima_kexec_file.buf) { >> +        pr_err("%s: No memory for ima kexec measurement buffer\n", >> +            __func__); >> +        return -ENOMEM; >> +    } >> + >> +    ima_kexec_file.size = kexec_segment_size; >> +    ima_kexec_file.read_pos = 0; >> +    ima_kexec_file.count = sizeof(ima_khdr);    /* reserved space */ >> + >> +    memset(&ima_khdr, 0, sizeof(ima_khdr)); >> +    ima_khdr.version = 1; > > Move this into ima_dump_measurement_list() since it's only used there > once and getting rid of this file-static variable is a plus. > > Yes. This will get rid of an extra static variable. >> + >> +    return 0; >> +} >> + >>   static int ima_dump_measurement_list(unsigned long *buffer_size, >> void **buffer, >>                        unsigned long segment_size) >>   { >>       struct ima_queue_entry *qe; >> -    struct seq_file file; >> -    struct ima_kexec_hdr khdr; > Don't remove it from here. Agreed. khdr doesn't need to be static. >>       int ret = 0; >> -    /* segment size can't change between kexec load and execute */ >> -    file.buf = vmalloc(segment_size); >> -    if (!file.buf) { >> -        ret = -ENOMEM; >> -        goto out; >> +    if (!ima_kexec_file.buf) { >> +        pr_err("%s: Kexec file buf not allocated\n", >> +            __func__); >> +        return -EINVAL; >>       } >> -    file.size = segment_size; >> -    file.read_pos = 0; >> -    file.count = sizeof(khdr);    /* reserved space */ >> +    /* >> +     * Ensure the kexec buffer is large enough to hold ima_khdr >> +     */ >> +    if (ima_kexec_file.size < sizeof(ima_khdr)) { >> +        pr_err("%s: Kexec buffer size too low to hold ima_khdr\n", >> +            __func__); >> +        ima_clear_kexec_file(); >> +        return -ENOMEM; >> +    } >> -    memset(&khdr, 0, sizeof(khdr)); >> -    khdr.version = 1; >> +    /* >> +     * If we reach here, then there is enough memory >> +     * of size kexec_segment_size in ima_kexec_file.buf >> +     * to copy at least partial IMA log. >> +     * Make best effort to copy as many IMA measurements >> +     * as possible. > You can reformat these comments to (at least) 80 columns. > Sure thing. >> +     */ >>       list_for_each_entry_rcu(qe, &ima_measurements, later) { >> -        if (file.count < file.size) { >> -            khdr.count++; >> -            ima_measurements_show(&file, qe); >> +        if (ima_kexec_file.count < ima_kexec_file.size) { >> +            ima_khdr.count++; >> +            ima_measurements_show(&ima_kexec_file, qe); >>           } else { >> -            ret = -EINVAL; >> +            ret = EFBIG; > > Hm, you are not looking for EFBIG after calling this function and the > overrun could actually also happen in the ima_measurement_show() above > and go unreported if this is the last element. > > if (ima_kexec_file.count < ima_kexec_file.size) { >     ima_khdr.count++; >     ima_measurements_show(&ima_kexec_file, qe); > } > > if (ima_kexec_file.count >= ima_kexec_file.size) { >     /* leave ret = 0; caller doesn't need to worry about undersized > buffer */ >     pr_err("%s: IMA log file is too big for Kexec buf\n", >         __func__); >     break; > } > This makes it more clean. Thanks. Will do. ~Tushar >> +            pr_err("%s: IMA log file is too big for Kexec buf\n", >> +                __func__); >>               break; >>           } >>       } >> -    if (ret < 0) >> -        goto out; >> - >>       /* >>        * fill in reserved space with some buffer details >>        * (eg. version, buffer size, number of measurements) >>        */ >> -    khdr.buffer_size = file.count; >> +    ima_khdr.buffer_size = ima_kexec_file.count; >>       if (ima_canonical_fmt) { >> -        khdr.version = cpu_to_le16(khdr.version); >> -        khdr.count = cpu_to_le64(khdr.count); >> -        khdr.buffer_size = cpu_to_le64(khdr.buffer_size); >> +        ima_khdr.version = cpu_to_le16(ima_khdr.version); >> +        ima_khdr.count = cpu_to_le64(ima_khdr.count); >> +        ima_khdr.buffer_size = cpu_to_le64(ima_khdr.buffer_size); >>       } >> -    memcpy(file.buf, &khdr, sizeof(khdr)); >> +    memcpy(ima_kexec_file.buf, &ima_khdr, sizeof(ima_khdr)); >>       print_hex_dump_debug("ima dump: ", DUMP_PREFIX_NONE, 16, 1, >> -                 file.buf, file.count < 100 ? file.count : 100, >> +                 ima_kexec_file.buf, ima_kexec_file.count < 100 ? >> +                 ima_kexec_file.count : 100, >>                    true); >> -    *buffer_size = file.count; >> -    *buffer = file.buf; >> -out: >> -    if (ret == -EINVAL) >> -        vfree(file.buf); >> +    *buffer_size = ima_kexec_file.count; >> +    *buffer = ima_kexec_file.buf; >> + >>       return ret; >>   } >> @@ -108,13 +161,20 @@ void ima_add_kexec_buffer(struct kimage *image) >>           return; >>       } >> -    ima_dump_measurement_list(&kexec_buffer_size, &kexec_buffer, >> -                  kexec_segment_size); >> -    if (!kexec_buffer) { >> +    ret = ima_alloc_kexec_buf(kexec_segment_size); >> +    if (ret < 0) { >>           pr_err("Not enough memory for the kexec measurement >> buffer.\n"); >>           return; >>       } >> +    ret = ima_dump_measurement_list(&kexec_buffer_size, &kexec_buffer, >> +                    kexec_segment_size); >> +    if (ret < 0) { >> +        pr_err("%s: Failed to dump IMA measurements. Error:%d.\n", >> +               __func__, ret); >> +        return; >> +    } >> + >>       kbuf.buffer = kexec_buffer; >>       kbuf.bufsz = kexec_buffer_size; >>       kbuf.memsz = kexec_segment_size;