From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id 16EF521BADAB3 for ; Fri, 20 Jul 2018 13:46:12 -0700 (PDT) From: "Verma, Vishal L" Subject: Re: [PATCHv3 1/2] libnvdimm: Use max contiguous area for namespace size Date: Fri, 20 Jul 2018 20:46:06 +0000 Message-ID: <1532119565.10343.15.camel@intel.com> References: <20180712154709.16444-1-keith.busch@intel.com> In-Reply-To: <20180712154709.16444-1-keith.busch@intel.com> Content-Language: en-US Content-ID: MIME-Version: 1.0 List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: linux-nvdimm-bounces@lists.01.org Sender: "Linux-nvdimm" To: "Williams, Dan J" , "ross.zwisler@linux.intel.com" , "Busch, Keith" , "linux-nvdimm@lists.01.org" , "Jiang, Dave" Cc: "stable@vger.kernel.org" List-ID: On Thu, 2018-07-12 at 09:47 -0600, Keith Busch wrote: > This patch will find the max contiguous area to determine the largest > pmem namespace size that can be created. If the requested size exceeds > the largest available, ENOSPC error will be returned. > > This fixes the allocation underrun error and wrong error return code > that have otherwise been observed as the following kernel warning: > > WARNING: CPU: PID: at drivers/nvdimm/namespace_devs.c:913 size_store > > Fixes: a1f3e4d6a0c3 ("libnvdimm, region: update nd_region_available_dpa() for multi-pmem support") > Cc: > Signed-off-by: Keith Busch Hi Keith, I was testing these patches and I found: When booting a VM which has both, a qemu ACPI.NFIT bus, and nfit_test buses, initially the nfit_test buses show correct max_available_extent. But the qemu ACPI.NFIT bus regions (which have an automatic full- capacity namespace created on them when they come up) show max_available_extent of the full region size, even as the available_size attr is zero. $ cat /sys/bus/nd/devices/region1/max_available_extent 17045651456 $ ndctl list -BNR --region=region1 [ { "provider":"ACPI.NFIT", "dev":"ndbus1", "regions":[ { "dev":"region1", "size":17045651456, "available_size":0, "type":"pmem", "numa_node":0, "persistence_domain":"unknown", "namespaces":[ { "dev":"namespace1.0", "mode":"raw", "size":17045651456, "sector_size":512, "blockdev":"pmem1", "numa_node":0 } ... If i reconfig the default namespace: $ sudo ndctl create-namespace --region=region1 --type=pmem -- reconfig=namespace1.0 --type=pmem --mode=fsdax --force { "dev":"namespace1.0", "mode":"fsdax", "map":"dev", "size":"15.63 GiB (16.78 GB)", "uuid":"55411e87-41a6-44e0-8198-97023de70413", "raw_uuid":"cb80c5c1-c582-4e12-9d24-2fd30bb7da20", "sector_size":512, "blockdev":"pmem1", "numa_node":0 } Then the max_available_extent gets updated correctly: $ cat /sys/bus/nd/devices/region1/max_available_extent 0 > --- > v2 -> v3: > > This one takes block regions into account by reserving pmem regions > on dimms and finding the largest intersection among all dimms in > the region. > > drivers/nvdimm/dimm_devs.c | 30 ++++++++++++++++++++++++++++++ > drivers/nvdimm/namespace_devs.c | 6 +++--- > drivers/nvdimm/nd-core.h | 9 +++++++++ > drivers/nvdimm/region_devs.c | 24 ++++++++++++++++++++++++ > 4 files changed, 66 insertions(+), 3 deletions(-) > > diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c > index 8d348b22ba45..9e977cbd1a60 100644 > --- a/drivers/nvdimm/dimm_devs.c > +++ b/drivers/nvdimm/dimm_devs.c > @@ -536,6 +536,36 @@ resource_size_t nd_blk_available_dpa(struct nd_region *nd_region) > return info.available; > } > > +/** > + * nd_pmem_max_contiguous_dpa - For the given dimm+region, return the max > + * contiguous unallocated dpa range. > + * @nd_region: constrain available space check to this reference region > + * @nd_mapping: container of dpa-resource-root + labels > + */ > +resource_size_t nd_pmem_max_contiguous_dpa(struct nd_region *nd_region, > + struct nd_mapping *nd_mapping) > +{ > + struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); > + struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(ndd->dev); > + resource_size_t max = 0; > + struct resource *res; > + > + /* if a dimm is disabled the available capacity is zero */ > + if (!ndd) > + return 0; > + > + if (reserve_free_pmem(nvdimm_bus, nd_mapping)) > + return 0; > + for_each_dpa_resource(ndd, res) { > + if (strcmp(res->name, "pmem-reserve") != 0) > + continue; > + if (resource_size(res) > max) > + max = resource_size(res); > + } > + release_free_pmem(nvdimm_bus, nd_mapping); > + return max; > +} > + > /** > * nd_pmem_available_dpa - for the given dimm+region account unallocated dpa > * @nd_mapping: container of dpa-resource-root + labels > diff --git a/drivers/nvdimm/namespace_devs.c b/drivers/nvdimm/namespace_devs.c > index 28afdd668905..c3afff2cdf1d 100644 > --- a/drivers/nvdimm/namespace_devs.c > +++ b/drivers/nvdimm/namespace_devs.c > @@ -836,7 +836,7 @@ static int __reserve_free_pmem(struct device *dev, void *data) > return 0; > } > > -static void release_free_pmem(struct nvdimm_bus *nvdimm_bus, > +void release_free_pmem(struct nvdimm_bus *nvdimm_bus, > struct nd_mapping *nd_mapping) > { > struct nvdimm_drvdata *ndd = to_ndd(nd_mapping); > @@ -847,7 +847,7 @@ static void release_free_pmem(struct nvdimm_bus *nvdimm_bus, > nvdimm_free_dpa(ndd, res); > } > > -static int reserve_free_pmem(struct nvdimm_bus *nvdimm_bus, > +int reserve_free_pmem(struct nvdimm_bus *nvdimm_bus, > struct nd_mapping *nd_mapping) > { > struct nvdimm *nvdimm = nd_mapping->nvdimm; > @@ -1032,7 +1032,7 @@ static ssize_t __size_store(struct device *dev, unsigned long long val) > > allocated += nvdimm_allocated_dpa(ndd, &label_id); > } > - available = nd_region_available_dpa(nd_region); > + available = nd_region_allocatable_dpa(nd_region); > > if (val > available + allocated) > return -ENOSPC; > diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h > index 79274ead54fb..1c5f5b389940 100644 > --- a/drivers/nvdimm/nd-core.h > +++ b/drivers/nvdimm/nd-core.h > @@ -100,6 +100,15 @@ struct nd_region; > struct nvdimm_drvdata; > struct nd_mapping; > void nd_mapping_free_labels(struct nd_mapping *nd_mapping); > + > +int reserve_free_pmem(struct nvdimm_bus *nvdimm_bus, > + struct nd_mapping *nd_mapping); > +void release_free_pmem(struct nvdimm_bus *nvdimm_bus, > + struct nd_mapping *nd_mapping); > + > +resource_size_t nd_pmem_max_contiguous_dpa(struct nd_region *nd_region, > + struct nd_mapping *nd_mapping); > +resource_size_t nd_region_allocatable_dpa(struct nd_region *nd_region); > resource_size_t nd_pmem_available_dpa(struct nd_region *nd_region, > struct nd_mapping *nd_mapping, resource_size_t *overlap); > resource_size_t nd_blk_available_dpa(struct nd_region *nd_region); > diff --git a/drivers/nvdimm/region_devs.c b/drivers/nvdimm/region_devs.c > index ec3543b83330..c30d5af02cc2 100644 > --- a/drivers/nvdimm/region_devs.c > +++ b/drivers/nvdimm/region_devs.c > @@ -389,6 +389,30 @@ resource_size_t nd_region_available_dpa(struct nd_region *nd_region) > return available; > } > > +resource_size_t nd_region_allocatable_dpa(struct nd_region *nd_region) > +{ > + resource_size_t available = 0; > + int i; > + > + if (is_memory(&nd_region->dev)) > + available = PHYS_ADDR_MAX; > + > + WARN_ON(!is_nvdimm_bus_locked(&nd_region->dev)); > + for (i = 0; i < nd_region->ndr_mappings; i++) { > + struct nd_mapping *nd_mapping = &nd_region->mapping[i]; > + > + if (is_memory(&nd_region->dev)) > + available = min(available, > + nd_pmem_max_contiguous_dpa(nd_region, > + nd_mapping)); > + else if (is_nd_blk(&nd_region->dev)) > + available += nd_blk_available_dpa(nd_region); > + } > + if (is_memory(&nd_region->dev)) > + return available * nd_region->ndr_mappings; > + return available; > +} > + > static ssize_t available_size_show(struct device *dev, > struct device_attribute *attr, char *buf) > { _______________________________________________ Linux-nvdimm mailing list Linux-nvdimm@lists.01.org https://lists.01.org/mailman/listinfo/linux-nvdimm From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga02.intel.com ([134.134.136.20]:61068 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727633AbeGTVgI (ORCPT ); Fri, 20 Jul 2018 17:36:08 -0400 From: "Verma, Vishal L" To: "Williams, Dan J" , "ross.zwisler@linux.intel.com" , "Busch, Keith" , "linux-nvdimm@lists.01.org" , "Jiang, Dave" CC: "stable@vger.kernel.org" Subject: Re: [PATCHv3 1/2] libnvdimm: Use max contiguous area for namespace size Date: Fri, 20 Jul 2018 20:46:06 +0000 Message-ID: <1532119565.10343.15.camel@intel.com> References: <20180712154709.16444-1-keith.busch@intel.com> In-Reply-To: <20180712154709.16444-1-keith.busch@intel.com> Content-Language: en-US Content-Type: text/plain; charset="utf-8" Content-ID: Content-Transfer-Encoding: base64 MIME-Version: 1.0 Sender: stable-owner@vger.kernel.org List-ID: DQpPbiBUaHUsIDIwMTgtMDctMTIgYXQgMDk6NDcgLTA2MDAsIEtlaXRoIEJ1c2NoIHdyb3RlOg0K PiBUaGlzIHBhdGNoIHdpbGwgZmluZCB0aGUgbWF4IGNvbnRpZ3VvdXMgYXJlYSB0byBkZXRlcm1p bmUgdGhlIGxhcmdlc3QNCj4gcG1lbSBuYW1lc3BhY2Ugc2l6ZSB0aGF0IGNhbiBiZSBjcmVhdGVk LiBJZiB0aGUgcmVxdWVzdGVkIHNpemUgZXhjZWVkcw0KPiB0aGUgbGFyZ2VzdCBhdmFpbGFibGUs IEVOT1NQQyBlcnJvciB3aWxsIGJlIHJldHVybmVkLg0KPiANCj4gVGhpcyBmaXhlcyB0aGUgYWxs b2NhdGlvbiB1bmRlcnJ1biBlcnJvciBhbmQgd3JvbmcgZXJyb3IgcmV0dXJuIGNvZGUNCj4gdGhh dCBoYXZlIG90aGVyd2lzZSBiZWVuIG9ic2VydmVkIGFzIHRoZSBmb2xsb3dpbmcga2VybmVsIHdh cm5pbmc6DQo+IA0KPiAgIFdBUk5JTkc6IENQVTogPENQVT4gUElEOiA8UElEPiBhdCBkcml2ZXJz L252ZGltbS9uYW1lc3BhY2VfZGV2cy5jOjkxMyBzaXplX3N0b3JlDQo+IA0KPiBGaXhlczogYTFm M2U0ZDZhMGMzICgibGlibnZkaW1tLCByZWdpb246IHVwZGF0ZSBuZF9yZWdpb25fYXZhaWxhYmxl X2RwYSgpIGZvciBtdWx0aS1wbWVtIHN1cHBvcnQiKQ0KPiBDYzogPHN0YWJsZUB2Z2VyLmtlcm5l bC5vcmc+DQo+IFNpZ25lZC1vZmYtYnk6IEtlaXRoIEJ1c2NoIDxrZWl0aC5idXNjaEBpbnRlbC5j b20+DQoNCkhpIEtlaXRoLA0KDQpJIHdhcyB0ZXN0aW5nIHRoZXNlIHBhdGNoZXMgYW5kIEkgZm91 bmQ6DQoNCldoZW4gYm9vdGluZyBhIFZNIHdoaWNoIGhhcyBib3RoLCBhIHFlbXUgQUNQSS5ORklU IGJ1cywgYW5kIG5maXRfdGVzdA0KYnVzZXMsIGluaXRpYWxseSB0aGUgbmZpdF90ZXN0IGJ1c2Vz IHNob3cgY29ycmVjdCBtYXhfYXZhaWxhYmxlX2V4dGVudC4NCkJ1dCB0aGUgcWVtdSBBQ1BJLk5G SVQgYnVzIHJlZ2lvbnMgKHdoaWNoIGhhdmUgYW4gYXV0b21hdGljIGZ1bGwtDQpjYXBhY2l0eSBu YW1lc3BhY2UgY3JlYXRlZCBvbiB0aGVtIHdoZW4gdGhleSBjb21lIHVwKSBzaG93DQptYXhfYXZh aWxhYmxlX2V4dGVudCBvZiB0aGUgZnVsbCByZWdpb24gc2l6ZSwgZXZlbiBhcyB0aGUNCmF2YWls YWJsZV9zaXplIGF0dHIgaXMgemVyby4NCg0KJCBjYXQgL3N5cy9idXMvbmQvZGV2aWNlcy9yZWdp b24xL21heF9hdmFpbGFibGVfZXh0ZW50DQoxNzA0NTY1MTQ1Ng0KDQokIG5kY3RsIGxpc3QgLUJO UiAtLXJlZ2lvbj1yZWdpb24xDQpbDQogIHsNCiAgICAicHJvdmlkZXIiOiJBQ1BJLk5GSVQiLA0K ICAgICJkZXYiOiJuZGJ1czEiLA0KICAgICJyZWdpb25zIjpbDQogICAgICB7DQogICAgICAgICJk ZXYiOiJyZWdpb24xIiwNCiAgICAgICAgInNpemUiOjE3MDQ1NjUxNDU2LA0KICAgICAgICAiYXZh aWxhYmxlX3NpemUiOjAsDQogICAgICAgICJ0eXBlIjoicG1lbSIsDQogICAgICAgICJudW1hX25v ZGUiOjAsDQogICAgICAgICJwZXJzaXN0ZW5jZV9kb21haW4iOiJ1bmtub3duIiwNCiAgICAgICAg Im5hbWVzcGFjZXMiOlsNCiAgICAgICAgICB7DQogICAgICAgICAgICAiZGV2IjoibmFtZXNwYWNl MS4wIiwNCiAgICAgICAgICAgICJtb2RlIjoicmF3IiwNCiAgICAgICAgICAgICJzaXplIjoxNzA0 NTY1MTQ1NiwNCiAgICAgICAgICAgICJzZWN0b3Jfc2l6ZSI6NTEyLA0KICAgICAgICAgICAgImJs b2NrZGV2IjoicG1lbTEiLA0KICAgICAgICAgICAgIm51bWFfbm9kZSI6MA0KICAgICAgICAgIH0N CgkuLi4NCg0KSWYgaSByZWNvbmZpZyB0aGUgZGVmYXVsdCBuYW1lc3BhY2U6DQoNCiQgc3VkbyBu ZGN0bCBjcmVhdGUtbmFtZXNwYWNlIC0tcmVnaW9uPXJlZ2lvbjEgLS10eXBlPXBtZW0gLS0NCnJl Y29uZmlnPW5hbWVzcGFjZTEuMCAtLXR5cGU9cG1lbSAtLW1vZGU9ZnNkYXggLS1mb3JjZQ0Kew0K ICAiZGV2IjoibmFtZXNwYWNlMS4wIiwNCiAgIm1vZGUiOiJmc2RheCIsDQogICJtYXAiOiJkZXYi LA0KICAic2l6ZSI6IjE1LjYzIEdpQiAoMTYuNzggR0IpIiwNCiAgInV1aWQiOiI1NTQxMWU4Ny00 MWE2LTQ0ZTAtODE5OC05NzAyM2RlNzA0MTMiLA0KICAicmF3X3V1aWQiOiJjYjgwYzVjMS1jNTgy LTRlMTItOWQyNC0yZmQzMGJiN2RhMjAiLA0KICAic2VjdG9yX3NpemUiOjUxMiwNCiAgImJsb2Nr ZGV2IjoicG1lbTEiLA0KICAibnVtYV9ub2RlIjowDQp9DQoNClRoZW4gdGhlIG1heF9hdmFpbGFi bGVfZXh0ZW50IGdldHMgdXBkYXRlZCBjb3JyZWN0bHk6DQoNCiQgY2F0IC9zeXMvYnVzL25kL2Rl dmljZXMvcmVnaW9uMS9tYXhfYXZhaWxhYmxlX2V4dGVudA0KMA0KDQo+IC0tLQ0KPiB2MiAtPiB2 MzoNCj4gDQo+ICAgVGhpcyBvbmUgdGFrZXMgYmxvY2sgcmVnaW9ucyBpbnRvIGFjY291bnQgYnkg cmVzZXJ2aW5nIHBtZW0gcmVnaW9ucw0KPiAgIG9uIGRpbW1zIGFuZCBmaW5kaW5nIHRoZSBsYXJn ZXN0IGludGVyc2VjdGlvbiBhbW9uZyBhbGwgZGltbXMgaW4NCj4gICB0aGUgcmVnaW9uLg0KPiAN Cj4gIGRyaXZlcnMvbnZkaW1tL2RpbW1fZGV2cy5jICAgICAgfCAzMCArKysrKysrKysrKysrKysr KysrKysrKysrKysrKysNCj4gIGRyaXZlcnMvbnZkaW1tL25hbWVzcGFjZV9kZXZzLmMgfCAgNiAr KystLS0NCj4gIGRyaXZlcnMvbnZkaW1tL25kLWNvcmUuaCAgICAgICAgfCAgOSArKysrKysrKysN Cj4gIGRyaXZlcnMvbnZkaW1tL3JlZ2lvbl9kZXZzLmMgICAgfCAyNCArKysrKysrKysrKysrKysr KysrKysrKysNCj4gIDQgZmlsZXMgY2hhbmdlZCwgNjYgaW5zZXJ0aW9ucygrKSwgMyBkZWxldGlv bnMoLSkNCj4gDQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL252ZGltbS9kaW1tX2RldnMuYyBiL2Ry aXZlcnMvbnZkaW1tL2RpbW1fZGV2cy5jDQo+IGluZGV4IDhkMzQ4YjIyYmE0NS4uOWU5NzdjYmQx YTYwIDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL252ZGltbS9kaW1tX2RldnMuYw0KPiArKysgYi9k cml2ZXJzL252ZGltbS9kaW1tX2RldnMuYw0KPiBAQCAtNTM2LDYgKzUzNiwzNiBAQCByZXNvdXJj ZV9zaXplX3QgbmRfYmxrX2F2YWlsYWJsZV9kcGEoc3RydWN0IG5kX3JlZ2lvbiAqbmRfcmVnaW9u KQ0KPiAgCXJldHVybiBpbmZvLmF2YWlsYWJsZTsNCj4gIH0NCj4gIA0KPiArLyoqDQo+ICsgKiBu ZF9wbWVtX21heF9jb250aWd1b3VzX2RwYSAtIEZvciB0aGUgZ2l2ZW4gZGltbStyZWdpb24sIHJl dHVybiB0aGUgbWF4DQo+ICsgKgkJCSAgIGNvbnRpZ3VvdXMgdW5hbGxvY2F0ZWQgZHBhIHJhbmdl Lg0KPiArICogQG5kX3JlZ2lvbjogY29uc3RyYWluIGF2YWlsYWJsZSBzcGFjZSBjaGVjayB0byB0 aGlzIHJlZmVyZW5jZSByZWdpb24NCj4gKyAqIEBuZF9tYXBwaW5nOiBjb250YWluZXIgb2YgZHBh LXJlc291cmNlLXJvb3QgKyBsYWJlbHMNCj4gKyAqLw0KPiArcmVzb3VyY2Vfc2l6ZV90IG5kX3Bt ZW1fbWF4X2NvbnRpZ3VvdXNfZHBhKHN0cnVjdCBuZF9yZWdpb24gKm5kX3JlZ2lvbiwNCj4gKwkJ CQkJICAgc3RydWN0IG5kX21hcHBpbmcgKm5kX21hcHBpbmcpDQo+ICt7DQo+ICsJc3RydWN0IG52 ZGltbV9kcnZkYXRhICpuZGQgPSB0b19uZGQobmRfbWFwcGluZyk7DQo+ICsJc3RydWN0IG52ZGlt bV9idXMgKm52ZGltbV9idXMgPSB3YWxrX3RvX252ZGltbV9idXMobmRkLT5kZXYpOw0KPiArCXJl c291cmNlX3NpemVfdCBtYXggPSAwOw0KPiArCXN0cnVjdCByZXNvdXJjZSAqcmVzOw0KPiArDQo+ ICsJLyogaWYgYSBkaW1tIGlzIGRpc2FibGVkIHRoZSBhdmFpbGFibGUgY2FwYWNpdHkgaXMgemVy byAqLw0KPiArCWlmICghbmRkKQ0KPiArCQlyZXR1cm4gMDsNCj4gKw0KPiArCWlmIChyZXNlcnZl X2ZyZWVfcG1lbShudmRpbW1fYnVzLCBuZF9tYXBwaW5nKSkNCj4gKwkJcmV0dXJuIDA7DQo+ICsJ Zm9yX2VhY2hfZHBhX3Jlc291cmNlKG5kZCwgcmVzKSB7DQo+ICsJCWlmIChzdHJjbXAocmVzLT5u YW1lLCAicG1lbS1yZXNlcnZlIikgIT0gMCkNCj4gKwkJCWNvbnRpbnVlOw0KPiArCQlpZiAocmVz b3VyY2Vfc2l6ZShyZXMpID4gbWF4KQ0KPiArCQkJbWF4ID0gcmVzb3VyY2Vfc2l6ZShyZXMpOw0K PiArCX0NCj4gKwlyZWxlYXNlX2ZyZWVfcG1lbShudmRpbW1fYnVzLCBuZF9tYXBwaW5nKTsNCj4g KwlyZXR1cm4gbWF4Ow0KPiArfQ0KPiArDQo+ICAvKioNCj4gICAqIG5kX3BtZW1fYXZhaWxhYmxl X2RwYSAtIGZvciB0aGUgZ2l2ZW4gZGltbStyZWdpb24gYWNjb3VudCB1bmFsbG9jYXRlZCBkcGEN Cj4gICAqIEBuZF9tYXBwaW5nOiBjb250YWluZXIgb2YgZHBhLXJlc291cmNlLXJvb3QgKyBsYWJl bHMNCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZkaW1tL25hbWVzcGFjZV9kZXZzLmMgYi9kcml2 ZXJzL252ZGltbS9uYW1lc3BhY2VfZGV2cy5jDQo+IGluZGV4IDI4YWZkZDY2ODkwNS4uYzNhZmZm MmNkZjFkIDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL252ZGltbS9uYW1lc3BhY2VfZGV2cy5jDQo+ ICsrKyBiL2RyaXZlcnMvbnZkaW1tL25hbWVzcGFjZV9kZXZzLmMNCj4gQEAgLTgzNiw3ICs4MzYs NyBAQCBzdGF0aWMgaW50IF9fcmVzZXJ2ZV9mcmVlX3BtZW0oc3RydWN0IGRldmljZSAqZGV2LCB2 b2lkICpkYXRhKQ0KPiAgCXJldHVybiAwOw0KPiAgfQ0KPiAgDQo+IC1zdGF0aWMgdm9pZCByZWxl YXNlX2ZyZWVfcG1lbShzdHJ1Y3QgbnZkaW1tX2J1cyAqbnZkaW1tX2J1cywNCj4gK3ZvaWQgcmVs ZWFzZV9mcmVlX3BtZW0oc3RydWN0IG52ZGltbV9idXMgKm52ZGltbV9idXMsDQo+ICAJCXN0cnVj dCBuZF9tYXBwaW5nICpuZF9tYXBwaW5nKQ0KPiAgew0KPiAgCXN0cnVjdCBudmRpbW1fZHJ2ZGF0 YSAqbmRkID0gdG9fbmRkKG5kX21hcHBpbmcpOw0KPiBAQCAtODQ3LDcgKzg0Nyw3IEBAIHN0YXRp YyB2b2lkIHJlbGVhc2VfZnJlZV9wbWVtKHN0cnVjdCBudmRpbW1fYnVzICpudmRpbW1fYnVzLA0K PiAgCQkJbnZkaW1tX2ZyZWVfZHBhKG5kZCwgcmVzKTsNCj4gIH0NCj4gIA0KPiAtc3RhdGljIGlu dCByZXNlcnZlX2ZyZWVfcG1lbShzdHJ1Y3QgbnZkaW1tX2J1cyAqbnZkaW1tX2J1cywNCj4gK2lu dCByZXNlcnZlX2ZyZWVfcG1lbShzdHJ1Y3QgbnZkaW1tX2J1cyAqbnZkaW1tX2J1cywNCj4gIAkJ c3RydWN0IG5kX21hcHBpbmcgKm5kX21hcHBpbmcpDQo+ICB7DQo+ICAJc3RydWN0IG52ZGltbSAq bnZkaW1tID0gbmRfbWFwcGluZy0+bnZkaW1tOw0KPiBAQCAtMTAzMiw3ICsxMDMyLDcgQEAgc3Rh dGljIHNzaXplX3QgX19zaXplX3N0b3JlKHN0cnVjdCBkZXZpY2UgKmRldiwgdW5zaWduZWQgbG9u ZyBsb25nIHZhbCkNCj4gIA0KPiAgCQlhbGxvY2F0ZWQgKz0gbnZkaW1tX2FsbG9jYXRlZF9kcGEo bmRkLCAmbGFiZWxfaWQpOw0KPiAgCX0NCj4gLQlhdmFpbGFibGUgPSBuZF9yZWdpb25fYXZhaWxh YmxlX2RwYShuZF9yZWdpb24pOw0KPiArCWF2YWlsYWJsZSA9IG5kX3JlZ2lvbl9hbGxvY2F0YWJs ZV9kcGEobmRfcmVnaW9uKTsNCj4gIA0KPiAgCWlmICh2YWwgPiBhdmFpbGFibGUgKyBhbGxvY2F0 ZWQpDQo+ICAJCXJldHVybiAtRU5PU1BDOw0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9udmRpbW0v bmQtY29yZS5oIGIvZHJpdmVycy9udmRpbW0vbmQtY29yZS5oDQo+IGluZGV4IDc5Mjc0ZWFkNTRm Yi4uMWM1ZjViMzg5OTQwIDEwMDY0NA0KPiAtLS0gYS9kcml2ZXJzL252ZGltbS9uZC1jb3JlLmgN Cj4gKysrIGIvZHJpdmVycy9udmRpbW0vbmQtY29yZS5oDQo+IEBAIC0xMDAsNiArMTAwLDE1IEBA IHN0cnVjdCBuZF9yZWdpb247DQo+ICBzdHJ1Y3QgbnZkaW1tX2RydmRhdGE7DQo+ICBzdHJ1Y3Qg bmRfbWFwcGluZzsNCj4gIHZvaWQgbmRfbWFwcGluZ19mcmVlX2xhYmVscyhzdHJ1Y3QgbmRfbWFw cGluZyAqbmRfbWFwcGluZyk7DQo+ICsNCj4gK2ludCByZXNlcnZlX2ZyZWVfcG1lbShzdHJ1Y3Qg bnZkaW1tX2J1cyAqbnZkaW1tX2J1cywNCj4gKwkJICAgICAgc3RydWN0IG5kX21hcHBpbmcgKm5k X21hcHBpbmcpOw0KPiArdm9pZCByZWxlYXNlX2ZyZWVfcG1lbShzdHJ1Y3QgbnZkaW1tX2J1cyAq bnZkaW1tX2J1cywNCj4gKwkJICAgICAgIHN0cnVjdCBuZF9tYXBwaW5nICpuZF9tYXBwaW5nKTsN Cj4gKw0KPiArcmVzb3VyY2Vfc2l6ZV90IG5kX3BtZW1fbWF4X2NvbnRpZ3VvdXNfZHBhKHN0cnVj dCBuZF9yZWdpb24gKm5kX3JlZ2lvbiwNCj4gKwkJCQkJICAgc3RydWN0IG5kX21hcHBpbmcgKm5k X21hcHBpbmcpOw0KPiArcmVzb3VyY2Vfc2l6ZV90IG5kX3JlZ2lvbl9hbGxvY2F0YWJsZV9kcGEo c3RydWN0IG5kX3JlZ2lvbiAqbmRfcmVnaW9uKTsNCj4gIHJlc291cmNlX3NpemVfdCBuZF9wbWVt X2F2YWlsYWJsZV9kcGEoc3RydWN0IG5kX3JlZ2lvbiAqbmRfcmVnaW9uLA0KPiAgCQlzdHJ1Y3Qg bmRfbWFwcGluZyAqbmRfbWFwcGluZywgcmVzb3VyY2Vfc2l6ZV90ICpvdmVybGFwKTsNCj4gIHJl c291cmNlX3NpemVfdCBuZF9ibGtfYXZhaWxhYmxlX2RwYShzdHJ1Y3QgbmRfcmVnaW9uICpuZF9y ZWdpb24pOw0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9udmRpbW0vcmVnaW9uX2RldnMuYyBiL2Ry aXZlcnMvbnZkaW1tL3JlZ2lvbl9kZXZzLmMNCj4gaW5kZXggZWMzNTQzYjgzMzMwLi5jMzBkNWFm MDJjYzIgMTAwNjQ0DQo+IC0tLSBhL2RyaXZlcnMvbnZkaW1tL3JlZ2lvbl9kZXZzLmMNCj4gKysr IGIvZHJpdmVycy9udmRpbW0vcmVnaW9uX2RldnMuYw0KPiBAQCAtMzg5LDYgKzM4OSwzMCBAQCBy ZXNvdXJjZV9zaXplX3QgbmRfcmVnaW9uX2F2YWlsYWJsZV9kcGEoc3RydWN0IG5kX3JlZ2lvbiAq bmRfcmVnaW9uKQ0KPiAgCXJldHVybiBhdmFpbGFibGU7DQo+ICB9DQo+ICANCj4gK3Jlc291cmNl X3NpemVfdCBuZF9yZWdpb25fYWxsb2NhdGFibGVfZHBhKHN0cnVjdCBuZF9yZWdpb24gKm5kX3Jl Z2lvbikNCj4gK3sNCj4gKwlyZXNvdXJjZV9zaXplX3QgYXZhaWxhYmxlID0gMDsNCj4gKwlpbnQg aTsNCj4gKw0KPiArCWlmIChpc19tZW1vcnkoJm5kX3JlZ2lvbi0+ZGV2KSkNCj4gKwkJYXZhaWxh YmxlID0gUEhZU19BRERSX01BWDsNCj4gKw0KPiArCVdBUk5fT04oIWlzX252ZGltbV9idXNfbG9j a2VkKCZuZF9yZWdpb24tPmRldikpOw0KPiArCWZvciAoaSA9IDA7IGkgPCBuZF9yZWdpb24tPm5k cl9tYXBwaW5nczsgaSsrKSB7DQo+ICsJCXN0cnVjdCBuZF9tYXBwaW5nICpuZF9tYXBwaW5nID0g Jm5kX3JlZ2lvbi0+bWFwcGluZ1tpXTsNCj4gKw0KPiArCQlpZiAoaXNfbWVtb3J5KCZuZF9yZWdp b24tPmRldikpDQo+ICsJCQlhdmFpbGFibGUgPSBtaW4oYXZhaWxhYmxlLA0KPiArCQkJCQluZF9w bWVtX21heF9jb250aWd1b3VzX2RwYShuZF9yZWdpb24sDQo+ICsJCQkJCQkJCSAgIG5kX21hcHBp bmcpKTsNCj4gKwkJZWxzZSBpZiAoaXNfbmRfYmxrKCZuZF9yZWdpb24tPmRldikpDQo+ICsJCQlh dmFpbGFibGUgKz0gbmRfYmxrX2F2YWlsYWJsZV9kcGEobmRfcmVnaW9uKTsNCj4gKwl9DQo+ICsJ aWYgKGlzX21lbW9yeSgmbmRfcmVnaW9uLT5kZXYpKQ0KPiArCQlyZXR1cm4gYXZhaWxhYmxlICog bmRfcmVnaW9uLT5uZHJfbWFwcGluZ3M7DQo+ICsJcmV0dXJuIGF2YWlsYWJsZTsNCj4gK30NCj4g Kw0KPiAgc3RhdGljIHNzaXplX3QgYXZhaWxhYmxlX3NpemVfc2hvdyhzdHJ1Y3QgZGV2aWNlICpk ZXYsDQo+ICAJCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpDQo+ICB7 DQo=