From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Williams, Dan J" Subject: [GIT PULL] libnvdimm for 4.3 Date: Fri, 4 Sep 2015 00:21:59 +0000 Message-ID: <1441326118.24518.6.camel@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga02.intel.com ([134.134.136.20]:17738 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753316AbbIDAWC (ORCPT ); Thu, 3 Sep 2015 20:22:02 -0400 Content-Language: en-US Content-ID: <1B08A7551D56E44FA601B442CAFD7102@intel.com> Sender: linux-acpi-owner@vger.kernel.org List-Id: linux-acpi@vger.kernel.org To: "torvalds@linux-foundation.org" , "akpm@linux-foundation.org" Cc: "hch@lst.de" , "linux-kernel@vger.kernel.org" , "linux-nvdimm@lists.01.org" , "toshi.kani@hp.com" , "ross.zwisler@linux.intel.com" , "linux-acpi@vger.kernel.org" , "boaz@plexistor.com" SGkgTGludXMsIHBsZWFzZSBwdWxsIGZyb206DQoNCiAgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHVi L3NjbS9saW51eC9rZXJuZWwvZ2l0L252ZGltbS9udmRpbW0gdGFncy9saWJudmRpbW0tZm9yLTQu Mw0KDQouLi50byByZWNlaXZlIHRoZSBsaWJudmRpbW0gdXBkYXRlIGFuZCByZWxhdGVkIGNoYW5n ZXMgZm9yIDQuMy4NCg0KVGhpcyB1cGRhdGUgaGFzIHN1Y2Nlc3NmdWxseSBjb21wbGV0ZWQgYSAw ZGF5LWtidWlsZCBydW4gYW5kIGhhcw0KYXBwZWFyZWQgaW4gYSBsaW51eC1uZXh0IHJlbGVhc2Uu ICBUaGUgY2hhbmdlcyBvdXRzaWRlIG9mIHRoZSB0eXBpY2FsDQpkcml2ZXJzL252ZGltbS8gYW5k IGRyaXZlcnMvYWNwaS9uZml0LltjaF0gcGF0aHMgYXJlIHJlbGF0ZWQgdG8gdGhlDQpyZW1vdmFs IG9mIElPUkVTT1VSQ0VfQ0FDSEVBQkxFLCB0aGUgaW50cm9kdWN0aW9uIG9mIG1lbXJlbWFwKCks IGFuZCB0aGUNCmludHJvZHVjdGlvbiBvZiBaT05FX0RFVklDRSArIGRldm1fbWVtcmVtYXBfcGFn ZXMoKS4NCg0KVGhpcyBoYXMgYSBtaW5vciBjb25mbGljdCB3aXRoIGEgZml4IHRoYXQgd2VudCBp bnRvIHY0LjIsIGNvbW1pdA0KZGU0YTE5NmMwMmEyICJuZml0LCBuZF9ibGs6IEJMSyBzdGF0dXMg cmVnaXN0ZXIgaXMgb25seSAzMiBiaXRzIiwgYnV0DQpvdGhlcndpc2UgbWVyZ2VzIGNsZWFubHkg d2l0aCBtYWlubGluZS4NCg0KLS0NCg0KVGhlIGZvbGxvd2luZyBjaGFuZ2VzIHNpbmNlIGNvbW1p dCBjYmZlOGZhNmNkNjcyMDExYzc1NWMzY2Q4NWM5ZmZkNGUyZDEwYTZmOg0KDQogIExpbnV4IDQu Mi1yYzQgKDIwMTUtMDctMjYgMTI6MjY6MjEgLTA3MDApDQoNCmFyZSBhdmFpbGFibGUgaW4gdGhl IGdpdCByZXBvc2l0b3J5IGF0Og0KDQogIGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9zY20vbGlu dXgva2VybmVsL2dpdC9udmRpbW0vbnZkaW1tIHRhZ3MvbGlibnZkaW1tLWZvci00LjMNCg0KZm9y IHlvdSB0byBmZXRjaCBjaGFuZ2VzIHVwIHRvIDAwNGYxYWZiZTE5OWU2YWIyMDgwNWI5NWFlZmQ4 M2NjZDI0YmM1Yzc6DQoNCiAgbGlibnZkaW1tLCBwbWVtOiBkaXJlY3QgbWFwIGxlZ2FjeSBwbWVt IGJ5IGRlZmF1bHQgKDIwMTUtMDgtMjggMjM6NDA6MDUgLTA0MDApDQoNCi0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0NCmxpYm52 ZGltbSBmb3IgNC4zOg0KDQoxLyBJbnRyb2R1Y2UgWk9ORV9ERVZJQ0UgYW5kIGRldm1fbWVtcmVt YXBfcGFnZXMoKSBhcyBhIGdlbmVyaWMNCiAgIG1lY2hhbmlzbSBmb3IgYWRkaW5nIGRldmljZS1k cml2ZXItZGlzY292ZXJlZCBtZW1vcnkgcmVnaW9ucyB0byB0aGUNCiAgIGtlcm5lbCdzIGRpcmVj dCBtYXAuICBUaGlzIGZhY2lsaXR5IGlzIHVzZWQgYnkgdGhlIHBtZW0gZHJpdmVyIHRvDQogICBl bmFibGUgcGZuX3RvX3BhZ2UoKSBvcGVyYXRpb25zIG9uIHRoZSBwYWdlIGZyYW1lcyByZXR1cm5l ZCBieSBEQVgNCiAgICgnZGlyZWN0X2FjY2VzcycgaW4gJ3N0cnVjdCBibG9ja19kZXZpY2Vfb3Bl cmF0aW9ucycpLiBGb3Igbm93LCB0aGUNCiAgICdtZW1tYXAnIGFsbG9jYXRpb24gZm9yIHRoZXNl ICJkZXZpY2UiIHBhZ2VzIGNvbWVzIGZyb20gIlN5c3RlbQ0KICAgUkFNIi4gIFN1cHBvcnQgZm9y IGFsbG9jYXRpbmcgdGhlIG1lbW1hcCBmcm9tIGRldmljZSBtZW1vcnkgd2lsbA0KICAgYXJyaXZl IGluIGEgbGF0ZXIga2VybmVsLg0KDQoyLyBJbnRyb2R1Y2UgbWVtcmVtYXAoKSB0byByZXBsYWNl IHVzYWdlcyBvZiBpb3JlbWFwX2NhY2hlKCkgYW5kDQogICBpb3JlbWFwX3d0KCkuICBtZW1yZW1h cCgpIGRyb3BzIHRoZSBfX2lvbWVtIGFubm90YXRpb24gZm9yIHRoZXNlDQogICBtYXBwaW5ncyB0 byBtZW1vcnkgdGhhdCBkbyBub3QgaGF2ZSBpL28gc2lkZSBlZmZlY3RzLiAgVGhlDQogICByZXBs YWNlbWVudCBvZiBpb3JlbWFwX2NhY2hlKCkgd2l0aCBtZW1yZW1hcCgpIGlzIGxpbWl0ZWQgdG8g dGhlDQogICBwbWVtIGRyaXZlciB0byBlYXNlIG1lcmdpbmcgdGhlIGFwaSBjaGFuZ2UgaW4gdjQu My4gIENvbXBsZXRpb24gb2YNCiAgIHRoZSBjb252ZXJzaW9uIGlzIHRhcmdldGVkIGZvciB2NC40 Lg0KDQozLyBTaW1pbGFyIHRvIHRoZSB1c2FnZSBvZiBtZW1jcHlfdG9fcG1lbSgpICsgd21iX3Bt ZW0oKSBpbiB0aGUgcG1lbQ0KICAgZHJpdmVyLCB1cGRhdGUgdGhlIFZGUyBEQVggaW1wbGVtZW50 YXRpb24gYW5kIFBNRU0gYXBpIHRvIHByb3ZpZGUNCiAgIHBlcnNpc3RlbmNlIGd1YXJhbnRlZXMg Zm9yIGtlcm5lbCBvcGVyYXRpb25zIG9uIGEgREFYIG1hcHBpbmcuDQoNCjQvIENvbnZlcnQgdGhl IEFDUEkgTkZJVCAnQkxLJyBkcml2ZXIgdG8gbWFwIHRoZSBibG9jayBhcGVydHVyZXMgYXMNCiAg IGNhY2hlYWJsZSB0byBpbXByb3ZlIHBlcmZvcm1hbmNlLg0KDQo1LyBNaXNjZWxsYW5lb3VzIHVw ZGF0ZXMgYW5kIGZpeGVzIHRvIGxpYm52ZGltbSBpbmNsdWRpbmcgc3VwcG9ydA0KICAgZm9yIGlz c3VpbmcgImFkZHJlc3MgcmFuZ2Ugc2NydWIiIGNvbW1hbmRzLCBjbGFyaWZ5aW5nIHRoZSBvcHRp bWFsDQogICAnc2VjdG9yIHNpemUnIG9mIHBtZW0gZGV2aWNlcywgYSBjbGFyaWZpY2F0aW9uIG9m IHRoZSB1c2FnZSBvZiB0aGUNCiAgIEFDUEkgJ19TVEEnIChzdGF0dXMpIHByb3BlcnR5IGZvciBE SU1NIGRldmljZXMsIGFuZCBvdGhlciBtaW5vcg0KICAgZml4ZXMuDQoNCi0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0NCkNocmlz dG9waCBIZWxsd2lnICg0KToNCiAgICAgIGRldnJlczogYWRkIGRldm1fbWVtcmVtYXANCiAgICAg IHBtZW06IHN3aXRjaCB0byBkZXZtXyBhbGxvY2F0aW9ucw0KICAgICAgbW06IG1vdmUgX19waHlz X3RvX3BmbiBhbmQgX19wZm5fdG9fcGh5cyB0byBhc20vZ2VuZXJpYy9tZW1vcnlfbW9kZWwuaA0K ICAgICAgYWRkIGRldm1fbWVtcmVtYXBfcGFnZXMNCg0KRGFuIFdpbGxpYW1zICgxNSk6DQogICAg ICBsaWJudmRpbW0sIGJ0dDogc3BhcnNlIGZpeA0KICAgICAgbW06IGVuaGFuY2UgcmVnaW9uX2lz X3JhbSgpIHRvIHJlZ2lvbl9pbnRlcnNlY3RzKCkNCiAgICAgIGFyY2gsIGRyaXZlcnM6IGRvbid0 IGluY2x1ZGUgPGFzbS9pby5oPiBkaXJlY3RseSwgdXNlIDxsaW51eC9pby5oPiBpbnN0ZWFkDQog ICAgICBjbGVhbnVwIElPUkVTT1VSQ0VfQ0FDSEVBQkxFIHZzIGlvcmVtYXAoKQ0KICAgICAgYXJj aDogaW50cm9kdWNlIG1lbXJlbWFwKCkNCiAgICAgIHZpc29yYnVzOiBzd2l0Y2ggZnJvbSBpb3Jl bWFwX2NhY2hlIHRvIG1lbXJlbWFwDQogICAgICBwbWVtOiBjb252ZXJ0IHRvIGdlbmVyaWMgbWVt cmVtYXANCiAgICAgIGxpYm52ZGltbSwgZTgyMDogbWFrZSBDT05GSUdfWDg2X1BNRU1fTEVHQUNZ IGEgdHJpc3RhdGUgb3B0aW9uDQogICAgICBNZXJnZSBicmFuY2ggJ3BtZW0tYXBpJyBpbnRvIGxp Ym52ZGltbS1mb3ItbmV4dA0KICAgICAgZGF4OiBkcm9wIHNpemUgcGFyYW1ldGVyIHRvIC0+ZGly ZWN0X2FjY2VzcygpDQogICAgICBtbTogWk9ORV9ERVZJQ0UgZm9yICJkZXZpY2UgbWVtb3J5Ig0K ICAgICAgeDg2LCBwbWVtOiBjbGFyaWZ5IHRoYXQgQVJDSF9IQVNfUE1FTV9BUEkgaW1wbGllcyBQ TUVNIG1hcHBlZCBXQg0KICAgICAgbGlibnZkaW1tLCBwZm46ICdzdHJ1Y3QgcGFnZScgcHJvdmlk ZXIgaW5mcmFzdHJ1Y3R1cmUNCiAgICAgIGxpYm52ZGltbSwgcG1lbTogJ3N0cnVjdCBwYWdlJyBm b3IgcG1lbQ0KICAgICAgbGlibnZkaW1tLCBwbWVtOiBkaXJlY3QgbWFwIGxlZ2FjeSBwbWVtIGJ5 IGRlZmF1bHQNCg0KTGluZGEgS25pcHBlcnMgKDEpOg0KICAgICAgbmZpdDogRG9uJ3QgY2hlY2sg X1NUQSBvbiBOVkRJTU0gZGV2aWNlcw0KDQpSYW5keSBEdW5sYXAgKDEpOg0KICAgICAgbnZkaW1t OiBmaXggaW5saW5lIGZ1bmN0aW9uIHJldHVybiB0eXBlIHdhcm5pbmcNCg0KUm9zcyBad2lzbGVy ICg3KToNCiAgICAgIHBtZW0sIHg4NjogbW92ZSB4ODYgUE1FTSBBUEkgdG8gbmV3IHBtZW0uaCBo ZWFkZXINCiAgICAgIHBtZW06IHJlbW92ZSBsYXllciB3aGVuIGNhbGxpbmcgYXJjaF9oYXNfd21i X3BtZW0oKQ0KICAgICAgcG1lbSwgeDg2OiBjbGVhbiB1cCBjb25kaXRpb25hbCBwbWVtIGluY2x1 ZGVzDQogICAgICBwbWVtOiBhZGQgY29weV9mcm9tX2l0ZXJfcG1lbSgpIGFuZCBjbGVhcl9wbWVt KCkNCiAgICAgIGRheDogdXBkYXRlIEkvTyBwYXRoIHRvIGRvIHByb3BlciBQTUVNIGZsdXNoaW5n DQogICAgICBwbWVtLCBkYXg6IGhhdmUgZGlyZWN0X2FjY2VzcyB1c2UgX19wbWVtIGFubm90YXRp b24NCiAgICAgIG5kX2JsazogY2hhbmdlIGFwZXJ0dXJlIG1hcHBpbmcgZnJvbSBXQyB0byBXQg0K DQpWaXNoYWwgVmVybWEgKDYpOg0KICAgICAgbGlibnZkaW1tOiBVcGRhdGUgbmFtZSBvZiB0aGUg YXJzX3N0YXR1c19yZWNvcmQgbWFzayBmaWVsZA0KICAgICAgbGlibnZkaW1tOiBBZGQgRFNNIHN1 cHBvcnQgZm9yIEFkZHJlc3MgUmFuZ2UgU2NydWIgY29tbWFuZHMNCiAgICAgIGxpYm52ZGltbSwg cG1lbTogQ2hhbmdlIHBtZW0gcGh5c2ljYWwgc2VjdG9yIHNpemUgdG8gUEFHRV9TSVpFDQogICAg ICBsaWJudmRpbW0sIGJ0dDogY2xlYW4gdXAgaW50ZXJuYWwgaW50ZXJmYWNlcw0KICAgICAgbGli bnZkaW1tLCBidHQ6IGNvbnNvbGlkYXRlIGFyZW5hIHZhbGlkYXRpb24NCiAgICAgIGxpYm52ZGlt bSwgYnR0OiB3cml0ZSBhbmQgdmFsaWRhdGUgcGFyZW50X3V1aWQNCg0KeWFsaW4gd2FuZyAoMSk6 DQogICAgICBudmRpbW06IGNoYW5nZSB0byB1c2UgZ2VuZXJpYyBrdmZyZWUoKQ0KDQogRG9jdW1l bnRhdGlvbi9maWxlc3lzdGVtcy9Mb2NraW5nICAgICAgICAgICAgICB8ICAgMyArLQ0KIE1BSU5U QUlORVJTICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKw0KIGFyY2gv YXJtL2luY2x1ZGUvYXNtL21lbW9yeS5oICAgICAgICAgICAgICAgICAgfCAgIDYgLQ0KIGFyY2gv YXJtL21hY2gtY2xwczcxMXgvYm9hcmQtY2RiODk3MTIuYyAgICAgICAgfCAgIDIgKy0NCiBhcmNo L2FybS9tYWNoLXNobW9iaWxlL3BtLXJjYXIuYyAgICAgICAgICAgICAgIHwgICAyICstDQogYXJj aC9hcm02NC9pbmNsdWRlL2FzbS9tZW1vcnkuaCAgICAgICAgICAgICAgICB8ICAgNiAtDQogYXJj aC9pYTY0L2luY2x1ZGUvYXNtL2lvLmggICAgICAgICAgICAgICAgICAgICB8ICAgMSArDQogYXJj aC9pYTY0L2tlcm5lbC9jeWNsb25lLmMgICAgICAgICAgICAgICAgICAgICB8ICAgMiArLQ0KIGFy Y2gvaWE2NC9tbS9pbml0LmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDQgKy0NCiBh cmNoL3Bvd2VycGMva2VybmVsL3BjaV9vZl9zY2FuLmMgICAgICAgICAgICAgIHwgICAyICstDQog YXJjaC9wb3dlcnBjL21tL21lbS5jICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgNCArLQ0K IGFyY2gvcG93ZXJwYy9zeXNkZXYvYXhvbnJhbS5jICAgICAgICAgICAgICAgICAgfCAgIDcgKy0N CiBhcmNoL3MzOTAvbW0vaW5pdC5jICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAyICst DQogYXJjaC9zaC9pbmNsdWRlL2FzbS9pby5oICAgICAgICAgICAgICAgICAgICAgICB8ICAgMSAr DQogYXJjaC9zaC9tbS9pbml0LmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgNSAr LQ0KIGFyY2gvc3BhcmMva2VybmVsL3BjaS5jICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDMg Ky0NCiBhcmNoL3RpbGUvbW0vaW5pdC5jICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAy ICstDQogYXJjaC91bmljb3JlMzIvaW5jbHVkZS9hc20vbWVtb3J5LmggICAgICAgICAgICB8ICAg NiAtDQogYXJjaC94ODYvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAg OSArLQ0KIGFyY2gveDg2L2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaCAgICAgICAgICAgICAgfCAg NzMgKy0tLS0tDQogYXJjaC94ODYvaW5jbHVkZS9hc20vaW8uaCAgICAgICAgICAgICAgICAgICAg ICB8ICAgNiAtDQogYXJjaC94ODYvaW5jbHVkZS9hc20vcG1lbS5oICAgICAgICAgICAgICAgICAg ICB8IDE1MyArKysrKysrKysrKw0KIGFyY2gveDg2L2luY2x1ZGUvdWFwaS9hc20vZTgyMC5oICAg ICAgICAgICAgICAgfCAgIDIgKy0NCiBhcmNoL3g4Ni9rZXJuZWwvTWFrZWZpbGUgICAgICAgICAg ICAgICAgICAgICAgIHwgICAyICstDQogYXJjaC94ODYva2VybmVsL3BtZW0uYyAgICAgICAgICAg ICAgICAgICAgICAgICB8ICA3OSArLS0tLS0NCiBhcmNoL3g4Ni9tbS9pbml0XzMyLmMgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICA0ICstDQogYXJjaC94ODYvbW0vaW5pdF82NC5jICAgICAg ICAgICAgICAgICAgICAgICAgICB8ICAgNCArLQ0KIGFyY2gveHRlbnNhL2luY2x1ZGUvYXNtL2lv LmggICAgICAgICAgICAgICAgICAgfCAgIDEgKw0KIGRyaXZlcnMvYWNwaS9LY29uZmlnICAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKw0KIGRyaXZlcnMvYWNwaS9uZml0LmMgICAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgNzkgKysrLS0tDQogZHJpdmVycy9hY3BpL25maXQuaCAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAxNyArLQ0KIGRyaXZlcnMvYmxvY2svYnJkLmMg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDggKy0NCiBkcml2ZXJzL2lzZG4vaWNuL2lj bi5oICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAyICstDQogZHJpdmVycy9tdGQvZGV2aWNl cy9zbHJhbS5jICAgICAgICAgICAgICAgICAgICB8ICAgMiArLQ0KIGRyaXZlcnMvbXRkL25hbmQv ZGlza29uY2hpcC5jICAgICAgICAgICAgICAgICAgfCAgIDIgKy0NCiBkcml2ZXJzL210ZC9vbmVu YW5kL2dlbmVyaWMuYyAgICAgICAgICAgICAgICAgIHwgICAyICstDQogZHJpdmVycy9udmRpbW0v S2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICB8ICAyMyArKw0KIGRyaXZlcnMvbnZkaW1t L01ha2VmaWxlICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDUgKw0KIGRyaXZlcnMvbnZkaW1t L2J0dC5jICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgNTAgKy0tLQ0KIGRyaXZlcnMvbnZk aW1tL2J0dC5oICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDMgKw0KIGRyaXZlcnMvbnZk aW1tL2J0dF9kZXZzLmMgICAgICAgICAgICAgICAgICAgICAgfCAyMTUgKysrKy0tLS0tLS0tLS0t LQ0KIGRyaXZlcnMvbnZkaW1tL2NsYWltLmMgICAgICAgICAgICAgICAgICAgICAgICAgfCAyMDEg KysrKysrKysrKysrKysrDQogZHJpdmVycy9udmRpbW0vZGltbV9kZXZzLmMgICAgICAgICAgICAg ICAgICAgICB8ICAgNSArLQ0KIGRyaXZlcnMvbnZkaW1tL2U4MjAuYyAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgODcgKysrKysrKw0KIGRyaXZlcnMvbnZkaW1tL25hbWVzcGFjZV9kZXZzLmMg ICAgICAgICAgICAgICAgfCAgODkgKysrKysrLQ0KIGRyaXZlcnMvbnZkaW1tL25kLWNvcmUuaCAg ICAgICAgICAgICAgICAgICAgICAgfCAgIDkgKw0KIGRyaXZlcnMvbnZkaW1tL25kLmggICAgICAg ICAgICAgICAgICAgICAgICAgICAgfCAgNjcgKysrKy0NCiBkcml2ZXJzL252ZGltbS9wZm4uaCAg ICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDM1ICsrKw0KIGRyaXZlcnMvbnZkaW1tL3Bmbl9k ZXZzLmMgICAgICAgICAgICAgICAgICAgICAgfCAzMzcgKysrKysrKysrKysrKysrKysrKysrKysr Kw0KIGRyaXZlcnMvbnZkaW1tL3BtZW0uYyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAyNDUg KysrKysrKysrKysrKysrLS0tDQogZHJpdmVycy9udmRpbW0vcmVnaW9uLmMgICAgICAgICAgICAg ICAgICAgICAgICB8ICAgMiArDQogZHJpdmVycy9udmRpbW0vcmVnaW9uX2RldnMuYyAgICAgICAg ICAgICAgICAgICB8ICAyMCArKw0KIGRyaXZlcnMvcGNpL3Byb2JlLmMgICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDMgKy0NCiBkcml2ZXJzL3BucC9tYW5hZ2VyLmMgICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAyIC0NCiBkcml2ZXJzL3MzOTAvYmxvY2svZGNzc2Jsay5jICAgICAg ICAgICAgICAgICAgIHwgIDEwICstDQogZHJpdmVycy9zY3NpL2FpYzk0eHgvYWljOTR4eF9pbml0 LmMgICAgICAgICAgICB8ICAgNyArLQ0KIGRyaXZlcnMvc2NzaS9hcmNtc3IvYXJjbXNyX2hiYS5j ICAgICAgICAgICAgICAgfCAgIDUgKy0NCiBkcml2ZXJzL3Njc2kvbXZzYXMvbXZfaW5pdC5jICAg ICAgICAgICAgICAgICAgIHwgIDE1ICstDQogZHJpdmVycy9zY3NpL3N1bjN4X2VzcC5jICAgICAg ICAgICAgICAgICAgICAgICB8ICAgMiArLQ0KIGRyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVy cy9paV9wY2kyMGtjLmMgICAgfCAgIDEgKw0KIGRyaXZlcnMvc3RhZ2luZy91bmlzeXMvdmlzb3Ji dXMvdmlzb3JjaGFubmVsLmMgfCAgMTYgKy0NCiBkcml2ZXJzL3N0YWdpbmcvdW5pc3lzL3Zpc29y YnVzL3Zpc29yY2hpcHNldC5jIHwgIDE3ICstDQogZHJpdmVycy90dHkvc2VyaWFsLzgyNTAvODI1 MF9jb3JlLmMgICAgICAgICAgICB8ICAgMiArLQ0KIGRyaXZlcnMvdmlkZW8vZmJkZXYvb2NmYi5j ICAgICAgICAgICAgICAgICAgICAgfCAgIDEgLQ0KIGRyaXZlcnMvdmlkZW8vZmJkZXYvczFkMTN4 eHhmYi5jICAgICAgICAgICAgICAgfCAgIDMgKy0NCiBkcml2ZXJzL3ZpZGVvL2ZiZGV2L3N0aWZi LmMgICAgICAgICAgICAgICAgICAgIHwgICAxICsNCiBmcy9ibG9ja19kZXYuYyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICA0ICstDQogZnMvZGF4LmMgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB8ICA2MiArKystLQ0KIGluY2x1ZGUvYXNtLWdlbmVyaWMv bWVtb3J5X21vZGVsLmggICAgICAgICAgICAgfCAgIDYgKw0KIGluY2x1ZGUvbGludXgvYmxrZGV2 LmggICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDggKy0NCiBpbmNsdWRlL2xpbnV4L2lvLW1h cHBpbmcuaCAgICAgICAgICAgICAgICAgICAgIHwgICAyICstDQogaW5jbHVkZS9saW51eC9pby5o ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAzMyArKysNCiBpbmNsdWRlL2xpbnV4L2xp Ym52ZGltbS5oICAgICAgICAgICAgICAgICAgICAgIHwgICA0ICsNCiBpbmNsdWRlL2xpbnV4L21l bW9yeV9ob3RwbHVnLmggICAgICAgICAgICAgICAgIHwgICA1ICstDQogaW5jbHVkZS9saW51eC9t bS5oICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgOSArLQ0KIGluY2x1ZGUvbGludXgv bW16b25lLmggICAgICAgICAgICAgICAgICAgICAgICAgfCAgMjMgKysNCiBpbmNsdWRlL2xpbnV4 L210ZC9tYXAuaCAgICAgICAgICAgICAgICAgICAgICAgIHwgICAyICstDQogaW5jbHVkZS9saW51 eC9wbWVtLmggICAgICAgICAgICAgICAgICAgICAgICAgICB8IDExNSArKysrKystLS0NCiBpbmNs dWRlL3VhcGkvbGludXgvbmRjdGwuaCAgICAgICAgICAgICAgICAgICAgIHwgIDEyICstDQogaW5j bHVkZS92aWRlby92Z2EuaCAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMiArLQ0KIGtl cm5lbC9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDIgKw0KIGtl cm5lbC9tZW1yZW1hcC5jICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxOTAgKysrKysr KysrKysrKysNCiBrZXJuZWwvcmVzb3VyY2UuYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHwgIDYxICsrKy0tDQogbGliL0tjb25maWcgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICAgMyArDQogbGliL2RldnJlcy5jICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICAxMyArLQ0KIGxpYi9wY2lfaW9tYXAuYyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgIDcgKy0NCiBtbS9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgIDE3ICsrDQogbW0vbWVtb3J5X2hvdHBsdWcuYyAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8ICAxNCArLQ0KIG1tL3BhZ2VfYWxsb2MuYyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgIDMgKw0KIHRvb2xzL3Rlc3RpbmcvbnZkaW1tL0tidWlsZCAgICAgICAgICAg ICAgICAgICAgfCAgMTMgKy0NCiB0b29scy90ZXN0aW5nL252ZGltbS90ZXN0L2lvbWFwLmMgICAg ICAgICAgICAgIHwgIDg1ICsrKysrKy0NCiB0b29scy90ZXN0aW5nL252ZGltbS90ZXN0L25maXQu YyAgICAgICAgICAgICAgIHwgMjA5ICsrKysrKysrKystLS0tLQ0KIDkyIGZpbGVzIGNoYW5nZWQs IDIxNDIgaW5zZXJ0aW9ucygrKSwgNzQ1IGRlbGV0aW9ucygtKQ0KIGNyZWF0ZSBtb2RlIDEwMDY0 NCBhcmNoL3g4Ni9pbmNsdWRlL2FzbS9wbWVtLmgNCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVy cy9udmRpbW0vY2xhaW0uYw0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL252ZGltbS9lODIw LmMNCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9udmRpbW0vcGZuLmgNCiBjcmVhdGUgbW9k ZSAxMDA2NDQgZHJpdmVycy9udmRpbW0vcGZuX2RldnMuYw0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBr ZXJuZWwvbWVtcmVtYXAuYw0KDQpjb21taXQgNWUzMjk0MDYyMWViNjIwNjRkOThmNDJjOTg4OWRi NzFiMDM2OGJkZQ0KQXV0aG9yOiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNv bT4NCkRhdGU6ICAgU2F0IEp1bCAxMSAxMDowMjo0NiAyMDE1IC0wNDAwDQoNCiAgICBsaWJudmRp bW0sIGJ0dDogc3BhcnNlIGZpeA0KICAgIA0KICAgIEZpeDoNCiAgICBkcml2ZXJzL252ZGltbS9i dHQuYzo2MzU6Mjk6IHdhcm5pbmc6IHJlc3RyaWN0ZWQgX19sZTY0IGRlZ3JhZGVzIHRvIGludGVn ZXINCiAgICANCiAgICBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1z QGludGVsLmNvbT4NCg0KY29tbWl0IGVjOTI3NzdmMmJhOTNjMDAzODdiOGZlNTM3ODBjMjVhZGM1 N2M3NDQNCkF1dGhvcjogVmlzaGFsIFZlcm1hIDx2aXNoYWwubC52ZXJtYUBpbnRlbC5jb20+DQpE YXRlOiAgIFRodSBKdWwgOSAxMzoyNTozNSAyMDE1IC0wNjAwDQoNCiAgICBsaWJudmRpbW06IFVw ZGF0ZSBuYW1lIG9mIHRoZSBhcnNfc3RhdHVzX3JlY29yZCBtYXNrIGZpZWxkDQogICAgDQogICAg VGhlIHNwZWMgc3VnZ2VzdHMgdGhhdCB0aGlzIGlzIGEgc2ltcGxlICdsZW5ndGgnIGZpZWxkLCBu b3QgYSBtYXNrLg0KICAgIFVwZGF0ZSB0aGUgbmFtZSBhY2NvcmRpbmdseS4NCiAgICANCiAgICBT aWduZWQtb2ZmLWJ5OiBWaXNoYWwgVmVybWEgPHZpc2hhbC5sLnZlcm1hQGludGVsLmNvbT4NCiAg ICBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4N Cg0KY29tbWl0IDM5YzY4NmI4NjJjZGIyMDQ5YjkwZTA5NWI2YzZjNzI3YjJhN2FiNjANCkF1dGhv cjogVmlzaGFsIFZlcm1hIDx2aXNoYWwubC52ZXJtYUBpbnRlbC5jb20+DQpEYXRlOiAgIFRodSBK dWwgOSAxMzoyNTozNiAyMDE1IC0wNjAwDQoNCiAgICBsaWJudmRpbW06IEFkZCBEU00gc3VwcG9y dCBmb3IgQWRkcmVzcyBSYW5nZSBTY3J1YiBjb21tYW5kcw0KICAgIA0KICAgIEFkZCBzdXBwb3J0 IGZvciB0aGUgdGhyZWUgQVJTIERTTSBjb21tYW5kczoNCiAgICAtIFF1ZXJ5IEFSUyBDYXBhYmls aXRpZXMgLSBRdWVyaWVzIHRoZSBmaXJtd2FyZSB0byBjaGVjayBpZiBhIGdpdmVuDQogICAgICBy YW5nZSBzdXBwb3J0cyBzY3J1YiwgYW5kIGlmIHNvLCB3aGljaCB0eXBlIChwZXJzaXN0ZW50IHZz LiB2b2xhdGlsZSkNCiAgICAtIFN0YXJ0IEFSUyAtIFN0YXJ0cyBhIHNjcnViIGZvciBhIGdpdmVu IHJhbmdlL3R5cGUNCiAgICAtIFF1ZXJ5IEFSUyBTdGF0dXMgLSBDaGVja3Mgc3RhdHVzIG9mIGEg cHJldmlvdXNseSBzdGFydGVkIHNjcnViLCBhbmQNCiAgICAgIHByb3ZpZGVzIHRoZSBlcnJvciBs b2dzIGlmIGFueS4NCiAgICANCiAgICAgIFRoZSBjb21tYW5kcyBhcmUgZGVzY3JpYmVkIGJ5IHRo ZSBleGFtcGxlIERTTSBzcGVjIGF0Og0KICAgICAgaHR0cDovL3BtZW0uaW8vZG9jdW1lbnRzL05W RElNTV9EU01fSW50ZXJmYWNlX0V4YW1wbGUucGRmDQogICAgDQogICAgQWxzbyBhZGQgdGhlc2Ug Y29tbWFuZHMgdG8gdGhlIG5maXRfdGVzdCB0ZXN0IGZyYW1ld29yaywgYW5kIHJldHVybg0KICAg IGNhbm5lZCBkYXRhLg0KICAgIA0KICAgIFNpZ25lZC1vZmYtYnk6IFZpc2hhbCBWZXJtYSA8dmlz aGFsLmwudmVybWFAaW50ZWwuY29tPg0KICAgIFNpZ25lZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8 ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KDQpjb21taXQgNmI0NzQ5NmE2ZmM4MTgxNmU3ZWRh ZjgyMjRkZmI4OGU0MDJhMDVmNQ0KQXV0aG9yOiBWaXNoYWwgVmVybWEgPHZpc2hhbC5sLnZlcm1h QGludGVsLmNvbT4NCkRhdGU6ICAgVGh1IEp1bCAyMyAxMTo1ODo0OCAyMDE1IC0wNjAwDQoNCiAg ICBsaWJudmRpbW0sIHBtZW06IENoYW5nZSBwbWVtIHBoeXNpY2FsIHNlY3RvciBzaXplIHRvIFBB R0VfU0laRQ0KICAgIA0KICAgIEJhc2VkIG9uIGEgcGF0Y2g6IGM4ZmEzMTcgYnJkOiBSZXF1ZXN0 IGZyb20gZmRpc2sgNGsgYWxpZ25tZW50IGJ5IEJvYXoNCiAgICBIYXJyb3NoLCBhbGxvdyBmZGlz ayB0byBjcmVhdGUgcHJvcGVybHkgYWxpZ25lZCBwYXJ0aXRpb25zIGZvciBEQVguIFRoaXMNCiAg ICB3aWxsIGFsc28gY2F1c2UgbWtmcy5leHQ0IHRvIGVtaXQgYSB3YXJuaW5nIGlmIHVzaW5nIGEg ZmlsZSBzeXN0ZW0gYmxvY2sNCiAgICBzaXplIG9mIGxlc3MgdGhhbiBQQUdFX1NJWkUuDQogICAg DQogICAgQ2M6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KICAgIENj OiBSb3NzIFp3aXNsZXIgPHJvc3Muendpc2xlckBsaW51eC5pbnRlbC5jb20+DQogICAgQ2M6IE1h dHRoZXcgV2lsY294IDxtYXR0aGV3LnIud2lsY294QGludGVsLmNvbT4NCiAgICBDYzogQ2hyaXN0 b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+DQogICAgQ2M6IEVsbGlvdHQsIFJvYmVydCA8RWxsaW90 dEBocC5jb20+DQogICAgU2lnbmVkLW9mZi1ieTogVmlzaGFsIFZlcm1hIDx2aXNoYWwubC52ZXJt YUBpbnRlbC5jb20+DQogICAgQWNrZWQtYnk6IEJvYXogSGFycm9zaCA8Ym9hekBwbGV4aXN0b3Iu Y29tPg0KICAgIEFja2VkLWJ5OiBSb3NzIFp3aXNsZXIgPHJvc3Muendpc2xlckBsaW51eC5pbnRl bC5jb20+DQogICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0Bp bnRlbC5jb20+DQoNCmNvbW1pdCA2MGU5NWY0M2ZjODU3M2U4MWY1NGIwYzFlMGJjNTQyYzIyNjBk OTU2DQpBdXRob3I6IExpbmRhIEtuaXBwZXJzIDxsaW5kYS5rbmlwcGVyc0BocC5jb20+DQpEYXRl OiAgIFdlZCBKdWwgMjIgMTY6MTc6MjIgMjAxNSAtMDQwMA0KDQogICAgbmZpdDogRG9uJ3QgY2hl Y2sgX1NUQSBvbiBOVkRJTU0gZGV2aWNlcw0KICAgIA0KICAgIFRoZSBfU1RBIG9ubHkgYXBwbGll cyB0byB0aGUgcm9vdCBkZXZpY2UsIG5vdCB0aGUgaW5kaXZpZHVhbCBOVkRJTU1TLA0KICAgIHNv IGRvbid0IGNoZWNrIGhlcmUuIE5WRElNTSBkZXZpY2Ugc3RhdGUgZmxhZ3MgYXJlIGNoZWNrZWQg ZWxzZXdoZXJlLg0KICAgIA0KICAgIFNpZ25lZC1vZmYtYnk6IExpbmRhIEtuaXBwZXJzIDxsaW5k YS5rbmlwcGVyc0BocC5jb20+DQogICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4u ai53aWxsaWFtc0BpbnRlbC5jb20+DQoNCmNvbW1pdCBmNmVmNWEyYTUwODE2YjU4ZTMxMjYyMDZk ZTEzZDBiOWZkZjg5ZGY1DQpBdXRob3I6IFJhbmR5IER1bmxhcCA8cmR1bmxhcEBpbmZyYWRlYWQu b3JnPg0KRGF0ZTogICBUdWUgSnVsIDI4IDEyOjI3OjAxIDIwMTUgLTA3MDANCg0KICAgIG52ZGlt bTogZml4IGlubGluZSBmdW5jdGlvbiByZXR1cm4gdHlwZSB3YXJuaW5nDQogICAgDQogICAgRml4 IG11bHRpcGxlIGJ1aWxkIHdhcm5pbmdzIHdoZW4gQ09ORklHX0JUVCBpcyBub3QgZW5hYmxlZDoN CiAgICANCiAgICBJbiBmaWxlIGluY2x1ZGVkIGZyb20gLi4vZHJpdmVycy9udmRpbW0vYnVzLmM6 Mjk6MDoNCiAgICAuLi9kcml2ZXJzL252ZGltbS9uZC5oOjE2OToxNTogd2FybmluZzogcmV0dXJu IHR5cGUgZGVmYXVsdHMgdG8gJ2ludCcgWy1XcmV0dXJuLXR5cGVdDQogICAgIHN0YXRpYyBpbmxp bmUgbmRfYnR0X3Byb2JlKHN0cnVjdCBuZF9uYW1lc3BhY2VfY29tbW9uICpuZG5zLCB2b2lkICpk cnZkYXRhKQ0KICAgICAgICAgICAgICAgICAgIF4NCiAgICANCiAgICBTaWduZWQtb2ZmLWJ5OiBS YW5keSBEdW5sYXAgPHJkdW5sYXBAaW5mcmFkZWFkLm9yZz4NCiAgICBDYzogRGFuIFdpbGxpYW1z IDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+DQogICAgQ2M6IGxpbnV4LW52ZGltbUBsaXN0cy4w MS5vcmcNCiAgICBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGlu dGVsLmNvbT4NCg0KY29tbWl0IDEyNGZlMjBkOTQ2MzBiNmYxNzNkYWU1ZWI4MTVlNmU2ZTM1MGM3 MmQNCkF1dGhvcjogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+DQpEYXRl OiAgIE1vbiBBdWcgMTAgMjM6MDc6MDUgMjAxNSAtMDQwMA0KDQogICAgbW06IGVuaGFuY2UgcmVn aW9uX2lzX3JhbSgpIHRvIHJlZ2lvbl9pbnRlcnNlY3RzKCkNCiAgICANCiAgICByZWdpb25faXNf cmFtKCkgaXMgdXNlZCB0byBwcmV2ZW50IHRoZSBlc3RhYmxpc2htZW50IG9mIGFsaWFzZWQgbWFw cGluZ3MNCiAgICB0byBwaHlzaWNhbCAiU3lzdGVtIFJBTSIgd2l0aCBpbmNvbXBhdGlibGUgY2Fj aGUgc2V0dGluZ3MuICBIb3dldmVyLCBpdA0KICAgIHVzZXMgIi0xIiB0byBpbmRpY2F0ZSBib3Ro ICJ1bmtub3duIiBtZW1vcnkgcmFuZ2VzIChyYW5nZXMgbm90IGRlc2NyaWJlZA0KICAgIGJ5IHBs YXRmb3JtIGZpcm13YXJlKSBhbmQgIm1peGVkIiByYW5nZXMgKHdoZXJlIHRoZSBwYXJhbWV0ZXJz IGRlc2NyaWJlDQogICAgYSByYW5nZSB0aGF0IHBhcnRpYWxseSBvdmVybGFwcyAiU3lzdGVtIFJB TSIpLg0KICAgIA0KICAgIEZpeCB0aGlzIHVwIGJ5IGV4cGxpY2l0bHkgdHJhY2tpbmcgdGhlICJ1 bmtub3duIiB2cyAibWl4ZWQiIHJlc291cmNlDQogICAgY2FzZXMgYW5kIHJldHVybmluZyBSRUdJ T05fSU5URVJTRUNUUywgUkVHSU9OX01JWEVELCBvciBSRUdJT05fRElTSk9JTlQuDQogICAgVGhp cyByZS13cml0ZSBhbHNvIGFkZHMgc3VwcG9ydCBmb3IgZGV0ZWN0aW5nIHdoZW4gdGhlIHJlcXVl c3RlZCByZWdpb24NCiAgICBjb21wbGV0ZWx5IGVjbGlwc2VzIGFsbCBvZiBhIHJlc291cmNlLiAg Tm90ZSwgdGhlIGltcGxlbWVudGF0aW9uIHRyZWF0cw0KICAgIG92ZXJsYXBzIGJldHdlZW4gInVu a25vd24iIGFuZCB0aGUgcmVxdWVzdGVkIG1lbW9yeSB0eXBlIGFzDQogICAgUkVHSU9OX0lOVEVS U0VDVFMuDQogICAgDQogICAgRmluYWxseSwgb3RoZXIgbWVtb3J5IHR5cGVzIGNhbiBiZSBwYXNz ZWQgaW4gYnkgbmFtZSwgZm9yIG5vdyB0aGUgb25seQ0KICAgIHVzYWdlICJTeXN0ZW0gUkFNIi4N CiAgICANCiAgICBTdWdnZXN0ZWQtYnk6IEx1aXMgUi4gUm9kcmlndWV6IDxtY2dyb2ZAc3VzZS5j b20+DQogICAgUmV2aWV3ZWQtYnk6IFRvc2hpIEthbmkgPHRvc2hpLmthbmlAaHAuY29tPg0KICAg IFNpZ25lZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0K DQpjb21taXQgMjU4NGNmODM1NzhjMjZkYjE0NDczMGVmNDk4ZjQwNzBmODJlZTNlYQ0KQXV0aG9y OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCkRhdGU6ICAgTW9uIEF1 ZyAxMCAyMzowNzowNSAyMDE1IC0wNDAwDQoNCiAgICBhcmNoLCBkcml2ZXJzOiBkb24ndCBpbmNs dWRlIDxhc20vaW8uaD4gZGlyZWN0bHksIHVzZSA8bGludXgvaW8uaD4gaW5zdGVhZA0KICAgIA0K ICAgIFByZXBhcmF0aW9uIGZvciB1bmlmb3JtIGRlZmluaXRpb24gb2YgaW9yZW1hcCwgaW9yZW1h cF93YywgaW9yZW1hcF93dCwNCiAgICBhbmQgaW9yZW1hcF9jYWNoZSwgdHJlZS13aWRlLg0KICAg IA0KICAgIEFja2VkLWJ5OiBDaHJpc3RvcGggSGVsbHdpZyA8aGNoQGxzdC5kZT4NCiAgICBTaWdu ZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCg0KY29t bWl0IDkyYjE5ZmY1MGU4ZjI0MjM5MmQ3OGIyYWFjYzViNWI2NzJmMTc5NmINCkF1dGhvcjogRGFu IFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+DQpEYXRlOiAgIE1vbiBBdWcgMTAg MjM6MDc6MDYgMjAxNSAtMDQwMA0KDQogICAgY2xlYW51cCBJT1JFU09VUkNFX0NBQ0hFQUJMRSB2 cyBpb3JlbWFwKCkNCiAgICANCiAgICBRdW90aW5nIEFybmQ6DQogICAgICAgIEkgd2FzIHRoaW5r aW5nIHRoZSBvcHBvc2l0ZSBhcHByb2FjaCBhbmQgYmFzaWNhbGx5IHJlbW92aW5nIGFsbCB1c2Vz DQogICAgICAgIG9mIElPUkVTT1VSQ0VfQ0FDSEVBQkxFIGZyb20gdGhlIGtlcm5lbC4gVGhlcmUg YXJlIG9ubHkgYSBoYW5kZnVsIG9mDQogICAgICAgIHRoZW0uYW5kIHdlIGNhbiBwcm9iYWJseSBy ZXBsYWNlIHRoZW0gYWxsIHdpdGggaGFyZGNvZGVkDQogICAgICAgIGlvcmVtYXBfY2FjaGVkKCkg Y2FsbHMgaW4gdGhlIGNhc2VzIHRoZXkgYXJlIGFjdHVhbGx5IHVzZWZ1bC4NCiAgICANCiAgICBB bGwgZXhpc3RpbmcgdXNhZ2VzIG9mIElPUkVTT1VSQ0VfQ0FDSEVBQkxFIGNhbGwgaW9yZW1hcCgp IGluc3RlYWQgb2YNCiAgICBpb3JlbWFwX25vY2FjaGUoKSBpZiB0aGUgcmVzb3VyY2UgaXMgY2Fj aGVhYmxlLCBob3dldmVyIGlvcmVtYXAoKSBpcw0KICAgIHVuY2FjaGVkIGJ5IGRlZmF1bHQuIENs ZWFybHkgbm9uZSBvZiB0aGUgZXhpc3RpbmcgdXNhZ2VzIGNhcmUgYWJvdXQgdGhlDQogICAgY2Fj aGVhYmlsaXR5LiBQYXJ0aWN1bGFybHkgZGV2bV9pb3JlbWFwX3Jlc291cmNlKCkgbmV2ZXIgd29y a2VkIGFzDQogICAgYWR2ZXJ0aXNlZCBzaW5jZSBpdCBhbHdheXMgZmVsbCBiYWNrIHRvIHBsYWlu IGlvcmVtYXAoKS4NCiAgICANCiAgICBDbGVhbiB0aGlzIHVwIGFzIHRoZSBuZXcgZGlyZWN0aW9u IHdlIHdhbnQgaXMgdG8gY29udmVydA0KICAgIGlvcmVtYXBfPHR5cGU+KCkgdXNhZ2VzIHRvIG1l bXJlbWFwKC4uLiwgZmxhZ3MpLg0KICAgIA0KICAgIFN1Z2dlc3RlZC1ieTogQXJuZCBCZXJnbWFu biA8YXJuZEBhcm5kYi5kZT4NCiAgICBSZXZpZXdlZC1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhj aEBsc3QuZGU+DQogICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFt c0BpbnRlbC5jb20+DQoNCmNvbW1pdCA5MjI4MWRlZTgyNWY2ZDJlYjA3YzQ0MTQzN2U0MTk2YTQ0 YjA4NjFjDQpBdXRob3I6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0K RGF0ZTogICBNb24gQXVnIDEwIDIzOjA3OjA2IDIwMTUgLTA0MDANCg0KICAgIGFyY2g6IGludHJv ZHVjZSBtZW1yZW1hcCgpDQogICAgDQogICAgRXhpc3RpbmcgdXNlcnMgb2YgaW9yZW1hcF9jYWNo ZSgpIGFyZSBtYXBwaW5nIG1lbW9yeSB0aGF0IGlzIGtub3duIGluDQogICAgYWR2YW5jZSB0byBu b3QgaGF2ZSBpL28gc2lkZSBlZmZlY3RzLiAgVGhlc2UgdXNlcnMgYXJlIGZvcmNlZCB0byBjYXN0 DQogICAgYXdheSB0aGUgX19pb21lbSBhbm5vdGF0aW9uLCBvciBvdGhlcndpc2UgbmVnbGVjdCB0 byBmaXggdGhlIHNwYXJzZQ0KICAgIGVycm9ycyB0aHJvd24gd2hlbiBkZXJlZmVyZW5jaW5nIHBv aW50ZXJzIHRvIHRoaXMgbWVtb3J5LiAgUHJvdmlkZQ0KICAgIG1lbXJlbWFwKCkgYXMgYSBub24g X19pb21lbSBhbm5vdGF0ZWQgaW9yZW1hcF8qKCkgaW4gdGhlIGNhc2Ugd2hlbg0KICAgIGlvcmVt YXAgaXMgb3RoZXJ3aXNlIGEgcG9pbnRlciB0byBjYWNoZWFibGUgbWVtb3J5LiBFbXBpcmljYWxs eSwNCiAgICBpb3JlbWFwXzxjYWNoZWFibGUtdHlwZT4oKSBjYWxsIHNpdGVzIGFyZSBzZWVraW5n IG1lbW9yeS1saWtlIHNlbWFudGljcw0KICAgIChlLmcuICBzcGVjdWxhdGl2ZSByZWFkcywgYW5k IHByZWZldGNoaW5nIHBlcm1pdHRlZCkuDQogICAgDQogICAgbWVtcmVtYXAoKSBpcyBhIGJyZWFr IGZyb20gdGhlIGlvcmVtYXAgaW1wbGVtZW50YXRpb24gcGF0dGVybiBvZiBhZGRpbmcNCiAgICBh IG5ldyBtZW1yZW1hcF88dHlwZT4oKSBmb3IgZWFjaCBtYXBwaW5nIHR5cGUgYW5kIGhhdmluZyBz aWxlbnQNCiAgICBjb21wYXRpYmlsaXR5IGZhbGwgYmFja3MuICBJbnN0ZWFkLCB0aGUgaW1wbGVt ZW50YXRpb24gZGVmaW5lcyBmbGFncw0KICAgIHRoYXQgYXJlIHBhc3NlZCB0byB0aGUgY2VudHJh bCBtZW1yZW1hcCgpIGFuZCBpZiBhIG1hcHBpbmcgdHlwZSBpcyBub3QNCiAgICBzdXBwb3J0ZWQg YnkgYW4gYXJjaCBtZW1yZW1hcCByZXR1cm5zIE5VTEwuDQogICAgDQogICAgV2UgaW50cm9kdWNl IGEgbWVtcmVtYXAgcHJvdG90eXBlIGFzIGEgdHJpdmlhbCB3cmFwcGVyIG9mDQogICAgaW9yZW1h cF9jYWNoZSgpIGFuZCBpb3JlbWFwX3d0KCkuICBMYXRlciwgb25jZSBhbGwgaW9yZW1hcF9jYWNo ZSgpIGFuZA0KICAgIGlvcmVtYXBfd3QoKSB1c2FnZSBoYXMgYmVlbiByZW1vdmVkIGZyb20gZHJp dmVycyB3ZSB0ZWFjaCBhcmNocyB0bw0KICAgIGltcGxlbWVudCBhcmNoX21lbXJlbWFwKCkgd2l0 aCB0aGUgYWJpbGl0eSB0byBzdHJpY3RseSBlbmZvcmNlIHRoZQ0KICAgIG1hcHBpbmcgdHlwZS4N CiAgICANCiAgICBDYzogQXJuZCBCZXJnbWFubiA8YXJuZEBhcm5kYi5kZT4NCiAgICBSZXZpZXdl ZC1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+DQogICAgU2lnbmVkLW9mZi1ieTog RGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+DQoNCmNvbW1pdCAzMTAzZGMw MzA0ZmQ5YzhhYjU3Njk3N2NkOTgxNDBkNGZiYWMxNzMwDQpBdXRob3I6IERhbiBXaWxsaWFtcyA8 ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KRGF0ZTogICBNb24gQXVnIDEwIDIzOjA3OjA2IDIw MTUgLTA0MDANCg0KICAgIHZpc29yYnVzOiBzd2l0Y2ggZnJvbSBpb3JlbWFwX2NhY2hlIHRvIG1l bXJlbWFwDQogICAgDQogICAgSW4gcHJlcGFyYXRpb24gZm9yIGRlcHJlY2F0aW5nIGlvcmVtYXBf Y2FjaGUoKSBjb252ZXJ0IGl0cyB1c2FnZSBpbg0KICAgIHZpc29yYnVzIHRvIG1lbXJlbWFwLg0K ICAgIA0KICAgIENjOiBCZW5qYW1pbiBSb21lciA8YmVuamFtaW4ucm9tZXJAdW5pc3lzLmNvbT4N CiAgICBDYzogRGF2aWQgS2Vyc2huZXIgPGRhdmlkLmtlcnNobmVyQHVuaXN5cy5jb20+DQogICAg QWNrZWQtYnk6IEdyZWcgS3JvYWgtSGFydG1hbiA8Z3JlZ2toQGxpbnV4Zm91bmRhdGlvbi5vcmc+ DQogICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5j b20+DQoNCmNvbW1pdCBlODM2YTI1NmU4ZmQ1NzljOWQ3YTM2ODVmMjI5ODEyMjVhMWNhNDUxDQpB dXRob3I6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KRGF0ZTogICBX ZWQgQXVnIDEyIDE4OjQyOjU2IDIwMTUgLTA0MDANCg0KICAgIHBtZW06IGNvbnZlcnQgdG8gZ2Vu ZXJpYyBtZW1yZW1hcA0KICAgIA0KICAgIEtpbGwgYXJjaF9tZW1yZW1hcF9wbWVtKCkgYW5kIGp1 c3QgbGV0IHRoZSBhcmNoaXRlY3R1cmUgc3BlY2lmeSB0aGUNCiAgICBmbGFncyB0byBiZSBwYXNz ZWQgdG8gbWVtcmVtYXAoKS4gIERlZmF1bHQgdG8gd3JpdGV0aHJvdWdoIGJ5IGRlZmF1bHQuDQog ICAgDQogICAgU3VnZ2VzdGVkLWJ5OiBDaHJpc3RvcGggSGVsbHdpZyA8aGNoQGxzdC5kZT4NCiAg ICBSZXZpZXdlZC1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+DQogICAgUmV2aWV3 ZWQtYnk6IFJvc3MgWndpc2xlciA8cm9zcy56d2lzbGVyQGxpbnV4LmludGVsLmNvbT4NCiAgICBT aWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCg0K Y29tbWl0IGZiZGUxNDE0YWNjMDQ0MDAyNDA4M2JmMGMzOTFiMjU5YmNmYzQ4MjYNCkF1dGhvcjog VmlzaGFsIFZlcm1hIDx2aXNoYWwubC52ZXJtYUBpbnRlbC5jb20+DQpEYXRlOiAgIFdlZCBKdWwg MjkgMTQ6NTg6MDcgMjAxNSAtMDYwMA0KDQogICAgbGlibnZkaW1tLCBidHQ6IGNsZWFuIHVwIGlu dGVybmFsIGludGVyZmFjZXMNCiAgICANCiAgICBDb25zb2xpZGF0ZSB0aGUgcGFyYW1ldGVycyBw YXNzZWQgdG8gYXJlbmFfaXNfdmFsaWQgaW50byBqdXN0IG5kX2J0dCwNCiAgICBhbmQgYW4gaW5m byBibG9jayB0byBpbmNyZWFzZSByZS11c2FiaWxpdHkuDQogICAgDQogICAgU2ltaWxhcmx5LCBi dHRfYXJlbmFfd3JpdGVfbGF5b3V0IGRvZXNuJ3QgbmVlZCB0byBiZSBwYXNzZWQgYSB1dWlkLCBh cw0KICAgIGl0IGNhbiBiZSBvYnRhaW5lZCBmcm9tIGFyZW5hLT5uZF9idHQuDQogICAgDQogICAg U2lnbmVkLW9mZi1ieTogVmlzaGFsIFZlcm1hIDx2aXNoYWwubC52ZXJtYUBpbnRlbC5jb20+DQog ICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+ DQoNCmNvbW1pdCBhYjQ1ZTc2MzI3MTdiODExZTA3ODZlNDZjYTVhZDI3OWNiNzMxYjY2DQpBdXRo b3I6IFZpc2hhbCBWZXJtYSA8dmlzaGFsLmwudmVybWFAaW50ZWwuY29tPg0KRGF0ZTogICBXZWQg SnVsIDI5IDE0OjU4OjA4IDIwMTUgLTA2MDANCg0KICAgIGxpYm52ZGltbSwgYnR0OiBjb25zb2xp ZGF0ZSBhcmVuYSB2YWxpZGF0aW9uDQogICAgDQogICAgVXNlIGFyZW5hX2lzX3ZhbGlkIGFzIGEg Y29tbW9uIHJvdXRpbmUgZm9yIGNoZWNraW5nIHRoZSB2YWxpZGl0eSBvZiBhbg0KICAgIGluZm8g YmxvY2sgZnJvbSBib3RoIGRpc2NvdmVyX2FyZW5hcywgYW5kIG5kX2J0dF9wcm9iZS4NCiAgICAN CiAgICBBcyBhIHJlc3VsdCwgZG9uJ3QgY2hlY2sgZm9yIHZhbGlkaXR5IG9mIHRoZSBCVFQncyBV VUlELCBhbmQgbGJhc2l6ZS4NCiAgICBUaGUgY2hlY2tzdW0gaW4gdGhlIEJUVCBpbmZvIGJsb2Nr IGd1YXJhbnRlZXMgc2VsZi1jb25zaXN0ZW5jeSwgYW5kIHdoZW4NCiAgICB3ZSdyZSBjYWxsZWQg ZnJvbSBuZF9idHRfcHJvYmUsIHdlIGRvbid0IGhhdmUgYSB2YWxpZCB1dWlkIG9yIGxiYXNpemUN CiAgICBhdmFpbGFibGUgdG8gY2hlY2sgYWdhaW5zdC4NCiAgICANCiAgICBBbHNvIGNsZWFudXAg dG8gcmV0dXJuIGEgYm9vbCBpbnN0ZWFkIG9mIGFuIGludC4NCiAgICANCiAgICBTaWduZWQtb2Zm LWJ5OiBWaXNoYWwgVmVybWEgPHZpc2hhbC5sLnZlcm1hQGludGVsLmNvbT4NCiAgICBTaWduZWQt b2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCg0KY29tbWl0 IDZlYzY4OTU0MmI1YmM1MTYxODc5MTdkNDliMTEyODQ3ZGZiNzViMGINCkF1dGhvcjogVmlzaGFs IFZlcm1hIDx2aXNoYWwubC52ZXJtYUBpbnRlbC5jb20+DQpEYXRlOiAgIFdlZCBKdWwgMjkgMTQ6 NTg6MDkgMjAxNSAtMDYwMA0KDQogICAgbGlibnZkaW1tLCBidHQ6IHdyaXRlIGFuZCB2YWxpZGF0 ZSBwYXJlbnRfdXVpZA0KICAgIA0KICAgIFdoZW4gYSBCVFQgaXMgaW5zdGFudGlhdGVkIG9uIGEg bmFtZXNwYWNlIGl0IG11c3QgdmFsaWRhdGUgdGhlIG5hbWVzcGFjZQ0KICAgIHV1aWQgbWF0Y2hl cyB0aGUgJ3BhcmVudF91dWlkJyBzdG9yZWQgaW4gdGhlIGJ0dCBzdXBlcmJsb2NrLiBUaGlzDQog ICAgcHJvcGVydHkgZW5mb3JjZXMgdGhhdCBjaGFuZ2luZyB0aGUgbmFtZXNwYWNlIFVVSUQgaW52 YWxpZGF0ZXMgYWxsDQogICAgZm9ybWVyIEJUVCBpbnN0YW5jZXMgb24gdGhhdCBzdG9yYWdlLiBG b3IgIklPIG5hbWVzcGFjZXMiIHRoYXQgZG9uJ3QNCiAgICBoYXZlIGEgbGFiZWwgb3IgVVVJRCwg dGhlIHBhcmVudF91dWlkIGlzIHNldCB0byB6ZXJvLCBhbmQgdGhpcw0KICAgIHZhbGlkYXRpb24g aXMgc2tpcHBlZC4gRm9yIHN1Y2ggY2FzZXMsIG9sZCBCVFRzIGhhdmUgdG8gYmUgaW52YWxpZGF0 ZWQNCiAgICBieSBmb3JjaW5nIHRoZSBuYW1lc3BhY2UgdG8gcmF3IG1vZGUsIGFuZCBvdmVyd3Jp dGluZyB0aGUgQlRUIGluZm8NCiAgICBibG9ja3MuDQogICAgDQogICAgQmFzZWQgb24gYSBwYXRj aCBieSBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCiAgICANCiAgICBT aWduZWQtb2ZmLWJ5OiBWaXNoYWwgVmVybWEgPHZpc2hhbC5sLnZlcm1hQGludGVsLmNvbT4NCiAg ICBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4N Cg0KY29tbWl0IDdkM2RjZjI2YTY1NTlmYTgyYWYzZjUzZTJjOGIxNjNjZWM5NWZkYWYNCkF1dGhv cjogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+DQpEYXRlOiAgIE1vbiBBdWcgMTAgMjM6 MDc6MDcgMjAxNSAtMDQwMA0KDQogICAgZGV2cmVzOiBhZGQgZGV2bV9tZW1yZW1hcA0KICAgIA0K ICAgIFNpZ25lZC1vZmYtYnk6IENocmlzdG9waCBIZWxsd2lnIDxoY2hAbHN0LmRlPg0KICAgIFNp Z25lZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KDQpj b21taXQgNzA4YWI2MmJlZjFlZDNhM2NmMDY1YTQxMzhiZDg3ZjVkMDgzY2ZlYg0KQXV0aG9yOiBD aHJpc3RvcGggSGVsbHdpZyA8aGNoQGxzdC5kZT4NCkRhdGU6ICAgTW9uIEF1ZyAxMCAyMzowNzow OCAyMDE1IC0wNDAwDQoNCiAgICBwbWVtOiBzd2l0Y2ggdG8gZGV2bV8gYWxsb2NhdGlvbnMNCiAg ICANCiAgICBTaWduZWQtb2ZmLWJ5OiBDaHJpc3RvcGggSGVsbHdpZyA8aGNoQGxzdC5kZT4NCiAg ICBbZGpidzogdG9vbHMvdGVzdGluZy9udmRpbW0vIGFuZCBtZW11bm1hcF9wbWVtIHN1cHBvcnRd DQogICAgUmV2aWV3ZWQtYnk6IFJvc3MgWndpc2xlciA8cm9zcy56d2lzbGVyQGxpbnV4LmludGVs LmNvbT4NCiAgICBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGlu dGVsLmNvbT4NCg0KY29tbWl0IDdhNjc4MzJjN2U0NGMyMDkzNWM1ZDZmMjI2NDAzNWEwZjdiZjBk OGYNCkF1dGhvcjogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+DQpEYXRl OiAgIFdlZCBBdWcgMTkgMDA6MzQ6MzQgMjAxNSAtMDQwMA0KDQogICAgbGlibnZkaW1tLCBlODIw OiBtYWtlIENPTkZJR19YODZfUE1FTV9MRUdBQ1kgYSB0cmlzdGF0ZSBvcHRpb24NCiAgICANCiAg ICBXZSBjdXJyZW50bHkgcmVnaXN0ZXIgYSBwbGF0Zm9ybSBkZXZpY2UgZm9yIGU4MjAgdHlwZS0x MiBtZW1vcnkgYW5kDQogICAgcmVnaXN0ZXIgYSBudmRpbW0gYnVzIGJlbmVhdGggaXQuICBSZWdp c3RlcmluZyB0aGUgcGxhdGZvcm0gZGV2aWNlDQogICAgdHJpZ2dlcnMgdGhlIGRldmljZS1jb3Jl IG1hY2hpbmVyeSB0byBwcm9iZSBmb3IgYSBkcml2ZXIsIGJ1dCB0aGF0DQogICAgc2VhcmNoIGN1 cnJlbnRseSBjb21lcyB1cCBlbXB0eS4gIEJ1aWxkaW5nIHRoZSBudmRpbW0tYnVzIHJlZ2lzdHJh dGlvbg0KICAgIGludG8gdGhlIGU4MjBfcG1lbSBwbGF0Zm9ybSBkZXZpY2UgcmVnaXN0cmF0aW9u IGluIHRoaXMgd2F5IGZvcmNlcw0KICAgIGxpYm52ZGltbSB0byBiZSBidWlsdC1pbi4gIEluc3Rl YWQsIGNvbnZlcnQgdGhlIGJ1aWx0LWluIHBvcnRpb24gb2YNCiAgICBDT05GSUdfWDg2X1BNRU1f TEVHQUNZIHRvIHNpbXBseSByZWdpc3RlciBhIHBsYXRmb3JtIGRldmljZSBhbmQgbW92ZSB0aGUN CiAgICByZXN0IG9mIHRoZSBsb2dpYyB0byB0aGUgZHJpdmVyIGZvciBlODIwX3BtZW0sIGZvciB0 aGUgZm9sbG93aW5nDQogICAgcmVhc29uczoNCiAgICANCiAgICAxLyBMZXR0aW5nIGU4MjBfcG1l bSBzdXBwb3J0IGJlIGEgbW9kdWxlIGFsbG93cyBidWlsZGluZyBhbmQgdGVzdGluZw0KICAgICAg IGxpYm52ZGltbS5rbyBjaGFuZ2VzIHdpdGhvdXQgcmVib290aW5nDQogICAgDQogICAgMi8gQWxs IHRoZSBub3JtYWwgcG9saWN5IGFyb3VuZCBtb2R1bGVzIGNhbiBiZSBhcHBsaWVkIHRvIGU4MjBf cG1lbQ0KICAgICAgICh1bmJpbmQgdG8gZGlzYWJsZSBhbmQvb3IgYmxhY2tsaXN0aW5nIHRoZSBt b2R1bGUgZnJvbSBsb2FkaW5nIGJ5DQogICAgICAgZGVmYXVsdCkNCiAgICANCiAgICAzLyBNb3Zp bmcgdGhlIGRyaXZlciB0byBhIGdlbmVyaWMgbG9jYXRpb24gYW5kIGNvbnZlcnRpbmcgaXQgdG8g c2Nhbg0KICAgICAgICJpb21lbV9yZXNvdXJjZSIgcmF0aGVyIHRoYW4gImU4MjAubWFwIiBtZWFu cyBhbnkgb3RoZXIgYXJjaGl0ZWN0dXJlIGNhbg0KICAgICAgIHRha2UgYWR2YW50YWdlIG9mIHRo aXMgc2ltcGxlIG52ZGltbSByZXNvdXJjZSBkaXNjb3ZlcnkgbWVjaGFuaXNtIGJ5DQogICAgICAg cmVnaXN0ZXJpbmcgYSByZXNvdXJjZSBuYW1lZCAiUGVyc2lzdGVudCBNZW1vcnkgKGxlZ2FjeSki DQogICAgDQogICAgQ2M6IENocmlzdG9waCBIZWxsd2lnIDxoY2hAbHN0LmRlPg0KICAgIFNpZ25l ZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KDQpjb21t aXQgNDA2MDM1MjY1NjliMzA0ZGQ5MmY3MjBmMmY4YWIxMWU4MjhlYTE0NQ0KQXV0aG9yOiBSb3Nz IFp3aXNsZXIgPHJvc3Muendpc2xlckBsaW51eC5pbnRlbC5jb20+DQpEYXRlOiAgIFR1ZSBBdWcg MTggMTM6NTU6MzYgMjAxNSAtMDYwMA0KDQogICAgcG1lbSwgeDg2OiBtb3ZlIHg4NiBQTUVNIEFQ SSB0byBuZXcgcG1lbS5oIGhlYWRlcg0KICAgIA0KICAgIE1vdmUgdGhlIHg4NiBQTUVNIEFQSSBp bXBsZW1lbnRhdGlvbiBvdXQgb2YgYXNtL2NhY2hlZmx1c2guaCBhbmQgaW50bw0KICAgIGl0cyBv d24gaGVhZGVyIGFzbS9wbWVtLmguICBUaGlzIHdpbGwgYWxsb3cgbWVtYmVycyBvZiB0aGUgUE1F TSBBUEkgdG8NCiAgICBiZSBtb3JlIGVhc2lseSBpZGVudGlmaWVkIG9uIHRoaXMgYW5kIG90aGVy IGFyY2hpdGVjdHVyZXMuDQogICAgDQogICAgU2lnbmVkLW9mZi1ieTogUm9zcyBad2lzbGVyIDxy b3NzLnp3aXNsZXJAbGludXguaW50ZWwuY29tPg0KICAgIFN1Z2dlc3RlZC1ieTogQ2hyaXN0b3Bo IEhlbGx3aWcgPGhjaEBsc3QuZGU+DQogICAgUmV2aWV3ZWQtYnk6IENocmlzdG9waCBIZWxsd2ln IDxoY2hAbHN0LmRlPg0KICAgIFNpZ25lZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2ls bGlhbXNAaW50ZWwuY29tPg0KDQpjb21taXQgMTgyNzliNDY3YTlkODlhZmU0NGFmYmMxOWQ3Njhl ODM0ZGJmNDU0NQ0KQXV0aG9yOiBSb3NzIFp3aXNsZXIgPHJvc3Muendpc2xlckBsaW51eC5pbnRl bC5jb20+DQpEYXRlOiAgIFR1ZSBBdWcgMTggMTM6NTU6MzcgMjAxNSAtMDYwMA0KDQogICAgcG1l bTogcmVtb3ZlIGxheWVyIHdoZW4gY2FsbGluZyBhcmNoX2hhc193bWJfcG1lbSgpDQogICAgDQog ICAgUHJpb3IgdG8gdGhpcyBjaGFuZ2UgYXJjaF9oYXNfd21iX3BtZW0oKSB3YXMgb25seSBjYWxs ZWQgYnkNCiAgICBhcmNoX2hhc19wbWVtX2FwaSgpLiAgQm90aCBhcmNoX2hhc193bWJfcG1lbSgp IGFuZCBhcmNoX2hhc19wbWVtX2FwaSgpDQogICAgY2hlY2tlZCB0byBtYWtlIHN1cmUgdGhhdCBD T05GSUdfQVJDSF9IQVNfUE1FTV9BUEkgd2FzIGVuYWJsZWQuDQogICAgDQogICAgSW5zdGVhZCwg cmVtb3ZlIHRoZSBvbGQgYXJjaF9oYXNfd21iX3BtZW0oKSB3cmFwcGVyIHRvIGJlIHJpZCBvZiBv bmUNCiAgICBleHRyYSBsYXllciBvZiBpbmRpcmVjdGlvbiBhbmQgdGhlIHJlZHVuZGFudCBDT05G SUdfQVJDSF9IQVNfUE1FTV9BUEkNCiAgICBjaGVjay4gUmVuYW1lIF9fYXJjaF9oYXNfd21iX3Bt ZW0oKSB0byBhcmNoX2hhc193bWJfcG1lbSgpIHNpbmNlIHdlIG5vDQogICAgbG9uZ2VyIGhhdmUg YSB3cmFwcGVyLCBhbmQganVzdCBoYXZlIGFyY2hfaGFzX3BtZW1fYXBpKCkgY2FsbCB0aGUNCiAg ICBhcmNoaXRlY3R1cmUgc3BlY2lmaWMgYXJjaF9oYXNfd21iX3BtZW0oKSBkaXJlY3RseS4NCiAg ICANCiAgICBTaWduZWQtb2ZmLWJ5OiBSb3NzIFp3aXNsZXIgPHJvc3Muendpc2xlckBsaW51eC5p bnRlbC5jb20+DQogICAgUmV2aWV3ZWQtYnk6IENocmlzdG9waCBIZWxsd2lnIDxoY2hAbHN0LmRl Pg0KICAgIFNpZ25lZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwu Y29tPg0KDQpjb21taXQgNGEzNzBkZjU1MzRlZjcyN2NiYTlhOWQ3NGJmMjJlMDYwOWY5MWQ2ZQ0K QXV0aG9yOiBSb3NzIFp3aXNsZXIgPHJvc3Muendpc2xlckBsaW51eC5pbnRlbC5jb20+DQpEYXRl OiAgIFR1ZSBBdWcgMTggMTM6NTU6MzggMjAxNSAtMDYwMA0KDQogICAgcG1lbSwgeDg2OiBjbGVh biB1cCBjb25kaXRpb25hbCBwbWVtIGluY2x1ZGVzDQogICAgDQogICAgUHJpb3IgdG8gdGhpcyBj aGFuZ2UgeDg2XzY0IHVzZWQgdGhlIHBtZW0gZGVmaW5lcyBpbg0KICAgIGFyY2gveDg2L2luY2x1 ZGUvYXNtL3BtZW0uaCwgYW5kIFVNIHVzZWQgdGhlIGRlZmF1bHQgb25lcyBhdCB0aGUNCiAgICB0 b3Agb2YgaW5jbHVkZS9saW51eC9wbWVtLmguICBUaGUgaW5jbHVzaW9uIG9yIGV4Y2x1c2lvbiBp biBsaW51eC9wbWVtLmgNCiAgICB3YXMgY29udHJvbGxlZCBieSBDT05GSUdfQVJDSF9IQVNfUE1F TV9BUEksIGJ1dCB0aGUgb25lcyBpbiBhc20vcG1lbS5oDQogICAgd2VyZSBjb250cm9sbGVkIGJ5 IEFSQ0hfSEFTX05PQ0FDSEVfVUFDQ0VTUy4NCiAgICANCiAgICBJbnN0ZWFkLCBjb250cm9sIHRo ZW0gYm90aCB3aXRoIENPTkZJR19BUkNIX0hBU19QTUVNX0FQSSBzbyB0aGF0IGl0J3MNCiAgICBj bGVhciB0aGF0IHRoZXkgYXJlIHJlbGF0ZWQgYW5kIHdlIGRvbid0IHJ1biBpbnRvIHRoZSBwb3Nz aWJpbGl0eSB3aGVyZQ0KICAgIHRoZXkgYXJlIGJvdGggaW5jbHVkZWQgb3IgZXhjbHVkZWQuICBB bHNvIHJlbW92ZSBhIGJ1bmNoIG9mIHN0YWxlDQogICAgZnVuY3Rpb24gcHJvdG90eXBlcyBtZWFu dCBmb3IgVU0gaW4gYXNtL3BtZW0uaCAtIHRoZXNlIGp1c3QgY29uZmxpY3RlZA0KICAgIHdpdGgg dGhlIGlubGluZSBkZWZhdWx0cyBpbiBsaW51eC9wbWVtLmggYW5kIGdhdmUgY29tcGlsZSBlcnJv cnMuDQogICAgDQogICAgU2lnbmVkLW9mZi1ieTogUm9zcyBad2lzbGVyIDxyb3NzLnp3aXNsZXJA bGludXguaW50ZWwuY29tPg0KICAgIFJldmlld2VkLWJ5OiBDaHJpc3RvcGggSGVsbHdpZyA8aGNo QGxzdC5kZT4NCiAgICBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1z QGludGVsLmNvbT4NCg0KY29tbWl0IDVkZTQ5MGRhZWM4YjYzNTRiOTBkNWM5ZDNlMjQxNWIxOTVm NWFkYjYNCkF1dGhvcjogUm9zcyBad2lzbGVyIDxyb3NzLnp3aXNsZXJAbGludXguaW50ZWwuY29t Pg0KRGF0ZTogICBUdWUgQXVnIDE4IDEzOjU1OjM5IDIwMTUgLTA2MDANCg0KICAgIHBtZW06IGFk ZCBjb3B5X2Zyb21faXRlcl9wbWVtKCkgYW5kIGNsZWFyX3BtZW0oKQ0KICAgIA0KICAgIEFkZCBz dXBwb3J0IGZvciB0d28gbmV3IFBNRU0gQVBJcywgY29weV9mcm9tX2l0ZXJfcG1lbSgpIGFuZA0K ICAgIGNsZWFyX3BtZW0oKS4gIGNvcHlfZnJvbV9pdGVyX3BtZW0oKSBpcyB1c2VkIHRvIGNvcHkg ZGF0YSBmcm9tIGFuDQogICAgaXRlcmF0b3IgaW50byBhIFBNRU0gYnVmZmVyLiAgY2xlYXJfcG1l bSgpIHplcm9zIGEgUE1FTSBtZW1vcnkgcmFuZ2UuDQogICAgDQogICAgQm90aCBvZiB0aGVzZSBu ZXcgQVBJcyBtdXN0IGJlIGV4cGxpY2l0bHkgb3JkZXJlZCB1c2luZyBhIHdtYl9wbWVtKCkNCiAg ICBmdW5jdGlvbiBjYWxsIGFuZCBhcmUgaW1wbGVtZW50ZWQgaW4gc3VjaCBhIHdheSB0aGF0IHRo ZSB3bWJfcG1lbSgpDQogICAgd2lsbCBtYWtlIHRoZSBzdG9yZXMgdG8gUE1FTSBkdXJhYmxlLiAg QmVjYXVzZSBib3RoIEFQSXMgYXJlIHVub3JkZXJlZA0KICAgIHRoZXkgY2FuIGJlIGNhbGxlZCBh cyBuZWVkZWQgd2l0aG91dCBpbnRyb2R1Y2luZyBhbnkgdW53YW50ZWQgbWVtb3J5DQogICAgYmFy cmllcnMuDQogICAgDQogICAgU2lnbmVkLW9mZi1ieTogUm9zcyBad2lzbGVyIDxyb3NzLnp3aXNs ZXJAbGludXguaW50ZWwuY29tPg0KICAgIFNpZ25lZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8ZGFu Lmoud2lsbGlhbXNAaW50ZWwuY29tPg0KDQpjb21taXQgMjc2NWNmYmIzNDJjNzI3YzNmZDQ3YjE2 NTE5NmNiMTZkYTE1ODAyMg0KQXV0aG9yOiBSb3NzIFp3aXNsZXIgPHJvc3Muendpc2xlckBsaW51 eC5pbnRlbC5jb20+DQpEYXRlOiAgIFR1ZSBBdWcgMTggMTM6NTU6NDAgMjAxNSAtMDYwMA0KDQog ICAgZGF4OiB1cGRhdGUgSS9PIHBhdGggdG8gZG8gcHJvcGVyIFBNRU0gZmx1c2hpbmcNCiAgICAN CiAgICBVcGRhdGUgdGhlIERBWCBJL08gcGF0aCBzbyB0aGF0IGFsbCBvcGVyYXRpb25zIHRoYXQg c3RvcmUgZGF0YSAoSS9PDQogICAgd3JpdGVzLCB6ZXJvaW5nIGJsb2NrcywgcHVuY2hpbmcgaG9s ZXMsIGV0Yy4pIHByb3Blcmx5IHN5bmNocm9uaXplIHRoZQ0KICAgIHN0b3JlcyB0byBtZWRpYSB1 c2luZyB0aGUgUE1FTSBBUEkuICBUaGlzIGVuc3VyZXMgdGhhdCB0aGUgZGF0YSBEQVggaXMNCiAg ICB3cml0aW5nIGlzIGR1cmFibGUgb24gbWVkaWEgYmVmb3JlIHRoZSBvcGVyYXRpb24gY29tcGxl dGVzLg0KICAgIA0KICAgIFNpZ25lZC1vZmYtYnk6IFJvc3MgWndpc2xlciA8cm9zcy56d2lzbGVy QGxpbnV4LmludGVsLmNvbT4NCiAgICBSZXZpZXdlZC1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhj aEBsc3QuZGU+DQogICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFt c0BpbnRlbC5jb20+DQoNCmNvbW1pdCBlMmUwNTM5NGU0YTM0MjBkYWI5NmY3MjhkZjQ1MzE4OTM0 OTRlMTVkDQpBdXRob3I6IFJvc3MgWndpc2xlciA8cm9zcy56d2lzbGVyQGxpbnV4LmludGVsLmNv bT4NCkRhdGU6ICAgVHVlIEF1ZyAxOCAxMzo1NTo0MSAyMDE1IC0wNjAwDQoNCiAgICBwbWVtLCBk YXg6IGhhdmUgZGlyZWN0X2FjY2VzcyB1c2UgX19wbWVtIGFubm90YXRpb24NCiAgICANCiAgICBV cGRhdGUgdGhlIGFubm90YXRpb24gZm9yIHRoZSBrYWRkciBwb2ludGVyIHJldHVybmVkIGJ5IGRp cmVjdF9hY2Nlc3MoKQ0KICAgIHNvIHRoYXQgaXQgaXMgYSBfX3BtZW0gcG9pbnRlci4gIFRoaXMg aXMgY29uc2lzdGVudCB3aXRoIHRoZSBQTUVNIGRyaXZlcg0KICAgIGFuZCB3aXRoIGhvdyB0aGlz IGRpcmVjdF9hY2Nlc3MoKSBwb2ludGVyIGlzIHVzZWQgaW4gdGhlIERBWCBjb2RlLg0KICAgIA0K ICAgIFNpZ25lZC1vZmYtYnk6IFJvc3MgWndpc2xlciA8cm9zcy56d2lzbGVyQGxpbnV4LmludGVs LmNvbT4NCiAgICBSZXZpZXdlZC1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+DQog ICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+ DQoNCmNvbW1pdCBhMDZhNzU3NjUyNmUxMGE5OWVhNzcyMTUzM2U3ZjJkZjNlMjZiYWFkDQpBdXRo b3I6IHlhbGluIHdhbmcgPHlhbGluLndhbmcyMDEwQGdtYWlsLmNvbT4NCkRhdGU6ICAgVGh1IEF1 ZyAyNyAxOTozNTo0OCAyMDE1IC0wNDAwDQoNCiAgICBudmRpbW06IGNoYW5nZSB0byB1c2UgZ2Vu ZXJpYyBrdmZyZWUoKQ0KICAgIA0KICAgIFNpZ25lZC1vZmYtYnk6IHlhbGluIHdhbmcgPHlhbGlu LndhbmcyMDEwQGdtYWlsLmNvbT4NCiAgICBSZXZpZXdlZC1ieTogUm9zcyBad2lzbGVyIDxyb3Nz Lnp3aXNsZXJAbGludXguaW50ZWwuY29tPg0KICAgIFNpZ25lZC1vZmYtYnk6IERhbiBXaWxsaWFt cyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KDQpjb21taXQgNjdhM2U4ZmU5MDE1NmQ0MWNk NDgwZDNkZmJiNDBmM2JjMDA3YzI2Mg0KQXV0aG9yOiBSb3NzIFp3aXNsZXIgPHJvc3Muendpc2xl ckBsaW51eC5pbnRlbC5jb20+DQpEYXRlOiAgIFRodSBBdWcgMjcgMTM6MTQ6MjAgMjAxNSAtMDYw MA0KDQogICAgbmRfYmxrOiBjaGFuZ2UgYXBlcnR1cmUgbWFwcGluZyBmcm9tIFdDIHRvIFdCDQog ICAgDQogICAgVGhpcyBzaG91bGQgcmVzdWx0IGluIGEgcHJldHR5IHNpemVhYmxlIHBlcmZvcm1h bmNlIGdhaW4gZm9yIHJlYWRzLiAgRm9yDQogICAgcm91Z2ggY29tcGFyaXNvbiBJIGRpZCBzb21l IHNpbXBsZSByZWFkIHRlc3RpbmcgdXNpbmcgUE1FTSB0byBjb21wYXJlDQogICAgcmVhZHMgb2Yg d3JpdGUgY29tYmluaW5nIChXQykgbWFwcGluZ3MgdnMgd3JpdGUtYmFjayAoV0IpLiAgVGhpcyB3 YXMNCiAgICBkb25lIG9uIGEgcmFuZG9tIGxhYiBtYWNoaW5lLg0KICAgIA0KICAgIFBNRU0gcmVh ZHMgZnJvbSBhIHdyaXRlIGNvbWJpbmluZyBtYXBwaW5nOg0KICAgIAkjIGRkIG9mPS9kZXYvbnVs bCBpZj0vZGV2L3BtZW0wIGJzPTQwOTYgY291bnQ9MTAwMDAwDQogICAgCTEwMDAwMCswIHJlY29y ZHMgaW4NCiAgICAJMTAwMDAwKzAgcmVjb3JkcyBvdXQNCiAgICAJNDA5NjAwMDAwIGJ5dGVzICg0 MTAgTUIpIGNvcGllZCwgOS4yODU1IHMsIDQ0LjEgTUIvcw0KICAgIA0KICAgIFBNRU0gcmVhZHMg ZnJvbSBhIHdyaXRlLWJhY2sgbWFwcGluZzoNCiAgICAJIyBkZCBvZj0vZGV2L251bGwgaWY9L2Rl di9wbWVtMCBicz00MDk2IGNvdW50PTEwMDAwMDANCiAgICAJMTAwMDAwMCswIHJlY29yZHMgaW4N CiAgICAJMTAwMDAwMCswIHJlY29yZHMgb3V0DQogICAgCTQwOTYwMDAwMDAgYnl0ZXMgKDQuMSBH QikgY29waWVkLCAzLjQ0MDM0IHMsIDEuMiBHQi9zDQogICAgDQogICAgVG8gYmUgYWJsZSB0byBz YWZlbHkgc3VwcG9ydCBhIHdyaXRlLWJhY2sgYXBlcnR1cmUgSSBuZWVkZWQgdG8gYWRkDQogICAg c3VwcG9ydCBmb3IgdGhlICJyZWFkIGZsdXNoIiBfRFNNIGZsYWcsIGFzIG91dGxpbmVkIGluIHRo ZSBEU00gc3BlYzoNCiAgICANCiAgICBodHRwOi8vcG1lbS5pby9kb2N1bWVudHMvTlZESU1NX0RT TV9JbnRlcmZhY2VfRXhhbXBsZS5wZGYNCiAgICANCiAgICBUaGlzIGZsYWcgdGVsbHMgdGhlIE5E IEJMSyBkcml2ZXIgdGhhdCBpdCBuZWVkcyB0byBmbHVzaCB0aGUgY2FjaGUgbGluZXMNCiAgICBh c3NvY2lhdGVkIHdpdGggdGhlIGFwZXJ0dXJlIGFmdGVyIHRoZSBhcGVydHVyZSBpcyBtb3ZlZCBi dXQgYmVmb3JlIGFueQ0KICAgIG5ldyBkYXRhIGlzIHJlYWQuICBUaGlzIGVuc3VyZXMgdGhhdCBh bnkgc3RhbGUgY2FjaGUgbGluZXMgZnJvbSB0aGUNCiAgICBwcmV2aW91cyBjb250ZW50cyBvZiB0 aGUgYXBlcnR1cmUgd2lsbCBiZSBkaXNjYXJkZWQgZnJvbSB0aGUgcHJvY2Vzc29yDQogICAgY2Fj aGUsIGFuZCB0aGUgbmV3IGRhdGEgd2lsbCBiZSByZWFkIHByb3Blcmx5IGZyb20gdGhlIERJTU0u ICBXZSBrbm93DQogICAgdGhhdCB0aGUgY2FjaGUgbGluZXMgYXJlIGNsZWFuIGFuZCB3aWxsIGJl IGRpc2NhcmRlZCB3aXRob3V0IGFueQ0KICAgIHdyaXRlYmFjayBiZWNhdXNlIGVpdGhlciBhKSB0 aGUgcHJldmlvdXMgYXBlcnR1cmUgb3BlcmF0aW9uIHdhcyBhIHJlYWQsDQogICAgYW5kIHdlIG5l dmVyIG1vZGlmaWVkIHRoZSBjb250ZW50cyBvZiB0aGUgYXBlcnR1cmUsIG9yIGIpIHRoZSBwcmV2 aW91cw0KICAgIGFwZXJ0dXJlIG9wZXJhdGlvbiB3YXMgYSB3cml0ZSBhbmQgd2UgbXVzdCBoYXZl IHdyaXR0ZW4gYmFjayB0aGUgZGlydGllZA0KICAgIGNvbnRlbnRzIG9mIHRoZSBhcGVydHVyZSB0 byB0aGUgRElNTSBiZWZvcmUgdGhlIEkvTyB3YXMgY29tcGxldGVkLg0KICAgIA0KICAgIEluIG9y ZGVyIHRvIGFkZCBzdXBwb3J0IGZvciB0aGUgInJlYWQgZmx1c2giIGZsYWcgSSBuZWVkZWQgdG8g YWRkIGENCiAgICBnZW5lcmljIHJvdXRpbmUgdG8gaW52YWxpZGF0ZSBjYWNoZSBsaW5lcywgbW1p b19mbHVzaF9yYW5nZSgpLiAgVGhpcyBpcw0KICAgIHByb3RlY3RlZCBieSB0aGUgQVJDSF9IQVNf TU1JT19GTFVTSCBLY29uZmlnIHZhcmlhYmxlLCBhbmQgaXMgY3VycmVudGx5DQogICAgb25seSBz dXBwb3J0ZWQgb24geDg2Lg0KICAgIA0KICAgIFNpZ25lZC1vZmYtYnk6IFJvc3MgWndpc2xlciA8 cm9zcy56d2lzbGVyQGxpbnV4LmludGVsLmNvbT4NCiAgICBTaWduZWQtb2ZmLWJ5OiBEYW4gV2ls bGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCg0KY29tbWl0IDRhOWJmODhhNWNhYTg0 OTViNWViMmI3MzhkNWZiNDA5MjRiYmM1MzgNCk1lcmdlOiBhMDZhNzU3NjUyNmUgNjdhM2U4ZmU5 MDE1DQpBdXRob3I6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KRGF0 ZTogICBUaHUgQXVnIDI3IDE5OjQwOjI2IDIwMTUgLTA0MDANCg0KICAgIE1lcmdlIGJyYW5jaCAn cG1lbS1hcGknIGludG8gbGlibnZkaW1tLWZvci1uZXh0DQoNCmNvbW1pdCBjYjM4OWI5YzBlMDBj MzBjOWRhZjIwMjg3ZjdkOTFlMjQ2NmVkYmIxDQpBdXRob3I6IERhbiBXaWxsaWFtcyA8ZGFuLmou d2lsbGlhbXNAaW50ZWwuY29tPg0KRGF0ZTogICBGcmkgQXVnIDcgMTc6NDE6MDAgMjAxNSAtMDQw MA0KDQogICAgZGF4OiBkcm9wIHNpemUgcGFyYW1ldGVyIHRvIC0+ZGlyZWN0X2FjY2VzcygpDQog ICAgDQogICAgTm9uZSBvZiB0aGUgaW1wbGVtZW50YXRpb25zIGN1cnJlbnRseSB1c2UgaXQuICBU aGUgY29tbW9uDQogICAgYmRldl9kaXJlY3RfYWNjZXNzKCkgZW50cnkgcG9pbnQgaGFuZGxlcyBh bGwgdGhlIHNpemUgY2hlY2tzIGJlZm9yZQ0KICAgIGNhbGxpbmcgLT5kaXJlY3RfYWNjZXNzKCku DQogICAgDQogICAgU2lnbmVkLW9mZi1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+ DQogICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5j b20+DQoNCmNvbW1pdCAwMTJkY2VmM2YwNTgzODUyNjg2MzBjMDAwM2U5YjdmOGRjYWZiZWI0DQpB dXRob3I6IENocmlzdG9waCBIZWxsd2lnIDxoY2hAbHN0LmRlPg0KRGF0ZTogICBGcmkgQXVnIDcg MTc6NDE6MDEgMjAxNSAtMDQwMA0KDQogICAgbW06IG1vdmUgX19waHlzX3RvX3BmbiBhbmQgX19w Zm5fdG9fcGh5cyB0byBhc20vZ2VuZXJpYy9tZW1vcnlfbW9kZWwuaA0KICAgIA0KICAgIFRocmVl IGFyY2hpdGVjdHVyZXMgYWxyZWFkeSBkZWZpbmUgdGhlc2UsIGFuZCB3ZSdsbCBuZWVkIHRoZW0g Z2VuZXJpY2x5DQogICAgc29vbi4NCiAgICANCiAgICBTaWduZWQtb2ZmLWJ5OiBDaHJpc3RvcGgg SGVsbHdpZyA8aGNoQGxzdC5kZT4NCiAgICBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRh bi5qLndpbGxpYW1zQGludGVsLmNvbT4NCg0KY29tbWl0IDAzM2ZiYWU5ODhmY2I2N2U1MDc3MjAz NTEyMTgxODkwODQ4YjhlOTANCkF1dGhvcjogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0Bp bnRlbC5jb20+DQpEYXRlOiAgIFN1biBBdWcgOSAxNToyOTowNiAyMDE1IC0wNDAwDQoNCiAgICBt bTogWk9ORV9ERVZJQ0UgZm9yICJkZXZpY2UgbWVtb3J5Ig0KICAgIA0KICAgIFdoaWxlIHBtZW0g aXMgdXNhYmxlIGFzIGEgYmxvY2sgZGV2aWNlIG9yIHZpYSBEQVggbWFwcGluZ3MgdG8gdXNlcnNw YWNlDQogICAgdGhlcmUgYXJlIHNldmVyYWwgdXNhZ2Ugc2NlbmFyaW9zIHRoYXQgY2FuIG5vdCB0 YXJnZXQgcG1lbSBkdWUgdG8gaXRzDQogICAgbGFjayBvZiBzdHJ1Y3QgcGFnZSBjb3ZlcmFnZS4g SW4gcHJlcGFyYXRpb24gZm9yICJob3QgcGx1Z2dpbmciIHBtZW0NCiAgICBpbnRvIHRoZSB2bWVt bWFwIGFkZCBaT05FX0RFVklDRSBhcyBhIG5ldyB6b25lIHRvIHRhZyB0aGVzZSBwYWdlcw0KICAg IHNlcGFyYXRlbHkgZnJvbSB0aGUgb25lcyB0aGF0IGFyZSBzdWJqZWN0IHRvIHN0YW5kYXJkIHBh Z2UgYWxsb2NhdGlvbnMuDQogICAgSW1wb3J0YW50bHkgImRldmljZSBtZW1vcnkiIGNhbiBiZSBy ZW1vdmVkIGF0IHdpbGwgYnkgdXNlcnNwYWNlDQogICAgdW5iaW5kaW5nIHRoZSBkcml2ZXIgb2Yg dGhlIGRldmljZS4NCiAgICANCiAgICBIYXZpbmcgYSBzZXBhcmF0ZSB6b25lIHByZXZlbnRzIGFs bG9jYXRpb24gYW5kIG90aGVyd2lzZSBtYXJrcyB0aGVzZQ0KICAgIHBhZ2VzIHRoYXQgYXJlIGRp c3RpbmN0IGZyb20gdHlwaWNhbCB1bmlmb3JtIG1lbW9yeS4gIERldmljZSBtZW1vcnkgaGFzDQog ICAgZGlmZmVyZW50IGxpZmV0aW1lIGFuZCBwZXJmb3JtYW5jZSBjaGFyYWN0ZXJpc3RpY3MgdGhh biBSQU0uICBIb3dldmVyLA0KICAgIHNpbmNlIHdlIGhhdmUgcnVuIG91dCBvZiBaT05FU19TSElG VCBiaXRzIHRoaXMgZnVuY3Rpb25hbGl0eSBjdXJyZW50bHkNCiAgICBkZXBlbmRzIG9uIHNhY3Jp ZmljaW5nIFpPTkVfRE1BLg0KICAgIA0KICAgIENjOiBILiBQZXRlciBBbnZpbiA8aHBhQHp5dG9y LmNvbT4NCiAgICBDYzogSW5nbyBNb2xuYXIgPG1pbmdvQHJlZGhhdC5jb20+DQogICAgQ2M6IERh dmUgSGFuc2VuIDxkYXZlLmhhbnNlbkBsaW51eC5pbnRlbC5jb20+DQogICAgQ2M6IFJpayB2YW4g UmllbCA8cmllbEByZWRoYXQuY29tPg0KICAgIENjOiBNZWwgR29ybWFuIDxtZ29ybWFuQHN1c2Uu ZGU+DQogICAgQ2M6IEplcm9tZSBHbGlzc2UgPGouZ2xpc3NlQGdtYWlsLmNvbT4NCiAgICBbaGNo OiB2YXJpb3VzIHNpbXBsaWZpY2F0aW9ucyBpbiB0aGUgYXJjaCBpbnRlcmZhY2VdDQogICAgU2ln bmVkLW9mZi1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+DQogICAgU2lnbmVkLW9m Zi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+DQoNCmNvbW1pdCA0 MWU5NGE4NTEzMDRmN2FjYWM4NDBhZGVjNDAwNGY4YWVlZTUzYWQ0DQpBdXRob3I6IENocmlzdG9w aCBIZWxsd2lnIDxoY2hAbHN0LmRlPg0KRGF0ZTogICBNb24gQXVnIDE3IDE2OjAwOjM1IDIwMTUg KzAyMDANCg0KICAgIGFkZCBkZXZtX21lbXJlbWFwX3BhZ2VzDQogICAgDQogICAgVGhpcyBiZWhh dmVzIGxpa2UgZGV2bV9tZW1yZW1hcCBleGNlcHQgdGhhdCBpdCBlbnN1cmVzIHdlIGhhdmUgcGFn ZQ0KICAgIHN0cnVjdHVyZXMgYXZhaWxhYmxlIHRoYXQgY2FuIGJhY2sgdGhlIHJlZ2lvbi4NCiAg ICANCiAgICBTaWduZWQtb2ZmLWJ5OiBDaHJpc3RvcGggSGVsbHdpZyA8aGNoQGxzdC5kZT4NCiAg ICBbZGpidzogY2F0Y2ggYXR0ZW1wdHMgdG8gcmVtYXAgUkFNLCBkcm9wIGZsYWdzXQ0KICAgIFNp Z25lZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KDQpj b21taXQgOTY2MDFhZGI3NDUxODZjY2JjZjViMDc4ZDQ3NTZmMTMzODFlYzJhZg0KQXV0aG9yOiBE YW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1zQGludGVsLmNvbT4NCkRhdGU6ICAgTW9uIEF1ZyAy NCAxODoyOTozOCAyMDE1IC0wNDAwDQoNCiAgICB4ODYsIHBtZW06IGNsYXJpZnkgdGhhdCBBUkNI X0hBU19QTUVNX0FQSSBpbXBsaWVzIFBNRU0gbWFwcGVkIFdCDQogICAgDQogICAgR2l2ZW4gdGhh dCBhIHdyaXRlLWJhY2sgKFdCKSBtYXBwaW5nIHBsdXMgbm9uLXRlbXBvcmFsIHN0b3JlcyBpcw0K ICAgIGV4cGVjdGVkIHRvIGJlIHRoZSBtb3N0IGVmZmljaWVudCB3YXkgdG8gYWNjZXNzIFBNRU0s IHVwZGF0ZSB0aGUNCiAgICBkZWZpbml0aW9uIG9mIEFSQ0hfSEFTX1BNRU1fQVBJIHRvIGltcGx5 IGFyY2ggc3VwcG9ydCBmb3INCiAgICBXQi1tYXBwZWQtUE1FTS4gIFRoaXMgaXMgbmVlZGVkIGFz IGEgcHJlLXJlcXVpc2l0ZSBmb3IgYWRkaW5nIFBNRU0gdG8NCiAgICB0aGUgZGlyZWN0IG1hcCBh bmQgbWFwcGluZyBpdCB3aXRoIHN0cnVjdCBwYWdlLg0KICAgIA0KICAgIFRoZSBhYm92ZSBjbGFy aWZpY2F0aW9uIGZvciBYODZfNjQgbWVhbnMgdGhhdCBtZW1jcHlfdG9fcG1lbSgpIGlzDQogICAg cGVybWl0dGVkIHRvIHVzZSB0aGUgbm9uLXRlbXBvcmFsIGFyY2hfbWVtY3B5X3RvX3BtZW0oKSBy YXRoZXIgdGhhbg0KICAgIG5lZWRsZXNzbHkgZmFsbCBiYWNrIHRvIGRlZmF1bHRfbWVtY3B5X3Rv X3BtZW0oKSB3aGVuIHRoZSBwY29tbWl0DQogICAgaW5zdHJ1Y3Rpb24gaXMgbm90IGF2YWlsYWJs ZS4gIFdoZW4gYXJjaF9tZW1jcHlfdG9fcG1lbSgpIGlzIG5vdA0KICAgIGd1YXJhbnRlZWQgdG8g Zmx1c2ggd3JpdGVzIG91dCBvZiBjYWNoZSwgaS5lLiBvbiBvbGRlciBYODZfMzINCiAgICBpbXBs ZW1lbnRhdGlvbnMgd2hlcmUgbm9uLXRlbXBvcmFsIHN0b3JlcyBtYXkganVzdCBkaXJ0eSBjYWNo ZSwNCiAgICBBUkNIX0hBU19QTUVNX0FQSSBpcyBzaW1wbHkgZGlzYWJsZWQuDQogICAgDQogICAg VGhlIGRlZmF1bHQgZmFsbCBiYWNrIGZvciBwZXJzaXN0ZW50IG1lbW9yeSBoYW5kbGluZyByZW1h aW5zLiAgTmFtZWx5LA0KICAgIG1hcCBpdCB3aXRoIHRoZSBXVCAod3JpdGUtdGhyb3VnaCkgY2Fj aGUtdHlwZSBhbmQgaG9wZSBmb3IgdGhlIGJlc3QuDQogICAgDQogICAgYXJjaF9oYXNfcG1lbV9h cGkoKSBpcyB1cGRhdGVkIHRvIG9ubHkgaW5kaWNhdGUgd2hldGhlciB0aGUgYXJjaA0KICAgIHBy b3ZpZGVzIHRoZSBwcm9wZXIgaGVscGVycyB0byBtZWV0IHRoZSBtaW5pbXVtICJ3cml0ZXMgYXJl IHZpc2libGUNCiAgICBvdXRzaWRlIHRoZSBjYWNoZSBoaWVyYXJjaHkgYWZ0ZXIgbWVtY3B5X3Rv X3BtZW0oKSArIHdtYl9wbWVtKCkiLiAgQ29kZQ0KICAgIHRoYXQgY2FyZXMgd2hldGhlciB3bWJf cG1lbSgpIGFjdHVhbGx5IGZsdXNoZXMgd3JpdGVzIHRvIHBtZW0gbXVzdCBub3cNCiAgICBjYWxs IGFyY2hfaGFzX3dtYl9wbWVtKCkgZGlyZWN0bHkuDQogICAgDQogICAgQ2M6IFRob21hcyBHbGVp eG5lciA8dGdseEBsaW51dHJvbml4LmRlPg0KICAgIENjOiBJbmdvIE1vbG5hciA8bWluZ29AcmVk aGF0LmNvbT4NCiAgICBDYzogIkguIFBldGVyIEFudmluIiA8aHBhQHp5dG9yLmNvbT4NCiAgICBS ZXZpZXdlZC1ieTogUm9zcyBad2lzbGVyIDxyb3NzLnp3aXNsZXJAbGludXguaW50ZWwuY29tPg0K ICAgIFtoY2g6IHNldCBBUkNIX0hBU19QTUVNX0FQST1uIG9uIHg4Nl8zMl0NCiAgICBSZXZpZXdl ZC1ieTogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+DQogICAgW3Rvc2hpOiB4ODZfMzIg Y29tcGlsZSBmaXhlc10NCiAgICBTaWduZWQtb2ZmLWJ5OiBUb3NoaSBLYW5pIDx0b3NoaS5rYW5p QGhwLmNvbT4NCiAgICBTaWduZWQtb2ZmLWJ5OiBEYW4gV2lsbGlhbXMgPGRhbi5qLndpbGxpYW1z QGludGVsLmNvbT4NCg0KY29tbWl0IGUxNDU1NzQ0YjI3YzllNjExNWMzNTA4YTdiMjkwMjE1N2My YzQzNDcNCkF1dGhvcjogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+DQpE YXRlOiAgIFRodSBKdWwgMzAgMTc6NTc6NDcgMjAxNSAtMDQwMA0KDQogICAgbGlibnZkaW1tLCBw Zm46ICdzdHJ1Y3QgcGFnZScgcHJvdmlkZXIgaW5mcmFzdHJ1Y3R1cmUNCiAgICANCiAgICBJbXBs ZW1lbnQgdGhlIGJhc2UgaW5mcmFzdHJ1Y3R1cmUgZm9yIGxpYm52ZGltbSBQRk4gZGV2aWNlcy4g U2ltaWxhciB0bw0KICAgIEJUVCBkZXZpY2VzIHRoZXkgdGFrZSBhIG5hbWVzcGFjZSBhcyBhIGJh Y2tpbmcgZGV2aWNlIGFuZCBsYXllcg0KICAgIGZ1bmN0aW9uYWxpdHkgb24gdG9wLiBJbiB0aGlz IGNhc2UgdGhlIGZ1bmN0aW9uYWxpdHkgaXMgcmVzZXJ2aW5nIHNwYWNlDQogICAgZm9yIGFuIGFy cmF5IG9mICdzdHJ1Y3QgcGFnZScgZW50cmllcyB0byBiZSBoYW5kZWQgb3V0IHRocm91Z2gNCiAg ICBwZm5fdG9fcGFnZSgpLiBGb3Igbm93IHRoaXMgaXMganVzdCB0aGUgYmFzaWMgbGlibnZkaW1t LWRldmljZS1tb2RlbCBmb3INCiAgICBjb25maWd1cmluZyB0aGUgYmFzZSBQRk4gZGV2aWNlLg0K ICAgIA0KICAgIEFzIHRoZSBuYW1lc3BhY2UgY2xhaW1pbmcgbWVjaGFuaXNtIGZvciBQRk4gZGV2 aWNlcyBpcyBtb3N0bHkgaWRlbnRpY2FsDQogICAgdG8gQlRUIGRldmljZXMgZHJpdmVycy9udmRp bW0vY2xhaW0uYyBpcyBjcmVhdGVkIHRvIGhvdXNlIHRoZSBjb21tb24NCiAgICBiaXRzLg0KICAg IA0KICAgIENjOiBSb3NzIFp3aXNsZXIgPHJvc3Muendpc2xlckBsaW51eC5pbnRlbC5jb20+DQog ICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+ DQoNCmNvbW1pdCAzMmFiMGEzZjUxNzAxY2IzN2FiOTYwNjM1MjU0ZDVmODRlYzNkZTBhDQpBdXRo b3I6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KRGF0ZTogICBTYXQg QXVnIDEgMDI6MTY6MzcgMjAxNSAtMDQwMA0KDQogICAgbGlibnZkaW1tLCBwbWVtOiAnc3RydWN0 IHBhZ2UnIGZvciBwbWVtDQogICAgDQogICAgRW5hYmxlIHRoZSBwbWVtIGRyaXZlciB0byBoYW5k bGUgUEZOIGRldmljZSBpbnN0YW5jZXMuICBBdHRhY2hpbmcgYSBwbWVtDQogICAgbmFtZXNwYWNl IHRvIGEgcGZuIGRldmljZSB0cmlnZ2VycyB0aGUgZHJpdmVyIHRvIGFsbG9jYXRlIGFuZCBpbml0 aWFsaXplDQogICAgc3RydWN0IHBhZ2UgZW50cmllcyBmb3IgcG1lbS4gIE1lbW9yeSBjYXBhY2l0 eSBmb3IgdGhpcyBhbGxvY2F0aW9uIGNvbWVzDQogICAgZXhjbHVzaXZlbHkgZnJvbSBSQU0gZm9y IG5vdyB3aGljaCBpcyBzdWl0YWJsZSBmb3IgbG93IFBNRU0gdG8gUkFNDQogICAgcmF0aW9zLiAg VGhpcyBtZWNoYW5pc20gd2lsbCBiZSBleHBhbmRlZCBsYXRlciBmb3Igc2V0dGluZyBhbiAiYWxs b2NhdGUNCiAgICBmcm9tIFBNRU0iIHBvbGljeS4NCiAgICANCiAgICBDYzogQm9heiBIYXJyb3No IDxib2F6QHBsZXhpc3Rvci5jb20+DQogICAgQ2M6IFJvc3MgWndpc2xlciA8cm9zcy56d2lzbGVy QGxpbnV4LmludGVsLmNvbT4NCiAgICBDYzogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+ DQogICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5j b20+DQoNCmNvbW1pdCAwMDRmMWFmYmUxOTllNmFiMjA4MDViOTVhZWZkODNjY2QyNGJjNWM3DQpB dXRob3I6IERhbiBXaWxsaWFtcyA8ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KRGF0ZTogICBN b24gQXVnIDI0IDE5OjIwOjIzIDIwMTUgLTA0MDANCg0KICAgIGxpYm52ZGltbSwgcG1lbTogZGly ZWN0IG1hcCBsZWdhY3kgcG1lbSBieSBkZWZhdWx0DQogICAgDQogICAgVGhlIGV4cGVjdGF0aW9u IGlzIHRoYXQgdGhlIGxlZ2FjeSAvIG5vbi1zdGFuZGFyZCBwbWVtIGRpc2NvdmVyeSBtZXRob2QN CiAgICAoZTgyMCB0eXBlLTEyKSB3aWxsIG9ubHkgZXZlciBiZSB1c2VkIHRvIGRlc2NyaWJlIHNt YWxsIHF1YW50aXRpZXMgb2YNCiAgICBwZXJzaXN0ZW50IG1lbW9yeS4gIExhcmdlciBjYXBhY2l0 aWVzIHdpbGwgYmUgZGVzY3JpYmVkIHZpYSB0aGUgQUNQSQ0KICAgIE5GSVQuICBXaGVuICJhbGxv Y2F0ZSBzdHJ1Y3QgcGFnZSBmcm9tIHBtZW0iIHN1cHBvcnQgaXMgYWRkZWQgdGhpcyBkZWZhdWx0 DQogICAgcG9saWN5IGNhbiBiZSBvdmVycmlkZGVuIGJ5IGFzc2lnbmluZyBhIGxlZ2FjeSBwbWVt IG5hbWVzcGFjZSB0byBhIHBmbg0KICAgIGRldmljZSwgaG93ZXZlciB0aGlzIHdvdWxkIGJlIG9u bHkgYmUgbmVjZXNzYXJ5IGlmIGEgcGxhdGZvcm0gdXNlZCB0aGUNCiAgICBsZWdhY3kgbWVjaGFu aXNtIHRvIGRlZmluZSBhIHZlcnkgbGFyZ2UgcmFuZ2UuDQogICAgDQogICAgQ2M6IENocmlzdG9w aCBIZWxsd2lnIDxoY2hAbHN0LmRlPg0KICAgIFNpZ25lZC1vZmYtYnk6IERhbiBXaWxsaWFtcyA8 ZGFuLmoud2lsbGlhbXNAaW50ZWwuY29tPg0KDQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932888AbbIDAWG (ORCPT ); Thu, 3 Sep 2015 20:22:06 -0400 Received: from mga02.intel.com ([134.134.136.20]:17738 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753316AbbIDAWC (ORCPT ); Thu, 3 Sep 2015 20:22:02 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.17,465,1437462000"; d="scan'208";a="761962777" From: "Williams, Dan J" To: "torvalds@linux-foundation.org" , "akpm@linux-foundation.org" CC: "hch@lst.de" , "linux-kernel@vger.kernel.org" , "linux-nvdimm@lists.01.org" , "toshi.kani@hp.com" , "ross.zwisler@linux.intel.com" , "linux-acpi@vger.kernel.org" , "boaz@plexistor.com" Subject: [GIT PULL] libnvdimm for 4.3 Thread-Topic: [GIT PULL] libnvdimm for 4.3 Thread-Index: AQHQ5qe2/j/9+qwOEEC+VY8TNnq3ow== Date: Fri, 4 Sep 2015 00:21:59 +0000 Message-ID: <1441326118.24518.6.camel@intel.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: <1B08A7551D56E44FA601B442CAFD7102@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 t840MEHY002965 Hi Linus, please pull from: git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm tags/libnvdimm-for-4.3 ...to receive the libnvdimm update and related changes for 4.3. This update has successfully completed a 0day-kbuild run and has appeared in a linux-next release. The changes outside of the typical drivers/nvdimm/ and drivers/acpi/nfit.[ch] paths are related to the removal of IORESOURCE_CACHEABLE, the introduction of memremap(), and the introduction of ZONE_DEVICE + devm_memremap_pages(). This has a minor conflict with a fix that went into v4.2, commit de4a196c02a2 "nfit, nd_blk: BLK status register is only 32 bits", but otherwise merges cleanly with mainline. -- The following changes since commit cbfe8fa6cd672011c755c3cd85c9ffd4e2d10a6f: Linux 4.2-rc4 (2015-07-26 12:26:21 -0700) are available in the git repository at: git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm tags/libnvdimm-for-4.3 for you to fetch changes up to 004f1afbe199e6ab20805b95aefd83ccd24bc5c7: libnvdimm, pmem: direct map legacy pmem by default (2015-08-28 23:40:05 -0400) ---------------------------------------------------------------- libnvdimm for 4.3: 1/ Introduce ZONE_DEVICE and devm_memremap_pages() as a generic mechanism for adding device-driver-discovered memory regions to the kernel's direct map. This facility is used by the pmem driver to enable pfn_to_page() operations on the page frames returned by DAX ('direct_access' in 'struct block_device_operations'). For now, the 'memmap' allocation for these "device" pages comes from "System RAM". Support for allocating the memmap from device memory will arrive in a later kernel. 2/ Introduce memremap() to replace usages of ioremap_cache() and ioremap_wt(). memremap() drops the __iomem annotation for these mappings to memory that do not have i/o side effects. The replacement of ioremap_cache() with memremap() is limited to the pmem driver to ease merging the api change in v4.3. Completion of the conversion is targeted for v4.4. 3/ Similar to the usage of memcpy_to_pmem() + wmb_pmem() in the pmem driver, update the VFS DAX implementation and PMEM api to provide persistence guarantees for kernel operations on a DAX mapping. 4/ Convert the ACPI NFIT 'BLK' driver to map the block apertures as cacheable to improve performance. 5/ Miscellaneous updates and fixes to libnvdimm including support for issuing "address range scrub" commands, clarifying the optimal 'sector size' of pmem devices, a clarification of the usage of the ACPI '_STA' (status) property for DIMM devices, and other minor fixes. ---------------------------------------------------------------- Christoph Hellwig (4): devres: add devm_memremap pmem: switch to devm_ allocations mm: move __phys_to_pfn and __pfn_to_phys to asm/generic/memory_model.h add devm_memremap_pages Dan Williams (15): libnvdimm, btt: sparse fix mm: enhance region_is_ram() to region_intersects() arch, drivers: don't include directly, use instead cleanup IORESOURCE_CACHEABLE vs ioremap() arch: introduce memremap() visorbus: switch from ioremap_cache to memremap pmem: convert to generic memremap libnvdimm, e820: make CONFIG_X86_PMEM_LEGACY a tristate option Merge branch 'pmem-api' into libnvdimm-for-next dax: drop size parameter to ->direct_access() mm: ZONE_DEVICE for "device memory" x86, pmem: clarify that ARCH_HAS_PMEM_API implies PMEM mapped WB libnvdimm, pfn: 'struct page' provider infrastructure libnvdimm, pmem: 'struct page' for pmem libnvdimm, pmem: direct map legacy pmem by default Linda Knippers (1): nfit: Don't check _STA on NVDIMM devices Randy Dunlap (1): nvdimm: fix inline function return type warning Ross Zwisler (7): pmem, x86: move x86 PMEM API to new pmem.h header pmem: remove layer when calling arch_has_wmb_pmem() pmem, x86: clean up conditional pmem includes pmem: add copy_from_iter_pmem() and clear_pmem() dax: update I/O path to do proper PMEM flushing pmem, dax: have direct_access use __pmem annotation nd_blk: change aperture mapping from WC to WB Vishal Verma (6): libnvdimm: Update name of the ars_status_record mask field libnvdimm: Add DSM support for Address Range Scrub commands libnvdimm, pmem: Change pmem physical sector size to PAGE_SIZE libnvdimm, btt: clean up internal interfaces libnvdimm, btt: consolidate arena validation libnvdimm, btt: write and validate parent_uuid yalin wang (1): nvdimm: change to use generic kvfree() Documentation/filesystems/Locking | 3 +- MAINTAINERS | 1 + arch/arm/include/asm/memory.h | 6 - arch/arm/mach-clps711x/board-cdb89712.c | 2 +- arch/arm/mach-shmobile/pm-rcar.c | 2 +- arch/arm64/include/asm/memory.h | 6 - arch/ia64/include/asm/io.h | 1 + arch/ia64/kernel/cyclone.c | 2 +- arch/ia64/mm/init.c | 4 +- arch/powerpc/kernel/pci_of_scan.c | 2 +- arch/powerpc/mm/mem.c | 4 +- arch/powerpc/sysdev/axonram.c | 7 +- arch/s390/mm/init.c | 2 +- arch/sh/include/asm/io.h | 1 + arch/sh/mm/init.c | 5 +- arch/sparc/kernel/pci.c | 3 +- arch/tile/mm/init.c | 2 +- arch/unicore32/include/asm/memory.h | 6 - arch/x86/Kconfig | 9 +- arch/x86/include/asm/cacheflush.h | 73 +----- arch/x86/include/asm/io.h | 6 - arch/x86/include/asm/pmem.h | 153 +++++++++++ arch/x86/include/uapi/asm/e820.h | 2 +- arch/x86/kernel/Makefile | 2 +- arch/x86/kernel/pmem.c | 79 +----- arch/x86/mm/init_32.c | 4 +- arch/x86/mm/init_64.c | 4 +- arch/xtensa/include/asm/io.h | 1 + drivers/acpi/Kconfig | 1 + drivers/acpi/nfit.c | 79 +++--- drivers/acpi/nfit.h | 17 +- drivers/block/brd.c | 8 +- drivers/isdn/icn/icn.h | 2 +- drivers/mtd/devices/slram.c | 2 +- drivers/mtd/nand/diskonchip.c | 2 +- drivers/mtd/onenand/generic.c | 2 +- drivers/nvdimm/Kconfig | 23 ++ drivers/nvdimm/Makefile | 5 + drivers/nvdimm/btt.c | 50 +--- drivers/nvdimm/btt.h | 3 + drivers/nvdimm/btt_devs.c | 215 ++++------------ drivers/nvdimm/claim.c | 201 +++++++++++++++ drivers/nvdimm/dimm_devs.c | 5 +- drivers/nvdimm/e820.c | 87 +++++++ drivers/nvdimm/namespace_devs.c | 89 ++++++- drivers/nvdimm/nd-core.h | 9 + drivers/nvdimm/nd.h | 67 ++++- drivers/nvdimm/pfn.h | 35 +++ drivers/nvdimm/pfn_devs.c | 337 +++++++++++++++++++++++++ drivers/nvdimm/pmem.c | 245 +++++++++++++++--- drivers/nvdimm/region.c | 2 + drivers/nvdimm/region_devs.c | 20 ++ drivers/pci/probe.c | 3 +- drivers/pnp/manager.c | 2 - drivers/s390/block/dcssblk.c | 10 +- drivers/scsi/aic94xx/aic94xx_init.c | 7 +- drivers/scsi/arcmsr/arcmsr_hba.c | 5 +- drivers/scsi/mvsas/mv_init.c | 15 +- drivers/scsi/sun3x_esp.c | 2 +- drivers/staging/comedi/drivers/ii_pci20kc.c | 1 + drivers/staging/unisys/visorbus/visorchannel.c | 16 +- drivers/staging/unisys/visorbus/visorchipset.c | 17 +- drivers/tty/serial/8250/8250_core.c | 2 +- drivers/video/fbdev/ocfb.c | 1 - drivers/video/fbdev/s1d13xxxfb.c | 3 +- drivers/video/fbdev/stifb.c | 1 + fs/block_dev.c | 4 +- fs/dax.c | 62 +++-- include/asm-generic/memory_model.h | 6 + include/linux/blkdev.h | 8 +- include/linux/io-mapping.h | 2 +- include/linux/io.h | 33 +++ include/linux/libnvdimm.h | 4 + include/linux/memory_hotplug.h | 5 +- include/linux/mm.h | 9 +- include/linux/mmzone.h | 23 ++ include/linux/mtd/map.h | 2 +- include/linux/pmem.h | 115 ++++++--- include/uapi/linux/ndctl.h | 12 +- include/video/vga.h | 2 +- kernel/Makefile | 2 + kernel/memremap.c | 190 ++++++++++++++ kernel/resource.c | 61 +++-- lib/Kconfig | 3 + lib/devres.c | 13 +- lib/pci_iomap.c | 7 +- mm/Kconfig | 17 ++ mm/memory_hotplug.c | 14 +- mm/page_alloc.c | 3 + tools/testing/nvdimm/Kbuild | 13 +- tools/testing/nvdimm/test/iomap.c | 85 ++++++- tools/testing/nvdimm/test/nfit.c | 209 ++++++++++----- 92 files changed, 2142 insertions(+), 745 deletions(-) create mode 100644 arch/x86/include/asm/pmem.h create mode 100644 drivers/nvdimm/claim.c create mode 100644 drivers/nvdimm/e820.c create mode 100644 drivers/nvdimm/pfn.h create mode 100644 drivers/nvdimm/pfn_devs.c create mode 100644 kernel/memremap.c commit 5e32940621eb62064d98f42c9889db71b0368bde Author: Dan Williams Date: Sat Jul 11 10:02:46 2015 -0400 libnvdimm, btt: sparse fix Fix: drivers/nvdimm/btt.c:635:29: warning: restricted __le64 degrades to integer Signed-off-by: Dan Williams commit ec92777f2ba93c00387b8fe53780c25adc57c744 Author: Vishal Verma Date: Thu Jul 9 13:25:35 2015 -0600 libnvdimm: Update name of the ars_status_record mask field The spec suggests that this is a simple 'length' field, not a mask. Update the name accordingly. Signed-off-by: Vishal Verma Signed-off-by: Dan Williams commit 39c686b862cdb2049b90e095b6c6c727b2a7ab60 Author: Vishal Verma Date: Thu Jul 9 13:25:36 2015 -0600 libnvdimm: Add DSM support for Address Range Scrub commands Add support for the three ARS DSM commands: - Query ARS Capabilities - Queries the firmware to check if a given range supports scrub, and if so, which type (persistent vs. volatile) - Start ARS - Starts a scrub for a given range/type - Query ARS Status - Checks status of a previously started scrub, and provides the error logs if any. The commands are described by the example DSM spec at: http://pmem.io/documents/NVDIMM_DSM_Interface_Example.pdf Also add these commands to the nfit_test test framework, and return canned data. Signed-off-by: Vishal Verma Signed-off-by: Dan Williams commit 6b47496a6fc81816e7edaf8224dfb88e402a05f5 Author: Vishal Verma Date: Thu Jul 23 11:58:48 2015 -0600 libnvdimm, pmem: Change pmem physical sector size to PAGE_SIZE Based on a patch: c8fa317 brd: Request from fdisk 4k alignment by Boaz Harrosh, allow fdisk to create properly aligned partitions for DAX. This will also cause mkfs.ext4 to emit a warning if using a file system block size of less than PAGE_SIZE. Cc: Dan Williams Cc: Ross Zwisler Cc: Matthew Wilcox Cc: Christoph Hellwig Cc: Elliott, Robert Signed-off-by: Vishal Verma Acked-by: Boaz Harrosh Acked-by: Ross Zwisler Signed-off-by: Dan Williams commit 60e95f43fc8573e81f54b0c1e0bc542c2260d956 Author: Linda Knippers Date: Wed Jul 22 16:17:22 2015 -0400 nfit: Don't check _STA on NVDIMM devices The _STA only applies to the root device, not the individual NVDIMMS, so don't check here. NVDIMM device state flags are checked elsewhere. Signed-off-by: Linda Knippers Signed-off-by: Dan Williams commit f6ef5a2a50816b58e3126206de13d0b9fdf89df5 Author: Randy Dunlap Date: Tue Jul 28 12:27:01 2015 -0700 nvdimm: fix inline function return type warning Fix multiple build warnings when CONFIG_BTT is not enabled: In file included from ../drivers/nvdimm/bus.c:29:0: ../drivers/nvdimm/nd.h:169:15: warning: return type defaults to 'int' [-Wreturn-type] static inline nd_btt_probe(struct nd_namespace_common *ndns, void *drvdata) ^ Signed-off-by: Randy Dunlap Cc: Dan Williams Cc: linux-nvdimm@lists.01.org Signed-off-by: Dan Williams commit 124fe20d94630b6f173dae5eb815e6e6e350c72d Author: Dan Williams Date: Mon Aug 10 23:07:05 2015 -0400 mm: enhance region_is_ram() to region_intersects() region_is_ram() is used to prevent the establishment of aliased mappings to physical "System RAM" with incompatible cache settings. However, it uses "-1" to indicate both "unknown" memory ranges (ranges not described by platform firmware) and "mixed" ranges (where the parameters describe a range that partially overlaps "System RAM"). Fix this up by explicitly tracking the "unknown" vs "mixed" resource cases and returning REGION_INTERSECTS, REGION_MIXED, or REGION_DISJOINT. This re-write also adds support for detecting when the requested region completely eclipses all of a resource. Note, the implementation treats overlaps between "unknown" and the requested memory type as REGION_INTERSECTS. Finally, other memory types can be passed in by name, for now the only usage "System RAM". Suggested-by: Luis R. Rodriguez Reviewed-by: Toshi Kani Signed-off-by: Dan Williams commit 2584cf83578c26db144730ef498f4070f82ee3ea Author: Dan Williams Date: Mon Aug 10 23:07:05 2015 -0400 arch, drivers: don't include directly, use instead Preparation for uniform definition of ioremap, ioremap_wc, ioremap_wt, and ioremap_cache, tree-wide. Acked-by: Christoph Hellwig Signed-off-by: Dan Williams commit 92b19ff50e8f242392d78b2aacc5b5b672f1796b Author: Dan Williams Date: Mon Aug 10 23:07:06 2015 -0400 cleanup IORESOURCE_CACHEABLE vs ioremap() Quoting Arnd: I was thinking the opposite approach and basically removing all uses of IORESOURCE_CACHEABLE from the kernel. There are only a handful of them.and we can probably replace them all with hardcoded ioremap_cached() calls in the cases they are actually useful. All existing usages of IORESOURCE_CACHEABLE call ioremap() instead of ioremap_nocache() if the resource is cacheable, however ioremap() is uncached by default. Clearly none of the existing usages care about the cacheability. Particularly devm_ioremap_resource() never worked as advertised since it always fell back to plain ioremap(). Clean this up as the new direction we want is to convert ioremap_() usages to memremap(..., flags). Suggested-by: Arnd Bergmann Reviewed-by: Christoph Hellwig Signed-off-by: Dan Williams commit 92281dee825f6d2eb07c441437e4196a44b0861c Author: Dan Williams Date: Mon Aug 10 23:07:06 2015 -0400 arch: introduce memremap() Existing users of ioremap_cache() are mapping memory that is known in advance to not have i/o side effects. These users are forced to cast away the __iomem annotation, or otherwise neglect to fix the sparse errors thrown when dereferencing pointers to this memory. Provide memremap() as a non __iomem annotated ioremap_*() in the case when ioremap is otherwise a pointer to cacheable memory. Empirically, ioremap_() call sites are seeking memory-like semantics (e.g. speculative reads, and prefetching permitted). memremap() is a break from the ioremap implementation pattern of adding a new memremap_() for each mapping type and having silent compatibility fall backs. Instead, the implementation defines flags that are passed to the central memremap() and if a mapping type is not supported by an arch memremap returns NULL. We introduce a memremap prototype as a trivial wrapper of ioremap_cache() and ioremap_wt(). Later, once all ioremap_cache() and ioremap_wt() usage has been removed from drivers we teach archs to implement arch_memremap() with the ability to strictly enforce the mapping type. Cc: Arnd Bergmann Reviewed-by: Christoph Hellwig Signed-off-by: Dan Williams commit 3103dc0304fd9c8ab576977cd98140d4fbac1730 Author: Dan Williams Date: Mon Aug 10 23:07:06 2015 -0400 visorbus: switch from ioremap_cache to memremap In preparation for deprecating ioremap_cache() convert its usage in visorbus to memremap. Cc: Benjamin Romer Cc: David Kershner Acked-by: Greg Kroah-Hartman Signed-off-by: Dan Williams commit e836a256e8fd579c9d7a3685f22981225a1ca451 Author: Dan Williams Date: Wed Aug 12 18:42:56 2015 -0400 pmem: convert to generic memremap Kill arch_memremap_pmem() and just let the architecture specify the flags to be passed to memremap(). Default to writethrough by default. Suggested-by: Christoph Hellwig Reviewed-by: Christoph Hellwig Reviewed-by: Ross Zwisler Signed-off-by: Dan Williams commit fbde1414acc0440024083bf0c391b259bcfc4826 Author: Vishal Verma Date: Wed Jul 29 14:58:07 2015 -0600 libnvdimm, btt: clean up internal interfaces Consolidate the parameters passed to arena_is_valid into just nd_btt, and an info block to increase re-usability. Similarly, btt_arena_write_layout doesn't need to be passed a uuid, as it can be obtained from arena->nd_btt. Signed-off-by: Vishal Verma Signed-off-by: Dan Williams commit ab45e7632717b811e0786e46ca5ad279cb731b66 Author: Vishal Verma Date: Wed Jul 29 14:58:08 2015 -0600 libnvdimm, btt: consolidate arena validation Use arena_is_valid as a common routine for checking the validity of an info block from both discover_arenas, and nd_btt_probe. As a result, don't check for validity of the BTT's UUID, and lbasize. The checksum in the BTT info block guarantees self-consistency, and when we're called from nd_btt_probe, we don't have a valid uuid or lbasize available to check against. Also cleanup to return a bool instead of an int. Signed-off-by: Vishal Verma Signed-off-by: Dan Williams commit 6ec689542b5bc516187917d49b112847dfb75b0b Author: Vishal Verma Date: Wed Jul 29 14:58:09 2015 -0600 libnvdimm, btt: write and validate parent_uuid When a BTT is instantiated on a namespace it must validate the namespace uuid matches the 'parent_uuid' stored in the btt superblock. This property enforces that changing the namespace UUID invalidates all former BTT instances on that storage. For "IO namespaces" that don't have a label or UUID, the parent_uuid is set to zero, and this validation is skipped. For such cases, old BTTs have to be invalidated by forcing the namespace to raw mode, and overwriting the BTT info blocks. Based on a patch by Dan Williams Signed-off-by: Vishal Verma Signed-off-by: Dan Williams commit 7d3dcf26a6559fa82af3f53e2c8b163cec95fdaf Author: Christoph Hellwig Date: Mon Aug 10 23:07:07 2015 -0400 devres: add devm_memremap Signed-off-by: Christoph Hellwig Signed-off-by: Dan Williams commit 708ab62bef1ed3a3cf065a4138bd87f5d083cfeb Author: Christoph Hellwig Date: Mon Aug 10 23:07:08 2015 -0400 pmem: switch to devm_ allocations Signed-off-by: Christoph Hellwig [djbw: tools/testing/nvdimm/ and memunmap_pmem support] Reviewed-by: Ross Zwisler Signed-off-by: Dan Williams commit 7a67832c7e44c20935c5d6f2264035a0f7bf0d8f Author: Dan Williams Date: Wed Aug 19 00:34:34 2015 -0400 libnvdimm, e820: make CONFIG_X86_PMEM_LEGACY a tristate option We currently register a platform device for e820 type-12 memory and register a nvdimm bus beneath it. Registering the platform device triggers the device-core machinery to probe for a driver, but that search currently comes up empty. Building the nvdimm-bus registration into the e820_pmem platform device registration in this way forces libnvdimm to be built-in. Instead, convert the built-in portion of CONFIG_X86_PMEM_LEGACY to simply register a platform device and move the rest of the logic to the driver for e820_pmem, for the following reasons: 1/ Letting e820_pmem support be a module allows building and testing libnvdimm.ko changes without rebooting 2/ All the normal policy around modules can be applied to e820_pmem (unbind to disable and/or blacklisting the module from loading by default) 3/ Moving the driver to a generic location and converting it to scan "iomem_resource" rather than "e820.map" means any other architecture can take advantage of this simple nvdimm resource discovery mechanism by registering a resource named "Persistent Memory (legacy)" Cc: Christoph Hellwig Signed-off-by: Dan Williams commit 40603526569b304dd92f720f2f8ab11e828ea145 Author: Ross Zwisler Date: Tue Aug 18 13:55:36 2015 -0600 pmem, x86: move x86 PMEM API to new pmem.h header Move the x86 PMEM API implementation out of asm/cacheflush.h and into its own header asm/pmem.h. This will allow members of the PMEM API to be more easily identified on this and other architectures. Signed-off-by: Ross Zwisler Suggested-by: Christoph Hellwig Reviewed-by: Christoph Hellwig Signed-off-by: Dan Williams commit 18279b467a9d89afe44afbc19d768e834dbf4545 Author: Ross Zwisler Date: Tue Aug 18 13:55:37 2015 -0600 pmem: remove layer when calling arch_has_wmb_pmem() Prior to this change arch_has_wmb_pmem() was only called by arch_has_pmem_api(). Both arch_has_wmb_pmem() and arch_has_pmem_api() checked to make sure that CONFIG_ARCH_HAS_PMEM_API was enabled. Instead, remove the old arch_has_wmb_pmem() wrapper to be rid of one extra layer of indirection and the redundant CONFIG_ARCH_HAS_PMEM_API check. Rename __arch_has_wmb_pmem() to arch_has_wmb_pmem() since we no longer have a wrapper, and just have arch_has_pmem_api() call the architecture specific arch_has_wmb_pmem() directly. Signed-off-by: Ross Zwisler Reviewed-by: Christoph Hellwig Signed-off-by: Dan Williams commit 4a370df5534ef727cba9a9d74bf22e0609f91d6e Author: Ross Zwisler Date: Tue Aug 18 13:55:38 2015 -0600 pmem, x86: clean up conditional pmem includes Prior to this change x86_64 used the pmem defines in arch/x86/include/asm/pmem.h, and UM used the default ones at the top of include/linux/pmem.h. The inclusion or exclusion in linux/pmem.h was controlled by CONFIG_ARCH_HAS_PMEM_API, but the ones in asm/pmem.h were controlled by ARCH_HAS_NOCACHE_UACCESS. Instead, control them both with CONFIG_ARCH_HAS_PMEM_API so that it's clear that they are related and we don't run into the possibility where they are both included or excluded. Also remove a bunch of stale function prototypes meant for UM in asm/pmem.h - these just conflicted with the inline defaults in linux/pmem.h and gave compile errors. Signed-off-by: Ross Zwisler Reviewed-by: Christoph Hellwig Signed-off-by: Dan Williams commit 5de490daec8b6354b90d5c9d3e2415b195f5adb6 Author: Ross Zwisler Date: Tue Aug 18 13:55:39 2015 -0600 pmem: add copy_from_iter_pmem() and clear_pmem() Add support for two new PMEM APIs, copy_from_iter_pmem() and clear_pmem(). copy_from_iter_pmem() is used to copy data from an iterator into a PMEM buffer. clear_pmem() zeros a PMEM memory range. Both of these new APIs must be explicitly ordered using a wmb_pmem() function call and are implemented in such a way that the wmb_pmem() will make the stores to PMEM durable. Because both APIs are unordered they can be called as needed without introducing any unwanted memory barriers. Signed-off-by: Ross Zwisler Signed-off-by: Dan Williams commit 2765cfbb342c727c3fd47b165196cb16da158022 Author: Ross Zwisler Date: Tue Aug 18 13:55:40 2015 -0600 dax: update I/O path to do proper PMEM flushing Update the DAX I/O path so that all operations that store data (I/O writes, zeroing blocks, punching holes, etc.) properly synchronize the stores to media using the PMEM API. This ensures that the data DAX is writing is durable on media before the operation completes. Signed-off-by: Ross Zwisler Reviewed-by: Christoph Hellwig Signed-off-by: Dan Williams commit e2e05394e4a3420dab96f728df4531893494e15d Author: Ross Zwisler Date: Tue Aug 18 13:55:41 2015 -0600 pmem, dax: have direct_access use __pmem annotation Update the annotation for the kaddr pointer returned by direct_access() so that it is a __pmem pointer. This is consistent with the PMEM driver and with how this direct_access() pointer is used in the DAX code. Signed-off-by: Ross Zwisler Reviewed-by: Christoph Hellwig Signed-off-by: Dan Williams commit a06a7576526e10a99ea7721533e7f2df3e26baad Author: yalin wang Date: Thu Aug 27 19:35:48 2015 -0400 nvdimm: change to use generic kvfree() Signed-off-by: yalin wang Reviewed-by: Ross Zwisler Signed-off-by: Dan Williams commit 67a3e8fe90156d41cd480d3dfbb40f3bc007c262 Author: Ross Zwisler Date: Thu Aug 27 13:14:20 2015 -0600 nd_blk: change aperture mapping from WC to WB This should result in a pretty sizeable performance gain for reads. For rough comparison I did some simple read testing using PMEM to compare reads of write combining (WC) mappings vs write-back (WB). This was done on a random lab machine. PMEM reads from a write combining mapping: # dd of=/dev/null if=/dev/pmem0 bs=4096 count=100000 100000+0 records in 100000+0 records out 409600000 bytes (410 MB) copied, 9.2855 s, 44.1 MB/s PMEM reads from a write-back mapping: # dd of=/dev/null if=/dev/pmem0 bs=4096 count=1000000 1000000+0 records in 1000000+0 records out 4096000000 bytes (4.1 GB) copied, 3.44034 s, 1.2 GB/s To be able to safely support a write-back aperture I needed to add support for the "read flush" _DSM flag, as outlined in the DSM spec: http://pmem.io/documents/NVDIMM_DSM_Interface_Example.pdf This flag tells the ND BLK driver that it needs to flush the cache lines associated with the aperture after the aperture is moved but before any new data is read. This ensures that any stale cache lines from the previous contents of the aperture will be discarded from the processor cache, and the new data will be read properly from the DIMM. We know that the cache lines are clean and will be discarded without any writeback because either a) the previous aperture operation was a read, and we never modified the contents of the aperture, or b) the previous aperture operation was a write and we must have written back the dirtied contents of the aperture to the DIMM before the I/O was completed. In order to add support for the "read flush" flag I needed to add a generic routine to invalidate cache lines, mmio_flush_range(). This is protected by the ARCH_HAS_MMIO_FLUSH Kconfig variable, and is currently only supported on x86. Signed-off-by: Ross Zwisler Signed-off-by: Dan Williams commit 4a9bf88a5caa8495b5eb2b738d5fb40924bbc538 Merge: a06a7576526e 67a3e8fe9015 Author: Dan Williams Date: Thu Aug 27 19:40:26 2015 -0400 Merge branch 'pmem-api' into libnvdimm-for-next commit cb389b9c0e00c30c9daf20287f7d91e2466edbb1 Author: Dan Williams Date: Fri Aug 7 17:41:00 2015 -0400 dax: drop size parameter to ->direct_access() None of the implementations currently use it. The common bdev_direct_access() entry point handles all the size checks before calling ->direct_access(). Signed-off-by: Christoph Hellwig Signed-off-by: Dan Williams commit 012dcef3f058385268630c0003e9b7f8dcafbeb4 Author: Christoph Hellwig Date: Fri Aug 7 17:41:01 2015 -0400 mm: move __phys_to_pfn and __pfn_to_phys to asm/generic/memory_model.h Three architectures already define these, and we'll need them genericly soon. Signed-off-by: Christoph Hellwig Signed-off-by: Dan Williams commit 033fbae988fcb67e5077203512181890848b8e90 Author: Dan Williams Date: Sun Aug 9 15:29:06 2015 -0400 mm: ZONE_DEVICE for "device memory" While pmem is usable as a block device or via DAX mappings to userspace there are several usage scenarios that can not target pmem due to its lack of struct page coverage. In preparation for "hot plugging" pmem into the vmemmap add ZONE_DEVICE as a new zone to tag these pages separately from the ones that are subject to standard page allocations. Importantly "device memory" can be removed at will by userspace unbinding the driver of the device. Having a separate zone prevents allocation and otherwise marks these pages that are distinct from typical uniform memory. Device memory has different lifetime and performance characteristics than RAM. However, since we have run out of ZONES_SHIFT bits this functionality currently depends on sacrificing ZONE_DMA. Cc: H. Peter Anvin Cc: Ingo Molnar Cc: Dave Hansen Cc: Rik van Riel Cc: Mel Gorman Cc: Jerome Glisse [hch: various simplifications in the arch interface] Signed-off-by: Christoph Hellwig Signed-off-by: Dan Williams commit 41e94a851304f7acac840adec4004f8aeee53ad4 Author: Christoph Hellwig Date: Mon Aug 17 16:00:35 2015 +0200 add devm_memremap_pages This behaves like devm_memremap except that it ensures we have page structures available that can back the region. Signed-off-by: Christoph Hellwig [djbw: catch attempts to remap RAM, drop flags] Signed-off-by: Dan Williams commit 96601adb745186ccbcf5b078d4756f13381ec2af Author: Dan Williams Date: Mon Aug 24 18:29:38 2015 -0400 x86, pmem: clarify that ARCH_HAS_PMEM_API implies PMEM mapped WB 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 commit e1455744b27c9e6115c3508a7b2902157c2c4347 Author: Dan Williams Date: Thu Jul 30 17:57:47 2015 -0400 libnvdimm, pfn: 'struct page' provider infrastructure Implement the base infrastructure for libnvdimm PFN devices. Similar to BTT devices they take a namespace as a backing device and layer functionality on top. In this case the functionality is reserving space for an array of 'struct page' entries to be handed out through pfn_to_page(). For now this is just the basic libnvdimm-device-model for configuring the base PFN device. As the namespace claiming mechanism for PFN devices is mostly identical to BTT devices drivers/nvdimm/claim.c is created to house the common bits. Cc: Ross Zwisler Signed-off-by: Dan Williams commit 32ab0a3f51701cb37ab960635254d5f84ec3de0a Author: Dan Williams Date: Sat Aug 1 02:16:37 2015 -0400 libnvdimm, pmem: 'struct page' for pmem Enable the pmem driver to handle PFN device instances. Attaching a pmem namespace to a pfn device triggers the driver to allocate and initialize struct page entries for pmem. Memory capacity for this allocation comes exclusively from RAM for now which is suitable for low PMEM to RAM ratios. This mechanism will be expanded later for setting an "allocate from PMEM" policy. Cc: Boaz Harrosh Cc: Ross Zwisler Cc: Christoph Hellwig Signed-off-by: Dan Williams commit 004f1afbe199e6ab20805b95aefd83ccd24bc5c7 Author: Dan Williams Date: Mon Aug 24 19:20:23 2015 -0400 libnvdimm, pmem: direct map legacy pmem by default The expectation is that the legacy / non-standard pmem discovery method (e820 type-12) will only ever be used to describe small quantities of persistent memory. Larger capacities will be described via the ACPI NFIT. When "allocate struct page from pmem" support is added this default policy can be overridden by assigning a legacy pmem namespace to a pfn device, however this would be only be necessary if a platform used the legacy mechanism to define a very large range. Cc: Christoph Hellwig Signed-off-by: Dan Williams {.n++%ݶw{.n+{G{ayʇڙ,jfhz_(階ݢj"mG?&~iOzv^m ?I