From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: "Williams, Dan J" Subject: Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code Date: Wed, 26 Aug 2015 21:34:20 +0000 Message-ID: <1440624859.31365.17.camel@intel.com> References: <20150826010220.8851.18077.stgit@dwillia2-desk3.amr.corp.intel.com> <20150826012751.8851.78564.stgit@dwillia2-desk3.amr.corp.intel.com> <20150826124124.GA7613@lst.de> In-Reply-To: <20150826124124.GA7613@lst.de> Content-Language: en-US Content-Type: text/plain; charset="utf-8" Content-ID: <453DD6BA4F29B541A82ABDFACA8189F2@intel.com> Content-Transfer-Encoding: base64 MIME-Version: 1.0 Sender: owner-linux-mm@kvack.org To: "hch@lst.de" Cc: "toshi.kani@hp.com" , "linux-kernel@vger.kernel.org" , "mingo@kernel.org" , "linux-mm@kvack.org" , "tglx@linutronix.de" , "hpa@zytor.com" , "linux-nvdimm@lists.01.org" , "mingo@redhat.com" , "ross.zwisler@linux.intel.com" , "boaz@plexistor.com" , "david@fromorbit.com" List-ID: T24gV2VkLCAyMDE1LTA4LTI2IGF0IDE0OjQxICswMjAwLCBDaHJpc3RvcGggSGVsbHdpZyB3cm90 ZToNCj4gSSBsaWtlIHRoZSBpbnRlbnQgYmVoaW5kIHRoaXMsIGJ1dCBub3QgdGhlIGltcGxlbWVu dGF0aW9uLg0KPiANCj4gSSB0aGluayB0aGUgcmlnaHQgYXBwcm9hY2ggaXMgdG8ga2VlcCB0aGUg ZGVmYXVsdHMgaW4gbGludXgvcG1lbS5oDQo+IGFuZCBzaW1wbHkgbm90IHNldCBDT05GSUdfQVJD SF9IQVNfUE1FTV9BUEkgZm9yIHg4Ni0zMi4NCg0KWWVzLCB0aGF0IG1ha2VzIHRoaW5ncyBtdWNo IGNsZWFuZXIuICBSZXZpc2VkIHBhdGNoIGFuZCBjaGFuZ2Vsb2cgYmVsb3c6DQoNCjg8LS0tLQ0K U3ViamVjdDogeDg2LCBwbWVtOiBjbGFyaWZ5IHRoYXQgQVJDSF9IQVNfUE1FTV9BUEkgaW1wbGll cyBQTUVNIG1hcHBlZCBXQg0KDQpGcm9tOiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGlu dGVsLmNvbT4NCg0KR2l2ZW4gdGhhdCBhIHdyaXRlLWJhY2sgKFdCKSBtYXBwaW5nIHBsdXMgbm9u LXRlbXBvcmFsIHN0b3JlcyBpcw0KZXhwZWN0ZWQgdG8gYmUgdGhlIG1vc3QgZWZmaWNpZW50IHdh eSB0byBhY2Nlc3MgUE1FTSwgdXBkYXRlIHRoZQ0KZGVmaW5pdGlvbiBvZiBBUkNIX0hBU19QTUVN X0FQSSB0byBpbXBseSBhcmNoIHN1cHBvcnQgZm9yDQpXQi1tYXBwZWQtUE1FTS4gIFRoaXMgaXMg bmVlZGVkIGFzIGEgcHJlLXJlcXVpc2l0ZSBmb3IgYWRkaW5nIFBNRU0gdG8NCnRoZSBkaXJlY3Qg bWFwIGFuZCBtYXBwaW5nIGl0IHdpdGggc3RydWN0IHBhZ2UuDQoNClRoZSBhYm92ZSBjbGFyaWZp Y2F0aW9uIGZvciBYODZfNjQgbWVhbnMgdGhhdCBtZW1jcHlfdG9fcG1lbSgpIGlzDQpwZXJtaXR0 ZWQgdG8gdXNlIHRoZSBub24tdGVtcG9yYWwgYXJjaF9tZW1jcHlfdG9fcG1lbSgpIHJhdGhlciB0 aGFuDQpuZWVkbGVzc2x5IGZhbGwgYmFjayB0byBkZWZhdWx0X21lbWNweV90b19wbWVtKCkgd2hl biB0aGUgcGNvbW1pdA0KaW5zdHJ1Y3Rpb24gaXMgbm90IGF2YWlsYWJsZS4gIFdoZW4gYXJjaF9t ZW1jcHlfdG9fcG1lbSgpIGlzIG5vdA0KZ3VhcmFudGVlZCB0byBmbHVzaCB3cml0ZXMgb3V0IG9m IGNhY2hlLCBpLmUuIG9uIG9sZGVyIFg4Nl8zMg0KaW1wbGVtZW50YXRpb25zIHdoZXJlIG5vbi10 ZW1wb3JhbCBzdG9yZXMgbWF5IGp1c3QgZGlydHkgY2FjaGUsDQpBUkNIX0hBU19QTUVNX0FQSSBp cyBzaW1wbHkgZGlzYWJsZWQuDQoNClRoZSBkZWZhdWx0IGZhbGwgYmFjayBmb3IgcGVyc2lzdGVu dCBtZW1vcnkgaGFuZGxpbmcgcmVtYWlucy4gIE5hbWVseSwNCm1hcCBpdCB3aXRoIHRoZSBXVCAo d3JpdGUtdGhyb3VnaCkgY2FjaGUtdHlwZSBhbmQgaG9wZSBmb3IgdGhlIGJlc3QuDQoNCmFyY2hf aGFzX3BtZW1fYXBpKCkgaXMgdXBkYXRlZCB0byBvbmx5IGluZGljYXRlIHdoZXRoZXIgdGhlIGFy Y2gNCnByb3ZpZGVzIHRoZSBwcm9wZXIgaGVscGVycyB0byBtZWV0IHRoZSBtaW5pbXVtICJ3cml0 ZXMgYXJlIHZpc2libGUNCm91dHNpZGUgdGhlIGNhY2hlIGhpZXJhcmNoeSBhZnRlciBtZW1jcHlf dG9fcG1lbSgpICsgd21iX3BtZW0oKSIuICBDb2RlDQp0aGF0IGNhcmVzIHdoZXRoZXIgd21iX3Bt ZW0oKSBhY3R1YWxseSBmbHVzaGVzIHdyaXRlcyB0byBwbWVtIG11c3Qgbm93DQpjYWxsIGFyY2hf aGFzX3dtYl9wbWVtKCkgZGlyZWN0bHkuDQoNCkNjOiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGlu dXRyb25peC5kZT4NCkNjOiBJbmdvIE1vbG5hciA8bWluZ29AcmVkaGF0LmNvbT4NCkNjOiAiSC4g UGV0ZXIgQW52aW4iIDxocGFAenl0b3IuY29tPg0KQ2M6IFRvc2hpIEthbmkgPHRvc2hpLmthbmlA aHAuY29tPg0KQ2M6IFJvc3MgWndpc2xlciA8cm9zcy56d2lzbGVyQGxpbnV4LmludGVsLmNvbT4N CkNjOiBDaHJpc3RvcGggSGVsbHdpZyA8aGNoQGxzdC5kZT4NCltoY2g6IHNldCBBUkNIX0hBU19Q TUVNX0FQST1uIG9uIFg4Nl8zMl0NClNpZ25lZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8ZGFuLmou d2lsbGlhbXNAaW50ZWwuY29tPg0KLS0tDQogYXJjaC94ODYvS2NvbmZpZyAgICAgICAgICAgIHwg ICAgMiArLQ0KIGFyY2gveDg2L2luY2x1ZGUvYXNtL2lvLmggICB8ICAgIDIgLS0NCiBhcmNoL3g4 Ni9pbmNsdWRlL2FzbS9wbWVtLmggfCAgICA4ICsrLS0tLS0tDQogZHJpdmVycy9hY3BpL25maXQu YyAgICAgICAgIHwgICAgMiArLQ0KIGRyaXZlcnMvbnZkaW1tL3BtZW0uYyAgICAgICB8ICAgIDIg Ky0NCiBpbmNsdWRlL2xpbnV4L3BtZW0uaCAgICAgICAgfCAgIDI4ICsrKysrKysrKysrKysrKysr LS0tLS0tLS0tLS0NCiA2IGZpbGVzIGNoYW5nZWQsIDIyIGluc2VydGlvbnMoKyksIDIyIGRlbGV0 aW9ucygtKQ0KDQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvS2NvbmZpZyBiL2FyY2gveDg2L0tjb25m aWcNCmluZGV4IDc2YzYxMTU0ZWQ1MC4uNTkxMjg1OWRmNTMzIDEwMDY0NA0KLS0tIGEvYXJjaC94 ODYvS2NvbmZpZw0KKysrIGIvYXJjaC94ODYvS2NvbmZpZw0KQEAgLTI3LDcgKzI3LDcgQEAgY29u ZmlnIFg4Ng0KIAlzZWxlY3QgQVJDSF9IQVNfRUxGX1JBTkRPTUlaRQ0KIAlzZWxlY3QgQVJDSF9I QVNfRkFTVF9NVUxUSVBMSUVSDQogCXNlbGVjdCBBUkNIX0hBU19HQ09WX1BST0ZJTEVfQUxMDQot CXNlbGVjdCBBUkNIX0hBU19QTUVNX0FQSQ0KKwlzZWxlY3QgQVJDSF9IQVNfUE1FTV9BUEkJCWlm IFg4Nl82NA0KIAlzZWxlY3QgQVJDSF9IQVNfU0dfQ0hBSU4NCiAJc2VsZWN0IEFSQ0hfSEFWRV9O TUlfU0FGRV9DTVBYQ0hHDQogCXNlbGVjdCBBUkNIX01JR0hUX0hBVkVfQUNQSV9QREMJCWlmIEFD UEkNCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pby5oIGIvYXJjaC94ODYvaW5j bHVkZS9hc20vaW8uaA0KaW5kZXggZDI0MWZiZDVjODdiLi44M2VjOWIxZDc3Y2MgMTAwNjQ0DQot LS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9pby5oDQorKysgYi9hcmNoL3g4Ni9pbmNsdWRlL2Fz bS9pby5oDQpAQCAtMjQ4LDggKzI0OCw2IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBmbHVzaF93cml0 ZV9idWZmZXJzKHZvaWQpDQogI2VuZGlmDQogfQ0KIA0KLSNkZWZpbmUgQVJDSF9NRU1SRU1BUF9Q TUVNIE1FTVJFTUFQX1dCDQotDQogI2VuZGlmIC8qIF9fS0VSTkVMX18gKi8NCiANCiBleHRlcm4g dm9pZCBuYXRpdmVfaW9fZGVsYXkodm9pZCk7DQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVk ZS9hc20vcG1lbS5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcG1lbS5oDQppbmRleCBhM2EwZGY2 NTQ1ZWUuLjUxMTFmMWYwNTNhNCAxMDA2NDQNCi0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3Bt ZW0uaA0KKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcG1lbS5oDQpAQCAtMTksNiArMTksNyBA QA0KICNpbmNsdWRlIDxhc20vc3BlY2lhbF9pbnNucy5oPg0KIA0KICNpZmRlZiBDT05GSUdfQVJD SF9IQVNfUE1FTV9BUEkNCisjZGVmaW5lIEFSQ0hfTUVNUkVNQVBfUE1FTSBNRU1SRU1BUF9XQg0K IC8qKg0KICAqIGFyY2hfbWVtY3B5X3RvX3BtZW0gLSBjb3B5IGRhdGEgdG8gcGVyc2lzdGVudCBt ZW1vcnkNCiAgKiBAZHN0OiBkZXN0aW5hdGlvbiBidWZmZXIgZm9yIHRoZSBjb3B5DQpAQCAtMTQx LDE4ICsxNDIsMTMgQEAgc3RhdGljIGlubGluZSB2b2lkIGFyY2hfY2xlYXJfcG1lbSh2b2lkIF9f cG1lbSAqYWRkciwgc2l6ZV90IHNpemUpDQogCV9fYXJjaF93Yl9jYWNoZV9wbWVtKHZhZGRyLCBz aXplKTsNCiB9DQogDQotc3RhdGljIGlubGluZSBib29sIGFyY2hfaGFzX3dtYl9wbWVtKHZvaWQp DQorc3RhdGljIGlubGluZSBib29sIF9fYXJjaF9oYXNfd21iX3BtZW0odm9pZCkNCiB7DQotI2lm ZGVmIENPTkZJR19YODZfNjQNCiAJLyoNCiAJICogV2UgcmVxdWlyZSB0aGF0IHdtYigpIGJlIGFu ICdzZmVuY2UnLCB0aGF0IGlzIG9ubHkgZ3VhcmFudGVlZCBvbg0KIAkgKiA2NC1iaXQgYnVpbGRz DQogCSAqLw0KIAlyZXR1cm4gc3RhdGljX2NwdV9oYXMoWDg2X0ZFQVRVUkVfUENPTU1JVCk7DQot I2Vsc2UNCi0JcmV0dXJuIGZhbHNlOw0KLSNlbmRpZg0KIH0NCiAjZW5kaWYgLyogQ09ORklHX0FS Q0hfSEFTX1BNRU1fQVBJICovDQotDQogI2VuZGlmIC8qIF9fQVNNX1g4Nl9QTUVNX0hfXyAqLw0K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNwaS9uZml0LmMgYi9kcml2ZXJzL2FjcGkvbmZpdC5jDQpp bmRleCA3YzI2MzhmOTE0YTkuLmMzZmUyMDYzNTU2MiAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvYWNw aS9uZml0LmMNCisrKyBiL2RyaXZlcnMvYWNwaS9uZml0LmMNCkBAIC0xMzY0LDcgKzEzNjQsNyBA QCBzdGF0aWMgaW50IGFjcGlfbmZpdF9ibGtfcmVnaW9uX2VuYWJsZShzdHJ1Y3QgbnZkaW1tX2J1 cyAqbnZkaW1tX2J1cywNCiAJCQlyZXR1cm4gLUVOT01FTTsNCiAJfQ0KIA0KLQlpZiAoIWFyY2hf aGFzX3BtZW1fYXBpKCkgJiYgIW5maXRfYmxrLT5udmRpbW1fZmx1c2gpDQorCWlmICghYXJjaF9o YXNfd21iX3BtZW0oKSAmJiAhbmZpdF9ibGstPm52ZGltbV9mbHVzaCkNCiAJCWRldl93YXJuKGRl diwgInVuYWJsZSB0byBndWFyYW50ZWUgcGVyc2lzdGVuY2Ugb2Ygd3JpdGVzXG4iKTsNCiANCiAJ aWYgKG1taW8tPmxpbmVfc2l6ZSA9PSAwKQ0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZkaW1tL3Bt ZW0uYyBiL2RyaXZlcnMvbnZkaW1tL3BtZW0uYw0KaW5kZXggM2I1YjljYjc1OGI2Li4yMGJmMTIy MzI4ZGEgMTAwNjQ0DQotLS0gYS9kcml2ZXJzL252ZGltbS9wbWVtLmMNCisrKyBiL2RyaXZlcnMv bnZkaW1tL3BtZW0uYw0KQEAgLTEyNSw3ICsxMjUsNyBAQCBzdGF0aWMgc3RydWN0IHBtZW1fZGV2 aWNlICpwbWVtX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRldiwNCiANCiAJcG1lbS0+cGh5c19hZGRy ID0gcmVzLT5zdGFydDsNCiAJcG1lbS0+c2l6ZSA9IHJlc291cmNlX3NpemUocmVzKTsNCi0JaWYg KCFhcmNoX2hhc19wbWVtX2FwaSgpKQ0KKwlpZiAoIWFyY2hfaGFzX3dtYl9wbWVtKCkpDQogCQlk ZXZfd2FybihkZXYsICJ1bmFibGUgdG8gZ3VhcmFudGVlIHBlcnNpc3RlbmNlIG9mIHdyaXRlc1xu Iik7DQogDQogCWlmICghZGV2bV9yZXF1ZXN0X21lbV9yZWdpb24oZGV2LCBwbWVtLT5waHlzX2Fk ZHIsIHBtZW0tPnNpemUsDQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9wbWVtLmggYi9pbmNs dWRlL2xpbnV4L3BtZW0uaA0KaW5kZXggYTlkODRiZjMzNWVlLi45ZWM0MjcxMDMxNWUgMTAwNjQ0 DQotLS0gYS9pbmNsdWRlL2xpbnV4L3BtZW0uaA0KKysrIGIvaW5jbHVkZS9saW51eC9wbWVtLmgN CkBAIC0xOSwxMiArMTksMTIgQEANCiAjaWZkZWYgQ09ORklHX0FSQ0hfSEFTX1BNRU1fQVBJDQog I2luY2x1ZGUgPGFzbS9wbWVtLmg+DQogI2Vsc2UNCi1zdGF0aWMgaW5saW5lIHZvaWQgYXJjaF93 bWJfcG1lbSh2b2lkKQ0KLXsNCi0JQlVHKCk7DQotfQ0KLQ0KLXN0YXRpYyBpbmxpbmUgYm9vbCBh cmNoX2hhc193bWJfcG1lbSh2b2lkKQ0KKy8qDQorICogVGhlc2UgYXJlIHNpbXBseSBoZXJlIHRv IGVuYWJsZSBjb21waWxhdGlvbiwgYWxsIGNhbGwgc2l0ZXMgZ2F0ZQ0KKyAqIGNhbGxpbmcgdGhl c2Ugc3ltYm9scyB3aXRoIGFyY2hfaGFzX3BtZW1fYXBpKCkgYW5kIHJlZGlyZWN0IHRvIHRoZQ0K KyAqIGltcGxlbWVudGF0aW9uIGluIGFzbS9wbWVtLmguDQorICovDQorc3RhdGljIGlubGluZSBi b29sIF9fYXJjaF9oYXNfd21iX3BtZW0odm9pZCkNCiB7DQogCXJldHVybiBmYWxzZTsNCiB9DQpA QCAtNTMsNyArNTMsNiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgYXJjaF9jbGVhcl9wbWVtKHZvaWQg X19wbWVtICphZGRyLCBzaXplX3Qgc2l6ZSkNCiAgKiBpbXBsZW1lbnRhdGlvbnMgZm9yIGFyY2hf bWVtY3B5X3RvX3BtZW0oKSwgYXJjaF93bWJfcG1lbSgpLA0KICAqIGFyY2hfY29weV9mcm9tX2l0 ZXJfcG1lbSgpLCBhcmNoX2NsZWFyX3BtZW0oKSBhbmQgYXJjaF9oYXNfd21iX3BtZW0oKS4NCiAg Ki8NCi0NCiBzdGF0aWMgaW5saW5lIHZvaWQgbWVtY3B5X2Zyb21fcG1lbSh2b2lkICpkc3QsIHZv aWQgX19wbWVtIGNvbnN0ICpzcmMsIHNpemVfdCBzaXplKQ0KIHsNCiAJbWVtY3B5KGRzdCwgKHZv aWQgX19mb3JjZSBjb25zdCAqKSBzcmMsIHNpemUpOw0KQEAgLTY0LDggKzYzLDEzIEBAIHN0YXRp YyBpbmxpbmUgdm9pZCBtZW11bm1hcF9wbWVtKHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCBfX3Bt ZW0gKmFkZHIpDQogCWRldm1fbWVtdW5tYXAoZGV2LCAodm9pZCBfX2ZvcmNlICopIGFkZHIpOw0K IH0NCiANCitzdGF0aWMgaW5saW5lIGJvb2wgYXJjaF9oYXNfcG1lbV9hcGkodm9pZCkNCit7DQor CXJldHVybiBJU19FTkFCTEVEKENPTkZJR19BUkNIX0hBU19QTUVNX0FQSSk7DQorfQ0KKw0KIC8q Kg0KLSAqIGFyY2hfaGFzX3BtZW1fYXBpIC0gdHJ1ZSBpZiB3bWJfcG1lbSgpIGVuc3VyZXMgZHVy YWJpbGl0eQ0KKyAqIGFyY2hfaGFzX3dtYl9wbWVtIC0gdHJ1ZSBpZiB3bWJfcG1lbSgpIGVuc3Vy ZXMgZHVyYWJpbGl0eQ0KICAqDQogICogRm9yIGEgZ2l2ZW4gY3B1IGltcGxlbWVudGF0aW9uIHdp dGhpbiBhbiBhcmNoaXRlY3R1cmUgaXQgaXMgcG9zc2libGUNCiAgKiB0aGF0IHdtYl9wbWVtKCkg cmVzb2x2ZXMgdG8gYSBub3AuICBJbiB0aGUgY2FzZSB0aGlzIHJldHVybnMNCkBAIC03Myw5ICs3 Nyw5IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBtZW11bm1hcF9wbWVtKHN0cnVjdCBkZXZpY2UgKmRl diwgdm9pZCBfX3BtZW0gKmFkZHIpDQogICogZmFsbCBiYWNrIHRvIGEgZGlmZmVyZW50IGRhdGEg Y29uc2lzdGVuY3kgbW9kZWwsIG9yIG90aGVyd2lzZSBub3RpZnkNCiAgKiB0aGUgdXNlci4NCiAg Ki8NCi1zdGF0aWMgaW5saW5lIGJvb2wgYXJjaF9oYXNfcG1lbV9hcGkodm9pZCkNCitzdGF0aWMg aW5saW5lIGJvb2wgYXJjaF9oYXNfd21iX3BtZW0odm9pZCkNCiB7DQotCXJldHVybiBJU19FTkFC TEVEKENPTkZJR19BUkNIX0hBU19QTUVNX0FQSSkgJiYgYXJjaF9oYXNfd21iX3BtZW0oKTsNCisJ cmV0dXJuIGFyY2hfaGFzX3BtZW1fYXBpKCkgJiYgX19hcmNoX2hhc193bWJfcG1lbSgpOw0KIH0N CiANCiAvKg0KQEAgLTE1OCw4ICsxNjIsMTAgQEAgc3RhdGljIGlubGluZSB2b2lkIG1lbWNweV90 b19wbWVtKHZvaWQgX19wbWVtICpkc3QsIGNvbnN0IHZvaWQgKnNyYywgc2l6ZV90IG4pDQogICov DQogc3RhdGljIGlubGluZSB2b2lkIHdtYl9wbWVtKHZvaWQpDQogew0KLQlpZiAoYXJjaF9oYXNf cG1lbV9hcGkoKSkNCisJaWYgKGFyY2hfaGFzX3dtYl9wbWVtKCkpDQogCQlhcmNoX3dtYl9wbWVt KCk7DQorCWVsc2UNCisJCXdtYigpOw0KIH0NCiANCiAvKioNCg0K -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: email@kvack.org From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752557AbbHZVeY (ORCPT ); Wed, 26 Aug 2015 17:34:24 -0400 Received: from mga09.intel.com ([134.134.136.24]:12342 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750968AbbHZVeW (ORCPT ); Wed, 26 Aug 2015 17:34:22 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.17,418,1437462000"; d="scan'208";a="791572618" From: "Williams, Dan J" To: "hch@lst.de" CC: "toshi.kani@hp.com" , "linux-kernel@vger.kernel.org" , "mingo@kernel.org" , "linux-mm@kvack.org" , "tglx@linutronix.de" , "hpa@zytor.com" , "linux-nvdimm@lists.01.org" , "mingo@redhat.com" , "ross.zwisler@linux.intel.com" , "boaz@plexistor.com" , "david@fromorbit.com" Subject: Re: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code Thread-Topic: [PATCH v2 5/9] x86, pmem: push fallback handling to arch code Thread-Index: AQHQ3585kOnBxM54REqrdIbgxDkOk54eryMAgACU5YA= Date: Wed, 26 Aug 2015 21:34:20 +0000 Message-ID: <1440624859.31365.17.camel@intel.com> References: <20150826010220.8851.18077.stgit@dwillia2-desk3.amr.corp.intel.com> <20150826012751.8851.78564.stgit@dwillia2-desk3.amr.corp.intel.com> <20150826124124.GA7613@lst.de> In-Reply-To: <20150826124124.GA7613@lst.de> 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: <453DD6BA4F29B541A82ABDFACA8189F2@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 mail.home.local id t7QLYU7M027879 On Wed, 2015-08-26 at 14:41 +0200, Christoph Hellwig wrote: > I like the intent behind this, but not the implementation. > > I think the right approach is to keep the defaults in linux/pmem.h > and simply not set CONFIG_ARCH_HAS_PMEM_API for x86-32. Yes, that makes things much cleaner. Revised patch and changelog below: 8<---- Subject: x86, pmem: clarify that ARCH_HAS_PMEM_API implies PMEM mapped WB From: Dan Williams Given that a write-back (WB) mapping plus non-temporal stores is expected to be the most efficient way to access PMEM, update the definition of ARCH_HAS_PMEM_API to imply arch support for WB-mapped-PMEM. This is needed as a pre-requisite for adding PMEM to the direct map and mapping it with struct page. The above clarification for X86_64 means that memcpy_to_pmem() is permitted to use the non-temporal arch_memcpy_to_pmem() rather than needlessly fall back to default_memcpy_to_pmem() when the pcommit instruction is not available. When arch_memcpy_to_pmem() is not guaranteed to flush writes out of cache, i.e. on older X86_32 implementations where non-temporal stores may just dirty cache, ARCH_HAS_PMEM_API is simply disabled. The default fall back for persistent memory handling remains. Namely, map it with the WT (write-through) cache-type and hope for the best. arch_has_pmem_api() is updated to only indicate whether the arch provides the proper helpers to meet the minimum "writes are visible outside the cache hierarchy after memcpy_to_pmem() + wmb_pmem()". Code that cares whether wmb_pmem() actually flushes writes to pmem must now call arch_has_wmb_pmem() directly. Cc: Thomas Gleixner Cc: Ingo Molnar Cc: "H. Peter Anvin" Cc: Toshi Kani Cc: Ross Zwisler Cc: Christoph Hellwig [hch: set ARCH_HAS_PMEM_API=n on X86_32] Signed-off-by: Dan Williams --- arch/x86/Kconfig | 2 +- arch/x86/include/asm/io.h | 2 -- arch/x86/include/asm/pmem.h | 8 ++------ drivers/acpi/nfit.c | 2 +- drivers/nvdimm/pmem.c | 2 +- include/linux/pmem.h | 28 +++++++++++++++++----------- 6 files changed, 22 insertions(+), 22 deletions(-) diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 76c61154ed50..5912859df533 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -27,7 +27,7 @@ config X86 select ARCH_HAS_ELF_RANDOMIZE select ARCH_HAS_FAST_MULTIPLIER select ARCH_HAS_GCOV_PROFILE_ALL - select ARCH_HAS_PMEM_API + select ARCH_HAS_PMEM_API if X86_64 select ARCH_HAS_SG_CHAIN select ARCH_HAVE_NMI_SAFE_CMPXCHG select ARCH_MIGHT_HAVE_ACPI_PDC if ACPI diff --git a/arch/x86/include/asm/io.h b/arch/x86/include/asm/io.h index d241fbd5c87b..83ec9b1d77cc 100644 --- a/arch/x86/include/asm/io.h +++ b/arch/x86/include/asm/io.h @@ -248,8 +248,6 @@ static inline void flush_write_buffers(void) #endif } -#define ARCH_MEMREMAP_PMEM MEMREMAP_WB - #endif /* __KERNEL__ */ extern void native_io_delay(void); diff --git a/arch/x86/include/asm/pmem.h b/arch/x86/include/asm/pmem.h index a3a0df6545ee..5111f1f053a4 100644 --- a/arch/x86/include/asm/pmem.h +++ b/arch/x86/include/asm/pmem.h @@ -19,6 +19,7 @@ #include #ifdef CONFIG_ARCH_HAS_PMEM_API +#define ARCH_MEMREMAP_PMEM MEMREMAP_WB /** * arch_memcpy_to_pmem - copy data to persistent memory * @dst: destination buffer for the copy @@ -141,18 +142,13 @@ static inline void arch_clear_pmem(void __pmem *addr, size_t size) __arch_wb_cache_pmem(vaddr, size); } -static inline bool arch_has_wmb_pmem(void) +static inline bool __arch_has_wmb_pmem(void) { -#ifdef CONFIG_X86_64 /* * We require that wmb() be an 'sfence', that is only guaranteed on * 64-bit builds */ return static_cpu_has(X86_FEATURE_PCOMMIT); -#else - return false; -#endif } #endif /* CONFIG_ARCH_HAS_PMEM_API */ - #endif /* __ASM_X86_PMEM_H__ */ diff --git a/drivers/acpi/nfit.c b/drivers/acpi/nfit.c index 7c2638f914a9..c3fe20635562 100644 --- a/drivers/acpi/nfit.c +++ b/drivers/acpi/nfit.c @@ -1364,7 +1364,7 @@ static int acpi_nfit_blk_region_enable(struct nvdimm_bus *nvdimm_bus, return -ENOMEM; } - if (!arch_has_pmem_api() && !nfit_blk->nvdimm_flush) + if (!arch_has_wmb_pmem() && !nfit_blk->nvdimm_flush) dev_warn(dev, "unable to guarantee persistence of writes\n"); if (mmio->line_size == 0) diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c index 3b5b9cb758b6..20bf122328da 100644 --- a/drivers/nvdimm/pmem.c +++ b/drivers/nvdimm/pmem.c @@ -125,7 +125,7 @@ static struct pmem_device *pmem_alloc(struct device *dev, pmem->phys_addr = res->start; pmem->size = resource_size(res); - if (!arch_has_pmem_api()) + if (!arch_has_wmb_pmem()) dev_warn(dev, "unable to guarantee persistence of writes\n"); if (!devm_request_mem_region(dev, pmem->phys_addr, pmem->size, diff --git a/include/linux/pmem.h b/include/linux/pmem.h index a9d84bf335ee..9ec42710315e 100644 --- a/include/linux/pmem.h +++ b/include/linux/pmem.h @@ -19,12 +19,12 @@ #ifdef CONFIG_ARCH_HAS_PMEM_API #include #else -static inline void arch_wmb_pmem(void) -{ - BUG(); -} - -static inline bool arch_has_wmb_pmem(void) +/* + * These are simply here to enable compilation, all call sites gate + * calling these symbols with arch_has_pmem_api() and redirect to the + * implementation in asm/pmem.h. + */ +static inline bool __arch_has_wmb_pmem(void) { return false; } @@ -53,7 +53,6 @@ static inline void arch_clear_pmem(void __pmem *addr, size_t size) * implementations for arch_memcpy_to_pmem(), arch_wmb_pmem(), * arch_copy_from_iter_pmem(), arch_clear_pmem() and arch_has_wmb_pmem(). */ - static inline void memcpy_from_pmem(void *dst, void __pmem const *src, size_t size) { memcpy(dst, (void __force const *) src, size); @@ -64,8 +63,13 @@ static inline void memunmap_pmem(struct device *dev, void __pmem *addr) devm_memunmap(dev, (void __force *) addr); } +static inline bool arch_has_pmem_api(void) +{ + return IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API); +} + /** - * arch_has_pmem_api - true if wmb_pmem() ensures durability + * arch_has_wmb_pmem - true if wmb_pmem() ensures durability * * For a given cpu implementation within an architecture it is possible * that wmb_pmem() resolves to a nop. In the case this returns @@ -73,9 +77,9 @@ static inline void memunmap_pmem(struct device *dev, void __pmem *addr) * fall back to a different data consistency model, or otherwise notify * the user. */ -static inline bool arch_has_pmem_api(void) +static inline bool arch_has_wmb_pmem(void) { - return IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API) && arch_has_wmb_pmem(); + return arch_has_pmem_api() && __arch_has_wmb_pmem(); } /* @@ -158,8 +162,10 @@ static inline void memcpy_to_pmem(void __pmem *dst, const void *src, size_t n) */ static inline void wmb_pmem(void) { - if (arch_has_pmem_api()) + if (arch_has_wmb_pmem()) arch_wmb_pmem(); + else + wmb(); } /** {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I