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 X-Spam-Level: X-Spam-Status: No, score=-13.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 19CBEC433DB for ; Fri, 29 Jan 2021 16:23:13 +0000 (UTC) Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [63.128.21.124]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 54EB064DD6 for ; Fri, 29 Jan 2021 16:23:12 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 54EB064DD6 Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=veeam.com Authentication-Results: mail.kernel.org; spf=tempfail smtp.mailfrom=dm-devel-bounces@redhat.com Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-394-onxqKiA4NmeD87Qn9y1xVg-1; Fri, 29 Jan 2021 11:23:09 -0500 X-MC-Unique: onxqKiA4NmeD87Qn9y1xVg-1 Received: from smtp.corp.redhat.com (int-mx02.intmail.prod.int.phx2.redhat.com [10.5.11.12]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 80F2A425D1; Fri, 29 Jan 2021 16:23:04 +0000 (UTC) Received: from colo-mx.corp.redhat.com (colo-mx01.intmail.prod.int.phx2.redhat.com [10.5.11.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 0284360BE2; Fri, 29 Jan 2021 16:23:04 +0000 (UTC) Received: from lists01.pubmisc.prod.ext.phx2.redhat.com (lists01.pubmisc.prod.ext.phx2.redhat.com [10.5.19.33]) by colo-mx.corp.redhat.com (Postfix) with ESMTP id 471FB1809C9F; Fri, 29 Jan 2021 16:23:03 +0000 (UTC) Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.rdu2.redhat.com [10.11.54.6]) by lists01.pubmisc.prod.ext.phx2.redhat.com (8.13.8/8.13.8) with ESMTP id 10TGIPCe011115 for ; Fri, 29 Jan 2021 11:18:25 -0500 Received: by smtp.corp.redhat.com (Postfix) id A32262166B2A; Fri, 29 Jan 2021 16:18:25 +0000 (UTC) Received: from mimecast-mx02.redhat.com (mimecast04.extmail.prod.ext.rdu2.redhat.com [10.11.55.20]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 9CAED2166B27 for ; Fri, 29 Jan 2021 16:18:23 +0000 (UTC) Received: from us-smtp-1.mimecast.com (us-smtp-delivery-1.mimecast.com [205.139.110.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id 3E4F5101A531 for ; Fri, 29 Jan 2021 16:18:23 +0000 (UTC) Received: from mx4.veeam.com (mx4.veeam.com [104.41.138.86]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-502-vLpyLGSvM8GhT8U7YNOcfQ-1; Fri, 29 Jan 2021 11:18:21 -0500 X-MC-Unique: vLpyLGSvM8GhT8U7YNOcfQ-1 Received: from mail.veeam.com (prgmbx01.amust.local [172.24.0.171]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mx4.veeam.com (Postfix) with ESMTPS id E29F9AE5AA; Fri, 29 Jan 2021 19:08:53 +0300 (MSK) Received: from veeam.com (172.24.14.5) by prgmbx01.amust.local (172.24.0.171) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.721.2; Fri, 29 Jan 2021 17:08:52 +0100 Date: Fri, 29 Jan 2021 19:08:49 +0300 From: Sergei Shtepa To: Damien Le Moal Message-ID: <20210129160849.GC32240@veeam.com> References: <1611853955-32167-1-git-send-email-sergei.shtepa@veeam.com> <1611853955-32167-3-git-send-email-sergei.shtepa@veeam.com> MIME-Version: 1.0 In-Reply-To: X-Originating-IP: [172.24.14.5] X-ClientProxiedBy: prgmbx02.amust.local (172.24.0.172) To prgmbx01.amust.local (172.24.0.171) X-EsetResult: clean, is OK X-EsetId: 37303A29C604D265667563 X-Veeam-MMEX: True X-Mimecast-Impersonation-Protect: Policy=CLT - Impersonation Protection Definition; Similar Internal Domain=false; Similar Monitored External Domain=false; Custom External Domain=false; Mimecast External Domain=false; Newly Observed Domain=false; Internal User Name=false; Custom Display Name List=false; Reply-to Address Mismatch=false; Targeted Threat Dictionary=false; Mimecast Threat Dictionary=false; Custom Threat Dictionary=false X-Scanned-By: MIMEDefang 2.78 on 10.11.54.6 X-MIME-Autoconverted: from quoted-printable to 8bit by lists01.pubmisc.prod.ext.phx2.redhat.com id 10TGIPCe011115 X-loop: dm-devel@redhat.com Cc: "snitzer@redhat.com" , Pavel Tide , "ming.lei@redhat.com" , "linux-block@vger.kernel.org" , "dm-devel@redhat.com" , "agk@redhat.com" Subject: Re: [dm-devel] [PATCH 2/2] [dm] blk_interposer for dm-linear X-BeenThere: dm-devel@redhat.com X-Mailman-Version: 2.1.12 Precedence: junk List-Id: device-mapper development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: dm-devel-bounces@redhat.com Errors-To: dm-devel-bounces@redhat.com X-Scanned-By: MIMEDefang 2.79 on 10.5.11.12 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=dm-devel-bounces@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Disposition: inline Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 VGhlIDAxLzI5LzIwMjEgMDQ6NDYsIERhbWllbiBMZSBNb2FsIHdyb3RlOgo+IE9uIDIwMjEvMDEv MjkgMjoyMywgU2VyZ2VpIFNodGVwYSB3cm90ZToKPiA+IEltcGxlbWVudCBhIGJsb2NrIGludGVy cG9zZXIgZm9yIGRldmljZS1tYXBwZXIgdG8gYXR0YWNoCj4gPiB0byBhbiBleGlzdGluZyBibG9j ayBsYXllciBzdGFjay4gVXNpbmcgdGhlIGludGVycG9zZXIsCj4gPiB3ZSBjYW4gY29ubmVjdCB0 aGUgZG0tbGluZWFyIHRvIGEgZGV2aWNlIHdpdGggYSBtb3VudGVkCj4gPiBmaWxlIHN5c3RlbS4K PiA+IAo+ID4gY2hhbmdlczoKPiA+ICAgKiB0aGUgbmV3IGRtX2ludGVycG9zZXIgc3RydWN0dXJl IGNvbnRhaW5zIGJsa19pbnRlcnBvc2VyCj4gPiAgICAgdG8gaW50ZXJjZXB0IGJpbyBmcm9tIHRo ZSBpbnRlcnBvc2VkIGRpc2sgYW5kIGludGVydmFsIHRyZWUKPiA+ICAgICBvZiBibG9jayBkZXZp Y2VzIG9uIHRoaXMgZGlzay4KPiA+ICAgKiB0aGUgbmV3IGludGVydmFsIHRyZWUgZm9yIGRldmlj ZSBtYXBwZXIuCj4gPiAgICogdGhlIGRtX3N1Ym1pdF9iaW9faW50ZXJwb3Nlcl9mbigpIGZ1bmN0 aW9uIGltcGxlbWVudHMKPiA+ICAgICB0aGUgYmlvIGludGVyY2VwdGlvbiBsb2dpYy4KPiA+ICAg KiB0aGUgZnVuY3Rpb25zIGRtX2ludGVycG9zZXJfYXR0YWNoX2RldigpICYKPiA+ICAgICBkbV9p bnRlcnBvc2VyX2RldGFjaF9kZXYoKSBhbGxvdyB0byBhdHRhY2ggYW5kIGRldGFjaCBkZXZpY2Vz Cj4gPiAgICAgdG8gZG1faW50ZXJwb3Nlci4KPiA+ICAgKiB0aGUgbmV3IHBhcmFtZXRlciAnbm9l eGNsJyBhbGxvd3MgdG8gY3JlYXRlIGRtLWxpbmVhciB0byBkZXZpY2UKPiA+ICAgICB3aXRoIGFu IGFscmVhZHkgbW91bnRlZCBmaWxlIHN5c3RlbS4KPiA+ICAgKiB0aGUgbm9uX2V4Y2x1c2l2ZSBw YXJhbWV0ZXIgaW4gZG1fdGFyZ2V0IHN0cnVjdHVyZSAtIGl0YHMgYSBzaWduCj4gPiAgICAgdGhh dCB0YXJnZXQgZGV2aWNlIHNob3VsZCBiZSBvcGVuZWQgd2l0aG91dCBGTU9ERV9FWENMIG1vZGUu Cj4gPiAgICogdGhlIG5ldyBpb2N0bCBJT0NUTF9ERVZfUkVNQVAgYWxsb3cgdG8gYXR0YWNoIGRt IGRldmljZSB0bwo+ID4gICAgIGEgcmVndWxhciBibG9jayBkZXZpY2UuCj4gCj4gU2FtZSBjb21t ZW50IGFib3V0IGNoYW5nZWxvZyBhcyBpbiB0aGUgcHJldmlvdXMgcGF0Y2guCj4gCj4gPiBTaWdu ZWQtb2ZmLWJ5OiBTZXJnZWkgU2h0ZXBhIDxzZXJnZWkuc2h0ZXBhQHZlZWFtLmNvbT4KPiA+IC0t LQo+ID4gIGRyaXZlcnMvbWQvZG0tY29yZS5oICAgICAgICAgIHwgIDQ2ICsrKy0KPiA+ICBkcml2 ZXJzL21kL2RtLWlvY3RsLmMgICAgICAgICB8ICAzOSArKysrCj4gPiAgZHJpdmVycy9tZC9kbS1s aW5lYXIuYyAgICAgICAgfCAgMTcgKy0KPiA+ICBkcml2ZXJzL21kL2RtLXRhYmxlLmMgICAgICAg ICB8ICAxMiArLQo+ID4gIGRyaXZlcnMvbWQvZG0uYyAgICAgICAgICAgICAgIHwgMzgzICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrLS0KPiA+ICBkcml2ZXJzL21kL2RtLmggICAgICAg ICAgICAgICB8ICAgMiArLQo+ID4gIGluY2x1ZGUvbGludXgvZGV2aWNlLW1hcHBlci5oIHwgICA3 ICsKPiA+ICBpbmNsdWRlL3VhcGkvbGludXgvZG0taW9jdGwuaCB8ICAxNSArLQo+ID4gIDggZmls ZXMgY2hhbmdlZCwgNDkzIGluc2VydGlvbnMoKyksIDI4IGRlbGV0aW9ucygtKQo+ID4gCj4gPiBk aWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1jb3JlLmggYi9kcml2ZXJzL21kL2RtLWNvcmUuaAo+ ID4gaW5kZXggMDg2ZDI5M2MyYjAzLi4wZjg3MGIxZDRiZTQgMTAwNjQ0Cj4gPiAtLS0gYS9kcml2 ZXJzL21kL2RtLWNvcmUuaAo+ID4gKysrIGIvZHJpdmVycy9tZC9kbS1jb3JlLmgKPiA+IEBAIC0x Myw3ICsxMyw3IEBACj4gPiAgI2luY2x1ZGUgPGxpbnV4L2t0aW1lLmg+Cj4gPiAgI2luY2x1ZGUg PGxpbnV4L2dlbmhkLmg+Cj4gPiAgI2luY2x1ZGUgPGxpbnV4L2Jsay1tcS5oPgo+ID4gLQo+IAo+ IHdoaXRlbGluZSBjaGFuZ2UuCj4gCj4gPiArI2luY2x1ZGUgPGxpbnV4L3JidHJlZS5oPgo+ID4g ICNpbmNsdWRlIDx0cmFjZS9ldmVudHMvYmxvY2suaD4KCkkgZG9uJ3Qgc2VlIGFueSBwcm9ibGVt IGluIHRoZSBmYWN0IHRoYXQgYSBuZXcgaW5jbHVkZSBhcHBlYXJlZCBpbnN0ZWFkIG9mIHdoaXRl bGluZS4KSXQgZG9lc24ndCBtYWtlIHNlbnNlIHRvIHNwbGl0IHRoZSBpbmNsdWRlIHNlY3Rpb24g Ynkgd2hpdGVsaW5lLgoKPiA+ICAKPiA+ICAjaW5jbHVkZSAiZG0uaCIKPiA+IEBAIC0xMDksNiAr MTA5LDkgQEAgc3RydWN0IG1hcHBlZF9kZXZpY2Ugewo+ID4gIAlib29sIGluaXRfdGlvX3BkdTox Owo+ID4gIAo+ID4gIAlzdHJ1Y3Qgc3JjdV9zdHJ1Y3QgaW9fYmFycmllcjsKPiA+ICsKPiA+ICsJ LyogaW50ZXJwb3NlciBkZXZpY2UgZm9yIHJlbWFwICovCj4gPiArCXN0cnVjdCBkbV9pbnRlcnBv c2VkX2RldiAqaXBfZGV2Owo+ID4gIH07Cj4gPiAgCj4gPiAgdm9pZCBkaXNhYmxlX2Rpc2NhcmQo c3RydWN0IG1hcHBlZF9kZXZpY2UgKm1kKTsKPiA+IEBAIC0xNjQsNiArMTY3LDQ3IEBAIHN0cnVj dCBkbV90YWJsZSB7Cj4gPiAgCXN0cnVjdCBkbV9tZF9tZW1wb29scyAqbWVtcG9vbHM7Cj4gPiAg fTsKPiA+ICAKPiA+ICsvKgo+ID4gKyAqIEludGVydmFsIHRyZWUgZm9yIGRldmljZSBtYXBwZXIK PiA+ICsgKi8KPiA+ICtzdHJ1Y3QgZG1fcmJfcmFuZ2Ugewo+ID4gKwlzdHJ1Y3QgcmJfbm9kZSBu b2RlOwo+ID4gKwlzZWN0b3JfdCBzdGFydDsJCS8qIHN0YXJ0IHNlY3RvciBvZiByYiBub2RlICov Cj4gPiArCXNlY3Rvcl90IGxhc3Q7CQkvKiBlbmQgc2VjdG9yIG9mIHJiIG5vZGUgKi8KPiA+ICsJ c2VjdG9yX3QgX3N1YnRyZWVfbGFzdDsgLyogaGlnaGVzdCBzZWN0b3IgaW4gc3VidHJlZSBvZiBy YiBub2RlICovCj4gPiArfTsKPiA+ICsKPiA+ICt2b2lkIGRtX3JiX2luc2VydChzdHJ1Y3QgZG1f cmJfcmFuZ2UgKm5vZGUsIHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9vdCk7Cj4gPiArdm9pZCBk bV9yYl9yZW1vdmUoc3RydWN0IGRtX3JiX3JhbmdlICpub2RlLCBzdHJ1Y3QgcmJfcm9vdF9jYWNo ZWQgKnJvb3QpOwo+ID4gKwo+ID4gK3N0cnVjdCBkbV9yYl9yYW5nZSAqZG1fcmJfaXRlcl9maXJz dChzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgKnJvb3QsIHNlY3Rvcl90IHN0YXJ0LCBzZWN0b3JfdCBs YXN0KTsKPiA+ICtzdHJ1Y3QgZG1fcmJfcmFuZ2UgKmRtX3JiX2l0ZXJfbmV4dChzdHJ1Y3QgZG1f cmJfcmFuZ2UgKm5vZGUsIHNlY3Rvcl90IHN0YXJ0LCBzZWN0b3JfdCBsYXN0KTsKPiA+ICsKPiA+ ICsvKgo+ID4gKyAqIEZvciBjb25uZWN0aW5nIGJsa19pbnRlcnBvc2VyIGFuZCBkbS10YXJnZXRz IGRldmljZXMuCj4gCj4gSXMgdGhpcyBjb21tZW50IGFib3V0IHRoZSBjYWxsYmFjayBvciB0aGUg c3RydWN0dXJlID8gSSB0aGluayB0aGUgbGF0dGVyLCBzbyBpdAo+IGlzIGluIHRoZSB3b3JuZyBw bGFjZS4gUGxlYXNlIGFsc28gYWRkIGEgY29tbWVudCBmb3IgdGhlIGNhbGxiYWNrIGRlZmluaXRp b24KPiBleHBsYWluaW5nIHdoYXQgaXQgc2hvdWxkIGJlIGRvaW5nLgoKT2suCgo+IAo+ID4gKyAq Lwo+ID4gK3R5cGVkZWYgdm9pZCAoKmRtX2ludGVycG9zZV9iaW9fdCkgKHZvaWQgKmNvbnRleHQs IHN0cnVjdCBkbV9yYl9yYW5nZSAqbm9kZSwgIHN0cnVjdCBiaW8gKmJpbyk7Cj4gPiArCj4gPiAr c3RydWN0IGRtX2ludGVycG9zZWRfZGV2IHsKPiA+ICsJc3RydWN0IGdlbmRpc2sgKmRpc2s7Cj4g PiArCXN0cnVjdCBkbV9yYl9yYW5nZSBub2RlOwo+ID4gKwl2b2lkICpjb250ZXh0Owo+ID4gKwlk bV9pbnRlcnBvc2VfYmlvX3QgZG1faW50ZXJwb3NlX2JpbzsKPiA+ICsKPiA+ICsJYXRvbWljNjRf dCBpcF9jbnQ7IC8qZm9yIGRlYnVnIHB1cnBvc2UqLwo+ID4gK307Cj4gPiArCj4gPiArc3RydWN0 IGRtX2ludGVycG9zZWRfZGV2ICpkbV9pbnRlcnBvc2VyX25ld19kZXYoc3RydWN0IGdlbmRpc2sg KmRpc2ssCj4gPiArCQkJCQkJc2VjdG9yX3Qgb2ZzLCBzZWN0b3JfdCBsZW4sCj4gPiArCQkJCQkJ dm9pZCAqY29udGV4dCwKPiA+ICsJCQkJCQlkbV9pbnRlcnBvc2VfYmlvX3QgZG1faW50ZXJwb3Nl X2Jpb190KTsKPiA+ICt2b2lkIGRtX2ludGVycG9zZXJfZnJlZV9kZXYoc3RydWN0IGRtX2ludGVy cG9zZWRfZGV2ICppcF9kZXYpOwo+ID4gK2ludCBkbV9pbnRlcnBvc2VyX2F0dGFjaF9kZXYoc3Ry dWN0IGRtX2ludGVycG9zZWRfZGV2ICppcF9kZXYpOwo+ID4gK2ludCBkbV9pbnRlcnBvc2VyX2Rl dGFjaF9kZXYoc3RydWN0IGRtX2ludGVycG9zZWRfZGV2ICppcF9kZXYpOwo+ID4gKwo+ID4gK2lu dCBkbV9yZW1hcF9pbnN0YWxsKHN0cnVjdCBtYXBwZWRfZGV2aWNlICptZCwgY29uc3QgY2hhciAq ZG9ub3JfZGV2aWNlX25hbWUpOwo+ID4gK2ludCBkbV9yZW1hcF91bmluc3RhbGwoc3RydWN0IG1h cHBlZF9kZXZpY2UgKm1kKTsKPiA+ICsKPiA+ICBzdGF0aWMgaW5saW5lIHN0cnVjdCBjb21wbGV0 aW9uICpkbV9nZXRfY29tcGxldGlvbl9mcm9tX2tvYmplY3Qoc3RydWN0IGtvYmplY3QgKmtvYmop Cj4gPiAgewo+ID4gIAlyZXR1cm4gJmNvbnRhaW5lcl9vZihrb2JqLCBzdHJ1Y3QgZG1fa29iamVj dF9ob2xkZXIsIGtvYmopLT5jb21wbGV0aW9uOwo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQv ZG0taW9jdGwuYyBiL2RyaXZlcnMvbWQvZG0taW9jdGwuYwo+ID4gaW5kZXggNWUzMDZiYmE0Mzc1 Li4yOTQ0ZDQ0MmMyNTYgMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL21kL2RtLWlvY3RsLmMKPiA+ ICsrKyBiL2RyaXZlcnMvbWQvZG0taW9jdGwuYwo+ID4gQEAgLTE2NDksNiArMTY0OSw0NCBAQCBz dGF0aWMgaW50IHRhcmdldF9tZXNzYWdlKHN0cnVjdCBmaWxlICpmaWxwLCBzdHJ1Y3QgZG1faW9j dGwgKnBhcmFtLCBzaXplX3QgcGFyYQo+ID4gIAlyZXR1cm4gcjsKPiA+ICB9Cj4gPiAgCj4gPiAr c3RhdGljIGlubGluZSBpbnQgZGV2X3JlbWFwX3N0YXJ0KHN0cnVjdCBtYXBwZWRfZGV2aWNlICpt ZCwgdWludDhfdCAqcGFyYW1zKQo+ID4gK3sKPiA+ICsJY2hhciAqZG9ub3JfZGV2aWNlX25hbWUg PSAoY2hhciAqKXBhcmFtczsKPiA+ICsKPiA+ICsJcmV0dXJuIGRtX3JlbWFwX2luc3RhbGwobWQs IGRvbm9yX2RldmljZV9uYW1lKTsKPiA+ICt9Cj4gPiArc3RhdGljIGludCBkZXZfcmVtYXBfZmlu aXNoKHN0cnVjdCBtYXBwZWRfZGV2aWNlICptZCkKPiA+ICt7Cj4gPiArCXJldHVybiBkbV9yZW1h cF91bmluc3RhbGwobWQpOwo+ID4gK30KPiA+ICsKPiA+ICtzdGF0aWMgaW50IGRldl9yZW1hcChz dHJ1Y3QgZmlsZSAqZmlscCwgc3RydWN0IGRtX2lvY3RsICpwYXJhbSwgc2l6ZV90IHBhcmFtX3Np emUpCj4gPiArewo+ID4gKwlpbnQgcmV0ID0gMDsKPiA+ICsJc3RydWN0IG1hcHBlZF9kZXZpY2Ug Km1kOwo+ID4gKwl2b2lkICpiaW5fZGF0YTsKPiA+ICsJc3RydWN0IGRtX3JlbWFwX3BhcmFtICpy ZW1hcF9wYXJhbTsKPiA+ICsKPiA+ICsJbWQgPSBmaW5kX2RldmljZShwYXJhbSk7Cj4gPiArCWlm ICghbWQpCj4gPiArCQlyZXR1cm4gLUVOWElPOwo+ID4gKwo+ID4gKwliaW5fZGF0YSA9ICh2b2lk ICopKHBhcmFtKSArIHBhcmFtLT5kYXRhX3N0YXJ0Owo+ID4gKwlyZW1hcF9wYXJhbSA9IGJpbl9k YXRhOwo+ID4gKwo+ID4gKwlpZiAocmVtYXBfcGFyYW0tPmNtZCA9PSBSRU1BUF9TVEFSVF9DTUQp Cj4gPiArCQlyZXQgPSBkZXZfcmVtYXBfc3RhcnQobWQsIHJlbWFwX3BhcmFtLT5wYXJhbXMpOwo+ ID4gKwllbHNlIGlmIChyZW1hcF9wYXJhbS0+Y21kID09IFJFTUFQX0ZJTklTSF9DTUQpCj4gPiAr CQlyZXQgPSBkZXZfcmVtYXBfZmluaXNoKG1kKTsKPiA+ICsJZWxzZSB7Cj4gPiArCQlETVdBUk4o IkludmFsaWQgcmVtYXAgY29tbWFuZCwgJWQiLCByZW1hcF9wYXJhbS0+Y21kKTsKPiA+ICsJCXJl dCA9IC1FSU5WQUw7Cj4gPiArCX0KPiA+ICsKPiA+ICsJZG1fcHV0KG1kKTsKPiA+ICsJcmV0dXJu IHJldDsKPiA+ICt9Cj4gPiArCj4gPiAgLyoKPiA+ICAgKiBUaGUgaW9jdGwgcGFyYW1ldGVyIGJs b2NrIGNvbnNpc3RzIG9mIHR3byBwYXJ0cywgYSBkbV9pb2N0bCBzdHJ1Y3QKPiA+ICAgKiBmb2xs b3dlZCBieSBhIGRhdGEgYnVmZmVyLiAgVGhpcyBmbGFnIGlzIHNldCBpZiB0aGUgc2Vjb25kIHBh cnQsCj4gPiBAQCAtMTY5MSw2ICsxNzI5LDcgQEAgc3RhdGljIGlvY3RsX2ZuIGxvb2t1cF9pb2N0 bCh1bnNpZ25lZCBpbnQgY21kLCBpbnQgKmlvY3RsX2ZsYWdzKQo+ID4gIAkJe0RNX0RFVl9TRVRf R0VPTUVUUllfQ01ELCAwLCBkZXZfc2V0X2dlb21ldHJ5fSwKPiA+ICAJCXtETV9ERVZfQVJNX1BP TEwsIElPQ1RMX0ZMQUdTX05PX1BBUkFNUywgZGV2X2FybV9wb2xsfSwKPiA+ICAJCXtETV9HRVRf VEFSR0VUX1ZFUlNJT04sIDAsIGdldF90YXJnZXRfdmVyc2lvbn0sCj4gPiArCQl7RE1fREVWX1JF TUFQX0NNRCwgMCwgZGV2X3JlbWFwfSwKPiA+ICAJfTsKPiA+ICAKPiA+ICAJaWYgKHVubGlrZWx5 KGNtZCA+PSBBUlJBWV9TSVpFKF9pb2N0bHMpKSkKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21k L2RtLWxpbmVhci5jIGIvZHJpdmVycy9tZC9kbS1saW5lYXIuYwo+ID4gaW5kZXggMDA3NzRiNWQ3 NjY4Li5mZmI4YjVjYTRkMTAgMTAwNjQ0Cj4gPiAtLS0gYS9kcml2ZXJzL21kL2RtLWxpbmVhci5j Cj4gPiArKysgYi9kcml2ZXJzL21kL2RtLWxpbmVhci5jCj4gPiBAQCAtMjgsMTIgKzI4LDEzIEBA IHN0cnVjdCBsaW5lYXJfYyB7Cj4gPiAgICovCj4gPiAgc3RhdGljIGludCBsaW5lYXJfY3RyKHN0 cnVjdCBkbV90YXJnZXQgKnRpLCB1bnNpZ25lZCBpbnQgYXJnYywgY2hhciAqKmFyZ3YpCj4gPiAg ewo+ID4gKwlmbW9kZV90IG1vZGU7Cj4gPiAgCXN0cnVjdCBsaW5lYXJfYyAqbGM7Cj4gPiAgCXVu c2lnbmVkIGxvbmcgbG9uZyB0bXA7Cj4gPiAgCWNoYXIgZHVtbXk7Cj4gPiAgCWludCByZXQ7Cj4g PiAgCj4gPiAtCWlmIChhcmdjICE9IDIpIHsKPiA+ICsJaWYgKChhcmdjIDwgMikgfHwgKGFyZ2Mg PiAzKSkgewo+ID4gIAkJdGktPmVycm9yID0gIkludmFsaWQgYXJndW1lbnQgY291bnQiOwo+ID4g IAkJcmV0dXJuIC1FSU5WQUw7Cj4gPiAgCX0KPiA+IEBAIC01MSw3ICs1MiwxOSBAQCBzdGF0aWMg aW50IGxpbmVhcl9jdHIoc3RydWN0IGRtX3RhcmdldCAqdGksIHVuc2lnbmVkIGludCBhcmdjLCBj aGFyICoqYXJndikKPiA+ICAJfQo+ID4gIAlsYy0+c3RhcnQgPSB0bXA7Cj4gPiAgCj4gPiAtCXJl dCA9IGRtX2dldF9kZXZpY2UodGksIGFyZ3ZbMF0sIGRtX3RhYmxlX2dldF9tb2RlKHRpLT50YWJs ZSksICZsYy0+ZGV2KTsKPiA+ICsJdGktPm5vbl9leGNsdXNpdmUgPSBmYWxzZTsKPiA+ICsJaWYg KGFyZ2MgPiAyKSB7Cj4gPiArCQlpZiAoc3RyY21wKCJub2V4Y2wiLCBhcmd2WzJdKSA9PSAwKQo+ ID4gKwkJCXRpLT5ub25fZXhjbHVzaXZlID0gdHJ1ZTsKPiA+ICsJCWVsc2UgaWYgKHN0cmNtcCgi ZXhjbCIsIGFyZ3ZbMl0pID09IDApCj4gPiArCQkJdGktPm5vbl9leGNsdXNpdmUgPSBmYWxzZTsK PiAKPiBJdCBhbHJlYWR5IGlzIGZhbHNlLgoKWWVzLCBhbmQgZXZlbiB0aGUgdmFsdWUgb2YgdGhl ICJleGNsIiBwYXJhbWV0ZXIgaXMgcmVkdW5kYW50LCBzaW5jZSBpdCBkZWZpbmVzCnRoZSBkZWZh dWx0IHZhbHVlLiBJIHRoaW5rIHRoaXMgY29kZSBzdHJ1Y3R1cmUgbW9yZSBjbGVhcmx5IHJlZmxl Y3RzIHRoZSBtZWFuaW5nCm9mIHRoZSBwYXJhbWV0ZXIuCgo+IAo+ID4gKwkJZWxzZSB7Cj4gPiAr CQkJdGktPmVycm9yID0gIkludmFsaWQgZXhjbHVzaXZlIG9wdGlvbiI7Cj4gPiArCQkJcmV0dXJu IC1FSU5WQUw7Cj4gPiArCQl9Cj4gPiArCX0KPiA+ICsKPiA+ICsJcmV0ID0gZG1fZ2V0X2Rldmlj ZSh0aSwgYXJndlswXSwgbW9kZSwgJmxjLT5kZXYpOwo+IAo+IFdoZXJlIGlzIG1vZGUgaW5pdGlh bGl6ZWQgPyBXaHkgcmVtb3ZlIGRtX3RhYmxlX2dldF9tb2RlKHRpLT50YWJsZSkgPwoKWWVzLiBJ dGBzIGEgYnVnLiBJbiB0aGlzIHBsYdGBZSBzaG91bGQgYmUgZG1fdGFibGVfZ2V0X21vZGUoKS4K Cj4gCj4gPiAgCWlmIChyZXQpIHsKPiA+ICAJCXRpLT5lcnJvciA9ICJEZXZpY2UgbG9va3VwIGZh aWxlZCI7Cj4gPiAgCQlnb3RvIGJhZDsKPiAKPiBJIHdvdWxkIHByZWZlciB0byBzZWUgdGhpcyBj aGFuZ2UgdG8gZG0tbGluZWFyIGluIGl0cyBvd24gcGF0Y2gsIGZvbGxvd2luZyB0aGlzCj4gb25l LCB3aXRoIGEgY2xlYXIgZXhwbGFuYXRpb24gaW4gdGhlIGNvbW1pdCBtZXNzYWdlIGhvdyB0aGlz IGNoYW5nZSByZWxhdGVzIHRvCj4gaW50ZXJwb3NlciBzaW5jZSB0aGUgZXhwbGFuYXRpb24gZm9y IHRoaXMgImV4Y2x1c2l2ZSIgY2hhbmdlIGlzIG5vd2hlcmUgdG8gYmUKPiBzZWVuLiBBbHNvIHBs ZWFzZSBjaGVjayBpZiB0aGVyZSBpcyBhIGZpbGUgZGVzY3JpYmluZyBkbS1saW5lYXIgb3B0aW9u cyB1bmRlcgo+IERvY3VtZW50YXRpb24vIChJIGNhbid0IHJlbWVtYmVyIGlmIHRoZXJlIGlzIG9u ZSkuIElmIHRoZXJlIGlzIG9uZSwgaXQgd2lsbCBuZWVkCj4gdG8gYmUgdXBkYXRlZCB0b28uCgpJ dCdzIGEgZ29vZCBpZGVhLgoKPiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLXRhYmxl LmMgYi9kcml2ZXJzL21kL2RtLXRhYmxlLmMKPiA+IGluZGV4IDRhY2YyMzQyZjdhZC4uZjE1YmMy MTcxZjI1IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9tZC9kbS10YWJsZS5jCj4gPiArKysgYi9k cml2ZXJzL21kL2RtLXRhYmxlLmMKPiA+IEBAIC0zMjIsNyArMzIyLDcgQEAgc3RhdGljIGludCBk ZXZpY2VfYXJlYV9pc19pbnZhbGlkKHN0cnVjdCBkbV90YXJnZXQgKnRpLCBzdHJ1Y3QgZG1fZGV2 ICpkZXYsCj4gPiAgICogZGV2aWNlIGFuZCBub3QgdG8gdG91Y2ggdGhlIGV4aXN0aW5nIGJkZXYg ZmllbGQgaW4gY2FzZQo+ID4gICAqIGl0IGlzIGFjY2Vzc2VkIGNvbmN1cnJlbnRseS4KPiA+ICAg Ki8KPiA+IC1zdGF0aWMgaW50IHVwZ3JhZGVfbW9kZShzdHJ1Y3QgZG1fZGV2X2ludGVybmFsICpk ZCwgZm1vZGVfdCBuZXdfbW9kZSwKPiA+ICtzdGF0aWMgaW50IHVwZ3JhZGVfbW9kZShzdHJ1Y3Qg ZG1fZGV2X2ludGVybmFsICpkZCwgZm1vZGVfdCBuZXdfbW9kZSwgYm9vbCBub25fZXhjbHVzaXZl LAo+ID4gIAkJCXN0cnVjdCBtYXBwZWRfZGV2aWNlICptZCkKPiA+ICB7Cj4gPiAgCWludCByOwo+ ID4gQEAgLTMzMCw3ICszMzAsNyBAQCBzdGF0aWMgaW50IHVwZ3JhZGVfbW9kZShzdHJ1Y3QgZG1f ZGV2X2ludGVybmFsICpkZCwgZm1vZGVfdCBuZXdfbW9kZSwKPiA+ICAKPiA+ICAJb2xkX2RldiA9 IGRkLT5kbV9kZXY7Cj4gPiAgCj4gPiAtCXIgPSBkbV9nZXRfdGFibGVfZGV2aWNlKG1kLCBkZC0+ ZG1fZGV2LT5iZGV2LT5iZF9kZXYsCj4gPiArCXIgPSBkbV9nZXRfdGFibGVfZGV2aWNlKG1kLCBk ZC0+ZG1fZGV2LT5iZGV2LT5iZF9kZXYsIG5vbl9leGNsdXNpdmUsCj4gPiAgCQkJCWRkLT5kbV9k ZXYtPm1vZGUgfCBuZXdfbW9kZSwgJm5ld19kZXYpOwo+ID4gIAlpZiAocikKPiA+ICAJCXJldHVy biByOwo+ID4gQEAgLTM4Nyw3ICszODcsOCBAQCBpbnQgZG1fZ2V0X2RldmljZShzdHJ1Y3QgZG1f dGFyZ2V0ICp0aSwgY29uc3QgY2hhciAqcGF0aCwgZm1vZGVfdCBtb2RlLAo+ID4gIAkJaWYgKCFk ZCkKPiA+ICAJCQlyZXR1cm4gLUVOT01FTTsKPiA+ICAKPiA+IC0JCWlmICgociA9IGRtX2dldF90 YWJsZV9kZXZpY2UodC0+bWQsIGRldiwgbW9kZSwgJmRkLT5kbV9kZXYpKSkgewo+ID4gKwkJciA9 IGRtX2dldF90YWJsZV9kZXZpY2UodC0+bWQsIGRldiwgbW9kZSwgdGktPm5vbl9leGNsdXNpdmUs ICZkZC0+ZG1fZGV2KTsKPiA+ICsJCWlmIChyKSB7Cj4gPiAgCQkJa2ZyZWUoZGQpOwo+ID4gIAkJ CXJldHVybiByOwo+ID4gIAkJfQo+ID4gQEAgLTM5Niw4ICszOTcsOSBAQCBpbnQgZG1fZ2V0X2Rl dmljZShzdHJ1Y3QgZG1fdGFyZ2V0ICp0aSwgY29uc3QgY2hhciAqcGF0aCwgZm1vZGVfdCBtb2Rl LAo+ID4gIAkJbGlzdF9hZGQoJmRkLT5saXN0LCAmdC0+ZGV2aWNlcyk7Cj4gPiAgCQlnb3RvIG91 dDsKPiA+ICAKPiA+IC0JfSBlbHNlIGlmIChkZC0+ZG1fZGV2LT5tb2RlICE9IChtb2RlIHwgZGQt PmRtX2Rldi0+bW9kZSkpIHsKPiA+IC0JCXIgPSB1cGdyYWRlX21vZGUoZGQsIG1vZGUsIHQtPm1k KTsKPiA+ICsJfSBlbHNlIGlmICgoZGQtPmRtX2Rldi0+bW9kZSAhPSAobW9kZSB8IGRkLT5kbV9k ZXYtPm1vZGUpKSAmJgo+ID4gKwkJICAgKGRkLT5kbV9kZXYtPm5vbl9leGNsdXNpdmUgIT0gdGkt Pm5vbl9leGNsdXNpdmUpKSB7Cj4gPiArCQlyID0gdXBncmFkZV9tb2RlKGRkLCBtb2RlLCB0aS0+ bm9uX2V4Y2x1c2l2ZSwgdC0+bWQpOwo+ID4gIAkJaWYgKHIpCj4gPiAgCQkJcmV0dXJuIHI7Cj4g PiAgCX0KPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLmMgYi9kcml2ZXJzL21kL2RtLmMK PiA+IGluZGV4IDdiYWM1NjRmM2ZhYS4uM2I4NzFkOThiN2I2IDEwMDY0NAo+ID4gLS0tIGEvZHJp dmVycy9tZC9kbS5jCj4gPiArKysgYi9kcml2ZXJzL21kL2RtLmMKPiA+IEBAIC0yOCw2ICsyOCw3 IEBACj4gPiAgI2luY2x1ZGUgPGxpbnV4L3JlZmNvdW50Lmg+Cj4gPiAgI2luY2x1ZGUgPGxpbnV4 L3BhcnRfc3RhdC5oPgo+ID4gICNpbmNsdWRlIDxsaW51eC9ibGstY3J5cHRvLmg+Cj4gPiArI2lu Y2x1ZGUgPGxpbnV4L2ludGVydmFsX3RyZWVfZ2VuZXJpYy5oPgo+ID4gIAo+ID4gICNkZWZpbmUg RE1fTVNHX1BSRUZJWCAiY29yZSIKPiA+ICAKPiA+IEBAIC01Niw2ICs1Nyw4IEBAIHN0YXRpYyBz dHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqZGVmZXJyZWRfcmVtb3ZlX3dvcmtxdWV1ZTsKPiA+ICBh dG9taWNfdCBkbV9nbG9iYWxfZXZlbnRfbnIgPSBBVE9NSUNfSU5JVCgwKTsKPiA+ICBERUNMQVJF X1dBSVRfUVVFVUVfSEVBRChkbV9nbG9iYWxfZXZlbnRxKTsKPiA+ICAKPiA+ICtzdGF0aWMgREVG SU5FX01VVEVYKGludGVycG9zZXJfbXV0ZXgpOyAvKiBzeW5jaHJvbml6aW5nIGFjY2VzcyB0byBi bGtfaW50ZXJwb3NlciAqLwo+IAo+IFdoeSBub3QgZG1faW50ZXJwb3Nlcl9tdXRleCBhcyB0aGUg bmFtZSA/IEFuZCB0aGUgY29tbWVudCBpcyBub3QgdmVyeSB1c2VmdWw6IGEKPiBtdXRleCBpcyBh bHdheXMgZm9yIHN5bmNocm9uaXppbmcgOikKClJpZ2h0LiBJJ2xsIGRvIGl0LgoKPiAKPiA+ICsK PiA+ICB2b2lkIGRtX2lzc3VlX2dsb2JhbF9ldmVudCh2b2lkKQo+ID4gIHsKPiA+ICAJYXRvbWlj X2luYygmZG1fZ2xvYmFsX2V2ZW50X25yKTsKPiA+IEBAIC0xNjIsNiArMTY1LDI2IEBAIHN0cnVj dCB0YWJsZV9kZXZpY2Ugewo+ID4gIAlzdHJ1Y3QgZG1fZGV2IGRtX2RldjsKPiA+ICB9Owo+ID4g IAo+ID4gKy8qCj4gPiArICogRGV2aWNlIG1hcHBlcmBzIGludGVycG9zZXIuCj4gPiArICovCj4g PiArc3RydWN0IGRtX2ludGVycG9zZXIgewo+ID4gKwlzdHJ1Y3QgYmxrX2ludGVycG9zZXIgYmxr X2lwOwo+ID4gKwlzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQ7Cj4gPiArCj4gPiArCXN0cnVjdCBr cmVmIGtyZWY7Cj4gPiArCXN0cnVjdCByd19zZW1hcGhvcmUgaXBfZGV2c19sb2NrOwo+ID4gKwlz dHJ1Y3QgcmJfcm9vdF9jYWNoZWQgaXBfZGV2c19yb290OyAvKiBkbV9pbnRlcnBvc2VkX2RldiB0 cmVlICovCj4gPiArfTsKPiA+ICsKPiA+ICsvKgo+ID4gKyAqIEludGVydmFsIHRyZWUgZm9yIGRl dmljZSBtYXBwZXIKPiA+ICsgKi8KPiA+ICsjZGVmaW5lIFNUQVJUKG5vZGUpICgobm9kZSktPnN0 YXJ0KQo+ID4gKyNkZWZpbmUgTEFTVChub2RlKSAoKG5vZGUpLT5sYXN0KQo+ID4gK0lOVEVSVkFM X1RSRUVfREVGSU5FKHN0cnVjdCBkbV9yYl9yYW5nZSwgbm9kZSwgc2VjdG9yX3QsIF9zdWJ0cmVl X2xhc3QsCj4gPiArCQkgICAgIFNUQVJULCBMQVNULCwgZG1fcmIpOwo+ID4gKwo+ID4gIC8qCj4g PiAgICogQmlvLWJhc2VkIERNJ3MgbWVtcG9vbHMnIHJlc2VydmVkIElPcyBzZXQgYnkgdGhlIHVz ZXIuCj4gPiAgICovCj4gPiBAQCAtNzMzLDI4ICs3NTYsMzQwIEBAIHN0YXRpYyB2b2lkIGRtX3B1 dF9saXZlX3RhYmxlX2Zhc3Qoc3RydWN0IG1hcHBlZF9kZXZpY2UgKm1kKSBfX3JlbGVhc2VzKFJD VSkKPiA+ICAJcmN1X3JlYWRfdW5sb2NrKCk7Cj4gPiAgfQo+ID4gIAo+ID4gK3N0YXRpYyB2b2lk IGRtX3N1Ym1pdF9iaW9faW50ZXJwb3Nlcl9mbihzdHJ1Y3QgYmlvICpiaW8pCj4gPiArewo+ID4g KwlzdHJ1Y3QgZG1faW50ZXJwb3NlciAqaXA7Cj4gPiArCXVuc2lnbmVkIGludCBub2lvX2ZsYWcg PSAwOwo+ID4gKwlzZWN0b3JfdCBzdGFydDsKPiA+ICsJc2VjdG9yX3QgbGFzdDsKPiA+ICsJc3Ry dWN0IGRtX3JiX3JhbmdlICpub2RlOwo+ID4gKwo+ID4gKwlpcCA9IGNvbnRhaW5lcl9vZihiaW8t PmJpX2Rpc2stPmludGVycG9zZXIsIHN0cnVjdCBkbV9pbnRlcnBvc2VyLCBibGtfaXApOwo+ID4g KwlzdGFydCA9IGJpby0+YmlfaXRlci5iaV9zZWN0b3I7Cj4gPiArCWxhc3QgPSBzdGFydCArIGRt X3NlY3Rvcl9kaXZfdXAoYmlvLT5iaV9pdGVyLmJpX3NpemUsIFNFQ1RPUl9TSVpFKTsKPiA+ICsK PiA+ICsJbm9pb19mbGFnID0gbWVtYWxsb2Nfbm9pb19zYXZlKCk7Cj4gPiArCWRvd25fcmVhZCgm aXAtPmlwX2RldnNfbG9jayk7Cj4gPiArCW5vZGUgPSBkbV9yYl9pdGVyX2ZpcnN0KCZpcC0+aXBf ZGV2c19yb290LCBzdGFydCwgbGFzdCk7Cj4gPiArCXdoaWxlIChub2RlKSB7Cj4gPiArCQlzdHJ1 Y3QgZG1faW50ZXJwb3NlZF9kZXYgKmlwX2RldiA9Cj4gPiArCQkJY29udGFpbmVyX29mKG5vZGUs IHN0cnVjdCBkbV9pbnRlcnBvc2VkX2Rldiwgbm9kZSk7Cj4gPiArCj4gPiArCQlhdG9taWM2NF9p bmMoJmlwX2Rldi0+aXBfY250KTsKPiA+ICsJCWlwX2Rldi0+ZG1faW50ZXJwb3NlX2JpbyhpcF9k ZXYtPmNvbnRleHQsIG5vZGUsIGJpbyk7Cj4gPiArCj4gPiArCQlub2RlID0gZG1fcmJfaXRlcl9u ZXh0KG5vZGUsIHN0YXJ0LCBsYXN0KTsKPiA+ICsJfQo+ID4gKwl1cF9yZWFkKCZpcC0+aXBfZGV2 c19sb2NrKTsKPiA+ICsJbWVtYWxsb2Nfbm9pb19yZXN0b3JlKG5vaW9fZmxhZyk7Cj4gPiArfQo+ ID4gKwo+ID4gK3N0YXRpYyB2b2lkIGZyZWVfaW50ZXJwb3NlcihzdHJ1Y3Qga3JlZiAqa3JlZikK PiA+ICt7Cj4gPiArCXN0cnVjdCBkbV9pbnRlcnBvc2VyICppcCA9IGNvbnRhaW5lcl9vZihrcmVm LCBzdHJ1Y3QgZG1faW50ZXJwb3Nlciwga3JlZik7Cj4gPiArCj4gPiArCWJsa19pbnRlcnBvc2Vy X2RldGFjaCgmaXAtPmJsa19pcCwgZG1fc3VibWl0X2Jpb19pbnRlcnBvc2VyX2ZuKTsKPiAKPiBO byBxdWV1ZSBmcmVlemUgPwoKWWVzLiBUaGUgcXVldWUgc2hvdWxkIGJlIGFscmVhZHkgZnJlZXpl LgoKPiAKPiA+ICsKPiA+ICsJa2ZyZWUoaXApOwo+ID4gK30KPiA+ICsKPiA+ICtzdGF0aWMgc3Ry dWN0IGRtX2ludGVycG9zZXIgKm5ld19pbnRlcnBvc2VyKHN0cnVjdCBnZW5kaXNrICpkaXNrKQo+ ID4gK3sKPiA+ICsJaW50IHJldCA9IDA7Cj4gPiArCXN0cnVjdCBkbV9pbnRlcnBvc2VyICppcDsK PiA+ICsKPiA+ICsJaXAgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgZG1faW50ZXJwb3NlciksIEdG UF9OT0lPKTsKPiA+ICsJaWYgKCFpcCkKPiA+ICsJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwo+ ID4gKwo+ID4gKwlrcmVmX2luaXQoJmlwLT5rcmVmKTsKPiA+ICsJaW5pdF9yd3NlbSgmaXAtPmlw X2RldnNfbG9jayk7Cj4gPiArCWlwLT5pcF9kZXZzX3Jvb3QgPSBSQl9ST09UX0NBQ0hFRDsKPiA+ ICsKPiA+ICsJcmV0ID0gYmxrX2ludGVycG9zZXJfYXR0YWNoKGRpc2ssICZpcC0+YmxrX2lwLCBk bV9zdWJtaXRfYmlvX2ludGVycG9zZXJfZm4pOwo+IAo+IE5vIHF1ZXVlIGZyZWV6ZSA/CgpZZXMs IGFnYWluLgoKPiAKPiA+ICsJaWYgKHJldCkgewo+ID4gKwkJRE1FUlIoIkZhaWxlZCB0byBhdHRh Y2sgYmxrX2ludGVycG9zZXIiKTsKPiA+ICsJCWtyZWZfcHV0KCZpcC0+a3JlZiwgZnJlZV9pbnRl cnBvc2VyKTsKPiA+ICsJCXJldHVybiBFUlJfUFRSKHJldCk7Cj4gPiArCX0KPiA+ICsKPiA+ICsJ cmV0dXJuIGlwOwo+ID4gK30KPiA+ICsKPiA+ICtzdGF0aWMgc3RydWN0IGRtX2ludGVycG9zZXIg KmdldF9pbnRlcnBvc2VyKHN0cnVjdCBnZW5kaXNrICpkaXNrKQo+ID4gK3sKPiA+ICsJc3RydWN0 IGRtX2ludGVycG9zZXIgKmlwOwo+ID4gKwo+ID4gKwlpZiAoIWJsa19oYXNfaW50ZXJwb3Nlcihk aXNrKSkKPiA+ICsJCXJldHVybiBOVUxMOwo+ID4gKwo+ID4gKwlpZiAoZGlzay0+aW50ZXJwb3Nl ci0+aXBfc3VibWl0X2JpbyAhPSBkbV9zdWJtaXRfYmlvX2ludGVycG9zZXJfZm4pIHsKPiA+ICsJ CURNRVJSKCJEaXNrcyBpbnRlcnBvc2VyIHNsb3QgYWxyZWFkeSBvY2N1cGllZC4iKTsKPiA+ICsJ CXJldHVybiBFUlJfUFRSKC1FQlVTWSk7Cj4gCj4gVGhpcyBpcyB3ZWlyZC4uLiBJZiB0aGVyZSBp cyBhbiBpbnRlcnBvc2VyLCB3aHkgbm90IGdldCBhIHJlZiBvbiB0aGF0IG9uZS4gVGhhdAo+IGlz IHdoYXQgdGhlIGZ1bmN0aW9uIG5hbWUgc3VnZ2VzdHMgYXQgbGVhc3QuCgpHZXR0aW5nIGEgcmVm IG9uIHRoYXQganVzdCBiZWxvdyBpbiB0aGlzIGZ1bmN0aW9uLiBCdXQgdGhlIG5hbWUgImdldF9k bV9pbnRlcnBvc2VyIgp3b3VsZCBiZSBiZXR0ZXIuCgo+IAo+ID4gKwl9Cj4gPiArCj4gPiArCWlw ID0gY29udGFpbmVyX29mKGRpc2stPmludGVycG9zZXIsIHN0cnVjdCBkbV9pbnRlcnBvc2VyLCBi bGtfaXApOwo+ID4gKwo+ID4gKwlrcmVmX2dldCgmaXAtPmtyZWYpOwo+ID4gKwlyZXR1cm4gaXA7 Cj4gPiArfQo+ID4gKwo+ID4gK3N0cnVjdCBkbV9pbnRlcnBvc2VkX2RldiAqZG1faW50ZXJwb3Nl cl9uZXdfZGV2KHN0cnVjdCBnZW5kaXNrICpkaXNrLCBzZWN0b3JfdCBvZnMsIHNlY3Rvcl90IGxl biwKPiA+ICsJCQkJCQl2b2lkICpjb250ZXh0LCBkbV9pbnRlcnBvc2VfYmlvX3QgZG1faW50ZXJw b3NlX2JpbykKPiA+ICt7Cj4gPiArCXNlY3Rvcl90IHN0YXJ0ID0gb2ZzOwo+ID4gKwlzZWN0b3Jf dCBsYXN0ID0gIG9mcyArIGxlbiAtIDE7Cj4gPiArCXN0cnVjdCBkbV9pbnRlcnBvc2VkX2RldiAq aXBfZGV2ID0gTlVMTDsKPiA+ICsKPiA+ICsJLyogQWxsb2NhdGUgbmV3IGlwX2RldiAqLwo+ID4g KwlpcF9kZXYgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgZG1faW50ZXJwb3NlZF9kZXYpLCBHRlBf S0VSTkVMKTsKPiA+ICsJaWYgKCFpcF9kZXYpCj4gPiArCQlyZXR1cm4gTlVMTDsKPiA+ICsKPiA+ ICsJaXBfZGV2LT5kaXNrID0gZGlzazsKPiA+ICsJaXBfZGV2LT5ub2RlLnN0YXJ0ID0gc3RhcnQ7 Cj4gPiArCWlwX2Rldi0+bm9kZS5sYXN0ID0gbGFzdDsKPiA+ICsKPiA+ICsJaXBfZGV2LT5jb250 ZXh0ID0gY29udGV4dDsKPiA+ICsJaXBfZGV2LT5kbV9pbnRlcnBvc2VfYmlvID0gZG1faW50ZXJw b3NlX2JpbzsKPiA+ICsKPiA+ICsJYXRvbWljNjRfc2V0KCZpcF9kZXYtPmlwX2NudCwgMCk7Cj4g PiArCj4gPiArCXJldHVybiBpcF9kZXY7Cj4gPiArfQo+ID4gKwo+ID4gK3ZvaWQgZG1faW50ZXJw b3Nlcl9mcmVlX2RldihzdHJ1Y3QgZG1faW50ZXJwb3NlZF9kZXYgKmlwX2RldikKPiA+ICt7Cj4g PiArCWtmcmVlKGlwX2Rldik7Cj4gPiArfQo+IAo+IE1ha2UgdGhpcyBpbmxpbmUgbWF5IGJlID8K Clllcy4gT3IgZXZlbiByZW1vdmUgdGhpcyBmdW5jdGlvbi4KCj4gCj4gPiArCj4gPiArc3RhdGlj IGlubGluZSB2b2lkIGRtX2Rpc2tfZnJlZXplKHN0cnVjdCBnZW5kaXNrICpkaXNrKQo+ID4gK3sK PiA+ICsJYmxrX21xX2ZyZWV6ZV9xdWV1ZShkaXNrLT5xdWV1ZSk7Cj4gPiArCWJsa19tcV9xdWll c2NlX3F1ZXVlKGRpc2stPnF1ZXVlKTsKPiAKPiBJIHRoaW5rIHlvdSBjYW4gcmVwbGFjZSB0aGlz IHdpdGggYmxrX21xX2ZyZWV6ZV9xdWV1ZV93YWl0KCkuCgpJIHRoaW5rIG5vLiBibGtfZnJlZXpl X3F1ZXVlX3N0YXJ0KCkgYWxzbyBpcyByZXF1aXJlZC4KCj4gCj4gPiArfQo+ID4gKwo+ID4gK3N0 YXRpYyBpbmxpbmUgdm9pZCBkbV9kaXNrX3VuZnJlZXplKHN0cnVjdCBnZW5kaXNrICpkaXNrKQo+ ID4gK3sKPiA+ICsJYmxrX21xX3VucXVpZXNjZV9xdWV1ZShkaXNrLT5xdWV1ZSk7Cj4gPiArCWJs a19tcV91bmZyZWV6ZV9xdWV1ZShkaXNrLT5xdWV1ZSk7Cj4gPiArfQo+ID4gKwo+ID4gK2ludCBk bV9pbnRlcnBvc2VyX2F0dGFjaF9kZXYoc3RydWN0IGRtX2ludGVycG9zZWRfZGV2ICppcF9kZXYp Cj4gPiArewo+ID4gKwlpbnQgcmV0ID0gMDsKPiA+ICsJc3RydWN0IGRtX2ludGVycG9zZXIgKmlw ID0gTlVMTDsKPiA+ICsJdW5zaWduZWQgaW50IG5vaW9fZmxhZyA9IDA7Cj4gPiArCj4gPiArCWlm ICghaXBfZGV2KQo+ID4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gPiArCj4gPiArCWRtX2Rpc2tfZnJl ZXplKGlwX2Rldi0+ZGlzayk7Cj4gPiArCW11dGV4X2xvY2soJmludGVycG9zZXJfbXV0ZXgpOwo+ ID4gKwlub2lvX2ZsYWcgPSBtZW1hbGxvY19ub2lvX3NhdmUoKTsKPiA+ICsKPiA+ICsJaXAgPSBn ZXRfaW50ZXJwb3NlcihpcF9kZXYtPmRpc2spOwo+ID4gKwlpZiAoaXAgPT0gTlVMTCkKPiA+ICsJ CWlwID0gbmV3X2ludGVycG9zZXIoaXBfZGV2LT5kaXNrKTsKPiA+ICsJaWYgKElTX0VSUihpcCkp IHsKPiA+ICsJCXJldCA9IFBUUl9FUlIoaXApOwo+ID4gKwkJZ290byBvdXQ7Cj4gPiArCX0KPiA+ ICsKPiA+ICsJLyogQXR0YWNoIGRtX2ludGVycG9zZWRfZGV2IHRvIGRtX2ludGVycG9zZXIgKi8K PiA+ICsJZG93bl93cml0ZSgmaXAtPmlwX2RldnNfbG9jayk7Cj4gPiArCWRvIHsKPiA+ICsJCXN0 cnVjdCBkbV9yYl9yYW5nZSAqbm9kZTsKPiA+ICsKPiA+ICsJCS8qIGNoZWNraW5nIHRoYXQgaXBf ZGV2IGFscmVhZHkgZXhpc3RzIGZvciB0aGlzIHJlZ2lvbiAqLwo+ID4gKwkJbm9kZSA9IGRtX3Ji X2l0ZXJfZmlyc3QoJmlwLT5pcF9kZXZzX3Jvb3QsIGlwX2Rldi0+bm9kZS5zdGFydCwgaXBfZGV2 LT5ub2RlLmxhc3QpOwo+ID4gKwkJaWYgKG5vZGUpIHsKPiA+ICsJCQlETUVSUigiRGlzayBwYXJ0 IGZvcm0gWyVsbHVdIHRvIFslbGx1XSBhbHJlYWR5IGhhdmUgaW50ZXJwb3NlciIsCj4gPiArCQkJ ICAgICAgbm9kZS0+c3RhcnQsIG5vZGUtPmxhc3QpOwo+ID4gKwo+ID4gKwkJCXJldCA9IC1FQlVT WTsKPiA+ICsJCQlicmVhazsKPiA+ICsJCX0KPiA+ICsKPiA+ICsJCS8qIGluc2VydCBpcF9kZXYg dG8gaXAgdHJlZSAqLwo+ID4gKwkJZG1fcmJfaW5zZXJ0KCZpcF9kZXYtPm5vZGUsICZpcC0+aXBf ZGV2c19yb290KTsKPiA+ICsJCS8qIGluY3JlbWVudCBpcCByZWZlcmVuY2UgY291bnRlciAqLwo+ ID4gKwkJa3JlZl9nZXQoJmlwLT5rcmVmKTsKPiA+ICsJfSB3aGlsZSAoZmFsc2UpOwo+ID4gKwl1 cF93cml0ZSgmaXAtPmlwX2RldnNfbG9jayk7Cj4gPiArCj4gPiArCWtyZWZfcHV0KCZpcC0+a3Jl ZiwgZnJlZV9pbnRlcnBvc2VyKTsKPiA+ICsKPiA+ICtvdXQ6Cj4gPiArCW1lbWFsbG9jX25vaW9f cmVzdG9yZShub2lvX2ZsYWcpOwo+ID4gKwltdXRleF91bmxvY2soJmludGVycG9zZXJfbXV0ZXgp Owo+ID4gKwlkbV9kaXNrX3VuZnJlZXplKGlwX2Rldi0+ZGlzayk7Cj4gPiArCj4gPiArCXJldHVy biByZXQ7Cj4gPiArfQo+ID4gKwo+ID4gK2ludCBkbV9pbnRlcnBvc2VyX2RldGFjaF9kZXYoc3Ry dWN0IGRtX2ludGVycG9zZWRfZGV2ICppcF9kZXYpCj4gPiArewo+ID4gKwlpbnQgcmV0ID0gMDsK PiA+ICsJc3RydWN0IGRtX2ludGVycG9zZXIgKmlwID0gTlVMTDsKPiA+ICsJdW5zaWduZWQgaW50 IG5vaW9fZmxhZyA9IDA7Cj4gPiArCj4gPiArCWlmICghaXBfZGV2KQo+ID4gKwkJcmV0dXJuIC1F SU5WQUw7Cj4gPiArCj4gPiArCWRtX2Rpc2tfZnJlZXplKGlwX2Rldi0+ZGlzayk7Cj4gPiArCW11 dGV4X2xvY2soJmludGVycG9zZXJfbXV0ZXgpOwo+ID4gKwlub2lvX2ZsYWcgPSBtZW1hbGxvY19u b2lvX3NhdmUoKTsKPiA+ICsKPiA+ICsJaXAgPSBnZXRfaW50ZXJwb3NlcihpcF9kZXYtPmRpc2sp Owo+ID4gKwlpZiAoSVNfRVJSKGlwKSkgewo+ID4gKwkJcmV0ID0gUFRSX0VSUihpcCk7Cj4gPiAr CQlETUVSUigiSW50ZXJwb3NlciBub3QgZm91bmQiKTsKPiA+ICsJCWdvdG8gb3V0Owo+ID4gKwl9 Cj4gPiArCWlmICh1bmxpa2VseShpcCA9PSBOVUxMKSkgewo+ID4gKwkJcmV0ID0gLUVOWElPOwo+ ID4gKwkJRE1FUlIoIkludGVycG9zZXIgbm90IGZvdW5kIik7Cj4gPiArCQlnb3RvIG91dDsKPiA+ ICsJfQo+ID4gKwo+ID4gKwlkb3duX3dyaXRlKCZpcC0+aXBfZGV2c19sb2NrKTsKPiA+ICsJZG8g ewo+ID4gKwkJZG1fcmJfcmVtb3ZlKCZpcF9kZXYtPm5vZGUsICZpcC0+aXBfZGV2c19yb290KTsK PiA+ICsJCS8qIHRoZSByZWZlcmVuY2UgY291bnRlciBoZXJlIGNhbm5vdCBiZSB6ZXJvICovCj4g PiArCQlrcmVmX3B1dCgmaXAtPmtyZWYsIGZyZWVfaW50ZXJwb3Nlcik7Cj4gPiArCj4gPiArCX0g d2hpbGUgKGZhbHNlKTsKPiA+ICsJdXBfd3JpdGUoJmlwLT5pcF9kZXZzX2xvY2spOwo+ID4gKwo+ ID4gKwkvKiBkZXRhY2ggYW5kIGZyZWUgaW50ZXJwb3NlciBpZiBpdGBzIG5vdCBuZWVkZWQgKi8K PiAKPiBzL2AvJy8KClRoYW5rcy4gSXQncyBteSBwcm9ibGVtLgoKPiAKPiA+ICsJa3JlZl9wdXQo JmlwLT5rcmVmLCBmcmVlX2ludGVycG9zZXIpOwo+ID4gK291dDoKPiA+ICsJbWVtYWxsb2Nfbm9p b19yZXN0b3JlKG5vaW9fZmxhZyk7Cj4gPiArCW11dGV4X3VubG9jaygmaW50ZXJwb3Nlcl9tdXRl eCk7Cj4gPiArCWRtX2Rpc2tfdW5mcmVlemUoaXBfZGV2LT5kaXNrKTsKPiA+ICsKPiA+ICsJcmV0 dXJuIHJldDsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGljIHZvaWQgZG1fcmVtYXBfZm4odm9pZCAq Y29udGV4dCwgc3RydWN0IGRtX3JiX3JhbmdlICpub2RlLCBzdHJ1Y3QgYmlvICpiaW8pCj4gPiAr ewo+ID4gKwlzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQgPSBjb250ZXh0Owo+ID4gKwo+ID4gKwkv KiBTZXQgYWNjZXB0b3IgZGV2aWNlLiAqLwo+ID4gKwliaW8tPmJpX2Rpc2sgPSBtZC0+ZGlzazsK PiA+ICsKPiA+ICsJLyogUmVtYXAgZGlza3Mgb2Zmc2V0ICovCj4gPiArCWJpby0+YmlfaXRlci5i aV9zZWN0b3IgLT0gbm9kZS0+c3RhcnQ7Cj4gPiArCj4gPiArCS8qCj4gPiArCSAqIGJpbyBzaG91 bGQgYmUgcmVzdWJtaXR0ZWQuCj4gPiArCSAqIFdlIGNhbiBqdXN0IGFkZCBiaW8gdG8gYmlvX2xp c3Qgb2YgdGhlIGN1cnJlbnQgcHJvY2Vzcy4KPiA+ICsJICogY3VycmVudC0+YmlvX2xpc3QgbXVz dCBiZSBpbml0aWFsaXplZCB3aGVuIHRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkLgo+ID4gKwkgKiBJ ZiBjYWxsIHN1Ym1pdF9iaW9fbm9hY2N0KCksIHRoZSBiaW8gd2lsbCBiZSBjaGVja2VkIHR3aWNl Lgo+ID4gKwkgKi8KPiA+ICsJQlVHX09OKCFjdXJyZW50LT5iaW9fbGlzdCk7Cj4gPiArCWJpb19s aXN0X2FkZCgmY3VycmVudC0+YmlvX2xpc3RbMF0sIGJpbyk7Cj4gPiArfQo+ID4gKwo+ID4gK2lu dCBkbV9yZW1hcF9pbnN0YWxsKHN0cnVjdCBtYXBwZWRfZGV2aWNlICptZCwgY29uc3QgY2hhciAq ZG9ub3JfZGV2aWNlX25hbWUpCj4gPiArewo+ID4gKwlpbnQgcmV0ID0gMDsKPiA+ICsJc3RydWN0 IGJsb2NrX2RldmljZSAqZG9ub3JfYmRldjsKPiA+ICsJZm1vZGVfdCBtb2RlID0gRk1PREVfUkVB RCB8IEZNT0RFX1dSSVRFOwo+ID4gKwo+ID4gKwlETURFQlVHKCJEbSByZW1hcCBpbnN0YWxsIGZv ciBtYXBwZWQgZGV2aWNlICVzIGFuZCBkb25vciBkZXZpY2UgJXMiLAo+ID4gKwkJbWQtPm5hbWUs IGRvbm9yX2RldmljZV9uYW1lKTsKPiA+ICsKPiA+ICsJZG9ub3JfYmRldiA9IGJsa2Rldl9nZXRf YnlfcGF0aChkb25vcl9kZXZpY2VfbmFtZSwgbW9kZSwgImRldmljZS1tYXBwZXIgcmVtYXAiKTsK PiA+ICsJaWYgKElTX0VSUihkb25vcl9iZGV2KSkgewo+ID4gKwkJRE1FUlIoIkNhbm5vdCBvcGVu IGRldmljZSBbJXNdIiwgZG9ub3JfZGV2aWNlX25hbWUpOwo+ID4gKwkJcmV0dXJuIFBUUl9FUlIo ZG9ub3JfYmRldik7Cj4gPiArCX0KPiA+ICsKPiA+ICsJZG8gewo+ID4gKwkJc2VjdG9yX3Qgb2Zz ID0gZ2V0X3N0YXJ0X3NlY3QoZG9ub3JfYmRldik7Cj4gPiArCQlzZWN0b3JfdCBsZW4gPSBiZGV2 X25yX3NlY3RvcnMoZG9ub3JfYmRldik7Cj4gPiArCj4gPiArCQltZC0+aXBfZGV2ID0gZG1faW50 ZXJwb3Nlcl9uZXdfZGV2KGRvbm9yX2JkZXYtPmJkX2Rpc2ssIG9mcywgbGVuLCBtZCwgZG1fcmVt YXBfZm4pOwo+ID4gKwkJaWYgKCFtZC0+aXBfZGV2KSB7Cj4gPiArCQkJcmV0ID0gLUVOT01FTTsK PiA+ICsJCQlicmVhazsKPiA+ICsJCX0KPiA+ICsKPiA+ICsJCURNREVCVUcoIk5ldyBpbnRlcnBv c2VkIGRldmljZSAweCVwIiwgbWQtPmlwX2Rldik7Cj4gPiArCQlyZXQgPSBkbV9pbnRlcnBvc2Vy X2F0dGFjaF9kZXYobWQtPmlwX2Rldik7Cj4gPiArCQlpZiAocmV0KSB7Cj4gPiArCQkJZG1faW50 ZXJwb3Nlcl9mcmVlX2RldihtZC0+aXBfZGV2KTsKPiA+ICsKPiA+ICsJCQltZC0+aXBfZGV2ID0g TlVMTDsKPiA+ICsJCQlETUVSUigiRmFpbGVkIHRvIGF0dGFjaCBkbSBpbnRlcnBvc2VyIik7Cj4g PiArCQkJYnJlYWs7Cj4gPiArCQl9Cj4gPiArCj4gPiArCQlETURFQlVHKCJBdHRhY2hlZCBzdWNj ZXNzZnVsbHkuIik7Cj4gPiArCX0gd2hpbGUgKGZhbHNlKTsKPiA+ICsKPiA+ICsJYmxrZGV2X3B1 dChkb25vcl9iZGV2LCBtb2RlKTsKPiA+ICsKPiA+ICsJcmV0dXJuIHJldDsKPiA+ICt9Cj4gPiAr Cj4gPiAraW50IGRtX3JlbWFwX3VuaW5zdGFsbChzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQpCj4g PiArewo+ID4gKwlpbnQgcmV0ID0gMDsKPiA+ICsKPiA+ICsJRE1ERUJVRygiRG0gcmVtYXAgdW5p bnN0YWxsIGZvciBtYXBwZWQgZGV2aWNlICVzIGlwX2Rldj0weCVwIiwgbWQtPm5hbWUsIG1kLT5p cF9kZXYpOwo+ID4gKwo+ID4gKwlpZiAoIW1kLT5pcF9kZXYpIHsKPiA+ICsJCURNRVJSKCJDYW5u b3QgZGV0YWNoIGRtIGludGVycG9zZXIiKTsKPiA+ICsJCXJldHVybiAtRUlOVkFMOwo+ID4gKwl9 Cj4gPiArCj4gPiArCXJldCA9IGRtX2ludGVycG9zZXJfZGV0YWNoX2RldihtZC0+aXBfZGV2KTsK PiA+ICsJaWYgKHJldCkgewo+ID4gKwkJRE1FUlIoIkZhaWxlZCB0byBkZXRhY2ggZG0gaW50ZXJw b3NlciIpOwo+ID4gKwkJcmV0dXJuIHJldDsKPiA+ICsJfQo+ID4gKwo+ID4gKwlETURFQlVHKCJE ZXRhY2hlZCBzdWNjZXNzZnVsbHkuICVsbHUgYmlvcyB3YXMgaW50ZXJwb3NlZCIsCj4gPiArCQlh dG9taWM2NF9yZWFkKCZtZC0+aXBfZGV2LT5pcF9jbnQpKTsKPiA+ICsJZG1faW50ZXJwb3Nlcl9m cmVlX2RldihtZC0+aXBfZGV2KTsKPiA+ICsJbWQtPmlwX2RldiA9IE5VTEw7Cj4gPiArCj4gPiAr CXJldHVybiAwOwo+ID4gK30KPiA+ICsKPiA+ICBzdGF0aWMgY2hhciAqX2RtX2NsYWltX3B0ciA9 ICJJIGJlbG9uZyB0byBkZXZpY2UtbWFwcGVyIjsKPiA+ICAKPiA+ICAvKgo+ID4gICAqIE9wZW4g YSB0YWJsZSBkZXZpY2Ugc28gd2UgY2FuIHVzZSBpdCBhcyBhIG1hcCBkZXN0aW5hdGlvbi4KPiA+ ICAgKi8KPiA+ICBzdGF0aWMgaW50IG9wZW5fdGFibGVfZGV2aWNlKHN0cnVjdCB0YWJsZV9kZXZp Y2UgKnRkLCBkZXZfdCBkZXYsCj4gPiAtCQkJICAgICBzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQp Cj4gPiArCQkJICAgICBzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQsIGJvb2wgbm9uX2V4Y2x1c2l2 ZSkKPiA+ICB7Cj4gPiAgCXN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXY7Cj4gPiAtCj4gPiAtCWlu dCByOwo+ID4gKwlpbnQgcmV0Owo+ID4gIAo+ID4gIAlCVUdfT04odGQtPmRtX2Rldi5iZGV2KTsK PiA+ICAKPiA+IC0JYmRldiA9IGJsa2Rldl9nZXRfYnlfZGV2KGRldiwgdGQtPmRtX2Rldi5tb2Rl IHwgRk1PREVfRVhDTCwgX2RtX2NsYWltX3B0cik7Cj4gPiAtCWlmIChJU19FUlIoYmRldikpCj4g PiAtCQlyZXR1cm4gUFRSX0VSUihiZGV2KTsKPiA+ICsJaWYgKG5vbl9leGNsdXNpdmUpCj4gPiAr CQliZGV2ID0gYmxrZGV2X2dldF9ieV9kZXYoZGV2LCB0ZC0+ZG1fZGV2Lm1vZGUsIE5VTEwpOwo+ ID4gKwllbHNlCj4gPiArCQliZGV2ID0gYmxrZGV2X2dldF9ieV9kZXYoZGV2LCB0ZC0+ZG1fZGV2 Lm1vZGUgfCBGTU9ERV9FWENMLCBfZG1fY2xhaW1fcHRyKTsKPiA+ICAKPiA+IC0JciA9IGJkX2xp bmtfZGlza19ob2xkZXIoYmRldiwgZG1fZGlzayhtZCkpOwo+ID4gLQlpZiAocikgewo+ID4gLQkJ YmxrZGV2X3B1dChiZGV2LCB0ZC0+ZG1fZGV2Lm1vZGUgfCBGTU9ERV9FWENMKTsKPiA+IC0JCXJl dHVybiByOwo+ID4gKwlpZiAoSVNfRVJSKGJkZXYpKSB7Cj4gPiArCQlyZXQgPSBQVFJfRVJSKGJk ZXYpOwo+ID4gKwkJaWYgKHJldCAhPSAtRUJVU1kpCj4gPiArCQkJcmV0dXJuIHJldDsKPiA+ICsJ fQo+ID4gKwo+ID4gKwlpZiAoIW5vbl9leGNsdXNpdmUpIHsKPiA+ICsJCXJldCA9IGJkX2xpbmtf ZGlza19ob2xkZXIoYmRldiwgZG1fZGlzayhtZCkpOwo+ID4gKwkJaWYgKHJldCkgewo+ID4gKwkJ CWJsa2Rldl9wdXQoYmRldiwgdGQtPmRtX2Rldi5tb2RlKTsKPiA+ICsJCQlyZXR1cm4gcmV0Owo+ ID4gKwkJfQo+ID4gIAl9Cj4gPiAgCj4gPiAgCXRkLT5kbV9kZXYuYmRldiA9IGJkZXY7Cj4gPiBA QCAtNzcwLDMzICsxMTA1LDM4IEBAIHN0YXRpYyB2b2lkIGNsb3NlX3RhYmxlX2RldmljZShzdHJ1 Y3QgdGFibGVfZGV2aWNlICp0ZCwgc3RydWN0IG1hcHBlZF9kZXZpY2UgKm1kCj4gPiAgCWlmICgh dGQtPmRtX2Rldi5iZGV2KQo+ID4gIAkJcmV0dXJuOwo+ID4gIAo+ID4gLQliZF91bmxpbmtfZGlz a19ob2xkZXIodGQtPmRtX2Rldi5iZGV2LCBkbV9kaXNrKG1kKSk7Cj4gPiAtCWJsa2Rldl9wdXQo dGQtPmRtX2Rldi5iZGV2LCB0ZC0+ZG1fZGV2Lm1vZGUgfCBGTU9ERV9FWENMKTsKPiA+ICsJaWYg KHRkLT5kbV9kZXYubW9kZSAmIEZNT0RFX0VYQ0wpCj4gPiArCQliZF91bmxpbmtfZGlza19ob2xk ZXIodGQtPmRtX2Rldi5iZGV2LCBkbV9kaXNrKG1kKSk7Cj4gPiArCj4gPiArCWJsa2Rldl9wdXQo dGQtPmRtX2Rldi5iZGV2LCB0ZC0+ZG1fZGV2Lm1vZGUpOwo+ID4gKwo+ID4gIAlwdXRfZGF4KHRk LT5kbV9kZXYuZGF4X2Rldik7Cj4gPiAgCXRkLT5kbV9kZXYuYmRldiA9IE5VTEw7Cj4gPiAgCXRk LT5kbV9kZXYuZGF4X2RldiA9IE5VTEw7Cj4gPiAgfQo+ID4gIAo+ID4gIHN0YXRpYyBzdHJ1Y3Qg dGFibGVfZGV2aWNlICpmaW5kX3RhYmxlX2RldmljZShzdHJ1Y3QgbGlzdF9oZWFkICpsLCBkZXZf dCBkZXYsCj4gPiAtCQkJCQkgICAgICBmbW9kZV90IG1vZGUpCj4gPiArCQkJCQkgICAgICBmbW9k ZV90IG1vZGUsIGJvb2wgbm9uX2V4Y2x1c2l2ZSkKPiA+ICB7Cj4gPiAgCXN0cnVjdCB0YWJsZV9k ZXZpY2UgKnRkOwo+ID4gIAo+ID4gIAlsaXN0X2Zvcl9lYWNoX2VudHJ5KHRkLCBsLCBsaXN0KQo+ ID4gLQkJaWYgKHRkLT5kbV9kZXYuYmRldi0+YmRfZGV2ID09IGRldiAmJiB0ZC0+ZG1fZGV2Lm1v ZGUgPT0gbW9kZSkKPiA+ICsJCWlmICh0ZC0+ZG1fZGV2LmJkZXYtPmJkX2RldiA9PSBkZXYgJiYK PiA+ICsJCSAgICB0ZC0+ZG1fZGV2Lm1vZGUgPT0gbW9kZSAmJgo+ID4gKwkJICAgIHRkLT5kbV9k ZXYubm9uX2V4Y2x1c2l2ZSA9PSBub25fZXhjbHVzaXZlKQo+ID4gIAkJCXJldHVybiB0ZDsKPiA+ ICAKPiA+ICAJcmV0dXJuIE5VTEw7Cj4gPiAgfQo+ID4gIAo+ID4gLWludCBkbV9nZXRfdGFibGVf ZGV2aWNlKHN0cnVjdCBtYXBwZWRfZGV2aWNlICptZCwgZGV2X3QgZGV2LCBmbW9kZV90IG1vZGUs Cj4gPiAraW50IGRtX2dldF90YWJsZV9kZXZpY2Uoc3RydWN0IG1hcHBlZF9kZXZpY2UgKm1kLCBk ZXZfdCBkZXYsIGZtb2RlX3QgbW9kZSwgYm9vbCBub25fZXhjbHVzaXZlLAo+ID4gIAkJCXN0cnVj dCBkbV9kZXYgKipyZXN1bHQpCj4gPiAgewo+ID4gIAlpbnQgcjsKPiA+ICAJc3RydWN0IHRhYmxl X2RldmljZSAqdGQ7Cj4gPiAgCj4gPiAgCW11dGV4X2xvY2soJm1kLT50YWJsZV9kZXZpY2VzX2xv Y2spOwo+ID4gLQl0ZCA9IGZpbmRfdGFibGVfZGV2aWNlKCZtZC0+dGFibGVfZGV2aWNlcywgZGV2 LCBtb2RlKTsKPiA+ICsJdGQgPSBmaW5kX3RhYmxlX2RldmljZSgmbWQtPnRhYmxlX2RldmljZXMs IGRldiwgbW9kZSwgbm9uX2V4Y2x1c2l2ZSk7Cj4gPiAgCWlmICghdGQpIHsKPiA+ICAJCXRkID0g a21hbGxvY19ub2RlKHNpemVvZigqdGQpLCBHRlBfS0VSTkVMLCBtZC0+bnVtYV9ub2RlX2lkKTsK PiA+ICAJCWlmICghdGQpIHsKPiA+IEBAIC04MDcsNyArMTE0Nyw4IEBAIGludCBkbV9nZXRfdGFi bGVfZGV2aWNlKHN0cnVjdCBtYXBwZWRfZGV2aWNlICptZCwgZGV2X3QgZGV2LCBmbW9kZV90IG1v ZGUsCj4gPiAgCQl0ZC0+ZG1fZGV2Lm1vZGUgPSBtb2RlOwo+ID4gIAkJdGQtPmRtX2Rldi5iZGV2 ID0gTlVMTDsKPiA+ICAKPiA+IC0JCWlmICgociA9IG9wZW5fdGFibGVfZGV2aWNlKHRkLCBkZXYs IG1kKSkpIHsKPiA+ICsJCXIgPSBvcGVuX3RhYmxlX2RldmljZSh0ZCwgZGV2LCBtZCwgbm9uX2V4 Y2x1c2l2ZSk7Cj4gPiArCQlpZiAocikgewo+ID4gIAkJCW11dGV4X3VubG9jaygmbWQtPnRhYmxl X2RldmljZXNfbG9jayk7Cj4gPiAgCQkJa2ZyZWUodGQpOwo+ID4gIAkJCXJldHVybiByOwo+ID4g QEAgLTIxODIsNiArMjUyMywxNCBAQCBzdGF0aWMgdm9pZCBfX2RtX2Rlc3Ryb3koc3RydWN0IG1h cHBlZF9kZXZpY2UgKm1kLCBib29sIHdhaXQpCj4gPiAgCj4gPiAgCW1pZ2h0X3NsZWVwKCk7Cj4g PiAgCj4gPiArCWlmIChtZC0+aXBfZGV2KSB7Cj4gPiArCQlpZiAoZG1faW50ZXJwb3Nlcl9kZXRh Y2hfZGV2KG1kLT5pcF9kZXYpKQo+ID4gKwkJCURNRVJSKCJGYWlsZWQgdG8gZGV0YWNoIGRtIGlu dGVycG9zZXIiKTsKPiA+ICsKPiA+ICsJCWRtX2ludGVycG9zZXJfZnJlZV9kZXYobWQtPmlwX2Rl dik7Cj4gPiArCQltZC0+aXBfZGV2ID0gTlVMTDsKPiA+ICsJfQo+ID4gKwo+ID4gIAlzcGluX2xv Y2soJl9taW5vcl9sb2NrKTsKPiA+ICAJaWRyX3JlcGxhY2UoJl9taW5vcl9pZHIsIE1JTk9SX0FM TE9DRUQsIE1JTk9SKGRpc2tfZGV2dChkbV9kaXNrKG1kKSkpKTsKPiA+ICAJc2V0X2JpdChETUZf RlJFRUlORywgJm1kLT5mbGFncyk7Cj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS5oIGIv ZHJpdmVycy9tZC9kbS5oCj4gPiBpbmRleCBmZmZlMWUyODljNTMuLjdiZjIwZmIyZGU3NCAxMDA2 NDQKPiA+IC0tLSBhL2RyaXZlcnMvbWQvZG0uaAo+ID4gKysrIGIvZHJpdmVycy9tZC9kbS5oCj4g PiBAQCAtMTc5LDcgKzE3OSw3IEBAIGludCBkbV9vcGVuX2NvdW50KHN0cnVjdCBtYXBwZWRfZGV2 aWNlICptZCk7Cj4gPiAgaW50IGRtX2xvY2tfZm9yX2RlbGV0aW9uKHN0cnVjdCBtYXBwZWRfZGV2 aWNlICptZCwgYm9vbCBtYXJrX2RlZmVycmVkLCBib29sIG9ubHlfZGVmZXJyZWQpOwo+ID4gIGlu dCBkbV9jYW5jZWxfZGVmZXJyZWRfcmVtb3ZlKHN0cnVjdCBtYXBwZWRfZGV2aWNlICptZCk7Cj4g PiAgaW50IGRtX3JlcXVlc3RfYmFzZWQoc3RydWN0IG1hcHBlZF9kZXZpY2UgKm1kKTsKPiA+IC1p bnQgZG1fZ2V0X3RhYmxlX2RldmljZShzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQsIGRldl90IGRl diwgZm1vZGVfdCBtb2RlLAo+ID4gK2ludCBkbV9nZXRfdGFibGVfZGV2aWNlKHN0cnVjdCBtYXBw ZWRfZGV2aWNlICptZCwgZGV2X3QgZGV2LCBmbW9kZV90IG1vZGUsIGJvb2wgbm9uX2V4Y2x1c2l2 ZSwKPiA+ICAJCQlzdHJ1Y3QgZG1fZGV2ICoqcmVzdWx0KTsKPiA+ICB2b2lkIGRtX3B1dF90YWJs ZV9kZXZpY2Uoc3RydWN0IG1hcHBlZF9kZXZpY2UgKm1kLCBzdHJ1Y3QgZG1fZGV2ICpkKTsKPiA+ ICAKPiA+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2RldmljZS1tYXBwZXIuaCBiL2luY2x1 ZGUvbGludXgvZGV2aWNlLW1hcHBlci5oCj4gPiBpbmRleCA2MWE2NmZiOGViYjMuLjcwMDAyMzYz YmZjMCAxMDA2NDQKPiA+IC0tLSBhL2luY2x1ZGUvbGludXgvZGV2aWNlLW1hcHBlci5oCj4gPiAr KysgYi9pbmNsdWRlL2xpbnV4L2RldmljZS1tYXBwZXIuaAo+ID4gQEAgLTE1MCw2ICsxNTAsNyBA QCBzdHJ1Y3QgZG1fZGV2IHsKPiA+ICAJc3RydWN0IGJsb2NrX2RldmljZSAqYmRldjsKPiA+ICAJ c3RydWN0IGRheF9kZXZpY2UgKmRheF9kZXY7Cj4gPiAgCWZtb2RlX3QgbW9kZTsKPiA+ICsJYm9v bCBub25fZXhjbHVzaXZlOwo+ID4gIAljaGFyIG5hbWVbMTZdOwo+ID4gIH07Cj4gPiAgCj4gPiBA QCAtMzI1LDYgKzMyNiwxMiBAQCBzdHJ1Y3QgZG1fdGFyZ2V0IHsKPiA+ICAJICogd2hldGhlciBv ciBub3QgaXRzIHVuZGVybHlpbmcgZGV2aWNlcyBoYXZlIHN1cHBvcnQuCj4gPiAgCSAqLwo+ID4g IAlib29sIGRpc2NhcmRzX3N1cHBvcnRlZDoxOwo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBTZXQg aWYgdGhpcyB0YXJnZXQgbmVlZHMgdG8gb3BlbiBkZXZpY2Ugd2l0aG91dCBGTU9ERV9FWENMCj4g PiArCSAqIG1vZGUuCj4gPiArCSAqLwo+ID4gKwlib29sIG5vbl9leGNsdXNpdmU6MTsKPiA+ICB9 Owo+ID4gIAo+ID4gIHZvaWQgKmRtX3Blcl9iaW9fZGF0YShzdHJ1Y3QgYmlvICpiaW8sIHNpemVf dCBkYXRhX3NpemUpOwo+ID4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51eC9kbS1pb2N0 bC5oIGIvaW5jbHVkZS91YXBpL2xpbnV4L2RtLWlvY3RsLmgKPiA+IGluZGV4IDQ5MzNiNmI2N2I4 NS4uMDhkN2RiZmY4MGY0IDEwMDY0NAo+ID4gLS0tIGEvaW5jbHVkZS91YXBpL2xpbnV4L2RtLWlv Y3RsLmgKPiA+ICsrKyBiL2luY2x1ZGUvdWFwaS9saW51eC9kbS1pb2N0bC5oCj4gPiBAQCAtMjE0 LDYgKzIxNCwxNSBAQCBzdHJ1Y3QgZG1fdGFyZ2V0X21zZyB7Cj4gPiAgCWNoYXIgbWVzc2FnZVsw XTsKPiA+ICB9Owo+ID4gIAo+ID4gK2VudW0gewo+ID4gKwlSRU1BUF9TVEFSVF9DTUQgPSAxLAo+ ID4gKwlSRU1BUF9GSU5JU0hfQ01ELAo+ID4gK307Cj4gPiArCj4gPiArc3RydWN0IGRtX3JlbWFw X3BhcmFtIHsKPiA+ICsJdWludDhfdCBjbWQ7Cj4gPiArCXVpbnQ4X3QgcGFyYW1zWzBdOwo+ID4g K307Cj4gPiAgLyoKPiA+ICAgKiBJZiB5b3UgY2hhbmdlIHRoaXMgbWFrZSBzdXJlIHlvdSBtYWtl IHRoZSBjb3JyZXNwb25kaW5nIGNoYW5nZQo+ID4gICAqIHRvIGRtLWlvY3RsLmM6bG9va3VwX2lv Y3RsKCkKPiA+IEBAIC0yNDQsNiArMjUzLDcgQEAgZW51bSB7Cj4gPiAgCURNX0RFVl9TRVRfR0VP TUVUUllfQ01ELAo+ID4gIAlETV9ERVZfQVJNX1BPTExfQ01ELAo+ID4gIAlETV9HRVRfVEFSR0VU X1ZFUlNJT05fQ01ELAo+ID4gKwlETV9ERVZfUkVNQVBfQ01ECj4gPiAgfTsKPiA+ICAKPiA+ICAj ZGVmaW5lIERNX0lPQ1RMIDB4ZmQKPiA+IEBAIC0yNTksNiArMjY5LDcgQEAgZW51bSB7Cj4gPiAg I2RlZmluZSBETV9ERVZfU1RBVFVTICAgIF9JT1dSKERNX0lPQ1RMLCBETV9ERVZfU1RBVFVTX0NN RCwgc3RydWN0IGRtX2lvY3RsKQo+ID4gICNkZWZpbmUgRE1fREVWX1dBSVQgICAgICBfSU9XUihE TV9JT0NUTCwgRE1fREVWX1dBSVRfQ01ELCBzdHJ1Y3QgZG1faW9jdGwpCj4gPiAgI2RlZmluZSBE TV9ERVZfQVJNX1BPTEwgIF9JT1dSKERNX0lPQ1RMLCBETV9ERVZfQVJNX1BPTExfQ01ELCBzdHJ1 Y3QgZG1faW9jdGwpCj4gPiArI2RlZmluZSBETV9ERVZfUkVNQVAgICAgIF9JT1dSKERNX0lPQ1RM LCBETV9ERVZfUkVNQVBfQ01ELCBzdHJ1Y3QgZG1faW9jdGwpCj4gPiAgCj4gPiAgI2RlZmluZSBE TV9UQUJMRV9MT0FEICAgIF9JT1dSKERNX0lPQ1RMLCBETV9UQUJMRV9MT0FEX0NNRCwgc3RydWN0 IGRtX2lvY3RsKQo+ID4gICNkZWZpbmUgRE1fVEFCTEVfQ0xFQVIgICBfSU9XUihETV9JT0NUTCwg RE1fVEFCTEVfQ0xFQVJfQ01ELCBzdHJ1Y3QgZG1faW9jdGwpCj4gPiBAQCAtMjcyLDkgKzI4Myw5 IEBAIGVudW0gewo+ID4gICNkZWZpbmUgRE1fREVWX1NFVF9HRU9NRVRSWQlfSU9XUihETV9JT0NU TCwgRE1fREVWX1NFVF9HRU9NRVRSWV9DTUQsIHN0cnVjdCBkbV9pb2N0bCkKPiA+ICAKPiA+ICAj ZGVmaW5lIERNX1ZFUlNJT05fTUFKT1IJNAo+ID4gLSNkZWZpbmUgRE1fVkVSU0lPTl9NSU5PUgk0 Mwo+ID4gKyNkZWZpbmUgRE1fVkVSU0lPTl9NSU5PUgk0NAo+ID4gICNkZWZpbmUgRE1fVkVSU0lP Tl9QQVRDSExFVkVMCTAKPiA+IC0jZGVmaW5lIERNX1ZFUlNJT05fRVhUUkEJIi1pb2N0bCAoMjAy MC0xMC0wMSkiCj4gPiArI2RlZmluZSBETV9WRVJTSU9OX0VYVFJBCSItaW9jdGwgKDIwMjAtMTIt MjUpIgo+ID4gIAo+ID4gIC8qIFN0YXR1cyBiaXRzICovCj4gPiAgI2RlZmluZSBETV9SRUFET05M WV9GTEFHCSgxIDw8IDApIC8qIEluL091dCAqLwo+ID4gCj4gCj4gCj4gLS0gCj4gRGFtaWVuIExl IE1vYWwKPiBXZXN0ZXJuIERpZ2l0YWwgUmVzZWFyY2gKPiAKCi0tIApTZXJnZWkgU2h0ZXBhClZl ZWFtIFNvZnR3YXJlIGRldmVsb3Blci4KCgotLQpkbS1kZXZlbCBtYWlsaW5nIGxpc3QKZG0tZGV2 ZWxAcmVkaGF0LmNvbQpodHRwczovL3d3dy5yZWRoYXQuY29tL21haWxtYW4vbGlzdGluZm8vZG0t ZGV2ZWw= 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 X-Spam-Level: X-Spam-Status: No, score=-16.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E5658C433E0 for ; Fri, 29 Jan 2021 16:36:38 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id AA3B164D9D for ; Fri, 29 Jan 2021 16:36:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231725AbhA2QgW (ORCPT ); Fri, 29 Jan 2021 11:36:22 -0500 Received: from mx4.veeam.com ([104.41.138.86]:54430 "EHLO mx4.veeam.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231658AbhA2QeV (ORCPT ); Fri, 29 Jan 2021 11:34:21 -0500 X-Greylist: delayed 1465 seconds by postgrey-1.27 at vger.kernel.org; Fri, 29 Jan 2021 11:34:14 EST Received: from mail.veeam.com (prgmbx01.amust.local [172.24.0.171]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mx4.veeam.com (Postfix) with ESMTPS id E29F9AE5AA; Fri, 29 Jan 2021 19:08:53 +0300 (MSK) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=veeam.com; s=mx4; t=1611936534; bh=p7Wcd5P77khpGpKdkCLH3mrKJVTBJFMVejFz6ZLWmBk=; h=Date:From:To:CC:Subject:References:In-Reply-To:From; b=lBVMvU3X5pM+yMSbvJ7dbl40Cmyjdj8UWzorbt45hIUmf0+ijzx+FzhQ23sFnzrJY KIOKyUsiDD2xw5SCdePvAsKRh1R2pd0O78oyAMfCEBd7MqpEsJvCRkj0uso7tNCMim z8S0r75jCs/OuZuRqxByocrEpLCnt8IdS4qIzGQw= Received: from veeam.com (172.24.14.5) by prgmbx01.amust.local (172.24.0.171) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.721.2; Fri, 29 Jan 2021 17:08:52 +0100 Date: Fri, 29 Jan 2021 19:08:49 +0300 From: Sergei Shtepa To: Damien Le Moal CC: "hare@suse.de" , "ming.lei@redhat.com" , "agk@redhat.com" , "snitzer@redhat.com" , "dm-devel@redhat.com" , "linux-block@vger.kernel.org" , Pavel Tide Subject: Re: [dm-devel] [PATCH 2/2] [dm] blk_interposer for dm-linear Message-ID: <20210129160849.GC32240@veeam.com> References: <1611853955-32167-1-git-send-email-sergei.shtepa@veeam.com> <1611853955-32167-3-git-send-email-sergei.shtepa@veeam.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: X-Originating-IP: [172.24.14.5] X-ClientProxiedBy: prgmbx02.amust.local (172.24.0.172) To prgmbx01.amust.local (172.24.0.171) X-EsetResult: clean, is OK X-EsetId: 37303A29C604D265667563 X-Veeam-MMEX: True Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org The 01/29/2021 04:46, Damien Le Moal wrote: > On 2021/01/29 2:23, Sergei Shtepa wrote: > > Implement a block interposer for device-mapper to attach > > to an existing block layer stack. Using the interposer, > > we can connect the dm-linear to a device with a mounted > > file system. > > > > changes: > > * the new dm_interposer structure contains blk_interposer > > to intercept bio from the interposed disk and interval tree > > of block devices on this disk. > > * the new interval tree for device mapper. > > * the dm_submit_bio_interposer_fn() function implements > > the bio interception logic. > > * the functions dm_interposer_attach_dev() & > > dm_interposer_detach_dev() allow to attach and detach devices > > to dm_interposer. > > * the new parameter 'noexcl' allows to create dm-linear to device > > with an already mounted file system. > > * the non_exclusive parameter in dm_target structure - it`s a sign > > that target device should be opened without FMODE_EXCL mode. > > * the new ioctl IOCTL_DEV_REMAP allow to attach dm device to > > a regular block device. > > Same comment about changelog as in the previous patch. > > > Signed-off-by: Sergei Shtepa > > --- > > drivers/md/dm-core.h | 46 +++- > > drivers/md/dm-ioctl.c | 39 ++++ > > drivers/md/dm-linear.c | 17 +- > > drivers/md/dm-table.c | 12 +- > > drivers/md/dm.c | 383 ++++++++++++++++++++++++++++++++-- > > drivers/md/dm.h | 2 +- > > include/linux/device-mapper.h | 7 + > > include/uapi/linux/dm-ioctl.h | 15 +- > > 8 files changed, 493 insertions(+), 28 deletions(-) > > > > diff --git a/drivers/md/dm-core.h b/drivers/md/dm-core.h > > index 086d293c2b03..0f870b1d4be4 100644 > > --- a/drivers/md/dm-core.h > > +++ b/drivers/md/dm-core.h > > @@ -13,7 +13,7 @@ > > #include > > #include > > #include > > - > > whiteline change. > > > +#include > > #include I don't see any problem in the fact that a new include appeared instead of whiteline. It doesn't make sense to split the include section by whiteline. > > > > #include "dm.h" > > @@ -109,6 +109,9 @@ struct mapped_device { > > bool init_tio_pdu:1; > > > > struct srcu_struct io_barrier; > > + > > + /* interposer device for remap */ > > + struct dm_interposed_dev *ip_dev; > > }; > > > > void disable_discard(struct mapped_device *md); > > @@ -164,6 +167,47 @@ struct dm_table { > > struct dm_md_mempools *mempools; > > }; > > > > +/* > > + * Interval tree for device mapper > > + */ > > +struct dm_rb_range { > > + struct rb_node node; > > + sector_t start; /* start sector of rb node */ > > + sector_t last; /* end sector of rb node */ > > + sector_t _subtree_last; /* highest sector in subtree of rb node */ > > +}; > > + > > +void dm_rb_insert(struct dm_rb_range *node, struct rb_root_cached *root); > > +void dm_rb_remove(struct dm_rb_range *node, struct rb_root_cached *root); > > + > > +struct dm_rb_range *dm_rb_iter_first(struct rb_root_cached *root, sector_t start, sector_t last); > > +struct dm_rb_range *dm_rb_iter_next(struct dm_rb_range *node, sector_t start, sector_t last); > > + > > +/* > > + * For connecting blk_interposer and dm-targets devices. > > Is this comment about the callback or the structure ? I think the latter, so it > is in the worng place. Please also add a comment for the callback definition > explaining what it should be doing. Ok. > > > + */ > > +typedef void (*dm_interpose_bio_t) (void *context, struct dm_rb_range *node, struct bio *bio); > > + > > +struct dm_interposed_dev { > > + struct gendisk *disk; > > + struct dm_rb_range node; > > + void *context; > > + dm_interpose_bio_t dm_interpose_bio; > > + > > + atomic64_t ip_cnt; /*for debug purpose*/ > > +}; > > + > > +struct dm_interposed_dev *dm_interposer_new_dev(struct gendisk *disk, > > + sector_t ofs, sector_t len, > > + void *context, > > + dm_interpose_bio_t dm_interpose_bio_t); > > +void dm_interposer_free_dev(struct dm_interposed_dev *ip_dev); > > +int dm_interposer_attach_dev(struct dm_interposed_dev *ip_dev); > > +int dm_interposer_detach_dev(struct dm_interposed_dev *ip_dev); > > + > > +int dm_remap_install(struct mapped_device *md, const char *donor_device_name); > > +int dm_remap_uninstall(struct mapped_device *md); > > + > > static inline struct completion *dm_get_completion_from_kobject(struct kobject *kobj) > > { > > return &container_of(kobj, struct dm_kobject_holder, kobj)->completion; > > diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c > > index 5e306bba4375..2944d442c256 100644 > > --- a/drivers/md/dm-ioctl.c > > +++ b/drivers/md/dm-ioctl.c > > @@ -1649,6 +1649,44 @@ static int target_message(struct file *filp, struct dm_ioctl *param, size_t para > > return r; > > } > > > > +static inline int dev_remap_start(struct mapped_device *md, uint8_t *params) > > +{ > > + char *donor_device_name = (char *)params; > > + > > + return dm_remap_install(md, donor_device_name); > > +} > > +static int dev_remap_finish(struct mapped_device *md) > > +{ > > + return dm_remap_uninstall(md); > > +} > > + > > +static int dev_remap(struct file *filp, struct dm_ioctl *param, size_t param_size) > > +{ > > + int ret = 0; > > + struct mapped_device *md; > > + void *bin_data; > > + struct dm_remap_param *remap_param; > > + > > + md = find_device(param); > > + if (!md) > > + return -ENXIO; > > + > > + bin_data = (void *)(param) + param->data_start; > > + remap_param = bin_data; > > + > > + if (remap_param->cmd == REMAP_START_CMD) > > + ret = dev_remap_start(md, remap_param->params); > > + else if (remap_param->cmd == REMAP_FINISH_CMD) > > + ret = dev_remap_finish(md); > > + else { > > + DMWARN("Invalid remap command, %d", remap_param->cmd); > > + ret = -EINVAL; > > + } > > + > > + dm_put(md); > > + return ret; > > +} > > + > > /* > > * The ioctl parameter block consists of two parts, a dm_ioctl struct > > * followed by a data buffer. This flag is set if the second part, > > @@ -1691,6 +1729,7 @@ static ioctl_fn lookup_ioctl(unsigned int cmd, int *ioctl_flags) > > {DM_DEV_SET_GEOMETRY_CMD, 0, dev_set_geometry}, > > {DM_DEV_ARM_POLL, IOCTL_FLAGS_NO_PARAMS, dev_arm_poll}, > > {DM_GET_TARGET_VERSION, 0, get_target_version}, > > + {DM_DEV_REMAP_CMD, 0, dev_remap}, > > }; > > > > if (unlikely(cmd >= ARRAY_SIZE(_ioctls))) > > diff --git a/drivers/md/dm-linear.c b/drivers/md/dm-linear.c > > index 00774b5d7668..ffb8b5ca4d10 100644 > > --- a/drivers/md/dm-linear.c > > +++ b/drivers/md/dm-linear.c > > @@ -28,12 +28,13 @@ struct linear_c { > > */ > > static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv) > > { > > + fmode_t mode; > > struct linear_c *lc; > > unsigned long long tmp; > > char dummy; > > int ret; > > > > - if (argc != 2) { > > + if ((argc < 2) || (argc > 3)) { > > ti->error = "Invalid argument count"; > > return -EINVAL; > > } > > @@ -51,7 +52,19 @@ static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv) > > } > > lc->start = tmp; > > > > - ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &lc->dev); > > + ti->non_exclusive = false; > > + if (argc > 2) { > > + if (strcmp("noexcl", argv[2]) == 0) > > + ti->non_exclusive = true; > > + else if (strcmp("excl", argv[2]) == 0) > > + ti->non_exclusive = false; > > It already is false. Yes, and even the value of the "excl" parameter is redundant, since it defines the default value. I think this code structure more clearly reflects the meaning of the parameter. > > > + else { > > + ti->error = "Invalid exclusive option"; > > + return -EINVAL; > > + } > > + } > > + > > + ret = dm_get_device(ti, argv[0], mode, &lc->dev); > > Where is mode initialized ? Why remove dm_table_get_mode(ti->table) ? Yes. It`s a bug. In this plaсe should be dm_table_get_mode(). > > > if (ret) { > > ti->error = "Device lookup failed"; > > goto bad; > > I would prefer to see this change to dm-linear in its own patch, following this > one, with a clear explanation in the commit message how this change relates to > interposer since the explanation for this "exclusive" change is nowhere to be > seen. Also please check if there is a file describing dm-linear options under > Documentation/ (I can't remember if there is one). If there is one, it will need > to be updated too. It's a good idea. > > > diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c > > index 4acf2342f7ad..f15bc2171f25 100644 > > --- a/drivers/md/dm-table.c > > +++ b/drivers/md/dm-table.c > > @@ -322,7 +322,7 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev, > > * device and not to touch the existing bdev field in case > > * it is accessed concurrently. > > */ > > -static int upgrade_mode(struct dm_dev_internal *dd, fmode_t new_mode, > > +static int upgrade_mode(struct dm_dev_internal *dd, fmode_t new_mode, bool non_exclusive, > > struct mapped_device *md) > > { > > int r; > > @@ -330,7 +330,7 @@ static int upgrade_mode(struct dm_dev_internal *dd, fmode_t new_mode, > > > > old_dev = dd->dm_dev; > > > > - r = dm_get_table_device(md, dd->dm_dev->bdev->bd_dev, > > + r = dm_get_table_device(md, dd->dm_dev->bdev->bd_dev, non_exclusive, > > dd->dm_dev->mode | new_mode, &new_dev); > > if (r) > > return r; > > @@ -387,7 +387,8 @@ int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode, > > if (!dd) > > return -ENOMEM; > > > > - if ((r = dm_get_table_device(t->md, dev, mode, &dd->dm_dev))) { > > + r = dm_get_table_device(t->md, dev, mode, ti->non_exclusive, &dd->dm_dev); > > + if (r) { > > kfree(dd); > > return r; > > } > > @@ -396,8 +397,9 @@ int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode, > > list_add(&dd->list, &t->devices); > > goto out; > > > > - } else if (dd->dm_dev->mode != (mode | dd->dm_dev->mode)) { > > - r = upgrade_mode(dd, mode, t->md); > > + } else if ((dd->dm_dev->mode != (mode | dd->dm_dev->mode)) && > > + (dd->dm_dev->non_exclusive != ti->non_exclusive)) { > > + r = upgrade_mode(dd, mode, ti->non_exclusive, t->md); > > if (r) > > return r; > > } > > diff --git a/drivers/md/dm.c b/drivers/md/dm.c > > index 7bac564f3faa..3b871d98b7b6 100644 > > --- a/drivers/md/dm.c > > +++ b/drivers/md/dm.c > > @@ -28,6 +28,7 @@ > > #include > > #include > > #include > > +#include > > > > #define DM_MSG_PREFIX "core" > > > > @@ -56,6 +57,8 @@ static struct workqueue_struct *deferred_remove_workqueue; > > atomic_t dm_global_event_nr = ATOMIC_INIT(0); > > DECLARE_WAIT_QUEUE_HEAD(dm_global_eventq); > > > > +static DEFINE_MUTEX(interposer_mutex); /* synchronizing access to blk_interposer */ > > Why not dm_interposer_mutex as the name ? And the comment is not very useful: a > mutex is always for synchronizing :) Right. I'll do it. > > > + > > void dm_issue_global_event(void) > > { > > atomic_inc(&dm_global_event_nr); > > @@ -162,6 +165,26 @@ struct table_device { > > struct dm_dev dm_dev; > > }; > > > > +/* > > + * Device mapper`s interposer. > > + */ > > +struct dm_interposer { > > + struct blk_interposer blk_ip; > > + struct mapped_device *md; > > + > > + struct kref kref; > > + struct rw_semaphore ip_devs_lock; > > + struct rb_root_cached ip_devs_root; /* dm_interposed_dev tree */ > > +}; > > + > > +/* > > + * Interval tree for device mapper > > + */ > > +#define START(node) ((node)->start) > > +#define LAST(node) ((node)->last) > > +INTERVAL_TREE_DEFINE(struct dm_rb_range, node, sector_t, _subtree_last, > > + START, LAST,, dm_rb); > > + > > /* > > * Bio-based DM's mempools' reserved IOs set by the user. > > */ > > @@ -733,28 +756,340 @@ static void dm_put_live_table_fast(struct mapped_device *md) __releases(RCU) > > rcu_read_unlock(); > > } > > > > +static void dm_submit_bio_interposer_fn(struct bio *bio) > > +{ > > + struct dm_interposer *ip; > > + unsigned int noio_flag = 0; > > + sector_t start; > > + sector_t last; > > + struct dm_rb_range *node; > > + > > + ip = container_of(bio->bi_disk->interposer, struct dm_interposer, blk_ip); > > + start = bio->bi_iter.bi_sector; > > + last = start + dm_sector_div_up(bio->bi_iter.bi_size, SECTOR_SIZE); > > + > > + noio_flag = memalloc_noio_save(); > > + down_read(&ip->ip_devs_lock); > > + node = dm_rb_iter_first(&ip->ip_devs_root, start, last); > > + while (node) { > > + struct dm_interposed_dev *ip_dev = > > + container_of(node, struct dm_interposed_dev, node); > > + > > + atomic64_inc(&ip_dev->ip_cnt); > > + ip_dev->dm_interpose_bio(ip_dev->context, node, bio); > > + > > + node = dm_rb_iter_next(node, start, last); > > + } > > + up_read(&ip->ip_devs_lock); > > + memalloc_noio_restore(noio_flag); > > +} > > + > > +static void free_interposer(struct kref *kref) > > +{ > > + struct dm_interposer *ip = container_of(kref, struct dm_interposer, kref); > > + > > + blk_interposer_detach(&ip->blk_ip, dm_submit_bio_interposer_fn); > > No queue freeze ? Yes. The queue should be already freeze. > > > + > > + kfree(ip); > > +} > > + > > +static struct dm_interposer *new_interposer(struct gendisk *disk) > > +{ > > + int ret = 0; > > + struct dm_interposer *ip; > > + > > + ip = kzalloc(sizeof(struct dm_interposer), GFP_NOIO); > > + if (!ip) > > + return ERR_PTR(-ENOMEM); > > + > > + kref_init(&ip->kref); > > + init_rwsem(&ip->ip_devs_lock); > > + ip->ip_devs_root = RB_ROOT_CACHED; > > + > > + ret = blk_interposer_attach(disk, &ip->blk_ip, dm_submit_bio_interposer_fn); > > No queue freeze ? Yes, again. > > > + if (ret) { > > + DMERR("Failed to attack blk_interposer"); > > + kref_put(&ip->kref, free_interposer); > > + return ERR_PTR(ret); > > + } > > + > > + return ip; > > +} > > + > > +static struct dm_interposer *get_interposer(struct gendisk *disk) > > +{ > > + struct dm_interposer *ip; > > + > > + if (!blk_has_interposer(disk)) > > + return NULL; > > + > > + if (disk->interposer->ip_submit_bio != dm_submit_bio_interposer_fn) { > > + DMERR("Disks interposer slot already occupied."); > > + return ERR_PTR(-EBUSY); > > This is weird... If there is an interposer, why not get a ref on that one. That > is what the function name suggests at least. Getting a ref on that just below in this function. But the name "get_dm_interposer" would be better. > > > + } > > + > > + ip = container_of(disk->interposer, struct dm_interposer, blk_ip); > > + > > + kref_get(&ip->kref); > > + return ip; > > +} > > + > > +struct dm_interposed_dev *dm_interposer_new_dev(struct gendisk *disk, sector_t ofs, sector_t len, > > + void *context, dm_interpose_bio_t dm_interpose_bio) > > +{ > > + sector_t start = ofs; > > + sector_t last = ofs + len - 1; > > + struct dm_interposed_dev *ip_dev = NULL; > > + > > + /* Allocate new ip_dev */ > > + ip_dev = kzalloc(sizeof(struct dm_interposed_dev), GFP_KERNEL); > > + if (!ip_dev) > > + return NULL; > > + > > + ip_dev->disk = disk; > > + ip_dev->node.start = start; > > + ip_dev->node.last = last; > > + > > + ip_dev->context = context; > > + ip_dev->dm_interpose_bio = dm_interpose_bio; > > + > > + atomic64_set(&ip_dev->ip_cnt, 0); > > + > > + return ip_dev; > > +} > > + > > +void dm_interposer_free_dev(struct dm_interposed_dev *ip_dev) > > +{ > > + kfree(ip_dev); > > +} > > Make this inline may be ? Yes. Or even remove this function. > > > + > > +static inline void dm_disk_freeze(struct gendisk *disk) > > +{ > > + blk_mq_freeze_queue(disk->queue); > > + blk_mq_quiesce_queue(disk->queue); > > I think you can replace this with blk_mq_freeze_queue_wait(). I think no. blk_freeze_queue_start() also is required. > > > +} > > + > > +static inline void dm_disk_unfreeze(struct gendisk *disk) > > +{ > > + blk_mq_unquiesce_queue(disk->queue); > > + blk_mq_unfreeze_queue(disk->queue); > > +} > > + > > +int dm_interposer_attach_dev(struct dm_interposed_dev *ip_dev) > > +{ > > + int ret = 0; > > + struct dm_interposer *ip = NULL; > > + unsigned int noio_flag = 0; > > + > > + if (!ip_dev) > > + return -EINVAL; > > + > > + dm_disk_freeze(ip_dev->disk); > > + mutex_lock(&interposer_mutex); > > + noio_flag = memalloc_noio_save(); > > + > > + ip = get_interposer(ip_dev->disk); > > + if (ip == NULL) > > + ip = new_interposer(ip_dev->disk); > > + if (IS_ERR(ip)) { > > + ret = PTR_ERR(ip); > > + goto out; > > + } > > + > > + /* Attach dm_interposed_dev to dm_interposer */ > > + down_write(&ip->ip_devs_lock); > > + do { > > + struct dm_rb_range *node; > > + > > + /* checking that ip_dev already exists for this region */ > > + node = dm_rb_iter_first(&ip->ip_devs_root, ip_dev->node.start, ip_dev->node.last); > > + if (node) { > > + DMERR("Disk part form [%llu] to [%llu] already have interposer", > > + node->start, node->last); > > + > > + ret = -EBUSY; > > + break; > > + } > > + > > + /* insert ip_dev to ip tree */ > > + dm_rb_insert(&ip_dev->node, &ip->ip_devs_root); > > + /* increment ip reference counter */ > > + kref_get(&ip->kref); > > + } while (false); > > + up_write(&ip->ip_devs_lock); > > + > > + kref_put(&ip->kref, free_interposer); > > + > > +out: > > + memalloc_noio_restore(noio_flag); > > + mutex_unlock(&interposer_mutex); > > + dm_disk_unfreeze(ip_dev->disk); > > + > > + return ret; > > +} > > + > > +int dm_interposer_detach_dev(struct dm_interposed_dev *ip_dev) > > +{ > > + int ret = 0; > > + struct dm_interposer *ip = NULL; > > + unsigned int noio_flag = 0; > > + > > + if (!ip_dev) > > + return -EINVAL; > > + > > + dm_disk_freeze(ip_dev->disk); > > + mutex_lock(&interposer_mutex); > > + noio_flag = memalloc_noio_save(); > > + > > + ip = get_interposer(ip_dev->disk); > > + if (IS_ERR(ip)) { > > + ret = PTR_ERR(ip); > > + DMERR("Interposer not found"); > > + goto out; > > + } > > + if (unlikely(ip == NULL)) { > > + ret = -ENXIO; > > + DMERR("Interposer not found"); > > + goto out; > > + } > > + > > + down_write(&ip->ip_devs_lock); > > + do { > > + dm_rb_remove(&ip_dev->node, &ip->ip_devs_root); > > + /* the reference counter here cannot be zero */ > > + kref_put(&ip->kref, free_interposer); > > + > > + } while (false); > > + up_write(&ip->ip_devs_lock); > > + > > + /* detach and free interposer if it`s not needed */ > > s/`/'/ Thanks. It's my problem. > > > + kref_put(&ip->kref, free_interposer); > > +out: > > + memalloc_noio_restore(noio_flag); > > + mutex_unlock(&interposer_mutex); > > + dm_disk_unfreeze(ip_dev->disk); > > + > > + return ret; > > +} > > + > > +static void dm_remap_fn(void *context, struct dm_rb_range *node, struct bio *bio) > > +{ > > + struct mapped_device *md = context; > > + > > + /* Set acceptor device. */ > > + bio->bi_disk = md->disk; > > + > > + /* Remap disks offset */ > > + bio->bi_iter.bi_sector -= node->start; > > + > > + /* > > + * bio should be resubmitted. > > + * We can just add bio to bio_list of the current process. > > + * current->bio_list must be initialized when this function is called. > > + * If call submit_bio_noacct(), the bio will be checked twice. > > + */ > > + BUG_ON(!current->bio_list); > > + bio_list_add(¤t->bio_list[0], bio); > > +} > > + > > +int dm_remap_install(struct mapped_device *md, const char *donor_device_name) > > +{ > > + int ret = 0; > > + struct block_device *donor_bdev; > > + fmode_t mode = FMODE_READ | FMODE_WRITE; > > + > > + DMDEBUG("Dm remap install for mapped device %s and donor device %s", > > + md->name, donor_device_name); > > + > > + donor_bdev = blkdev_get_by_path(donor_device_name, mode, "device-mapper remap"); > > + if (IS_ERR(donor_bdev)) { > > + DMERR("Cannot open device [%s]", donor_device_name); > > + return PTR_ERR(donor_bdev); > > + } > > + > > + do { > > + sector_t ofs = get_start_sect(donor_bdev); > > + sector_t len = bdev_nr_sectors(donor_bdev); > > + > > + md->ip_dev = dm_interposer_new_dev(donor_bdev->bd_disk, ofs, len, md, dm_remap_fn); > > + if (!md->ip_dev) { > > + ret = -ENOMEM; > > + break; > > + } > > + > > + DMDEBUG("New interposed device 0x%p", md->ip_dev); > > + ret = dm_interposer_attach_dev(md->ip_dev); > > + if (ret) { > > + dm_interposer_free_dev(md->ip_dev); > > + > > + md->ip_dev = NULL; > > + DMERR("Failed to attach dm interposer"); > > + break; > > + } > > + > > + DMDEBUG("Attached successfully."); > > + } while (false); > > + > > + blkdev_put(donor_bdev, mode); > > + > > + return ret; > > +} > > + > > +int dm_remap_uninstall(struct mapped_device *md) > > +{ > > + int ret = 0; > > + > > + DMDEBUG("Dm remap uninstall for mapped device %s ip_dev=0x%p", md->name, md->ip_dev); > > + > > + if (!md->ip_dev) { > > + DMERR("Cannot detach dm interposer"); > > + return -EINVAL; > > + } > > + > > + ret = dm_interposer_detach_dev(md->ip_dev); > > + if (ret) { > > + DMERR("Failed to detach dm interposer"); > > + return ret; > > + } > > + > > + DMDEBUG("Detached successfully. %llu bios was interposed", > > + atomic64_read(&md->ip_dev->ip_cnt)); > > + dm_interposer_free_dev(md->ip_dev); > > + md->ip_dev = NULL; > > + > > + return 0; > > +} > > + > > static char *_dm_claim_ptr = "I belong to device-mapper"; > > > > /* > > * Open a table device so we can use it as a map destination. > > */ > > static int open_table_device(struct table_device *td, dev_t dev, > > - struct mapped_device *md) > > + struct mapped_device *md, bool non_exclusive) > > { > > struct block_device *bdev; > > - > > - int r; > > + int ret; > > > > BUG_ON(td->dm_dev.bdev); > > > > - bdev = blkdev_get_by_dev(dev, td->dm_dev.mode | FMODE_EXCL, _dm_claim_ptr); > > - if (IS_ERR(bdev)) > > - return PTR_ERR(bdev); > > + if (non_exclusive) > > + bdev = blkdev_get_by_dev(dev, td->dm_dev.mode, NULL); > > + else > > + bdev = blkdev_get_by_dev(dev, td->dm_dev.mode | FMODE_EXCL, _dm_claim_ptr); > > > > - r = bd_link_disk_holder(bdev, dm_disk(md)); > > - if (r) { > > - blkdev_put(bdev, td->dm_dev.mode | FMODE_EXCL); > > - return r; > > + if (IS_ERR(bdev)) { > > + ret = PTR_ERR(bdev); > > + if (ret != -EBUSY) > > + return ret; > > + } > > + > > + if (!non_exclusive) { > > + ret = bd_link_disk_holder(bdev, dm_disk(md)); > > + if (ret) { > > + blkdev_put(bdev, td->dm_dev.mode); > > + return ret; > > + } > > } > > > > td->dm_dev.bdev = bdev; > > @@ -770,33 +1105,38 @@ static void close_table_device(struct table_device *td, struct mapped_device *md > > if (!td->dm_dev.bdev) > > return; > > > > - bd_unlink_disk_holder(td->dm_dev.bdev, dm_disk(md)); > > - blkdev_put(td->dm_dev.bdev, td->dm_dev.mode | FMODE_EXCL); > > + if (td->dm_dev.mode & FMODE_EXCL) > > + bd_unlink_disk_holder(td->dm_dev.bdev, dm_disk(md)); > > + > > + blkdev_put(td->dm_dev.bdev, td->dm_dev.mode); > > + > > put_dax(td->dm_dev.dax_dev); > > td->dm_dev.bdev = NULL; > > td->dm_dev.dax_dev = NULL; > > } > > > > static struct table_device *find_table_device(struct list_head *l, dev_t dev, > > - fmode_t mode) > > + fmode_t mode, bool non_exclusive) > > { > > struct table_device *td; > > > > list_for_each_entry(td, l, list) > > - if (td->dm_dev.bdev->bd_dev == dev && td->dm_dev.mode == mode) > > + if (td->dm_dev.bdev->bd_dev == dev && > > + td->dm_dev.mode == mode && > > + td->dm_dev.non_exclusive == non_exclusive) > > return td; > > > > return NULL; > > } > > > > -int dm_get_table_device(struct mapped_device *md, dev_t dev, fmode_t mode, > > +int dm_get_table_device(struct mapped_device *md, dev_t dev, fmode_t mode, bool non_exclusive, > > struct dm_dev **result) > > { > > int r; > > struct table_device *td; > > > > mutex_lock(&md->table_devices_lock); > > - td = find_table_device(&md->table_devices, dev, mode); > > + td = find_table_device(&md->table_devices, dev, mode, non_exclusive); > > if (!td) { > > td = kmalloc_node(sizeof(*td), GFP_KERNEL, md->numa_node_id); > > if (!td) { > > @@ -807,7 +1147,8 @@ int dm_get_table_device(struct mapped_device *md, dev_t dev, fmode_t mode, > > td->dm_dev.mode = mode; > > td->dm_dev.bdev = NULL; > > > > - if ((r = open_table_device(td, dev, md))) { > > + r = open_table_device(td, dev, md, non_exclusive); > > + if (r) { > > mutex_unlock(&md->table_devices_lock); > > kfree(td); > > return r; > > @@ -2182,6 +2523,14 @@ static void __dm_destroy(struct mapped_device *md, bool wait) > > > > might_sleep(); > > > > + if (md->ip_dev) { > > + if (dm_interposer_detach_dev(md->ip_dev)) > > + DMERR("Failed to detach dm interposer"); > > + > > + dm_interposer_free_dev(md->ip_dev); > > + md->ip_dev = NULL; > > + } > > + > > spin_lock(&_minor_lock); > > idr_replace(&_minor_idr, MINOR_ALLOCED, MINOR(disk_devt(dm_disk(md)))); > > set_bit(DMF_FREEING, &md->flags); > > diff --git a/drivers/md/dm.h b/drivers/md/dm.h > > index fffe1e289c53..7bf20fb2de74 100644 > > --- a/drivers/md/dm.h > > +++ b/drivers/md/dm.h > > @@ -179,7 +179,7 @@ int dm_open_count(struct mapped_device *md); > > int dm_lock_for_deletion(struct mapped_device *md, bool mark_deferred, bool only_deferred); > > int dm_cancel_deferred_remove(struct mapped_device *md); > > int dm_request_based(struct mapped_device *md); > > -int dm_get_table_device(struct mapped_device *md, dev_t dev, fmode_t mode, > > +int dm_get_table_device(struct mapped_device *md, dev_t dev, fmode_t mode, bool non_exclusive, > > struct dm_dev **result); > > void dm_put_table_device(struct mapped_device *md, struct dm_dev *d); > > > > diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h > > index 61a66fb8ebb3..70002363bfc0 100644 > > --- a/include/linux/device-mapper.h > > +++ b/include/linux/device-mapper.h > > @@ -150,6 +150,7 @@ struct dm_dev { > > struct block_device *bdev; > > struct dax_device *dax_dev; > > fmode_t mode; > > + bool non_exclusive; > > char name[16]; > > }; > > > > @@ -325,6 +326,12 @@ struct dm_target { > > * whether or not its underlying devices have support. > > */ > > bool discards_supported:1; > > + > > + /* > > + * Set if this target needs to open device without FMODE_EXCL > > + * mode. > > + */ > > + bool non_exclusive:1; > > }; > > > > void *dm_per_bio_data(struct bio *bio, size_t data_size); > > diff --git a/include/uapi/linux/dm-ioctl.h b/include/uapi/linux/dm-ioctl.h > > index 4933b6b67b85..08d7dbff80f4 100644 > > --- a/include/uapi/linux/dm-ioctl.h > > +++ b/include/uapi/linux/dm-ioctl.h > > @@ -214,6 +214,15 @@ struct dm_target_msg { > > char message[0]; > > }; > > > > +enum { > > + REMAP_START_CMD = 1, > > + REMAP_FINISH_CMD, > > +}; > > + > > +struct dm_remap_param { > > + uint8_t cmd; > > + uint8_t params[0]; > > +}; > > /* > > * If you change this make sure you make the corresponding change > > * to dm-ioctl.c:lookup_ioctl() > > @@ -244,6 +253,7 @@ enum { > > DM_DEV_SET_GEOMETRY_CMD, > > DM_DEV_ARM_POLL_CMD, > > DM_GET_TARGET_VERSION_CMD, > > + DM_DEV_REMAP_CMD > > }; > > > > #define DM_IOCTL 0xfd > > @@ -259,6 +269,7 @@ enum { > > #define DM_DEV_STATUS _IOWR(DM_IOCTL, DM_DEV_STATUS_CMD, struct dm_ioctl) > > #define DM_DEV_WAIT _IOWR(DM_IOCTL, DM_DEV_WAIT_CMD, struct dm_ioctl) > > #define DM_DEV_ARM_POLL _IOWR(DM_IOCTL, DM_DEV_ARM_POLL_CMD, struct dm_ioctl) > > +#define DM_DEV_REMAP _IOWR(DM_IOCTL, DM_DEV_REMAP_CMD, struct dm_ioctl) > > > > #define DM_TABLE_LOAD _IOWR(DM_IOCTL, DM_TABLE_LOAD_CMD, struct dm_ioctl) > > #define DM_TABLE_CLEAR _IOWR(DM_IOCTL, DM_TABLE_CLEAR_CMD, struct dm_ioctl) > > @@ -272,9 +283,9 @@ enum { > > #define DM_DEV_SET_GEOMETRY _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl) > > > > #define DM_VERSION_MAJOR 4 > > -#define DM_VERSION_MINOR 43 > > +#define DM_VERSION_MINOR 44 > > #define DM_VERSION_PATCHLEVEL 0 > > -#define DM_VERSION_EXTRA "-ioctl (2020-10-01)" > > +#define DM_VERSION_EXTRA "-ioctl (2020-12-25)" > > > > /* Status bits */ > > #define DM_READONLY_FLAG (1 << 0) /* In/Out */ > > > > > -- > Damien Le Moal > Western Digital Research > -- Sergei Shtepa Veeam Software developer.