From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Williams, Dan J" Subject: Re: [PATCH v5 09/21] libnvdimm, nd_pmem: add libnvdimm support to the pmem driver Date: Wed, 3 Jun 2015 19:31:38 +0000 Message-ID: <1433359894.21035.33.camel@intel.com> References: <20150602001134.4506.45867.stgit@dwillia2-desk3.amr.corp.intel.com> <20150602001458.4506.76492.stgit@dwillia2-desk3.amr.corp.intel.com> <20150603074424.GA24949@infradead.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20150603074424.GA24949-wEGCiKHe2LqWVfeAwA7xHQ@public.gmane.org> Content-Language: en-US Content-ID: <95CF8A738187FF49A5764E226AE11926-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org> Sender: linux-api-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org To: "hch-wEGCiKHe2LqWVfeAwA7xHQ@public.gmane.org" Cc: "linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "mingo-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org" , "linux-nvdimm-y27Ovi1pjclAfugRpC6u6w@public.gmane.org" , "neilb-l3A5Bk7waGM@public.gmane.org" , "linux-api-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" , "hch-jcswGhMUV9g@public.gmane.org" , "axboe-tSWWG44O7X1aa/9Udqfwiw@public.gmane.org" , "akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b@public.gmane.org" , "sfr-3FnU+UHB4dNDw9hX6IcOSA@public.gmane.org" , "gregkh-hQyY1W1yCW8ekmWlsbkhG0B+6BGkLq7r@public.gmane.org" , "rafael-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org" , "linux-acpi-u79uwXL29TY76Z2rM5mHXA@public.gmane.org" List-Id: linux-api@vger.kernel.org T24gV2VkLCAyMDE1LTA2LTAzIGF0IDAwOjQ0IC0wNzAwLCBDaHJpc3RvcGggSGVsbHdpZyB3cm90 ZToNCj4gVGhpcyBwYXRjaCBkb2Vzbid0IGFwcGx5LCBhcyBpdCBzZWVtcyB0byB1c2Ugc29tZSBn aXQgbWFnaWMuDQo+IA0KPiBCdXQgbG9va2luZyBhdCBpdCBpdCdzIGFsc28gd3JvbmcgaW4gdGhh dCBpdCBtaXhlcyBhIGZpbGUgbW92ZQ0KPiBhbmQgYWN0dWFsIGNoYW5nZXMgdG8gdGhlIGZpbGUu DQoNCkkgbGlrZSBtb3ZlLW1vZGlmeSBwYXRjaGVzIGJlY2F1c2UgdGhleSBtYWtlIHRoZSByZWFz b24gZm9yIHRoZSBtb3ZlDQpjbGVhcmVyIGFuZCByZXZlcnRpYmxlLiAgQ29uc2lkZXIgYSBnZW5l cmFsIGNhc2Ugd2hlcmUgd2UgbGF0ZXIgZGVjaWRlDQp0aGUgcmVhc29uIGZvciBhIG1vdmUgd2Fz IGludmFsaWQuICBSZXZlcnRpbmcgdGhlIHJlYXNvbiBhbHNvIHJldmVydHMNCnRoZSBmaWxlIG1v dmUsIHRoYXQgZG9lc24ndCBhdXRvbWF0aWNhbGx5IGhhcHBlbiB3aGVuIGl0IGlzIHNwbGl0IHRv DQphbm90aGVyIGNvbW1pdC4NCg0KSW4gY2FzZSB5b3UgZG9uJ3Qgd2FudCB0byBtZXNzIGFyb3Vu ZCB3aXRoICdnaXQgYXBwbHknIGhlcmUncyB0aGUNCnVubWFnaWNhbCB2ZXJzaW9uIG9mIHRoZSBw YXRjaCAocmViYXNlZCBhY2NvcmRpbmcgdG8gdGhlIGNvbW1lbnRzIHlvdQ0KbWFkZSB0byBwYXRj aCAyKS4uLg0KDQo4PC0tLQ0KbGlibnZkaW1tLCBuZF9wbWVtOiBhZGQgbGlibnZkaW1tIHN1cHBv cnQgdG8gdGhlIHBtZW0gZHJpdmVyDQoNCkZyb206IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlh bXNAaW50ZWwuY29tPg0KDQpuZF9wbWVtIGF0dGFjaGVzIHRvIHBlcnNpc3RlbnQgbWVtb3J5IHJl Z2lvbnMgYW5kIG5hbWVzcGFjZXMgZW1pdHRlZCBieQ0KdGhlIGxpYm52ZGltbSBzdWJzeXN0ZW0s IGFuZCwgc2FtZSBhcyB0aGUgb3JpZ2luYWwgcG1lbSBkcml2ZXIsIHByZXNlbnRzDQp0aGUgc3lz dGVtLXBoeXNpY2FsLWFkZHJlc3MgcmFuZ2UgYXMgYSBibG9jayBkZXZpY2UuDQoNClRoZSBleGlz dGluZyBlODIwLXR5cGUtMTIgdG8gcG1lbSBzZXR1cCBpcyBjb252ZXJ0ZWQgdG8gYSBmdWxsIGxp Ym52ZGltbQ0KYnVzIHRoYXQgZW1pdHMgYW4gbmRfbmFtZXNwYWNlX2lvIGRldmljZS4NCg0KQ2M6 IEFuZHkgTHV0b21pcnNraSA8bHV0b0BhbWFjYXBpdGFsLm5ldD4NCkNjOiBCb2F6IEhhcnJvc2gg PGJvYXpAcGxleGlzdG9yLmNvbT4NCkNjOiBILiBQZXRlciBBbnZpbiA8aHBhQHp5dG9yLmNvbT4N CkNjOiBKZW5zIEF4Ym9lIDxheGJvZUBmYi5jb20+DQpDYzogSW5nbyBNb2xuYXIgPG1pbmdvQGtl cm5lbC5vcmc+DQpDYzogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+DQpTaWduZWQtb2Zm LWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCi0tLQ0KIGFyY2gv eDg2L0tjb25maWcgICAgICAgIHwgICAgMyArDQogYXJjaC94ODYva2VybmVsL3BtZW0uYyAgfCAg IDkyICsrKysrKysrKysrLS0tLS0tDQogZHJpdmVycy9ibG9jay9LY29uZmlnICAgfCAgIDExIC0t DQogZHJpdmVycy9ibG9jay9NYWtlZmlsZSAgfCAgICAxIA0KIGRyaXZlcnMvYmxvY2svcG1lbS5j ICAgIHwgIDI2MiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQ0KIGRyaXZlcnMvbnZkaW1tL0tjb25maWcgIHwgICAyMiArKysrDQogZHJpdmVycy9udmRpbW0v TWFrZWZpbGUgfCAgICAzICsNCiBkcml2ZXJzL252ZGltbS9wbWVtLmMgICB8ICAyNjAgKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysNCiA4IGZpbGVzIGNoYW5n ZWQsIDM0NyBpbnNlcnRpb25zKCspLCAzMDcgZGVsZXRpb25zKC0pDQogZGVsZXRlIG1vZGUgMTAw NjQ0IGRyaXZlcnMvYmxvY2svcG1lbS5jDQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvbnZk aW1tL3BtZW0uYw0KDQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvS2NvbmZpZyBiL2FyY2gveDg2L0tj b25maWcNCmluZGV4IDIyNmQ1Njk2ZTFkMS4uMWEyY2JmNjQxNjY3IDEwMDY0NA0KLS0tIGEvYXJj aC94ODYvS2NvbmZpZw0KKysrIGIvYXJjaC94ODYvS2NvbmZpZw0KQEAgLTE0MjQsNiArMTQyNCw5 IEBAIHNvdXJjZSAibW0vS2NvbmZpZyINCiANCiBjb25maWcgWDg2X1BNRU1fTEVHQUNZDQogCWJv b2wgIlN1cHBvcnQgbm9uLXN0YW5kYXJkIE5WRElNTXMgYW5kIEFEUiBwcm90ZWN0ZWQgbWVtb3J5 Ig0KKwlkZXBlbmRzIG9uIFBIWVNfQUREUl9UXzY0QklUDQorCWRlcGVuZHMgb24gQkxLX0RFVg0K KwlzZWxlY3QgTElCTlZESU1NDQogCWhlbHANCiAJICBUcmVhdCBtZW1vcnkgbWFya2VkIHVzaW5n IHRoZSBub24tc3RhbmRhcmQgZTgyMCB0eXBlIG9mIDEyIGFzIHVzZWQNCiAJICBieSB0aGUgSW50 ZWwgU2FuZHkgQnJpZGdlLUVQIHJlZmVyZW5jZSBCSU9TIGFzIHByb3RlY3RlZCBtZW1vcnkuDQpk aWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3BtZW0uYyBiL2FyY2gveDg2L2tlcm5lbC9wbWVt LmMNCmluZGV4IDM0MjBjODc0ZGRjNS4uNDBkNzM0YzhlM2IxIDEwMDY0NA0KLS0tIGEvYXJjaC94 ODYva2VybmVsL3BtZW0uYw0KKysrIGIvYXJjaC94ODYva2VybmVsL3BtZW0uYw0KQEAgLTEsNTMg KzEsODEgQEANCiAvKg0KICAqIENvcHlyaWdodCAoYykgMjAxNSwgQ2hyaXN0b3BoIEhlbGx3aWcu DQorICogQ29weXJpZ2h0IChjKSAyMDE1LCBJbnRlbCBDb3Jwb3JhdGlvbi4NCiAgKi8NCi0jaW5j bHVkZSA8bGludXgvbWVtYmxvY2suaD4NCiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNl Lmg+DQotI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4NCisjaW5jbHVkZSA8bGludXgvbGlibnZkaW1t Lmg+DQorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPg0KICNpbmNsdWRlIDxhc20vZTgyMC5oPg0K LSNpbmNsdWRlIDxhc20vcGFnZV90eXBlcy5oPg0KLSNpbmNsdWRlIDxhc20vc2V0dXAuaD4NCiAN Ci1zdGF0aWMgX19pbml0IHZvaWQgcmVnaXN0ZXJfcG1lbV9kZXZpY2Uoc3RydWN0IHJlc291cmNl ICpyZXMpDQorc3RhdGljIHZvaWQgZTgyMF9wbWVtX3JlbGVhc2Uoc3RydWN0IGRldmljZSAqZGV2 KQ0KIHsNCi0Jc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldjsNCi0JaW50IGVycm9yOw0KKwlz dHJ1Y3QgbnZkaW1tX2J1cyAqbnZkaW1tX2J1cyA9IGRldi0+cGxhdGZvcm1fZGF0YTsNCiANCi0J cGRldiA9IHBsYXRmb3JtX2RldmljZV9hbGxvYygicG1lbSIsIFBMQVRGT1JNX0RFVklEX0FVVE8p Ow0KLQlpZiAoIXBkZXYpDQotCQlyZXR1cm47DQorCWlmIChudmRpbW1fYnVzKQ0KKwkJbnZkaW1t X2J1c191bnJlZ2lzdGVyKG52ZGltbV9idXMpOw0KK30NCiANCi0JZXJyb3IgPSBwbGF0Zm9ybV9k ZXZpY2VfYWRkX3Jlc291cmNlcyhwZGV2LCByZXMsIDEpOw0KLQlpZiAoZXJyb3IpDQotCQlnb3Rv IG91dF9wdXRfcGRldjsNCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBlODIwX3BtZW0g PSB7DQorCS5uYW1lID0gImU4MjBfcG1lbSIsDQorCS5pZCA9IC0xLA0KKwkuZGV2ID0gew0KKwkJ LnJlbGVhc2UgPSBlODIwX3BtZW1fcmVsZWFzZSwNCisJfSwNCit9Ow0KIA0KLQllcnJvciA9IHBs YXRmb3JtX2RldmljZV9hZGQocGRldik7DQotCWlmIChlcnJvcikNCi0JCWdvdG8gb3V0X3B1dF9w ZGV2Ow0KLQlyZXR1cm47DQorc3RhdGljIGNvbnN0IHN0cnVjdCBhdHRyaWJ1dGVfZ3JvdXAgKmU4 MjBfcG1lbV9hdHRyaWJ1dGVfZ3JvdXBzW10gPSB7DQorCSZudmRpbW1fYnVzX2F0dHJpYnV0ZV9n cm91cCwNCisJTlVMTCwNCit9Ow0KIA0KLW91dF9wdXRfcGRldjoNCi0JZGV2X3dhcm4oJnBkZXYt PmRldiwgImZhaWxlZCB0byBhZGQgJ3BtZW0nIChwZXJzaXN0ZW50IG1lbW9yeSkgZGV2aWNlIVxu Iik7DQotCXBsYXRmb3JtX2RldmljZV9wdXQocGRldik7DQotfQ0KK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgYXR0cmlidXRlX2dyb3VwICplODIwX3BtZW1fcmVnaW9uX2F0dHJpYnV0ZV9ncm91cHNbXSA9 IHsNCisJJm5kX3JlZ2lvbl9hdHRyaWJ1dGVfZ3JvdXAsDQorCSZuZF9kZXZpY2VfYXR0cmlidXRl X2dyb3VwLA0KKwlOVUxMLA0KK307DQogDQotc3RhdGljIF9faW5pdCBpbnQgcmVnaXN0ZXJfcG1l bV9kZXZpY2VzKHZvaWQpDQorc3RhdGljIF9faW5pdCBpbnQgcmVnaXN0ZXJfZTgyMF9wbWVtKHZv aWQpDQogew0KLQlpbnQgaTsNCisJc3RhdGljIHN0cnVjdCBudmRpbW1fYnVzX2Rlc2NyaXB0b3Ig bmRfZGVzYzsNCisJc3RydWN0IGRldmljZSAqZGV2ID0gJmU4MjBfcG1lbS5kZXY7DQorCXN0cnVj dCBudmRpbW1fYnVzICpudmRpbW1fYnVzOw0KKwlpbnQgcmMsIGk7DQorDQorCXJjID0gcGxhdGZv cm1fZGV2aWNlX3JlZ2lzdGVyKCZlODIwX3BtZW0pOw0KKwlpZiAocmMpDQorCQlyZXR1cm4gcmM7 DQorDQorCW5kX2Rlc2MuYXR0cl9ncm91cHMgPSBlODIwX3BtZW1fYXR0cmlidXRlX2dyb3VwczsN CisJbmRfZGVzYy5wcm92aWRlcl9uYW1lID0gImU4MjAiOw0KKwludmRpbW1fYnVzID0gbnZkaW1t X2J1c19yZWdpc3RlcihkZXYsICZuZF9kZXNjKTsNCisJaWYgKCFudmRpbW1fYnVzKQ0KKwkJZ290 byBlcnI7DQorCWRldi0+cGxhdGZvcm1fZGF0YSA9IG52ZGltbV9idXM7DQogDQogCWZvciAoaSA9 IDA7IGkgPCBlODIwLm5yX21hcDsgaSsrKSB7DQogCQlzdHJ1Y3QgZTgyMGVudHJ5ICplaSA9ICZl ODIwLm1hcFtpXTsNCisJCXN0cnVjdCByZXNvdXJjZSByZXMgPSB7DQorCQkJLmZsYWdzCT0gSU9S RVNPVVJDRV9NRU0sDQorCQkJLnN0YXJ0CT0gZWktPmFkZHIsDQorCQkJLmVuZAk9IGVpLT5hZGRy ICsgZWktPnNpemUgLSAxLA0KKwkJfTsNCisJCXN0cnVjdCBuZF9yZWdpb25fZGVzYyBuZHJfZGVz YzsNCisNCisJCWlmIChlaS0+dHlwZSAhPSBFODIwX1BSQU0pDQorCQkJY29udGludWU7DQogDQot CQlpZiAoZWktPnR5cGUgPT0gRTgyMF9QUkFNKSB7DQotCQkJc3RydWN0IHJlc291cmNlIHJlcyA9 IHsNCi0JCQkJLmZsYWdzCT0gSU9SRVNPVVJDRV9NRU0sDQotCQkJCS5zdGFydAk9IGVpLT5hZGRy LA0KLQkJCQkuZW5kCT0gZWktPmFkZHIgKyBlaS0+c2l6ZSAtIDEsDQotCQkJfTsNCi0JCQlyZWdp c3Rlcl9wbWVtX2RldmljZSgmcmVzKTsNCi0JCX0NCisJCW1lbXNldCgmbmRyX2Rlc2MsIDAsIHNp emVvZihuZHJfZGVzYykpOw0KKwkJbmRyX2Rlc2MucmVzID0gJnJlczsNCisJCW5kcl9kZXNjLmF0 dHJfZ3JvdXBzID0gZTgyMF9wbWVtX3JlZ2lvbl9hdHRyaWJ1dGVfZ3JvdXBzOw0KKwkJaWYgKCFu dmRpbW1fcG1lbV9yZWdpb25fY3JlYXRlKG52ZGltbV9idXMsICZuZHJfZGVzYykpDQorCQkJZ290 byBlcnI7DQogCX0NCiANCiAJcmV0dXJuIDA7DQorDQorIGVycjoNCisJZGV2X2VycihkZXYsICJm YWlsZWQgdG8gcmVnaXN0ZXIgbGVnYWN5IHBlcnNpc3RlbnQgbWVtb3J5IHJhbmdlc1xuIik7DQor CXBsYXRmb3JtX2RldmljZV91bnJlZ2lzdGVyKCZlODIwX3BtZW0pOw0KKwlyZXR1cm4gLUVOWElP Ow0KIH0NCi1kZXZpY2VfaW5pdGNhbGwocmVnaXN0ZXJfcG1lbV9kZXZpY2VzKTsNCitsYXRlX2lu aXRjYWxsKHJlZ2lzdGVyX2U4MjBfcG1lbSk7DQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9L Y29uZmlnIGIvZHJpdmVycy9ibG9jay9LY29uZmlnDQppbmRleCBlYjFmZWQ1YmQ1MTYuLjFiODA5 NGQ0ZDdhZiAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvYmxvY2svS2NvbmZpZw0KKysrIGIvZHJpdmVy cy9ibG9jay9LY29uZmlnDQpAQCAtNDA0LDE3ICs0MDQsNiBAQCBjb25maWcgQkxLX0RFVl9SQU1f REFYDQogCSAgYW5kIHdpbGwgcHJldmVudCBSQU0gYmxvY2sgZGV2aWNlIGJhY2tpbmcgc3RvcmUg bWVtb3J5IGZyb20gYmVpbmcNCiAJICBhbGxvY2F0ZWQgZnJvbSBoaWdobWVtIChvbmx5IGEgcHJv YmxlbSBmb3IgaGlnaG1lbSBzeXN0ZW1zKS4NCiANCi1jb25maWcgQkxLX0RFVl9QTUVNDQotCXRy aXN0YXRlICJQZXJzaXN0ZW50IG1lbW9yeSBibG9jayBkZXZpY2Ugc3VwcG9ydCINCi0JaGVscA0K LQkgIFNheWluZyBZIGhlcmUgd2lsbCBhbGxvdyB5b3UgdG8gdXNlIGEgY29udGlndW91cyByYW5n ZSBvZiByZXNlcnZlZA0KLQkgIG1lbW9yeSBhcyBvbmUgb3IgbW9yZSBwZXJzaXN0ZW50IGJsb2Nr IGRldmljZXMuDQotDQotCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hv b3NlIE0gaGVyZTogdGhlIG1vZHVsZSB3aWxsIGJlDQotCSAgY2FsbGVkICdwbWVtJy4NCi0NCi0J ICBJZiB1bnN1cmUsIHNheSBOLg0KLQ0KIGNvbmZpZyBDRFJPTV9QS1RDRFZEDQogCXRyaXN0YXRl ICJQYWNrZXQgd3JpdGluZyBvbiBDRC9EVkQgbWVkaWEiDQogCWRlcGVuZHMgb24gIVVNTA0KZGlm ZiAtLWdpdCBhL2RyaXZlcnMvYmxvY2svTWFrZWZpbGUgYi9kcml2ZXJzL2Jsb2NrL01ha2VmaWxl DQppbmRleCA5Y2M2YzE4YTFjN2UuLjAyYjY4OGQxNDM4ZCAxMDA2NDQNCi0tLSBhL2RyaXZlcnMv YmxvY2svTWFrZWZpbGUNCisrKyBiL2RyaXZlcnMvYmxvY2svTWFrZWZpbGUNCkBAIC0xNCw3ICsx NCw2IEBAIG9iai0kKENPTkZJR19QUzNfVlJBTSkJCSs9IHBzM3ZyYW0ubw0KIG9iai0kKENPTkZJ R19BVEFSSV9GTE9QUFkpCSs9IGF0YWZsb3Aubw0KIG9iai0kKENPTkZJR19BTUlHQV9aMlJBTSkJ Kz0gejJyYW0ubw0KIG9iai0kKENPTkZJR19CTEtfREVWX1JBTSkJKz0gYnJkLm8NCi1vYmotJChD T05GSUdfQkxLX0RFVl9QTUVNKQkrPSBwbWVtLm8NCiBvYmotJChDT05GSUdfQkxLX0RFVl9MT09Q KQkrPSBsb29wLm8NCiBvYmotJChDT05GSUdfQkxLX0NQUV9EQSkJKz0gY3BxYXJyYXkubw0KIG9i ai0kKENPTkZJR19CTEtfQ1BRX0NJU1NfREEpICArPSBjY2lzcy5vDQpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ibG9jay9wbWVtLmMgYi9kcml2ZXJzL2Jsb2NrL3BtZW0uYw0KZGVsZXRlZCBmaWxlIG1v ZGUgMTAwNjQ0DQppbmRleCBlYWJmNGE4ZDAwODUuLjAwMDAwMDAwMDAwMA0KLS0tIGEvZHJpdmVy cy9ibG9jay9wbWVtLmMNCisrKyAvZGV2L251bGwNCkBAIC0xLDI2MiArMCwwIEBADQotLyoNCi0g KiBQZXJzaXN0ZW50IE1lbW9yeSBEcml2ZXINCi0gKg0KLSAqIENvcHlyaWdodCAoYykgMjAxNCwg SW50ZWwgQ29ycG9yYXRpb24uDQotICogQ29weXJpZ2h0IChjKSAyMDE1LCBDaHJpc3RvcGggSGVs bHdpZyA8aGNoQGxzdC5kZT4uDQotICogQ29weXJpZ2h0IChjKSAyMDE1LCBCb2F6IEhhcnJvc2gg PGJvYXpAcGxleGlzdG9yLmNvbT4uDQotICoNCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdA0KLSAqIHVuZGVy IHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UsDQotICogdmVyc2lvbiAyLCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbi4NCi0gKg0KLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQNCi0gKiBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3INCi0gKiBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVi bGljIExpY2Vuc2UgZm9yDQotICogbW9yZSBkZXRhaWxzLg0KLSAqLw0KLQ0KLSNpbmNsdWRlIDxh c20vY2FjaGVmbHVzaC5oPg0KLSNpbmNsdWRlIDxsaW51eC9ibGtkZXYuaD4NCi0jaW5jbHVkZSA8 bGludXgvaGRyZWcuaD4NCi0jaW5jbHVkZSA8bGludXgvaW5pdC5oPg0KLSNpbmNsdWRlIDxsaW51 eC9wbGF0Zm9ybV9kZXZpY2UuaD4NCi0jaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQotI2luY2x1 ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+DQotI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4NCi0NCi0j ZGVmaW5lIFBNRU1fTUlOT1JTCQkxNg0KLQ0KLXN0cnVjdCBwbWVtX2RldmljZSB7DQotCXN0cnVj dCByZXF1ZXN0X3F1ZXVlCSpwbWVtX3F1ZXVlOw0KLQlzdHJ1Y3QgZ2VuZGlzawkJKnBtZW1fZGlz azsNCi0NCi0JLyogT25lIGNvbnRpZ3VvdXMgbWVtb3J5IHJlZ2lvbiBwZXIgZGV2aWNlICovDQot CXBoeXNfYWRkcl90CQlwaHlzX2FkZHI7DQotCXZvaWQJCQkqdmlydF9hZGRyOw0KLQlzaXplX3QJ CQlzaXplOw0KLX07DQotDQotc3RhdGljIGludCBwbWVtX21ham9yOw0KLXN0YXRpYyBhdG9taWNf dCBwbWVtX2luZGV4Ow0KLQ0KLXN0YXRpYyB2b2lkIHBtZW1fZG9fYnZlYyhzdHJ1Y3QgcG1lbV9k ZXZpY2UgKnBtZW0sIHN0cnVjdCBwYWdlICpwYWdlLA0KLQkJCXVuc2lnbmVkIGludCBsZW4sIHVu c2lnbmVkIGludCBvZmYsIGludCBydywNCi0JCQlzZWN0b3JfdCBzZWN0b3IpDQotew0KLQl2b2lk ICptZW0gPSBrbWFwX2F0b21pYyhwYWdlKTsNCi0Jc2l6ZV90IHBtZW1fb2ZmID0gc2VjdG9yIDw8 IDk7DQotDQotCWlmIChydyA9PSBSRUFEKSB7DQotCQltZW1jcHkobWVtICsgb2ZmLCBwbWVtLT52 aXJ0X2FkZHIgKyBwbWVtX29mZiwgbGVuKTsNCi0JCWZsdXNoX2RjYWNoZV9wYWdlKHBhZ2UpOw0K LQl9IGVsc2Ugew0KLQkJZmx1c2hfZGNhY2hlX3BhZ2UocGFnZSk7DQotCQltZW1jcHkocG1lbS0+ dmlydF9hZGRyICsgcG1lbV9vZmYsIG1lbSArIG9mZiwgbGVuKTsNCi0JfQ0KLQ0KLQlrdW5tYXBf YXRvbWljKG1lbSk7DQotfQ0KLQ0KLXN0YXRpYyB2b2lkIHBtZW1fbWFrZV9yZXF1ZXN0KHN0cnVj dCByZXF1ZXN0X3F1ZXVlICpxLCBzdHJ1Y3QgYmlvICpiaW8pDQotew0KLQlzdHJ1Y3QgYmxvY2tf ZGV2aWNlICpiZGV2ID0gYmlvLT5iaV9iZGV2Ow0KLQlzdHJ1Y3QgcG1lbV9kZXZpY2UgKnBtZW0g PSBiZGV2LT5iZF9kaXNrLT5wcml2YXRlX2RhdGE7DQotCWludCBydzsNCi0Jc3RydWN0IGJpb192 ZWMgYnZlYzsNCi0Jc2VjdG9yX3Qgc2VjdG9yOw0KLQlzdHJ1Y3QgYnZlY19pdGVyIGl0ZXI7DQot CWludCBlcnIgPSAwOw0KLQ0KLQlpZiAoYmlvX2VuZF9zZWN0b3IoYmlvKSA+IGdldF9jYXBhY2l0 eShiZGV2LT5iZF9kaXNrKSkgew0KLQkJZXJyID0gLUVJTzsNCi0JCWdvdG8gb3V0Ow0KLQl9DQot DQotCUJVR19PTihiaW8tPmJpX3J3ICYgUkVRX0RJU0NBUkQpOw0KLQ0KLQlydyA9IGJpb19kYXRh X2RpcihiaW8pOw0KLQlzZWN0b3IgPSBiaW8tPmJpX2l0ZXIuYmlfc2VjdG9yOw0KLQliaW9fZm9y X2VhY2hfc2VnbWVudChidmVjLCBiaW8sIGl0ZXIpIHsNCi0JCXBtZW1fZG9fYnZlYyhwbWVtLCBi dmVjLmJ2X3BhZ2UsIGJ2ZWMuYnZfbGVuLCBidmVjLmJ2X29mZnNldCwNCi0JCQkgICAgIHJ3LCBz ZWN0b3IpOw0KLQkJc2VjdG9yICs9IGJ2ZWMuYnZfbGVuID4+IDk7DQotCX0NCi0NCi1vdXQ6DQot CWJpb19lbmRpbyhiaW8sIGVycik7DQotfQ0KLQ0KLXN0YXRpYyBpbnQgcG1lbV9yd19wYWdlKHN0 cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIHNlY3Rvcl90IHNlY3RvciwNCi0JCSAgICAgICBzdHJ1 Y3QgcGFnZSAqcGFnZSwgaW50IHJ3KQ0KLXsNCi0Jc3RydWN0IHBtZW1fZGV2aWNlICpwbWVtID0g YmRldi0+YmRfZGlzay0+cHJpdmF0ZV9kYXRhOw0KLQ0KLQlwbWVtX2RvX2J2ZWMocG1lbSwgcGFn ZSwgUEFHRV9DQUNIRV9TSVpFLCAwLCBydywgc2VjdG9yKTsNCi0JcGFnZV9lbmRpbyhwYWdlLCBy dyAmIFdSSVRFLCAwKTsNCi0NCi0JcmV0dXJuIDA7DQotfQ0KLQ0KLXN0YXRpYyBsb25nIHBtZW1f ZGlyZWN0X2FjY2VzcyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBzZWN0b3JfdCBzZWN0b3Is DQotCQkJICAgICAgdm9pZCAqKmthZGRyLCB1bnNpZ25lZCBsb25nICpwZm4sIGxvbmcgc2l6ZSkN Ci17DQotCXN0cnVjdCBwbWVtX2RldmljZSAqcG1lbSA9IGJkZXYtPmJkX2Rpc2stPnByaXZhdGVf ZGF0YTsNCi0Jc2l6ZV90IG9mZnNldCA9IHNlY3RvciA8PCA5Ow0KLQ0KLQlpZiAoIXBtZW0pDQot CQlyZXR1cm4gLUVOT0RFVjsNCi0NCi0JKmthZGRyID0gcG1lbS0+dmlydF9hZGRyICsgb2Zmc2V0 Ow0KLQkqcGZuID0gKHBtZW0tPnBoeXNfYWRkciArIG9mZnNldCkgPj4gUEFHRV9TSElGVDsNCi0N Ci0JcmV0dXJuIHBtZW0tPnNpemUgLSBvZmZzZXQ7DQotfQ0KLQ0KLXN0YXRpYyBjb25zdCBzdHJ1 Y3QgYmxvY2tfZGV2aWNlX29wZXJhdGlvbnMgcG1lbV9mb3BzID0gew0KLQkub3duZXIgPQkJVEhJ U19NT0RVTEUsDQotCS5yd19wYWdlID0JCXBtZW1fcndfcGFnZSwNCi0JLmRpcmVjdF9hY2Nlc3Mg PQlwbWVtX2RpcmVjdF9hY2Nlc3MsDQotfTsNCi0NCi1zdGF0aWMgc3RydWN0IHBtZW1fZGV2aWNl ICpwbWVtX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHJlc291cmNlICpyZXMpDQot ew0KLQlzdHJ1Y3QgcG1lbV9kZXZpY2UgKnBtZW07DQotCXN0cnVjdCBnZW5kaXNrICpkaXNrOw0K LQlpbnQgaWR4LCBlcnI7DQotDQotCWVyciA9IC1FTk9NRU07DQotCXBtZW0gPSBremFsbG9jKHNp emVvZigqcG1lbSksIEdGUF9LRVJORUwpOw0KLQlpZiAoIXBtZW0pDQotCQlnb3RvIG91dDsNCi0N Ci0JcG1lbS0+cGh5c19hZGRyID0gcmVzLT5zdGFydDsNCi0JcG1lbS0+c2l6ZSA9IHJlc291cmNl X3NpemUocmVzKTsNCi0NCi0JZXJyID0gLUVJTlZBTDsNCi0JaWYgKCFyZXF1ZXN0X21lbV9yZWdp b24ocG1lbS0+cGh5c19hZGRyLCBwbWVtLT5zaXplLCAicG1lbSIpKSB7DQotCQlkZXZfd2Fybihk ZXYsICJjb3VsZCBub3QgcmVzZXJ2ZSByZWdpb24gWzB4JXBhOjB4JXp4XVxuIiwgJnBtZW0tPnBo eXNfYWRkciwgcG1lbS0+c2l6ZSk7DQotCQlnb3RvIG91dF9mcmVlX2RldjsNCi0JfQ0KLQ0KLQkv Kg0KLQkgKiBNYXAgdGhlIG1lbW9yeSBhcyBub24tY2FjaGFibGUsIGFzIHdlIGNhbid0IHdyaXRl IGJhY2sgdGhlIGNvbnRlbnRzDQotCSAqIG9mIHRoZSBDUFUgY2FjaGVzIGluIGNhc2Ugb2YgYSBj cmFzaC4NCi0JICovDQotCWVyciA9IC1FTk9NRU07DQotCXBtZW0tPnZpcnRfYWRkciA9IGlvcmVt YXBfbm9jYWNoZShwbWVtLT5waHlzX2FkZHIsIHBtZW0tPnNpemUpOw0KLQlpZiAoIXBtZW0tPnZp cnRfYWRkcikNCi0JCWdvdG8gb3V0X3JlbGVhc2VfcmVnaW9uOw0KLQ0KLQlwbWVtLT5wbWVtX3F1 ZXVlID0gYmxrX2FsbG9jX3F1ZXVlKEdGUF9LRVJORUwpOw0KLQlpZiAoIXBtZW0tPnBtZW1fcXVl dWUpDQotCQlnb3RvIG91dF91bm1hcDsNCi0NCi0JYmxrX3F1ZXVlX21ha2VfcmVxdWVzdChwbWVt LT5wbWVtX3F1ZXVlLCBwbWVtX21ha2VfcmVxdWVzdCk7DQotCWJsa19xdWV1ZV9tYXhfaHdfc2Vj dG9ycyhwbWVtLT5wbWVtX3F1ZXVlLCAxMDI0KTsNCi0JYmxrX3F1ZXVlX2JvdW5jZV9saW1pdChw bWVtLT5wbWVtX3F1ZXVlLCBCTEtfQk9VTkNFX0FOWSk7DQotDQotCWRpc2sgPSBhbGxvY19kaXNr KFBNRU1fTUlOT1JTKTsNCi0JaWYgKCFkaXNrKQ0KLQkJZ290byBvdXRfZnJlZV9xdWV1ZTsNCi0N Ci0JaWR4ID0gYXRvbWljX2luY19yZXR1cm4oJnBtZW1faW5kZXgpIC0gMTsNCi0NCi0JZGlzay0+ bWFqb3IJCT0gcG1lbV9tYWpvcjsNCi0JZGlzay0+Zmlyc3RfbWlub3IJPSBQTUVNX01JTk9SUyAq IGlkeDsNCi0JZGlzay0+Zm9wcwkJPSAmcG1lbV9mb3BzOw0KLQlkaXNrLT5wcml2YXRlX2RhdGEJ PSBwbWVtOw0KLQlkaXNrLT5xdWV1ZQkJPSBwbWVtLT5wbWVtX3F1ZXVlOw0KLQlkaXNrLT5mbGFn cwkJPSBHRU5IRF9GTF9FWFRfREVWVDsNCi0Jc3ByaW50ZihkaXNrLT5kaXNrX25hbWUsICJwbWVt JWQiLCBpZHgpOw0KLQlkaXNrLT5kcml2ZXJmc19kZXYgPSBkZXY7DQotCXNldF9jYXBhY2l0eShk aXNrLCBwbWVtLT5zaXplID4+IDkpOw0KLQlwbWVtLT5wbWVtX2Rpc2sgPSBkaXNrOw0KLQ0KLQlh ZGRfZGlzayhkaXNrKTsNCi0NCi0JcmV0dXJuIHBtZW07DQotDQotb3V0X2ZyZWVfcXVldWU6DQot CWJsa19jbGVhbnVwX3F1ZXVlKHBtZW0tPnBtZW1fcXVldWUpOw0KLW91dF91bm1hcDoNCi0JaW91 bm1hcChwbWVtLT52aXJ0X2FkZHIpOw0KLW91dF9yZWxlYXNlX3JlZ2lvbjoNCi0JcmVsZWFzZV9t ZW1fcmVnaW9uKHBtZW0tPnBoeXNfYWRkciwgcG1lbS0+c2l6ZSk7DQotb3V0X2ZyZWVfZGV2Og0K LQlrZnJlZShwbWVtKTsNCi1vdXQ6DQotCXJldHVybiBFUlJfUFRSKGVycik7DQotfQ0KLQ0KLXN0 YXRpYyB2b2lkIHBtZW1fZnJlZShzdHJ1Y3QgcG1lbV9kZXZpY2UgKnBtZW0pDQotew0KLQlkZWxf Z2VuZGlzayhwbWVtLT5wbWVtX2Rpc2spOw0KLQlwdXRfZGlzayhwbWVtLT5wbWVtX2Rpc2spOw0K LQlibGtfY2xlYW51cF9xdWV1ZShwbWVtLT5wbWVtX3F1ZXVlKTsNCi0JaW91bm1hcChwbWVtLT52 aXJ0X2FkZHIpOw0KLQlyZWxlYXNlX21lbV9yZWdpb24ocG1lbS0+cGh5c19hZGRyLCBwbWVtLT5z aXplKTsNCi0Ja2ZyZWUocG1lbSk7DQotfQ0KLQ0KLXN0YXRpYyBpbnQgcG1lbV9wcm9iZShzdHJ1 Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KLXsNCi0Jc3RydWN0IHBtZW1fZGV2aWNlICpwbWVt Ow0KLQlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsNCi0NCi0JaWYgKFdBUk5fT04ocGRldi0+bnVtX3Jl c291cmNlcyA+IDEpKQ0KLQkJcmV0dXJuIC1FTlhJTzsNCi0NCi0JcmVzID0gcGxhdGZvcm1fZ2V0 X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsNCi0JaWYgKCFyZXMpDQotCQlyZXR1 cm4gLUVOWElPOw0KLQ0KLQlwbWVtID0gcG1lbV9hbGxvYygmcGRldi0+ZGV2LCByZXMpOw0KLQlp ZiAoSVNfRVJSKHBtZW0pKQ0KLQkJcmV0dXJuIFBUUl9FUlIocG1lbSk7DQotDQotCXBsYXRmb3Jt X3NldF9kcnZkYXRhKHBkZXYsIHBtZW0pOw0KLQ0KLQlyZXR1cm4gMDsNCi19DQotDQotc3RhdGlj IGludCBwbWVtX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQ0KLXsNCi0Jc3Ry dWN0IHBtZW1fZGV2aWNlICpwbWVtID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7DQotDQot CXBtZW1fZnJlZShwbWVtKTsNCi0JcmV0dXJuIDA7DQotfQ0KLQ0KLXN0YXRpYyBzdHJ1Y3QgcGxh dGZvcm1fZHJpdmVyIHBtZW1fZHJpdmVyID0gew0KLQkucHJvYmUJCT0gcG1lbV9wcm9iZSwNCi0J LnJlbW92ZQkJPSBwbWVtX3JlbW92ZSwNCi0JLmRyaXZlcgkJPSB7DQotCQkub3duZXIJPSBUSElT X01PRFVMRSwNCi0JCS5uYW1lCT0gInBtZW0iLA0KLQl9LA0KLX07DQotDQotc3RhdGljIGludCBf X2luaXQgcG1lbV9pbml0KHZvaWQpDQotew0KLQlpbnQgZXJyb3I7DQotDQotCXBtZW1fbWFqb3Ig PSByZWdpc3Rlcl9ibGtkZXYoMCwgInBtZW0iKTsNCi0JaWYgKHBtZW1fbWFqb3IgPCAwKQ0KLQkJ cmV0dXJuIHBtZW1fbWFqb3I7DQotDQotCWVycm9yID0gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVy KCZwbWVtX2RyaXZlcik7DQotCWlmIChlcnJvcikNCi0JCXVucmVnaXN0ZXJfYmxrZGV2KHBtZW1f bWFqb3IsICJwbWVtIik7DQotCXJldHVybiBlcnJvcjsNCi19DQotbW9kdWxlX2luaXQocG1lbV9p bml0KTsNCi0NCi1zdGF0aWMgdm9pZCBwbWVtX2V4aXQodm9pZCkNCi17DQotCXBsYXRmb3JtX2Ry aXZlcl91bnJlZ2lzdGVyKCZwbWVtX2RyaXZlcik7DQotCXVucmVnaXN0ZXJfYmxrZGV2KHBtZW1f bWFqb3IsICJwbWVtIik7DQotfQ0KLW1vZHVsZV9leGl0KHBtZW1fZXhpdCk7DQotDQotTU9EVUxF X0FVVEhPUigiUm9zcyBad2lzbGVyIDxyb3NzLnp3aXNsZXJAbGludXguaW50ZWwuY29tPiIpOw0K LU1PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsNCmRpZmYgLS1naXQgYS9kcml2ZXJzL252ZGltbS9L Y29uZmlnIGIvZHJpdmVycy9udmRpbW0vS2NvbmZpZw0KaW5kZXggNGYyMjkxOTM4ZWEwLi44MThm MjE5YjAzN2MgMTAwNjQ0DQotLS0gYS9kcml2ZXJzL252ZGltbS9LY29uZmlnDQorKysgYi9kcml2 ZXJzL252ZGltbS9LY29uZmlnDQpAQCAtMSw0ICsxLDQgQEANCi1jb25maWcgTElCTlZESU1NDQor bWVudWNvbmZpZyBMSUJOVkRJTU0NCiAJdHJpc3RhdGUgIk5WRElNTSAoTm9uLVZvbGF0aWxlIE1l bW9yeSBEZXZpY2UpIFN1cHBvcnQiDQogCWhlbHANCiAJICBHZW5lcmljIHN1cHBvcnQgZm9yIG5v bi12b2xhdGlsZSBtZW1vcnkgZGV2aWNlcyBpbmNsdWRpbmcNCkBAIC0xMSwzICsxMSwyMyBAQCBj b25maWcgTElCTlZESU1NDQogCSAgQ09ORklHX0RBWCkuICBBIEJMSyBuYW1lc3BhY2UgcmVmZXJz IHRvIGFuIE5WRElNTSBjb250cm9sDQogCSAgcmVnaW9uIHdoaWNoIGV4cG9zZXMgYW4gbW1pbyBy ZWdpc3RlciBzZXQgZm9yIHdpbmRvd2VkDQogCSAgYWNjZXNzIG1vZGUgdG8gbm9uLXZvbGF0aWxl IG1lbW9yeS4NCisNCitpZiBMSUJOVkRJTU0NCisNCitjb25maWcgQkxLX0RFVl9QTUVNDQorCXRy aXN0YXRlICJQTUVNOiBQZXJzaXN0ZW50IG1lbW9yeSBibG9jayBkZXZpY2Ugc3VwcG9ydCINCisJ ZGVmYXVsdCBMSUJOVkRJTU0NCisJaGVscA0KKwkgIE1lbW9yeSByYW5nZXMgZm9yIFBNRU0gYXJl IGRlc2NyaWJlZCBieSBlaXRoZXIgYW4gTkZJVA0KKwkgIChOVkRJTU0gRmlybXdhcmUgSW50ZXJm YWNlIFRhYmxlLCBzZWUgQ09ORklHX05GSVRfQUNQSSksIGENCisJICBub24tc3RhbmRhcmQgT0VN LXNwZWNpZmljIEU4MjAgbWVtb3J5IHR5cGUgKHR5cGUtMTIsIHNlZQ0KKwkgIENPTkZJR19YODZf UE1FTV9MRUdBQ1kpLCBvciBpdCBpcyBtYW51YWxseSBzcGVjaWZpZWQgYnkgdGhlDQorCSAgJ21l bW1hcD1ubltLTUddIXNzW0tNR10nIGtlcm5lbCBjb21tYW5kIGxpbmUgKHNlZQ0KKwkgIERvY3Vt ZW50YXRpb24va2VybmVsLXBhcmFtZXRlcnMudHh0KS4gIFRoaXMgZHJpdmVyIGNvbnZlcnRzDQor CSAgdGhlc2UgcGVyc2lzdGVudCBtZW1vcnkgcmFuZ2VzIGludG8gYmxvY2sgZGV2aWNlcyB0aGF0 IGFyZQ0KKwkgIGNhcGFibGUgb2YgREFYIChkaXJlY3QtYWNjZXNzKSBmaWxlIHN5c3RlbSBtYXBw aW5ncy4gIFNlZQ0KKwkgIERvY3VtZW50YXRpb24vYmxvY2tkZXYvbmQudHh0IGZvciBtb3JlIGRl dGFpbHMuDQorDQorCSAgU2F5IFkgaWYgeW91IHdhbnQgdG8gdXNlIGEgTlZESU1NIGRlc2NyaWJl ZCBieSBORklUDQorDQorZW5kaWYNCmRpZmYgLS1naXQgYS9kcml2ZXJzL252ZGltbS9NYWtlZmls ZSBiL2RyaXZlcnMvbnZkaW1tL01ha2VmaWxlDQppbmRleCBhZjVlMjc2MGRkYmQuLjRkMmEyN2Y1 MmZhYSAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvbnZkaW1tL01ha2VmaWxlDQorKysgYi9kcml2ZXJz L252ZGltbS9NYWtlZmlsZQ0KQEAgLTEsNCArMSw3IEBADQogb2JqLSQoQ09ORklHX0xJQk5WRElN TSkgKz0gbGlibnZkaW1tLm8NCitvYmotJChDT05GSUdfQkxLX0RFVl9QTUVNKSArPSBuZF9wbWVt Lm8NCisNCituZF9wbWVtLXkgOj0gcG1lbS5vDQogDQogbGlibnZkaW1tLXkgOj0gY29yZS5vDQog bGlibnZkaW1tLXkgKz0gYnVzLm8NCmRpZmYgLS1naXQgYS9kcml2ZXJzL252ZGltbS9wbWVtLmMg Yi9kcml2ZXJzL252ZGltbS9wbWVtLmMNCm5ldyBmaWxlIG1vZGUgMTAwNjQ0DQppbmRleCAwMDAw MDAwMDAwMDAuLmNmNWQ1M2VkYTllNQ0KLS0tIC9kZXYvbnVsbA0KKysrIGIvZHJpdmVycy9udmRp bW0vcG1lbS5jDQpAQCAtMCwwICsxLDI2MCBAQA0KKy8qDQorICogUGVyc2lzdGVudCBNZW1vcnkg RHJpdmVyDQorICoNCisgKiBDb3B5cmlnaHQgKGMpIDIwMTQtMjAxNSwgSW50ZWwgQ29ycG9yYXRp b24uDQorICogQ29weXJpZ2h0IChjKSAyMDE1LCBDaHJpc3RvcGggSGVsbHdpZyA8aGNoQGxzdC5k ZT4uDQorICogQ29weXJpZ2h0IChjKSAyMDE1LCBCb2F6IEhhcnJvc2ggPGJvYXpAcGxleGlzdG9y LmNvbT4uDQorICoNCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdA0KKyAqIHVuZGVyIHRoZSB0ZXJtcyBhbmQg Y29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UsDQorICogdmVyc2lv biAyLCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4NCisgKg0K KyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxsIGJlIHVz ZWZ1bCwgYnV0IFdJVEhPVVQNCisgKiBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3INCisgKiBGSVRORVNTIEZPUiBBIFBB UlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9y DQorICogbW9yZSBkZXRhaWxzLg0KKyAqLw0KKw0KKyNpbmNsdWRlIDxhc20vY2FjaGVmbHVzaC5o Pg0KKyNpbmNsdWRlIDxsaW51eC9ibGtkZXYuaD4NCisjaW5jbHVkZSA8bGludXgvaGRyZWcuaD4N CisjaW5jbHVkZSA8bGludXgvaW5pdC5oPg0KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZp Y2UuaD4NCisjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+DQorI2luY2x1ZGUgPGxpbnV4L21vZHVs ZXBhcmFtLmg+DQorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4NCisjaW5jbHVkZSA8bGludXgvbmQu aD4NCisjaW5jbHVkZSAibmQuaCINCisNCisjZGVmaW5lIFBNRU1fTUlOT1JTCQkxNg0KKw0KK3N0 cnVjdCBwbWVtX2RldmljZSB7DQorCXN0cnVjdCByZXF1ZXN0X3F1ZXVlCSpwbWVtX3F1ZXVlOw0K KwlzdHJ1Y3QgZ2VuZGlzawkJKnBtZW1fZGlzazsNCisNCisJLyogT25lIGNvbnRpZ3VvdXMgbWVt b3J5IHJlZ2lvbiBwZXIgZGV2aWNlICovDQorCXBoeXNfYWRkcl90CQlwaHlzX2FkZHI7DQorCXZv aWQJCQkqdmlydF9hZGRyOw0KKwlzaXplX3QJCQlzaXplOw0KK307DQorDQorc3RhdGljIGludCBw bWVtX21ham9yOw0KKw0KK3N0YXRpYyB2b2lkIHBtZW1fZG9fYnZlYyhzdHJ1Y3QgcG1lbV9kZXZp Y2UgKnBtZW0sIHN0cnVjdCBwYWdlICpwYWdlLA0KKwkJCXVuc2lnbmVkIGludCBsZW4sIHVuc2ln bmVkIGludCBvZmYsIGludCBydywNCisJCQlzZWN0b3JfdCBzZWN0b3IpDQorew0KKwl2b2lkICpt ZW0gPSBrbWFwX2F0b21pYyhwYWdlKTsNCisJc2l6ZV90IHBtZW1fb2ZmID0gc2VjdG9yIDw8IDk7 DQorDQorCWlmIChydyA9PSBSRUFEKSB7DQorCQltZW1jcHkobWVtICsgb2ZmLCBwbWVtLT52aXJ0 X2FkZHIgKyBwbWVtX29mZiwgbGVuKTsNCisJCWZsdXNoX2RjYWNoZV9wYWdlKHBhZ2UpOw0KKwl9 IGVsc2Ugew0KKwkJZmx1c2hfZGNhY2hlX3BhZ2UocGFnZSk7DQorCQltZW1jcHkocG1lbS0+dmly dF9hZGRyICsgcG1lbV9vZmYsIG1lbSArIG9mZiwgbGVuKTsNCisJfQ0KKw0KKwlrdW5tYXBfYXRv bWljKG1lbSk7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIHBtZW1fbWFrZV9yZXF1ZXN0KHN0cnVjdCBy ZXF1ZXN0X3F1ZXVlICpxLCBzdHJ1Y3QgYmlvICpiaW8pDQorew0KKwlzdHJ1Y3QgYmxvY2tfZGV2 aWNlICpiZGV2ID0gYmlvLT5iaV9iZGV2Ow0KKwlzdHJ1Y3QgcG1lbV9kZXZpY2UgKnBtZW0gPSBi ZGV2LT5iZF9kaXNrLT5wcml2YXRlX2RhdGE7DQorCWludCBydzsNCisJc3RydWN0IGJpb192ZWMg YnZlYzsNCisJc2VjdG9yX3Qgc2VjdG9yOw0KKwlzdHJ1Y3QgYnZlY19pdGVyIGl0ZXI7DQorCWlu dCBlcnIgPSAwOw0KKw0KKwlpZiAoYmlvX2VuZF9zZWN0b3IoYmlvKSA+IGdldF9jYXBhY2l0eShi ZGV2LT5iZF9kaXNrKSkgew0KKwkJZXJyID0gLUVJTzsNCisJCWdvdG8gb3V0Ow0KKwl9DQorDQor CUJVR19PTihiaW8tPmJpX3J3ICYgUkVRX0RJU0NBUkQpOw0KKw0KKwlydyA9IGJpb19kYXRhX2Rp cihiaW8pOw0KKwlzZWN0b3IgPSBiaW8tPmJpX2l0ZXIuYmlfc2VjdG9yOw0KKwliaW9fZm9yX2Vh Y2hfc2VnbWVudChidmVjLCBiaW8sIGl0ZXIpIHsNCisJCXBtZW1fZG9fYnZlYyhwbWVtLCBidmVj LmJ2X3BhZ2UsIGJ2ZWMuYnZfbGVuLCBidmVjLmJ2X29mZnNldCwNCisJCQkgICAgIHJ3LCBzZWN0 b3IpOw0KKwkJc2VjdG9yICs9IGJ2ZWMuYnZfbGVuID4+IDk7DQorCX0NCisNCitvdXQ6DQorCWJp b19lbmRpbyhiaW8sIGVycik7DQorfQ0KKw0KK3N0YXRpYyBpbnQgcG1lbV9yd19wYWdlKHN0cnVj dCBibG9ja19kZXZpY2UgKmJkZXYsIHNlY3Rvcl90IHNlY3RvciwNCisJCSAgICAgICBzdHJ1Y3Qg cGFnZSAqcGFnZSwgaW50IHJ3KQ0KK3sNCisJc3RydWN0IHBtZW1fZGV2aWNlICpwbWVtID0gYmRl di0+YmRfZGlzay0+cHJpdmF0ZV9kYXRhOw0KKw0KKwlwbWVtX2RvX2J2ZWMocG1lbSwgcGFnZSwg UEFHRV9DQUNIRV9TSVpFLCAwLCBydywgc2VjdG9yKTsNCisJcGFnZV9lbmRpbyhwYWdlLCBydyAm IFdSSVRFLCAwKTsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyBsb25nIHBtZW1fZGly ZWN0X2FjY2VzcyhzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBzZWN0b3JfdCBzZWN0b3IsDQor CQkJICAgICAgdm9pZCAqKmthZGRyLCB1bnNpZ25lZCBsb25nICpwZm4sIGxvbmcgc2l6ZSkNCit7 DQorCXN0cnVjdCBwbWVtX2RldmljZSAqcG1lbSA9IGJkZXYtPmJkX2Rpc2stPnByaXZhdGVfZGF0 YTsNCisJc2l6ZV90IG9mZnNldCA9IHNlY3RvciA8PCA5Ow0KKw0KKwlpZiAoIXBtZW0pDQorCQly ZXR1cm4gLUVOT0RFVjsNCisNCisJKmthZGRyID0gcG1lbS0+dmlydF9hZGRyICsgb2Zmc2V0Ow0K KwkqcGZuID0gKHBtZW0tPnBoeXNfYWRkciArIG9mZnNldCkgPj4gUEFHRV9TSElGVDsNCisNCisJ cmV0dXJuIHBtZW0tPnNpemUgLSBvZmZzZXQ7DQorfQ0KKw0KK3N0YXRpYyBjb25zdCBzdHJ1Y3Qg YmxvY2tfZGV2aWNlX29wZXJhdGlvbnMgcG1lbV9mb3BzID0gew0KKwkub3duZXIgPQkJVEhJU19N T0RVTEUsDQorCS5yd19wYWdlID0JCXBtZW1fcndfcGFnZSwNCisJLmRpcmVjdF9hY2Nlc3MgPQlw bWVtX2RpcmVjdF9hY2Nlc3MsDQorfTsNCisNCitzdGF0aWMgc3RydWN0IHBtZW1fZGV2aWNlICpw bWVtX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IHJlc291cmNlICpyZXMsIGludCBp ZCkNCit7DQorCXN0cnVjdCBwbWVtX2RldmljZSAqcG1lbTsNCisJc3RydWN0IGdlbmRpc2sgKmRp c2s7DQorCWludCBlcnI7DQorDQorCWVyciA9IC1FTk9NRU07DQorCXBtZW0gPSBremFsbG9jKHNp emVvZigqcG1lbSksIEdGUF9LRVJORUwpOw0KKwlpZiAoIXBtZW0pDQorCQlnb3RvIG91dDsNCisN CisJcG1lbS0+cGh5c19hZGRyID0gcmVzLT5zdGFydDsNCisJcG1lbS0+c2l6ZSA9IHJlc291cmNl X3NpemUocmVzKTsNCisNCisJZXJyID0gLUVJTlZBTDsNCisJaWYgKCFyZXF1ZXN0X21lbV9yZWdp b24ocG1lbS0+cGh5c19hZGRyLCBwbWVtLT5zaXplLCAicG1lbSIpKSB7DQorCQlkZXZfd2Fybihk ZXYsICJjb3VsZCBub3QgcmVzZXJ2ZSByZWdpb24gWzB4JXBhOjB4JXp4XVxuIiwgJnBtZW0tPnBo eXNfYWRkciwgcG1lbS0+c2l6ZSk7DQorCQlnb3RvIG91dF9mcmVlX2RldjsNCisJfQ0KKw0KKwkv Kg0KKwkgKiBNYXAgdGhlIG1lbW9yeSBhcyBub24tY2FjaGFibGUsIGFzIHdlIGNhbid0IHdyaXRl IGJhY2sgdGhlIGNvbnRlbnRzDQorCSAqIG9mIHRoZSBDUFUgY2FjaGVzIGluIGNhc2Ugb2YgYSBj cmFzaC4NCisJICovDQorCWVyciA9IC1FTk9NRU07DQorCXBtZW0tPnZpcnRfYWRkciA9IGlvcmVt YXBfbm9jYWNoZShwbWVtLT5waHlzX2FkZHIsIHBtZW0tPnNpemUpOw0KKwlpZiAoIXBtZW0tPnZp cnRfYWRkcikNCisJCWdvdG8gb3V0X3JlbGVhc2VfcmVnaW9uOw0KKw0KKwlwbWVtLT5wbWVtX3F1 ZXVlID0gYmxrX2FsbG9jX3F1ZXVlKEdGUF9LRVJORUwpOw0KKwlpZiAoIXBtZW0tPnBtZW1fcXVl dWUpDQorCQlnb3RvIG91dF91bm1hcDsNCisNCisJYmxrX3F1ZXVlX21ha2VfcmVxdWVzdChwbWVt LT5wbWVtX3F1ZXVlLCBwbWVtX21ha2VfcmVxdWVzdCk7DQorCWJsa19xdWV1ZV9tYXhfaHdfc2Vj dG9ycyhwbWVtLT5wbWVtX3F1ZXVlLCAxMDI0KTsNCisJYmxrX3F1ZXVlX2JvdW5jZV9saW1pdChw bWVtLT5wbWVtX3F1ZXVlLCBCTEtfQk9VTkNFX0FOWSk7DQorDQorCWRpc2sgPSBhbGxvY19kaXNr KFBNRU1fTUlOT1JTKTsNCisJaWYgKCFkaXNrKQ0KKwkJZ290byBvdXRfZnJlZV9xdWV1ZTsNCisN CisJZGlzay0+bWFqb3IJCT0gcG1lbV9tYWpvcjsNCisJZGlzay0+Zmlyc3RfbWlub3IJPSBQTUVN X01JTk9SUyAqIGlkOw0KKwlkaXNrLT5mb3BzCQk9ICZwbWVtX2ZvcHM7DQorCWRpc2stPnByaXZh dGVfZGF0YQk9IHBtZW07DQorCWRpc2stPnF1ZXVlCQk9IHBtZW0tPnBtZW1fcXVldWU7DQorCWRp c2stPmZsYWdzCQk9IEdFTkhEX0ZMX0VYVF9ERVZUOw0KKwlzcHJpbnRmKGRpc2stPmRpc2tfbmFt ZSwgInBtZW0lZCIsIGlkKTsNCisJZGlzay0+ZHJpdmVyZnNfZGV2ID0gZGV2Ow0KKwlzZXRfY2Fw YWNpdHkoZGlzaywgcG1lbS0+c2l6ZSA+PiA5KTsNCisJcG1lbS0+cG1lbV9kaXNrID0gZGlzazsN CisNCisJYWRkX2Rpc2soZGlzayk7DQorDQorCXJldHVybiBwbWVtOw0KKw0KK291dF9mcmVlX3F1 ZXVlOg0KKwlibGtfY2xlYW51cF9xdWV1ZShwbWVtLT5wbWVtX3F1ZXVlKTsNCitvdXRfdW5tYXA6 DQorCWlvdW5tYXAocG1lbS0+dmlydF9hZGRyKTsNCitvdXRfcmVsZWFzZV9yZWdpb246DQorCXJl bGVhc2VfbWVtX3JlZ2lvbihwbWVtLT5waHlzX2FkZHIsIHBtZW0tPnNpemUpOw0KK291dF9mcmVl X2RldjoNCisJa2ZyZWUocG1lbSk7DQorb3V0Og0KKwlyZXR1cm4gRVJSX1BUUihlcnIpOw0KK30N CisNCitzdGF0aWMgdm9pZCBwbWVtX2ZyZWUoc3RydWN0IHBtZW1fZGV2aWNlICpwbWVtKQ0KK3sN CisJZGVsX2dlbmRpc2socG1lbS0+cG1lbV9kaXNrKTsNCisJcHV0X2Rpc2socG1lbS0+cG1lbV9k aXNrKTsNCisJYmxrX2NsZWFudXBfcXVldWUocG1lbS0+cG1lbV9xdWV1ZSk7DQorCWlvdW5tYXAo cG1lbS0+dmlydF9hZGRyKTsNCisJcmVsZWFzZV9tZW1fcmVnaW9uKHBtZW0tPnBoeXNfYWRkciwg cG1lbS0+c2l6ZSk7DQorCWtmcmVlKHBtZW0pOw0KK30NCisNCitzdGF0aWMgaW50IG5kX3BtZW1f cHJvYmUoc3RydWN0IGRldmljZSAqZGV2KQ0KK3sNCisJc3RydWN0IG5kX3JlZ2lvbiAqbmRfcmVn aW9uID0gdG9fbmRfcmVnaW9uKGRldi0+cGFyZW50KTsNCisJc3RydWN0IG5kX25hbWVzcGFjZV9p byAqbnNpbyA9IHRvX25kX25hbWVzcGFjZV9pbyhkZXYpOw0KKwlzdHJ1Y3QgcG1lbV9kZXZpY2Ug KnBtZW07DQorDQorCXBtZW0gPSBwbWVtX2FsbG9jKGRldiwgJm5zaW8tPnJlcywgbmRfcmVnaW9u LT5pZCk7DQorCWlmIChJU19FUlIocG1lbSkpDQorCQlyZXR1cm4gUFRSX0VSUihwbWVtKTsNCisN CisJZGV2X3NldF9kcnZkYXRhKGRldiwgcG1lbSk7DQorDQorCXJldHVybiAwOw0KK30NCisNCitz dGF0aWMgaW50IG5kX3BtZW1fcmVtb3ZlKHN0cnVjdCBkZXZpY2UgKmRldikNCit7DQorCXN0cnVj dCBwbWVtX2RldmljZSAqcG1lbSA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOw0KKw0KKwlwbWVtX2Zy ZWUocG1lbSk7DQorCXJldHVybiAwOw0KK30NCisNCitNT0RVTEVfQUxJQVMoInBtZW0iKTsNCitN T0RVTEVfQUxJQVNfTkRfREVWSUNFKE5EX0RFVklDRV9OQU1FU1BBQ0VfSU8pOw0KK3N0YXRpYyBz dHJ1Y3QgbmRfZGV2aWNlX2RyaXZlciBuZF9wbWVtX2RyaXZlciA9IHsNCisJLnByb2JlID0gbmRf cG1lbV9wcm9iZSwNCisJLnJlbW92ZSA9IG5kX3BtZW1fcmVtb3ZlLA0KKwkuZHJ2ID0gew0KKwkJ Lm5hbWUgPSAibmRfcG1lbSIsDQorCX0sDQorCS50eXBlID0gTkRfRFJJVkVSX05BTUVTUEFDRV9J TywNCit9Ow0KKw0KK3N0YXRpYyBpbnQgX19pbml0IHBtZW1faW5pdCh2b2lkKQ0KK3sNCisJaW50 IGVycm9yOw0KKw0KKwlwbWVtX21ham9yID0gcmVnaXN0ZXJfYmxrZGV2KDAsICJwbWVtIik7DQor CWlmIChwbWVtX21ham9yIDwgMCkNCisJCXJldHVybiBwbWVtX21ham9yOw0KKw0KKwllcnJvciA9 IG5kX2RyaXZlcl9yZWdpc3RlcigmbmRfcG1lbV9kcml2ZXIpOw0KKwlpZiAoZXJyb3IpIHsNCisJ CXVucmVnaXN0ZXJfYmxrZGV2KHBtZW1fbWFqb3IsICJwbWVtIik7DQorCQlyZXR1cm4gZXJyb3I7 DQorCX0NCisNCisJcmV0dXJuIDA7DQorfQ0KK21vZHVsZV9pbml0KHBtZW1faW5pdCk7DQorDQor c3RhdGljIHZvaWQgcG1lbV9leGl0KHZvaWQpDQorew0KKwlkcml2ZXJfdW5yZWdpc3RlcigmbmRf cG1lbV9kcml2ZXIuZHJ2KTsNCisJdW5yZWdpc3Rlcl9ibGtkZXYocG1lbV9tYWpvciwgInBtZW0i KTsNCit9DQorbW9kdWxlX2V4aXQocG1lbV9leGl0KTsNCisNCitNT0RVTEVfQVVUSE9SKCJSb3Nz IFp3aXNsZXIgPHJvc3Muendpc2xlckBsaW51eC5pbnRlbC5jb20+Iik7DQorTU9EVUxFX0xJQ0VO U0UoIkdQTCB2MiIpOw0KDQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758680AbbFCTcD (ORCPT ); Wed, 3 Jun 2015 15:32:03 -0400 Received: from mga11.intel.com ([192.55.52.93]:20724 "EHLO mga11.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754620AbbFCTbv (ORCPT ); Wed, 3 Jun 2015 15:31:51 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.13,548,1427785200"; d="scan'208";a="720249115" From: "Williams, Dan J" To: "hch@infradead.org" CC: "linux-kernel@vger.kernel.org" , "mingo@kernel.org" , "linux-nvdimm@ml01.01.org" , "neilb@suse.de" , "linux-api@vger.kernel.org" , "hch@lst.de" , "axboe@kernel.dk" , "akpm@linux-foundation.org" , "sfr@canb.auug.org.au" , "gregkh@linuxfoundation.org" , "rafael@kernel.org" , "linux-acpi@vger.kernel.org" Subject: Re: [PATCH v5 09/21] libnvdimm, nd_pmem: add libnvdimm support to the pmem driver Thread-Topic: [PATCH v5 09/21] libnvdimm, nd_pmem: add libnvdimm support to the pmem driver Thread-Index: AQHQnMmMvoLSoI+Mv0ivIZtBByu80Z2a3f0AgADFlQA= Date: Wed, 3 Jun 2015 19:31:38 +0000 Message-ID: <1433359894.21035.33.camel@intel.com> References: <20150602001134.4506.45867.stgit@dwillia2-desk3.amr.corp.intel.com> <20150602001458.4506.76492.stgit@dwillia2-desk3.amr.corp.intel.com> <20150603074424.GA24949@infradead.org> In-Reply-To: <20150603074424.GA24949@infradead.org> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.22.254.138] Content-Type: text/plain; charset="utf-8" Content-ID: <95CF8A738187FF49A5764E226AE11926@intel.com> MIME-Version: 1.0 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: 8bit X-MIME-Autoconverted: from base64 to 8bit by nfs id t53JW9fC032491 On Wed, 2015-06-03 at 00:44 -0700, Christoph Hellwig wrote: > This patch doesn't apply, as it seems to use some git magic. > > But looking at it it's also wrong in that it mixes a file move > and actual changes to the file. I like move-modify patches because they make the reason for the move clearer and revertible. Consider a general case where we later decide the reason for a move was invalid. Reverting the reason also reverts the file move, that doesn't automatically happen when it is split to another commit. In case you don't want to mess around with 'git apply' here's the unmagical version of the patch (rebased according to the comments you made to patch 2)... 8<--- libnvdimm, nd_pmem: add libnvdimm support to the pmem driver From: Dan Williams nd_pmem attaches to persistent memory regions and namespaces emitted by the libnvdimm subsystem, and, same as the original pmem driver, presents the system-physical-address range as a block device. The existing e820-type-12 to pmem setup is converted to a full libnvdimm bus that emits an nd_namespace_io device. Cc: Andy Lutomirski Cc: Boaz Harrosh Cc: H. Peter Anvin Cc: Jens Axboe Cc: Ingo Molnar Cc: Christoph Hellwig Signed-off-by: Dan Williams --- arch/x86/Kconfig | 3 + arch/x86/kernel/pmem.c | 92 +++++++++++------ drivers/block/Kconfig | 11 -- drivers/block/Makefile | 1 drivers/block/pmem.c | 262 ----------------------------------------------- drivers/nvdimm/Kconfig | 22 ++++ drivers/nvdimm/Makefile | 3 + drivers/nvdimm/pmem.c | 260 +++++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 347 insertions(+), 307 deletions(-) delete mode 100644 drivers/block/pmem.c create mode 100644 drivers/nvdimm/pmem.c diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 226d5696e1d1..1a2cbf641667 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -1424,6 +1424,9 @@ source "mm/Kconfig" config X86_PMEM_LEGACY bool "Support non-standard NVDIMMs and ADR protected memory" + depends on PHYS_ADDR_T_64BIT + depends on BLK_DEV + select LIBNVDIMM help Treat memory marked using the non-standard e820 type of 12 as used by the Intel Sandy Bridge-EP reference BIOS as protected memory. diff --git a/arch/x86/kernel/pmem.c b/arch/x86/kernel/pmem.c index 3420c874ddc5..40d734c8e3b1 100644 --- a/arch/x86/kernel/pmem.c +++ b/arch/x86/kernel/pmem.c @@ -1,53 +1,81 @@ /* * Copyright (c) 2015, Christoph Hellwig. + * Copyright (c) 2015, Intel Corporation. */ -#include #include -#include +#include +#include #include -#include -#include -static __init void register_pmem_device(struct resource *res) +static void e820_pmem_release(struct device *dev) { - struct platform_device *pdev; - int error; + struct nvdimm_bus *nvdimm_bus = dev->platform_data; - pdev = platform_device_alloc("pmem", PLATFORM_DEVID_AUTO); - if (!pdev) - return; + if (nvdimm_bus) + nvdimm_bus_unregister(nvdimm_bus); +} - error = platform_device_add_resources(pdev, res, 1); - if (error) - goto out_put_pdev; +static struct platform_device e820_pmem = { + .name = "e820_pmem", + .id = -1, + .dev = { + .release = e820_pmem_release, + }, +}; - error = platform_device_add(pdev); - if (error) - goto out_put_pdev; - return; +static const struct attribute_group *e820_pmem_attribute_groups[] = { + &nvdimm_bus_attribute_group, + NULL, +}; -out_put_pdev: - dev_warn(&pdev->dev, "failed to add 'pmem' (persistent memory) device!\n"); - platform_device_put(pdev); -} +static const struct attribute_group *e820_pmem_region_attribute_groups[] = { + &nd_region_attribute_group, + &nd_device_attribute_group, + NULL, +}; -static __init int register_pmem_devices(void) +static __init int register_e820_pmem(void) { - int i; + static struct nvdimm_bus_descriptor nd_desc; + struct device *dev = &e820_pmem.dev; + struct nvdimm_bus *nvdimm_bus; + int rc, i; + + rc = platform_device_register(&e820_pmem); + if (rc) + return rc; + + nd_desc.attr_groups = e820_pmem_attribute_groups; + nd_desc.provider_name = "e820"; + nvdimm_bus = nvdimm_bus_register(dev, &nd_desc); + if (!nvdimm_bus) + goto err; + dev->platform_data = nvdimm_bus; for (i = 0; i < e820.nr_map; i++) { struct e820entry *ei = &e820.map[i]; + struct resource res = { + .flags = IORESOURCE_MEM, + .start = ei->addr, + .end = ei->addr + ei->size - 1, + }; + struct nd_region_desc ndr_desc; + + if (ei->type != E820_PRAM) + continue; - if (ei->type == E820_PRAM) { - struct resource res = { - .flags = IORESOURCE_MEM, - .start = ei->addr, - .end = ei->addr + ei->size - 1, - }; - register_pmem_device(&res); - } + memset(&ndr_desc, 0, sizeof(ndr_desc)); + ndr_desc.res = &res; + ndr_desc.attr_groups = e820_pmem_region_attribute_groups; + if (!nvdimm_pmem_region_create(nvdimm_bus, &ndr_desc)) + goto err; } return 0; + + err: + dev_err(dev, "failed to register legacy persistent memory ranges\n"); + platform_device_unregister(&e820_pmem); + return -ENXIO; } -device_initcall(register_pmem_devices); +late_initcall(register_e820_pmem); diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig index eb1fed5bd516..1b8094d4d7af 100644 --- a/drivers/block/Kconfig +++ b/drivers/block/Kconfig @@ -404,17 +404,6 @@ config BLK_DEV_RAM_DAX and will prevent RAM block device backing store memory from being allocated from highmem (only a problem for highmem systems). -config BLK_DEV_PMEM - tristate "Persistent memory block device support" - help - Saying Y here will allow you to use a contiguous range of reserved - memory as one or more persistent block devices. - - To compile this driver as a module, choose M here: the module will be - called 'pmem'. - - If unsure, say N. - config CDROM_PKTCDVD tristate "Packet writing on CD/DVD media" depends on !UML diff --git a/drivers/block/Makefile b/drivers/block/Makefile index 9cc6c18a1c7e..02b688d1438d 100644 --- a/drivers/block/Makefile +++ b/drivers/block/Makefile @@ -14,7 +14,6 @@ obj-$(CONFIG_PS3_VRAM) += ps3vram.o obj-$(CONFIG_ATARI_FLOPPY) += ataflop.o obj-$(CONFIG_AMIGA_Z2RAM) += z2ram.o obj-$(CONFIG_BLK_DEV_RAM) += brd.o -obj-$(CONFIG_BLK_DEV_PMEM) += pmem.o obj-$(CONFIG_BLK_DEV_LOOP) += loop.o obj-$(CONFIG_BLK_CPQ_DA) += cpqarray.o obj-$(CONFIG_BLK_CPQ_CISS_DA) += cciss.o diff --git a/drivers/block/pmem.c b/drivers/block/pmem.c deleted file mode 100644 index eabf4a8d0085..000000000000 --- a/drivers/block/pmem.c +++ /dev/null @@ -1,262 +0,0 @@ -/* - * Persistent Memory Driver - * - * Copyright (c) 2014, Intel Corporation. - * Copyright (c) 2015, Christoph Hellwig . - * Copyright (c) 2015, Boaz Harrosh . - * - * This program is free software; you can redistribute it and/or modify it - * under the terms and conditions of the GNU General Public License, - * version 2, as published by the Free Software Foundation. - * - * This program is distributed in the hope it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - */ - -#include -#include -#include -#include -#include -#include -#include -#include - -#define PMEM_MINORS 16 - -struct pmem_device { - struct request_queue *pmem_queue; - struct gendisk *pmem_disk; - - /* One contiguous memory region per device */ - phys_addr_t phys_addr; - void *virt_addr; - size_t size; -}; - -static int pmem_major; -static atomic_t pmem_index; - -static void pmem_do_bvec(struct pmem_device *pmem, struct page *page, - unsigned int len, unsigned int off, int rw, - sector_t sector) -{ - void *mem = kmap_atomic(page); - size_t pmem_off = sector << 9; - - if (rw == READ) { - memcpy(mem + off, pmem->virt_addr + pmem_off, len); - flush_dcache_page(page); - } else { - flush_dcache_page(page); - memcpy(pmem->virt_addr + pmem_off, mem + off, len); - } - - kunmap_atomic(mem); -} - -static void pmem_make_request(struct request_queue *q, struct bio *bio) -{ - struct block_device *bdev = bio->bi_bdev; - struct pmem_device *pmem = bdev->bd_disk->private_data; - int rw; - struct bio_vec bvec; - sector_t sector; - struct bvec_iter iter; - int err = 0; - - if (bio_end_sector(bio) > get_capacity(bdev->bd_disk)) { - err = -EIO; - goto out; - } - - BUG_ON(bio->bi_rw & REQ_DISCARD); - - rw = bio_data_dir(bio); - sector = bio->bi_iter.bi_sector; - bio_for_each_segment(bvec, bio, iter) { - pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len, bvec.bv_offset, - rw, sector); - sector += bvec.bv_len >> 9; - } - -out: - bio_endio(bio, err); -} - -static int pmem_rw_page(struct block_device *bdev, sector_t sector, - struct page *page, int rw) -{ - struct pmem_device *pmem = bdev->bd_disk->private_data; - - pmem_do_bvec(pmem, page, PAGE_CACHE_SIZE, 0, rw, sector); - page_endio(page, rw & WRITE, 0); - - return 0; -} - -static long pmem_direct_access(struct block_device *bdev, sector_t sector, - void **kaddr, unsigned long *pfn, long size) -{ - struct pmem_device *pmem = bdev->bd_disk->private_data; - size_t offset = sector << 9; - - if (!pmem) - return -ENODEV; - - *kaddr = pmem->virt_addr + offset; - *pfn = (pmem->phys_addr + offset) >> PAGE_SHIFT; - - return pmem->size - offset; -} - -static const struct block_device_operations pmem_fops = { - .owner = THIS_MODULE, - .rw_page = pmem_rw_page, - .direct_access = pmem_direct_access, -}; - -static struct pmem_device *pmem_alloc(struct device *dev, struct resource *res) -{ - struct pmem_device *pmem; - struct gendisk *disk; - int idx, err; - - err = -ENOMEM; - pmem = kzalloc(sizeof(*pmem), GFP_KERNEL); - if (!pmem) - goto out; - - pmem->phys_addr = res->start; - pmem->size = resource_size(res); - - err = -EINVAL; - if (!request_mem_region(pmem->phys_addr, pmem->size, "pmem")) { - dev_warn(dev, "could not reserve region [0x%pa:0x%zx]\n", &pmem->phys_addr, pmem->size); - goto out_free_dev; - } - - /* - * Map the memory as non-cachable, as we can't write back the contents - * of the CPU caches in case of a crash. - */ - err = -ENOMEM; - pmem->virt_addr = ioremap_nocache(pmem->phys_addr, pmem->size); - if (!pmem->virt_addr) - goto out_release_region; - - pmem->pmem_queue = blk_alloc_queue(GFP_KERNEL); - if (!pmem->pmem_queue) - goto out_unmap; - - blk_queue_make_request(pmem->pmem_queue, pmem_make_request); - blk_queue_max_hw_sectors(pmem->pmem_queue, 1024); - blk_queue_bounce_limit(pmem->pmem_queue, BLK_BOUNCE_ANY); - - disk = alloc_disk(PMEM_MINORS); - if (!disk) - goto out_free_queue; - - idx = atomic_inc_return(&pmem_index) - 1; - - disk->major = pmem_major; - disk->first_minor = PMEM_MINORS * idx; - disk->fops = &pmem_fops; - disk->private_data = pmem; - disk->queue = pmem->pmem_queue; - disk->flags = GENHD_FL_EXT_DEVT; - sprintf(disk->disk_name, "pmem%d", idx); - disk->driverfs_dev = dev; - set_capacity(disk, pmem->size >> 9); - pmem->pmem_disk = disk; - - add_disk(disk); - - return pmem; - -out_free_queue: - blk_cleanup_queue(pmem->pmem_queue); -out_unmap: - iounmap(pmem->virt_addr); -out_release_region: - release_mem_region(pmem->phys_addr, pmem->size); -out_free_dev: - kfree(pmem); -out: - return ERR_PTR(err); -} - -static void pmem_free(struct pmem_device *pmem) -{ - del_gendisk(pmem->pmem_disk); - put_disk(pmem->pmem_disk); - blk_cleanup_queue(pmem->pmem_queue); - iounmap(pmem->virt_addr); - release_mem_region(pmem->phys_addr, pmem->size); - kfree(pmem); -} - -static int pmem_probe(struct platform_device *pdev) -{ - struct pmem_device *pmem; - struct resource *res; - - if (WARN_ON(pdev->num_resources > 1)) - return -ENXIO; - - res = platform_get_resource(pdev, IORESOURCE_MEM, 0); - if (!res) - return -ENXIO; - - pmem = pmem_alloc(&pdev->dev, res); - if (IS_ERR(pmem)) - return PTR_ERR(pmem); - - platform_set_drvdata(pdev, pmem); - - return 0; -} - -static int pmem_remove(struct platform_device *pdev) -{ - struct pmem_device *pmem = platform_get_drvdata(pdev); - - pmem_free(pmem); - return 0; -} - -static struct platform_driver pmem_driver = { - .probe = pmem_probe, - .remove = pmem_remove, - .driver = { - .owner = THIS_MODULE, - .name = "pmem", - }, -}; - -static int __init pmem_init(void) -{ - int error; - - pmem_major = register_blkdev(0, "pmem"); - if (pmem_major < 0) - return pmem_major; - - error = platform_driver_register(&pmem_driver); - if (error) - unregister_blkdev(pmem_major, "pmem"); - return error; -} -module_init(pmem_init); - -static void pmem_exit(void) -{ - platform_driver_unregister(&pmem_driver); - unregister_blkdev(pmem_major, "pmem"); -} -module_exit(pmem_exit); - -MODULE_AUTHOR("Ross Zwisler "); -MODULE_LICENSE("GPL v2"); diff --git a/drivers/nvdimm/Kconfig b/drivers/nvdimm/Kconfig index 4f2291938ea0..818f219b037c 100644 --- a/drivers/nvdimm/Kconfig +++ b/drivers/nvdimm/Kconfig @@ -1,4 +1,4 @@ -config LIBNVDIMM +menuconfig LIBNVDIMM tristate "NVDIMM (Non-Volatile Memory Device) Support" help Generic support for non-volatile memory devices including @@ -11,3 +11,23 @@ config LIBNVDIMM CONFIG_DAX). A BLK namespace refers to an NVDIMM control region which exposes an mmio register set for windowed access mode to non-volatile memory. + +if LIBNVDIMM + +config BLK_DEV_PMEM + tristate "PMEM: Persistent memory block device support" + default LIBNVDIMM + help + Memory ranges for PMEM are described by either an NFIT + (NVDIMM Firmware Interface Table, see CONFIG_NFIT_ACPI), a + non-standard OEM-specific E820 memory type (type-12, see + CONFIG_X86_PMEM_LEGACY), or it is manually specified by the + 'memmap=nn[KMG]!ss[KMG]' kernel command line (see + Documentation/kernel-parameters.txt). This driver converts + these persistent memory ranges into block devices that are + capable of DAX (direct-access) file system mappings. See + Documentation/blockdev/nd.txt for more details. + + Say Y if you want to use a NVDIMM described by NFIT + +endif diff --git a/drivers/nvdimm/Makefile b/drivers/nvdimm/Makefile index af5e2760ddbd..4d2a27f52faa 100644 --- a/drivers/nvdimm/Makefile +++ b/drivers/nvdimm/Makefile @@ -1,4 +1,7 @@ obj-$(CONFIG_LIBNVDIMM) += libnvdimm.o +obj-$(CONFIG_BLK_DEV_PMEM) += nd_pmem.o + +nd_pmem-y := pmem.o libnvdimm-y := core.o libnvdimm-y += bus.o diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c new file mode 100644 index 000000000000..cf5d53eda9e5 --- /dev/null +++ b/drivers/nvdimm/pmem.c @@ -0,0 +1,260 @@ +/* + * Persistent Memory Driver + * + * Copyright (c) 2014-2015, Intel Corporation. + * Copyright (c) 2015, Christoph Hellwig . + * Copyright (c) 2015, Boaz Harrosh . + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "nd.h" + +#define PMEM_MINORS 16 + +struct pmem_device { + struct request_queue *pmem_queue; + struct gendisk *pmem_disk; + + /* One contiguous memory region per device */ + phys_addr_t phys_addr; + void *virt_addr; + size_t size; +}; + +static int pmem_major; + +static void pmem_do_bvec(struct pmem_device *pmem, struct page *page, + unsigned int len, unsigned int off, int rw, + sector_t sector) +{ + void *mem = kmap_atomic(page); + size_t pmem_off = sector << 9; + + if (rw == READ) { + memcpy(mem + off, pmem->virt_addr + pmem_off, len); + flush_dcache_page(page); + } else { + flush_dcache_page(page); + memcpy(pmem->virt_addr + pmem_off, mem + off, len); + } + + kunmap_atomic(mem); +} + +static void pmem_make_request(struct request_queue *q, struct bio *bio) +{ + struct block_device *bdev = bio->bi_bdev; + struct pmem_device *pmem = bdev->bd_disk->private_data; + int rw; + struct bio_vec bvec; + sector_t sector; + struct bvec_iter iter; + int err = 0; + + if (bio_end_sector(bio) > get_capacity(bdev->bd_disk)) { + err = -EIO; + goto out; + } + + BUG_ON(bio->bi_rw & REQ_DISCARD); + + rw = bio_data_dir(bio); + sector = bio->bi_iter.bi_sector; + bio_for_each_segment(bvec, bio, iter) { + pmem_do_bvec(pmem, bvec.bv_page, bvec.bv_len, bvec.bv_offset, + rw, sector); + sector += bvec.bv_len >> 9; + } + +out: + bio_endio(bio, err); +} + +static int pmem_rw_page(struct block_device *bdev, sector_t sector, + struct page *page, int rw) +{ + struct pmem_device *pmem = bdev->bd_disk->private_data; + + pmem_do_bvec(pmem, page, PAGE_CACHE_SIZE, 0, rw, sector); + page_endio(page, rw & WRITE, 0); + + return 0; +} + +static long pmem_direct_access(struct block_device *bdev, sector_t sector, + void **kaddr, unsigned long *pfn, long size) +{ + struct pmem_device *pmem = bdev->bd_disk->private_data; + size_t offset = sector << 9; + + if (!pmem) + return -ENODEV; + + *kaddr = pmem->virt_addr + offset; + *pfn = (pmem->phys_addr + offset) >> PAGE_SHIFT; + + return pmem->size - offset; +} + +static const struct block_device_operations pmem_fops = { + .owner = THIS_MODULE, + .rw_page = pmem_rw_page, + .direct_access = pmem_direct_access, +}; + +static struct pmem_device *pmem_alloc(struct device *dev, struct resource *res, int id) +{ + struct pmem_device *pmem; + struct gendisk *disk; + int err; + + err = -ENOMEM; + pmem = kzalloc(sizeof(*pmem), GFP_KERNEL); + if (!pmem) + goto out; + + pmem->phys_addr = res->start; + pmem->size = resource_size(res); + + err = -EINVAL; + if (!request_mem_region(pmem->phys_addr, pmem->size, "pmem")) { + dev_warn(dev, "could not reserve region [0x%pa:0x%zx]\n", &pmem->phys_addr, pmem->size); + goto out_free_dev; + } + + /* + * Map the memory as non-cachable, as we can't write back the contents + * of the CPU caches in case of a crash. + */ + err = -ENOMEM; + pmem->virt_addr = ioremap_nocache(pmem->phys_addr, pmem->size); + if (!pmem->virt_addr) + goto out_release_region; + + pmem->pmem_queue = blk_alloc_queue(GFP_KERNEL); + if (!pmem->pmem_queue) + goto out_unmap; + + blk_queue_make_request(pmem->pmem_queue, pmem_make_request); + blk_queue_max_hw_sectors(pmem->pmem_queue, 1024); + blk_queue_bounce_limit(pmem->pmem_queue, BLK_BOUNCE_ANY); + + disk = alloc_disk(PMEM_MINORS); + if (!disk) + goto out_free_queue; + + disk->major = pmem_major; + disk->first_minor = PMEM_MINORS * id; + disk->fops = &pmem_fops; + disk->private_data = pmem; + disk->queue = pmem->pmem_queue; + disk->flags = GENHD_FL_EXT_DEVT; + sprintf(disk->disk_name, "pmem%d", id); + disk->driverfs_dev = dev; + set_capacity(disk, pmem->size >> 9); + pmem->pmem_disk = disk; + + add_disk(disk); + + return pmem; + +out_free_queue: + blk_cleanup_queue(pmem->pmem_queue); +out_unmap: + iounmap(pmem->virt_addr); +out_release_region: + release_mem_region(pmem->phys_addr, pmem->size); +out_free_dev: + kfree(pmem); +out: + return ERR_PTR(err); +} + +static void pmem_free(struct pmem_device *pmem) +{ + del_gendisk(pmem->pmem_disk); + put_disk(pmem->pmem_disk); + blk_cleanup_queue(pmem->pmem_queue); + iounmap(pmem->virt_addr); + release_mem_region(pmem->phys_addr, pmem->size); + kfree(pmem); +} + +static int nd_pmem_probe(struct device *dev) +{ + struct nd_region *nd_region = to_nd_region(dev->parent); + struct nd_namespace_io *nsio = to_nd_namespace_io(dev); + struct pmem_device *pmem; + + pmem = pmem_alloc(dev, &nsio->res, nd_region->id); + if (IS_ERR(pmem)) + return PTR_ERR(pmem); + + dev_set_drvdata(dev, pmem); + + return 0; +} + +static int nd_pmem_remove(struct device *dev) +{ + struct pmem_device *pmem = dev_get_drvdata(dev); + + pmem_free(pmem); + return 0; +} + +MODULE_ALIAS("pmem"); +MODULE_ALIAS_ND_DEVICE(ND_DEVICE_NAMESPACE_IO); +static struct nd_device_driver nd_pmem_driver = { + .probe = nd_pmem_probe, + .remove = nd_pmem_remove, + .drv = { + .name = "nd_pmem", + }, + .type = ND_DRIVER_NAMESPACE_IO, +}; + +static int __init pmem_init(void) +{ + int error; + + pmem_major = register_blkdev(0, "pmem"); + if (pmem_major < 0) + return pmem_major; + + error = nd_driver_register(&nd_pmem_driver); + if (error) { + unregister_blkdev(pmem_major, "pmem"); + return error; + } + + return 0; +} +module_init(pmem_init); + +static void pmem_exit(void) +{ + driver_unregister(&nd_pmem_driver.drv); + unregister_blkdev(pmem_major, "pmem"); +} +module_exit(pmem_exit); + +MODULE_AUTHOR("Ross Zwisler "); +MODULE_LICENSE("GPL v2"); {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I