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: Sat, 29 Aug 2015 04:04:58 +0000 Message-ID: <1440821097.32027.2.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> <1440624859.31365.17.camel@intel.com> <1440798084.14237.106.camel@hp.com> <1440798506.14237.107.camel@hp.com> In-Reply-To: <1440798506.14237.107.camel@hp.com> Content-Language: en-US Content-Type: text/plain; charset="utf-8" Content-ID: <6CFD6EBACCB8CF4D8609EFFF43D04829@intel.com> Content-Transfer-Encoding: base64 MIME-Version: 1.0 Sender: owner-linux-mm@kvack.org To: "toshi.kani@hp.com" Cc: "linux-kernel@vger.kernel.org" , "mingo@kernel.org" , "linux-mm@kvack.org" , "tglx@linutronix.de" , "hch@lst.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: T24gRnJpLCAyMDE1LTA4LTI4IGF0IDE1OjQ4IC0wNjAwLCBUb3NoaSBLYW5pIHdyb3RlOg0KPiBP biBGcmksIDIwMTUtMDgtMjggYXQgMTQ6NDcgLTA3MDAsIERhbiBXaWxsaWFtcyB3cm90ZToNCj4g PiBPbiBGcmksIEF1ZyAyOCwgMjAxNSBhdCAyOjQxIFBNLCBUb3NoaSBLYW5pIDx0b3NoaS5rYW5p QGhwLmNvbT4gd3JvdGU6DQo+ID4gPiBPbiBXZWQsIDIwMTUtMDgtMjYgYXQgMjE6MzQgKzAwMDAs IFdpbGxpYW1zLCBEYW4gSiB3cm90ZToNCj4gPiBbLi5dDQo+ID4gPiA+IC0jZGVmaW5lIEFSQ0hf TUVNUkVNQVBfUE1FTSBNRU1SRU1BUF9XQg0KPiA+ID4gDQo+ID4gPiBTaG91bGQgaXQgYmUgYmV0 dGVyIHRvIGRvOg0KPiA+ID4gDQo+ID4gPiAjZWxzZSAgIC8qICFDT05GSUdfQVJDSF9IQVNfUE1F TV9BUEkgKi8NCj4gPiA+ICNkZWZpbmUgQVJDSF9NRU1SRU1BUF9QTUVNIE1FTVJFTUFQX1dUDQo+ ID4gPiANCj4gPiA+IHNvIHRoYXQgeW91IGNhbiByZW1vdmUgYWxsICcjaWZkZWYgQVJDSF9NRU1S RU1BUF9QTUVNJyBzdHVmZj8NCj4gPiANCj4gPiBZZWFoLCB0aGF0IHNlZW1zIGxpa2UgYSBuaWNl IGluY3JlbWVudGFsIGNsZWFudXAgZm9yIG1lbXJlbWFwX3BtZW0oKQ0KPiA+IHRvIGp1c3QgdW5j b25kaXRpb25hbGx5IHVzZSBBUkNIX01FTVJFTUFQX1BNRU0sIGZlZWwgZnJlZSB0byBzZW5kIGl0 DQo+ID4gYWxvbmcuDQo+IA0KPiBPSy4gV2lsbCBkby4NCj4gDQoNCkhlcmUncyB0aGUgcmUtd29y a2VkIHBhdGNoIHdpdGggVG9zaGkncyBmaXhlcyBmb2xkZWQgaW46DQoNCjg8LS0tLS0NClN1Ympl Y3Q6IHg4NiwgcG1lbTogY2xhcmlmeSB0aGF0IEFSQ0hfSEFTX1BNRU1fQVBJIGltcGxpZXMgUE1F TSBtYXBwZWQgV0INCg0KRnJvbTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5j b20+DQoNCkdpdmVuIHRoYXQgYSB3cml0ZS1iYWNrIChXQikgbWFwcGluZyBwbHVzIG5vbi10ZW1w b3JhbCBzdG9yZXMgaXMNCmV4cGVjdGVkIHRvIGJlIHRoZSBtb3N0IGVmZmljaWVudCB3YXkgdG8g YWNjZXNzIFBNRU0sIHVwZGF0ZSB0aGUNCmRlZmluaXRpb24gb2YgQVJDSF9IQVNfUE1FTV9BUEkg dG8gaW1wbHkgYXJjaCBzdXBwb3J0IGZvcg0KV0ItbWFwcGVkLVBNRU0uICBUaGlzIGlzIG5lZWRl ZCBhcyBhIHByZS1yZXF1aXNpdGUgZm9yIGFkZGluZyBQTUVNIHRvDQp0aGUgZGlyZWN0IG1hcCBh bmQgbWFwcGluZyBpdCB3aXRoIHN0cnVjdCBwYWdlLg0KDQpUaGUgYWJvdmUgY2xhcmlmaWNhdGlv biBmb3IgWDg2XzY0IG1lYW5zIHRoYXQgbWVtY3B5X3RvX3BtZW0oKSBpcw0KcGVybWl0dGVkIHRv IHVzZSB0aGUgbm9uLXRlbXBvcmFsIGFyY2hfbWVtY3B5X3RvX3BtZW0oKSByYXRoZXIgdGhhbg0K bmVlZGxlc3NseSBmYWxsIGJhY2sgdG8gZGVmYXVsdF9tZW1jcHlfdG9fcG1lbSgpIHdoZW4gdGhl IHBjb21taXQNCmluc3RydWN0aW9uIGlzIG5vdCBhdmFpbGFibGUuICBXaGVuIGFyY2hfbWVtY3B5 X3RvX3BtZW0oKSBpcyBub3QNCmd1YXJhbnRlZWQgdG8gZmx1c2ggd3JpdGVzIG91dCBvZiBjYWNo ZSwgaS5lLiBvbiBvbGRlciBYODZfMzINCmltcGxlbWVudGF0aW9ucyB3aGVyZSBub24tdGVtcG9y YWwgc3RvcmVzIG1heSBqdXN0IGRpcnR5IGNhY2hlLA0KQVJDSF9IQVNfUE1FTV9BUEkgaXMgc2lt cGx5IGRpc2FibGVkLg0KDQpUaGUgZGVmYXVsdCBmYWxsIGJhY2sgZm9yIHBlcnNpc3RlbnQgbWVt b3J5IGhhbmRsaW5nIHJlbWFpbnMuICBOYW1lbHksDQptYXAgaXQgd2l0aCB0aGUgV1QgKHdyaXRl LXRocm91Z2gpIGNhY2hlLXR5cGUgYW5kIGhvcGUgZm9yIHRoZSBiZXN0Lg0KDQphcmNoX2hhc19w bWVtX2FwaSgpIGlzIHVwZGF0ZWQgdG8gb25seSBpbmRpY2F0ZSB3aGV0aGVyIHRoZSBhcmNoDQpw cm92aWRlcyB0aGUgcHJvcGVyIGhlbHBlcnMgdG8gbWVldCB0aGUgbWluaW11bSAid3JpdGVzIGFy ZSB2aXNpYmxlDQpvdXRzaWRlIHRoZSBjYWNoZSBoaWVyYXJjaHkgYWZ0ZXIgbWVtY3B5X3RvX3Bt ZW0oKSArIHdtYl9wbWVtKCkiLiAgQ29kZQ0KdGhhdCBjYXJlcyB3aGV0aGVyIHdtYl9wbWVtKCkg YWN0dWFsbHkgZmx1c2hlcyB3cml0ZXMgdG8gcG1lbSBtdXN0IG5vdw0KY2FsbCBhcmNoX2hhc193 bWJfcG1lbSgpIGRpcmVjdGx5Lg0KDQpDYzogVGhvbWFzIEdsZWl4bmVyIDx0Z2x4QGxpbnV0cm9u aXguZGU+DQpDYzogSW5nbyBNb2xuYXIgPG1pbmdvQHJlZGhhdC5jb20+DQpDYzogIkguIFBldGVy IEFudmluIiA8aHBhQHp5dG9yLmNvbT4NClJldmlld2VkLWJ5OiBSb3NzIFp3aXNsZXIgPHJvc3Mu endpc2xlckBsaW51eC5pbnRlbC5jb20+DQpbaGNoOiBzZXQgQVJDSF9IQVNfUE1FTV9BUEk9biBv biB4ODZfMzJdDQpSZXZpZXdlZC1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+DQpb dG9zaGk6IHg4Nl8zMiBjb21waWxlIGZpeGVzXQ0KU2lnbmVkLW9mZi1ieTogVG9zaGkgS2FuaSA8 dG9zaGkua2FuaUBocC5jb20+DQpTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndp bGxpYW1zQGludGVsLmNvbT4NCi0tLQ0KIGFyY2gveDg2L0tjb25maWcgICAgICAgICAgICB8ICAg IDIgKy0NCiBhcmNoL3g4Ni9pbmNsdWRlL2FzbS9wbWVtLmggfCAgICA5ICstLS0tLS0tLQ0KIGRy aXZlcnMvYWNwaS9uZml0LmMgICAgICAgICB8ICAgIDMgKystDQogZHJpdmVycy9udmRpbW0vcG1l bS5jICAgICAgIHwgICAgMiArLQ0KIGluY2x1ZGUvbGludXgvcG1lbS5oICAgICAgICB8ICAgMzYg KysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tDQogNSBmaWxlcyBjaGFuZ2VkLCAy NyBpbnNlcnRpb25zKCspLCAyNSBkZWxldGlvbnMoLSkNCg0KZGlmZiAtLWdpdCBhL2FyY2gveDg2 L0tjb25maWcgYi9hcmNoL3g4Ni9LY29uZmlnDQppbmRleCAwM2FiNjEyMjMyNWEuLmVmNGM2YmJi M2FmMSAxMDA2NDQNCi0tLSBhL2FyY2gveDg2L0tjb25maWcNCisrKyBiL2FyY2gveDg2L0tjb25m aWcNCkBAIC0yNyw3ICsyNyw3IEBAIGNvbmZpZyBYODYNCiAJc2VsZWN0IEFSQ0hfSEFTX0VMRl9S QU5ET01JWkUNCiAJc2VsZWN0IEFSQ0hfSEFTX0ZBU1RfTVVMVElQTElFUg0KIAlzZWxlY3QgQVJD SF9IQVNfR0NPVl9QUk9GSUxFX0FMTA0KLQlzZWxlY3QgQVJDSF9IQVNfUE1FTV9BUEkNCisJc2Vs ZWN0IEFSQ0hfSEFTX1BNRU1fQVBJCQlpZiBYODZfNjQNCiAJc2VsZWN0IEFSQ0hfSEFTX01NSU9f RkxVU0gNCiAJc2VsZWN0IEFSQ0hfSEFTX1NHX0NIQUlODQogCXNlbGVjdCBBUkNIX0hBVkVfTk1J X1NBRkVfQ01QWENIRw0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BtZW0uaCBi L2FyY2gveDg2L2luY2x1ZGUvYXNtL3BtZW0uaA0KaW5kZXggYmIwMjZjNWFkZjhhLi5kOGNlM2Vj ODE2YWIgMTAwNjQ0DQotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wbWVtLmgNCisrKyBiL2Fy Y2gveDg2L2luY2x1ZGUvYXNtL3BtZW0uaA0KQEAgLTE4LDggKzE4LDYgQEANCiAjaW5jbHVkZSA8 YXNtL2NwdWZlYXR1cmUuaD4NCiAjaW5jbHVkZSA8YXNtL3NwZWNpYWxfaW5zbnMuaD4NCiANCi0j ZGVmaW5lIEFSQ0hfTUVNUkVNQVBfUE1FTSBNRU1SRU1BUF9XQg0KLQ0KICNpZmRlZiBDT05GSUdf QVJDSF9IQVNfUE1FTV9BUEkNCiAvKioNCiAgKiBhcmNoX21lbWNweV90b19wbWVtIC0gY29weSBk YXRhIHRvIHBlcnNpc3RlbnQgbWVtb3J5DQpAQCAtMTQzLDE4ICsxNDEsMTMgQEAgc3RhdGljIGlu bGluZSB2b2lkIGFyY2hfY2xlYXJfcG1lbSh2b2lkIF9fcG1lbSAqYWRkciwgc2l6ZV90IHNpemUp DQogCV9fYXJjaF93Yl9jYWNoZV9wbWVtKHZhZGRyLCBzaXplKTsNCiB9DQogDQotc3RhdGljIGlu bGluZSBib29sIGFyY2hfaGFzX3dtYl9wbWVtKHZvaWQpDQorc3RhdGljIGlubGluZSBib29sIF9f YXJjaF9oYXNfd21iX3BtZW0odm9pZCkNCiB7DQotI2lmZGVmIENPTkZJR19YODZfNjQNCiAJLyoN CiAJICogV2UgcmVxdWlyZSB0aGF0IHdtYigpIGJlIGFuICdzZmVuY2UnLCB0aGF0IGlzIG9ubHkg Z3VhcmFudGVlZCBvbg0KIAkgKiA2NC1iaXQgYnVpbGRzDQogCSAqLw0KIAlyZXR1cm4gc3RhdGlj X2NwdV9oYXMoWDg2X0ZFQVRVUkVfUENPTU1JVCk7DQotI2Vsc2UNCi0JcmV0dXJuIGZhbHNlOw0K LSNlbmRpZg0KIH0NCiAjZW5kaWYgLyogQ09ORklHX0FSQ0hfSEFTX1BNRU1fQVBJICovDQotDQog I2VuZGlmIC8qIF9fQVNNX1g4Nl9QTUVNX0hfXyAqLw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYWNw aS9uZml0LmMgYi9kcml2ZXJzL2FjcGkvbmZpdC5jDQppbmRleCA1NmZmZjAxNDE2MzYuLmY2MWU2 OWZhMmFkMSAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvYWNwaS9uZml0LmMNCisrKyBiL2RyaXZlcnMv YWNwaS9uZml0LmMNCkBAIC0yMCw2ICsyMCw3IEBADQogI2luY2x1ZGUgPGxpbnV4L3NvcnQuaD4N CiAjaW5jbHVkZSA8bGludXgvcG1lbS5oPg0KICNpbmNsdWRlIDxsaW51eC9pby5oPg0KKyNpbmNs dWRlIDxhc20vY2FjaGVmbHVzaC5oPg0KICNpbmNsdWRlICJuZml0LmgiDQogDQogLyoNCkBAIC0x MzcxLDcgKzEzNzIsNyBAQCBzdGF0aWMgaW50IGFjcGlfbmZpdF9ibGtfcmVnaW9uX2VuYWJsZShz dHJ1Y3QgbnZkaW1tX2J1cyAqbnZkaW1tX2J1cywNCiAJCQlyZXR1cm4gLUVOT01FTTsNCiAJfQ0K IA0KLQlpZiAoIWFyY2hfaGFzX3BtZW1fYXBpKCkgJiYgIW5maXRfYmxrLT5udmRpbW1fZmx1c2gp DQorCWlmICghYXJjaF9oYXNfd21iX3BtZW0oKSAmJiAhbmZpdF9ibGstPm52ZGltbV9mbHVzaCkN CiAJCWRldl93YXJuKGRldiwgInVuYWJsZSB0byBndWFyYW50ZWUgcGVyc2lzdGVuY2Ugb2Ygd3Jp dGVzXG4iKTsNCiANCiAJaWYgKG1taW8tPmxpbmVfc2l6ZSA9PSAwKQ0KZGlmZiAtLWdpdCBhL2Ry aXZlcnMvbnZkaW1tL3BtZW0uYyBiL2RyaXZlcnMvbnZkaW1tL3BtZW0uYw0KaW5kZXggM2I1Yjlj Yjc1OGI2Li4yMGJmMTIyMzI4ZGEgMTAwNjQ0DQotLS0gYS9kcml2ZXJzL252ZGltbS9wbWVtLmMN CisrKyBiL2RyaXZlcnMvbnZkaW1tL3BtZW0uYw0KQEAgLTEyNSw3ICsxMjUsNyBAQCBzdGF0aWMg c3RydWN0IHBtZW1fZGV2aWNlICpwbWVtX2FsbG9jKHN0cnVjdCBkZXZpY2UgKmRldiwNCiANCiAJ cG1lbS0+cGh5c19hZGRyID0gcmVzLT5zdGFydDsNCiAJcG1lbS0+c2l6ZSA9IHJlc291cmNlX3Np emUocmVzKTsNCi0JaWYgKCFhcmNoX2hhc19wbWVtX2FwaSgpKQ0KKwlpZiAoIWFyY2hfaGFzX3dt Yl9wbWVtKCkpDQogCQlkZXZfd2FybihkZXYsICJ1bmFibGUgdG8gZ3VhcmFudGVlIHBlcnNpc3Rl bmNlIG9mIHdyaXRlc1xuIik7DQogDQogCWlmICghZGV2bV9yZXF1ZXN0X21lbV9yZWdpb24oZGV2 LCBwbWVtLT5waHlzX2FkZHIsIHBtZW0tPnNpemUsDQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9wbWVtLmggYi9pbmNsdWRlL2xpbnV4L3BtZW0uaA0KaW5kZXggYTlkODRiZjMzNWVlLi44NWY4 MTBiMzM5MTcgMTAwNjQ0DQotLS0gYS9pbmNsdWRlL2xpbnV4L3BtZW0uaA0KKysrIGIvaW5jbHVk ZS9saW51eC9wbWVtLmgNCkBAIC0xNywxNiArMTcsMjMgQEANCiAjaW5jbHVkZSA8bGludXgvdWlv Lmg+DQogDQogI2lmZGVmIENPTkZJR19BUkNIX0hBU19QTUVNX0FQSQ0KKyNkZWZpbmUgQVJDSF9N RU1SRU1BUF9QTUVNIE1FTVJFTUFQX1dCDQogI2luY2x1ZGUgPGFzbS9wbWVtLmg+DQogI2Vsc2UN Ci1zdGF0aWMgaW5saW5lIHZvaWQgYXJjaF93bWJfcG1lbSh2b2lkKQ0KKyNkZWZpbmUgQVJDSF9N RU1SRU1BUF9QTUVNIE1FTVJFTUFQX1dUDQorLyoNCisgKiBUaGVzZSBhcmUgc2ltcGx5IGhlcmUg dG8gZW5hYmxlIGNvbXBpbGF0aW9uLCBhbGwgY2FsbCBzaXRlcyBnYXRlDQorICogY2FsbGluZyB0 aGVzZSBzeW1ib2xzIHdpdGggYXJjaF9oYXNfcG1lbV9hcGkoKSBhbmQgcmVkaXJlY3QgdG8gdGhl DQorICogaW1wbGVtZW50YXRpb24gaW4gYXNtL3BtZW0uaC4NCisgKi8NCitzdGF0aWMgaW5saW5l IGJvb2wgX19hcmNoX2hhc193bWJfcG1lbSh2b2lkKQ0KIHsNCi0JQlVHKCk7DQorCXJldHVybiBm YWxzZTsNCiB9DQogDQotc3RhdGljIGlubGluZSBib29sIGFyY2hfaGFzX3dtYl9wbWVtKHZvaWQp DQorc3RhdGljIGlubGluZSB2b2lkIGFyY2hfd21iX3BtZW0odm9pZCkNCiB7DQotCXJldHVybiBm YWxzZTsNCisJQlVHKCk7DQogfQ0KIA0KIHN0YXRpYyBpbmxpbmUgdm9pZCBhcmNoX21lbWNweV90 b19wbWVtKHZvaWQgX19wbWVtICpkc3QsIGNvbnN0IHZvaWQgKnNyYywNCkBAIC01Myw3ICs2MCw2 IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBhcmNoX2NsZWFyX3BtZW0odm9pZCBfX3BtZW0gKmFkZHIs IHNpemVfdCBzaXplKQ0KICAqIGltcGxlbWVudGF0aW9ucyBmb3IgYXJjaF9tZW1jcHlfdG9fcG1l bSgpLCBhcmNoX3dtYl9wbWVtKCksDQogICogYXJjaF9jb3B5X2Zyb21faXRlcl9wbWVtKCksIGFy Y2hfY2xlYXJfcG1lbSgpIGFuZCBhcmNoX2hhc193bWJfcG1lbSgpLg0KICAqLw0KLQ0KIHN0YXRp YyBpbmxpbmUgdm9pZCBtZW1jcHlfZnJvbV9wbWVtKHZvaWQgKmRzdCwgdm9pZCBfX3BtZW0gY29u c3QgKnNyYywgc2l6ZV90IHNpemUpDQogew0KIAltZW1jcHkoZHN0LCAodm9pZCBfX2ZvcmNlIGNv bnN0ICopIHNyYywgc2l6ZSk7DQpAQCAtNjQsOCArNzAsMTMgQEAgc3RhdGljIGlubGluZSB2b2lk IG1lbXVubWFwX3BtZW0oc3RydWN0IGRldmljZSAqZGV2LCB2b2lkIF9fcG1lbSAqYWRkcikNCiAJ ZGV2bV9tZW11bm1hcChkZXYsICh2b2lkIF9fZm9yY2UgKikgYWRkcik7DQogfQ0KIA0KK3N0YXRp YyBpbmxpbmUgYm9vbCBhcmNoX2hhc19wbWVtX2FwaSh2b2lkKQ0KK3sNCisJcmV0dXJuIElTX0VO QUJMRUQoQ09ORklHX0FSQ0hfSEFTX1BNRU1fQVBJKTsNCit9DQorDQogLyoqDQotICogYXJjaF9o YXNfcG1lbV9hcGkgLSB0cnVlIGlmIHdtYl9wbWVtKCkgZW5zdXJlcyBkdXJhYmlsaXR5DQorICog YXJjaF9oYXNfd21iX3BtZW0gLSB0cnVlIGlmIHdtYl9wbWVtKCkgZW5zdXJlcyBkdXJhYmlsaXR5 DQogICoNCiAgKiBGb3IgYSBnaXZlbiBjcHUgaW1wbGVtZW50YXRpb24gd2l0aGluIGFuIGFyY2hp dGVjdHVyZSBpdCBpcyBwb3NzaWJsZQ0KICAqIHRoYXQgd21iX3BtZW0oKSByZXNvbHZlcyB0byBh IG5vcC4gIEluIHRoZSBjYXNlIHRoaXMgcmV0dXJucw0KQEAgLTczLDkgKzg0LDkgQEAgc3RhdGlj IGlubGluZSB2b2lkIG1lbXVubWFwX3BtZW0oc3RydWN0IGRldmljZSAqZGV2LCB2b2lkIF9fcG1l bSAqYWRkcikNCiAgKiBmYWxsIGJhY2sgdG8gYSBkaWZmZXJlbnQgZGF0YSBjb25zaXN0ZW5jeSBt b2RlbCwgb3Igb3RoZXJ3aXNlIG5vdGlmeQ0KICAqIHRoZSB1c2VyLg0KICAqLw0KLXN0YXRpYyBp bmxpbmUgYm9vbCBhcmNoX2hhc19wbWVtX2FwaSh2b2lkKQ0KK3N0YXRpYyBpbmxpbmUgYm9vbCBh cmNoX2hhc193bWJfcG1lbSh2b2lkKQ0KIHsNCi0JcmV0dXJuIElTX0VOQUJMRUQoQ09ORklHX0FS Q0hfSEFTX1BNRU1fQVBJKSAmJiBhcmNoX2hhc193bWJfcG1lbSgpOw0KKwlyZXR1cm4gYXJjaF9o YXNfcG1lbV9hcGkoKSAmJiBfX2FyY2hfaGFzX3dtYl9wbWVtKCk7DQogfQ0KIA0KIC8qDQpAQCAt MTIwLDEzICsxMzEsOCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZGVmYXVsdF9jbGVhcl9wbWVtKHZv aWQgX19wbWVtICphZGRyLCBzaXplX3Qgc2l6ZSkNCiBzdGF0aWMgaW5saW5lIHZvaWQgX19wbWVt ICptZW1yZW1hcF9wbWVtKHN0cnVjdCBkZXZpY2UgKmRldiwNCiAJCXJlc291cmNlX3NpemVfdCBv ZmZzZXQsIHVuc2lnbmVkIGxvbmcgc2l6ZSkNCiB7DQotI2lmZGVmIEFSQ0hfTUVNUkVNQVBfUE1F TQ0KIAlyZXR1cm4gKHZvaWQgX19wbWVtICopIGRldm1fbWVtcmVtYXAoZGV2LCBvZmZzZXQsIHNp emUsDQogCQkJQVJDSF9NRU1SRU1BUF9QTUVNKTsNCi0jZWxzZQ0KLQlyZXR1cm4gKHZvaWQgX19w bWVtICopIGRldm1fbWVtcmVtYXAoZGV2LCBvZmZzZXQsIHNpemUsDQotCQkJTUVNUkVNQVBfV1Qp Ow0KLSNlbmRpZg0KIH0NCiANCiAvKioNCkBAIC0xNTgsOCArMTY0LDEwIEBAIHN0YXRpYyBpbmxp bmUgdm9pZCBtZW1jcHlfdG9fcG1lbSh2b2lkIF9fcG1lbSAqZHN0LCBjb25zdCB2b2lkICpzcmMs IHNpemVfdCBuKQ0KICAqLw0KIHN0YXRpYyBpbmxpbmUgdm9pZCB3bWJfcG1lbSh2b2lkKQ0KIHsN Ci0JaWYgKGFyY2hfaGFzX3BtZW1fYXBpKCkpDQorCWlmIChhcmNoX2hhc193bWJfcG1lbSgpKQ0K IAkJYXJjaF93bWJfcG1lbSgpOw0KKwllbHNlDQorCQl3bWIoKTsNCiB9DQogDQogLyoqDQoNCg== -- 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 S1752044AbbH2EFJ (ORCPT ); Sat, 29 Aug 2015 00:05:09 -0400 Received: from mga03.intel.com ([134.134.136.65]:39497 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751703AbbH2EFH (ORCPT ); Sat, 29 Aug 2015 00:05:07 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.17,429,1437462000"; d="scan'208";a="777928467" From: "Williams, Dan J" To: "toshi.kani@hp.com" CC: "linux-kernel@vger.kernel.org" , "mingo@kernel.org" , "linux-mm@kvack.org" , "tglx@linutronix.de" , "hch@lst.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: AQHQ3585kOnBxM54REqrdIbgxDkOk54eryMAgACU5YCAAyakAIAAAaYAgAAAUQCAAGkzgA== Date: Sat, 29 Aug 2015 04:04:58 +0000 Message-ID: <1440821097.32027.2.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> <1440624859.31365.17.camel@intel.com> <1440798084.14237.106.camel@hp.com> <1440798506.14237.107.camel@hp.com> In-Reply-To: <1440798506.14237.107.camel@hp.com> Accept-Language: en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [10.22.254.140] Content-Type: text/plain; charset="utf-8" Content-ID: <6CFD6EBACCB8CF4D8609EFFF43D04829@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 t7T45VVE009900 On Fri, 2015-08-28 at 15:48 -0600, Toshi Kani wrote: > On Fri, 2015-08-28 at 14:47 -0700, Dan Williams wrote: > > On Fri, Aug 28, 2015 at 2:41 PM, Toshi Kani wrote: > > > On Wed, 2015-08-26 at 21:34 +0000, Williams, Dan J wrote: > > [..] > > > > -#define ARCH_MEMREMAP_PMEM MEMREMAP_WB > > > > > > Should it be better to do: > > > > > > #else /* !CONFIG_ARCH_HAS_PMEM_API */ > > > #define ARCH_MEMREMAP_PMEM MEMREMAP_WT > > > > > > so that you can remove all '#ifdef ARCH_MEMREMAP_PMEM' stuff? > > > > Yeah, that seems like a nice incremental cleanup for memremap_pmem() > > to just unconditionally use ARCH_MEMREMAP_PMEM, feel free to send it > > along. > > OK. Will do. > Here's the re-worked patch with Toshi's fixes folded in: 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" Reviewed-by: Ross Zwisler [hch: set ARCH_HAS_PMEM_API=n on x86_32] Reviewed-by: Christoph Hellwig [toshi: x86_32 compile fixes] Signed-off-by: Toshi Kani Signed-off-by: Dan Williams --- arch/x86/Kconfig | 2 +- arch/x86/include/asm/pmem.h | 9 +-------- drivers/acpi/nfit.c | 3 ++- drivers/nvdimm/pmem.c | 2 +- include/linux/pmem.h | 36 ++++++++++++++++++++++-------------- 5 files changed, 27 insertions(+), 25 deletions(-) diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 03ab6122325a..ef4c6bbb3af1 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_MMIO_FLUSH select ARCH_HAS_SG_CHAIN select ARCH_HAVE_NMI_SAFE_CMPXCHG diff --git a/arch/x86/include/asm/pmem.h b/arch/x86/include/asm/pmem.h index bb026c5adf8a..d8ce3ec816ab 100644 --- a/arch/x86/include/asm/pmem.h +++ b/arch/x86/include/asm/pmem.h @@ -18,8 +18,6 @@ #include #include -#define ARCH_MEMREMAP_PMEM MEMREMAP_WB - #ifdef CONFIG_ARCH_HAS_PMEM_API /** * arch_memcpy_to_pmem - copy data to persistent memory @@ -143,18 +141,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 56fff0141636..f61e69fa2ad1 100644 --- a/drivers/acpi/nfit.c +++ b/drivers/acpi/nfit.c @@ -20,6 +20,7 @@ #include #include #include +#include #include "nfit.h" /* @@ -1371,7 +1372,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..85f810b33917 100644 --- a/include/linux/pmem.h +++ b/include/linux/pmem.h @@ -17,16 +17,23 @@ #include #ifdef CONFIG_ARCH_HAS_PMEM_API +#define ARCH_MEMREMAP_PMEM MEMREMAP_WB #include #else -static inline void arch_wmb_pmem(void) +#define ARCH_MEMREMAP_PMEM MEMREMAP_WT +/* + * 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) { - BUG(); + return false; } -static inline bool arch_has_wmb_pmem(void) +static inline void arch_wmb_pmem(void) { - return false; + BUG(); } static inline void arch_memcpy_to_pmem(void __pmem *dst, const void *src, @@ -53,7 +60,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 +70,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 +84,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(); } /* @@ -120,13 +131,8 @@ static inline void default_clear_pmem(void __pmem *addr, size_t size) static inline void __pmem *memremap_pmem(struct device *dev, resource_size_t offset, unsigned long size) { -#ifdef ARCH_MEMREMAP_PMEM return (void __pmem *) devm_memremap(dev, offset, size, ARCH_MEMREMAP_PMEM); -#else - return (void __pmem *) devm_memremap(dev, offset, size, - MEMREMAP_WT); -#endif } /** @@ -158,8 +164,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