From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Michael S. Tsirkin" Subject: Re: [PATCH 11/17] lib/interval_tree: fast overlap detection Date: Tue, 1 Aug 2017 20:16:37 +0300 Message-ID: <20170801201628-mutt-send-email-mst@kernel.org> References: <20170719014603.19029-1-dave@stgolabs.net> <20170719014603.19029-12-dave@stgolabs.net> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20170719014603.19029-12-dave@stgolabs.net> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Davidlohr Bueso Cc: mhocko@suse.com, jack@suse.cz, Davidlohr Bueso , peterz@infradead.org, mgorman@techsingularity.net, Jason Wang , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, hch@infradead.org, Doug Ledford , linux-rdma@vger.kernel.org, akpm@linux-foundation.org, ldufour@linux.vnet.ibm.com, torvalds@linux-foundation.org, mingo@kernel.org, kirill.shutemov@linux.intel.com, Christian Benvenuti List-Id: linux-rdma@vger.kernel.org T24gVHVlLCBKdWwgMTgsIDIwMTcgYXQgMDY6NDU6NTdQTSAtMDcwMCwgRGF2aWRsb2hyIEJ1ZXNv IHdyb3RlOgo+IEFsbG93IGludGVydmFsIHRyZWVzIHRvIHF1aWNrbHkgY2hlY2sgZm9yIG92ZXJs YXBzIHRvIGF2b2lkCj4gdW5uZWNlc2FyeSB0cmVlIGxvb2t1cHMgaW4gaW50ZXJ2YWxfdHJlZV9p dGVyX2ZpcnN0KCkuCj4gCj4gQXMgb2YgdGhpcyBwYXRjaCwgYWxsIGludGVydmFsIHRyZWUgZmxh dm9ycyB3aWxsIHJlcXVpcmUKPiB1c2luZyBhICdyYl9yb290X2NhY2hlZCcgc3VjaCB0aGF0IHdl IGNhbiBoYXZlIHRoZSBsZWZ0bW9zdAo+IG5vZGUgZWFzaWx5IGF2YWlsYWJsZS4gV2hpbGUgbW9z dCB1c2VycyB3aWxsIG1ha2UgdXNlIG9mIHRoaXMKPiBmZWF0dXJlLCB0aG9zZSB3aXRoIHNwZWNp YWwgZnVuY3Rpb25zIChpbiBhZGRpdGlvbiB0byB0aGUgZ2VuZXJpYwo+IGluc2VydCwgZGVsZXRl LCBzZWFyY2ggY2FsbHMpIHdpbGwgYXZvaWQgdXNpbmcgdGhlIGNhY2hlZAo+IG9wdGlvbiBhcyB0 aGV5IGNhbiBkbyBmdW5reSB0aGluZ3Mgd2l0aCBpbnNlcnRpb25zIC0tIGZvciBleGFtcGxlLAo+ IHZtYV9pbnRlcnZhbF90cmVlX2luc2VydF9hZnRlcigpLgo+IAo+IENjOiBEYXZpZCBBaXJsaWUg PGFpcmxpZWRAbGludXguaWU+Cj4gQ2M6IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK PiBDYzogIk1pY2hhZWwgUy4gVHNpcmtpbiIgPG1zdEByZWRoYXQuY29tPgo+IENjOiBKYXNvbiBX YW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPgo+IENjOiBEb3VnIExlZGZvcmQgPGRsZWRmb3JkQHJl ZGhhdC5jb20+Cj4gQ2M6IENocmlzdGlhbiBCZW52ZW51dGkgPGJlbnZlQGNpc2NvLmNvbT4KPiBD YzogbGludXgtcmRtYUB2Z2VyLmtlcm5lbC5vcmcKPiBBY2tlZC1ieTogQ2hyaXN0aWFuIEvDtm5p ZyA8Y2hyaXN0aWFuLmtvZW5pZ0BhbWQuY29tPgo+IEFja2VkLWJ5OiBQZXRlciBaaWpsc3RyYSAo SW50ZWwpIDxwZXRlcnpAaW5mcmFkZWFkLm9yZz4KPiBTaWduZWQtb2ZmLWJ5OiBEYXZpZGxvaHIg QnVlc28gPGRidWVzb0BzdXNlLmRlPgoKRm9yIHZob3N0IGJpdHM6CgpBY2tlZC1ieTogTWljaGFl bCBTLiBUc2lya2luIDxtc3RAcmVkaGF0LmNvbT4KCgo+IC0tLQo+ICBkcml2ZXJzL2dwdS9kcm0v YW1kL2FtZGdwdS9hbWRncHVfbW4uYyAgICAgICAgICAgICB8ICA4ICsrLS0KPiAgZHJpdmVycy9n cHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3ZtLmMgICAgICAgICAgICAgfCAgNyArKy0tCj4gIGRy aXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV92bS5oICAgICAgICAgICAgIHwgIDIgKy0K PiAgZHJpdmVycy9ncHUvZHJtL2RybV9tbS5jICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAx OSArKysrKy0tLS0KPiAgZHJpdmVycy9ncHUvZHJtL2RybV92bWFfbWFuYWdlci5jICAgICAgICAg ICAgICAgICAgfCAgMiArLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbV91c2VycHRy LmMgICAgICAgICAgICB8ICA2ICstLQo+ICBkcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5o ICAgICAgICAgICAgICAgICAgICB8ICAyICstCj4gIGRyaXZlcnMvZ3B1L2RybS9yYWRlb24vcmFk ZW9uX21uLmMgICAgICAgICAgICAgICAgIHwgIDggKystLQo+ICBkcml2ZXJzL2dwdS9kcm0vcmFk ZW9uL3JhZGVvbl92bS5jICAgICAgICAgICAgICAgICB8ICA3ICsrLS0KPiAgZHJpdmVycy9pbmZp bmliYW5kL2NvcmUvdW1lbV9yYnRyZWUuYyAgICAgICAgICAgICAgfCAgNCArLQo+ICBkcml2ZXJz L2luZmluaWJhbmQvY29yZS91dmVyYnNfY21kLmMgICAgICAgICAgICAgICB8ICAyICstCj4gIGRy aXZlcnMvaW5maW5pYmFuZC9ody9oZmkxL21tdV9yYi5jICAgICAgICAgICAgICAgIHwgMTAgKyst LS0KPiAgZHJpdmVycy9pbmZpbmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb20uYyAgICAgICAgICAg fCAgNiArLS0KPiAgZHJpdmVycy9pbmZpbmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb20uaCAgICAg ICAgICAgfCAgMiArLQo+ICAuLi4vaW5maW5pYmFuZC9ody91c25pYy91c25pY191aW9tX2ludGVy dmFsX3RyZWUuYyB8IDE1ICsrKy0tLS0KPiAgLi4uL2luZmluaWJhbmQvaHcvdXNuaWMvdXNuaWNf dWlvbV9pbnRlcnZhbF90cmVlLmggfCAxMiArKystLS0KPiAgZHJpdmVycy92aG9zdC92aG9zdC5j ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQo+ICBkcml2ZXJzL3Zob3N0L3Zo b3N0LmggICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAyICstCj4gIGZzL2h1Z2V0bGJm cy9pbm9kZS5jICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDYgKy0tCj4gIGZzL2lu b2RlLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDIgKy0KPiAg aW5jbHVkZS9kcm0vZHJtX21tLmggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMiAr LQo+ICBpbmNsdWRlL2xpbnV4L2ZzLmggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8 ICA0ICstCj4gIGluY2x1ZGUvbGludXgvaW50ZXJ2YWxfdHJlZS5oICAgICAgICAgICAgICAgICAg ICAgIHwgIDggKystLQo+ICBpbmNsdWRlL2xpbnV4L2ludGVydmFsX3RyZWVfZ2VuZXJpYy5oICAg ICAgICAgICAgICB8IDQ2ICsrKysrKysrKysrKysrKysrLS0tLS0KPiAgaW5jbHVkZS9saW51eC9t bS5oICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxNyArKysrLS0tLQo+ICBpbmNs dWRlL2xpbnV4L3JtYXAuaCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICA0ICstCj4g IGluY2x1ZGUvcmRtYS9pYl91bWVtX29kcC5oICAgICAgICAgICAgICAgICAgICAgICAgIHwgMTEg KysrKy0tCj4gIGluY2x1ZGUvcmRtYS9pYl92ZXJicy5oICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgIDIgKy0KPiAgbGliL2ludGVydmFsX3RyZWVfdGVzdC5jICAgICAgICAgICAgICAgICAg ICAgICAgICAgfCAgNCArLQo+ICBtbS9pbnRlcnZhbF90cmVlLmMgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB8IDEwICsrLS0tCj4gIG1tL21lbW9yeS5jICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgIDQgKy0KPiAgbW0vbW1hcC5jICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxMCArKy0tLQo+ICBtbS9ybWFwLmMgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICA0ICstCj4gIDMzIGZpbGVzIGNo YW5nZWQsIDE0NSBpbnNlcnRpb25zKCspLCAxMDUgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5jIGIvZHJpdmVycy9ncHUv ZHJtL2FtZC9hbWRncHUvYW1kZ3B1X21uLmMKPiBpbmRleCAzOGY3MzlmYjcyN2IuLjNmOGFlZjIx YjlhNiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4u Ywo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5jCj4gQEAgLTUx LDcgKzUxLDcgQEAgc3RydWN0IGFtZGdwdV9tbiB7Cj4gIAo+ICAJLyogb2JqZWN0cyBwcm90ZWN0 ZWQgYnkgbG9jayAqLwo+ICAJc3RydWN0IG11dGV4CQlsb2NrOwo+IC0Jc3RydWN0IHJiX3Jvb3QJ CW9iamVjdHM7Cj4gKwlzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQJb2JqZWN0czsKPiAgfTsKPiAgCj4g IHN0cnVjdCBhbWRncHVfbW5fbm9kZSB7Cj4gQEAgLTc2LDggKzc2LDggQEAgc3RhdGljIHZvaWQg YW1kZ3B1X21uX2Rlc3Ryb3koc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQo+ICAJbXV0ZXhfbG9j aygmYWRldi0+bW5fbG9jayk7Cj4gIAltdXRleF9sb2NrKCZybW4tPmxvY2spOwo+ICAJaGFzaF9k ZWwoJnJtbi0+bm9kZSk7Cj4gLQlyYnRyZWVfcG9zdG9yZGVyX2Zvcl9lYWNoX2VudHJ5X3NhZmUo bm9kZSwgbmV4dF9ub2RlLCAmcm1uLT5vYmplY3RzLAo+IC0JCQkJCSAgICAgaXQucmIpIHsKPiAr CXJidHJlZV9wb3N0b3JkZXJfZm9yX2VhY2hfZW50cnlfc2FmZShub2RlLCBuZXh0X25vZGUsCj4g KwkJCQkJICAgICAmcm1uLT5vYmplY3RzLnJiX3Jvb3QsIGl0LnJiKSB7Cj4gIAkJbGlzdF9mb3Jf ZWFjaF9lbnRyeV9zYWZlKGJvLCBuZXh0X2JvLCAmbm9kZS0+Ym9zLCBtbl9saXN0KSB7Cj4gIAkJ CWJvLT5tbiA9IE5VTEw7Cj4gIAkJCWxpc3RfZGVsX2luaXQoJmJvLT5tbl9saXN0KTsKPiBAQCAt MjUyLDcgKzI1Miw3IEBAIHN0YXRpYyBzdHJ1Y3QgYW1kZ3B1X21uICphbWRncHVfbW5fZ2V0KHN0 cnVjdCBhbWRncHVfZGV2aWNlICphZGV2KQo+ICAJcm1uLT5tbSA9IG1tOwo+ICAJcm1uLT5tbi5v cHMgPSAmYW1kZ3B1X21uX29wczsKPiAgCW11dGV4X2luaXQoJnJtbi0+bG9jayk7Cj4gLQlybW4t Pm9iamVjdHMgPSBSQl9ST09UOwo+ICsJcm1uLT5vYmplY3RzID0gUkJfUk9PVF9DQUNIRUQ7Cj4g IAo+ICAJciA9IF9fbW11X25vdGlmaWVyX3JlZ2lzdGVyKCZybW4tPm1uLCBtbSk7Cj4gIAlpZiAo cikKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1X3ZtLmMg Yi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfdm0uYwo+IGluZGV4IDU3OTVmODEz NjlmMC4uZjg3MmUyMTc5YmJkIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1k Z3B1L2FtZGdwdV92bS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X3ZtLmMKPiBAQCAtMjQwNSw3ICsyNDA1LDcgQEAgaW50IGFtZGdwdV92bV9pbml0KHN0cnVjdCBh bWRncHVfZGV2aWNlICphZGV2LCBzdHJ1Y3QgYW1kZ3B1X3ZtICp2bSwKPiAgCWludCByLCBpOwo+ ICAJdTY0IGZsYWdzOwo+ICAKPiAtCXZtLT52YSA9IFJCX1JPT1Q7Cj4gKwl2bS0+dmEgPSBSQl9S T09UX0NBQ0hFRDsKPiAgCXZtLT5jbGllbnRfaWQgPSBhdG9taWM2NF9pbmNfcmV0dXJuKCZhZGV2 LT52bV9tYW5hZ2VyLmNsaWVudF9jb3VudGVyKTsKPiAgCWZvciAoaSA9IDA7IGkgPCBBTURHUFVf TUFYX1ZNSFVCUzsgaSsrKQo+ICAJCXZtLT5yZXNlcnZlZF92bWlkW2ldID0gTlVMTDsKPiBAQCAt MjUxMiwxMCArMjUxMiwxMSBAQCB2b2lkIGFtZGdwdV92bV9maW5pKHN0cnVjdCBhbWRncHVfZGV2 aWNlICphZGV2LCBzdHJ1Y3QgYW1kZ3B1X3ZtICp2bSkKPiAgCj4gIAlhbWRfc2NoZWRfZW50aXR5 X2Zpbmkodm0tPmVudGl0eS5zY2hlZCwgJnZtLT5lbnRpdHkpOwo+ICAKPiAtCWlmICghUkJfRU1Q VFlfUk9PVCgmdm0tPnZhKSkgewo+ICsJaWYgKCFSQl9FTVBUWV9ST09UKCZ2bS0+dmEucmJfcm9v dCkpIHsKPiAgCQlkZXZfZXJyKGFkZXYtPmRldiwgInN0aWxsIGFjdGl2ZSBibyBpbnNpZGUgdm1c biIpOwo+ICAJfQo+IC0JcmJ0cmVlX3Bvc3RvcmRlcl9mb3JfZWFjaF9lbnRyeV9zYWZlKG1hcHBp bmcsIHRtcCwgJnZtLT52YSwgcmIpIHsKPiArCXJidHJlZV9wb3N0b3JkZXJfZm9yX2VhY2hfZW50 cnlfc2FmZShtYXBwaW5nLCB0bXAsCj4gKwkJCQkJICAgICAmdm0tPnZhLnJiX3Jvb3QsIHJiKSB7 Cj4gIAkJbGlzdF9kZWwoJm1hcHBpbmctPmxpc3QpOwo+ICAJCWFtZGdwdV92bV9pdF9yZW1vdmUo bWFwcGluZywgJnZtLT52YSk7Cj4gIAkJa2ZyZWUobWFwcGluZyk7Cj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV92bS5oIGIvZHJpdmVycy9ncHUvZHJtL2Ft ZC9hbWRncHUvYW1kZ3B1X3ZtLmgKPiBpbmRleCA5MzZmMTU4YmM1ZWMuLmViZmZjMTI1M2Y4NSAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfdm0uaAo+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV92bS5oCj4gQEAgLTEwNiw3ICsx MDYsNyBAQCBzdHJ1Y3QgYW1kZ3B1X3ZtX3B0IHsKPiAgCj4gIHN0cnVjdCBhbWRncHVfdm0gewo+ ICAJLyogdHJlZSBvZiB2aXJ0dWFsIGFkZHJlc3NlcyBtYXBwZWQgKi8KPiAtCXN0cnVjdCByYl9y b290CQl2YTsKPiArCXN0cnVjdCByYl9yb290X2NhY2hlZAl2YTsKPiAgCj4gIAkvKiBwcm90ZWN0 aW5nIGludmFsaWRhdGVkICovCj4gIAlzcGlubG9ja190CQlzdGF0dXNfbG9jazsKPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9tbS5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9tbS5j Cj4gaW5kZXggZjc5NDA4OWQzMGFjLi42MWExYzhlYTc0YmMgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2RybV9tbS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9tbS5jCj4gQEAg LTE2OSw3ICsxNjksNyBAQCBJTlRFUlZBTF9UUkVFX0RFRklORShzdHJ1Y3QgZHJtX21tX25vZGUs IHJiLAo+ICBzdHJ1Y3QgZHJtX21tX25vZGUgKgo+ICBfX2RybV9tbV9pbnRlcnZhbF9maXJzdChj b25zdCBzdHJ1Y3QgZHJtX21tICptbSwgdTY0IHN0YXJ0LCB1NjQgbGFzdCkKPiAgewo+IC0JcmV0 dXJuIGRybV9tbV9pbnRlcnZhbF90cmVlX2l0ZXJfZmlyc3QoKHN0cnVjdCByYl9yb290ICopJm1t LT5pbnRlcnZhbF90cmVlLAo+ICsJcmV0dXJuIGRybV9tbV9pbnRlcnZhbF90cmVlX2l0ZXJfZmly c3QoKHN0cnVjdCByYl9yb290X2NhY2hlZCAqKSZtbS0+aW50ZXJ2YWxfdHJlZSwKPiAgCQkJCQkg ICAgICAgc3RhcnQsIGxhc3QpID86IChzdHJ1Y3QgZHJtX21tX25vZGUgKikmbW0tPmhlYWRfbm9k ZTsKPiAgfQo+ICBFWFBPUlRfU1lNQk9MKF9fZHJtX21tX2ludGVydmFsX2ZpcnN0KTsKPiBAQCAt MTgwLDYgKzE4MCw3IEBAIHN0YXRpYyB2b2lkIGRybV9tbV9pbnRlcnZhbF90cmVlX2FkZF9ub2Rl KHN0cnVjdCBkcm1fbW1fbm9kZSAqaG9sZV9ub2RlLAo+ICAJc3RydWN0IGRybV9tbSAqbW0gPSBo b2xlX25vZGUtPm1tOwo+ICAJc3RydWN0IHJiX25vZGUgKipsaW5rLCAqcmI7Cj4gIAlzdHJ1Y3Qg ZHJtX21tX25vZGUgKnBhcmVudDsKPiArCWJvb2wgbGVmdG1vc3QgPSB0cnVlOwo+ICAKPiAgCW5v ZGUtPl9fc3VidHJlZV9sYXN0ID0gTEFTVChub2RlKTsKPiAgCj4gQEAgLTE5Niw5ICsxOTcsMTAg QEAgc3RhdGljIHZvaWQgZHJtX21tX2ludGVydmFsX3RyZWVfYWRkX25vZGUoc3RydWN0IGRybV9t bV9ub2RlICpob2xlX25vZGUsCj4gIAo+ICAJCXJiID0gJmhvbGVfbm9kZS0+cmI7Cj4gIAkJbGlu ayA9ICZob2xlX25vZGUtPnJiLnJiX3JpZ2h0Owo+ICsJCWxlZnRtb3N0ID0gZmFsc2U7Cj4gIAl9 IGVsc2Ugewo+ICAJCXJiID0gTlVMTDsKPiAtCQlsaW5rID0gJm1tLT5pbnRlcnZhbF90cmVlLnJi X25vZGU7Cj4gKwkJbGluayA9ICZtbS0+aW50ZXJ2YWxfdHJlZS5yYl9yb290LnJiX25vZGU7Cj4g IAl9Cj4gIAo+ICAJd2hpbGUgKCpsaW5rKSB7Cj4gQEAgLTIwOCwxNCArMjEwLDE1IEBAIHN0YXRp YyB2b2lkIGRybV9tbV9pbnRlcnZhbF90cmVlX2FkZF9ub2RlKHN0cnVjdCBkcm1fbW1fbm9kZSAq aG9sZV9ub2RlLAo+ICAJCQlwYXJlbnQtPl9fc3VidHJlZV9sYXN0ID0gbm9kZS0+X19zdWJ0cmVl X2xhc3Q7Cj4gIAkJaWYgKG5vZGUtPnN0YXJ0IDwgcGFyZW50LT5zdGFydCkKPiAgCQkJbGluayA9 ICZwYXJlbnQtPnJiLnJiX2xlZnQ7Cj4gLQkJZWxzZQo+ICsJCWVsc2Ugewo+ICAJCQlsaW5rID0g JnBhcmVudC0+cmIucmJfcmlnaHQ7Cj4gKwkJCWxlZnRtb3N0ID0gdHJ1ZTsKPiArCQl9Cj4gIAl9 Cj4gIAo+ICAJcmJfbGlua19ub2RlKCZub2RlLT5yYiwgcmIsIGxpbmspOwo+IC0JcmJfaW5zZXJ0 X2F1Z21lbnRlZCgmbm9kZS0+cmIsCj4gLQkJCSAgICAmbW0tPmludGVydmFsX3RyZWUsCj4gLQkJ CSAgICAmZHJtX21tX2ludGVydmFsX3RyZWVfYXVnbWVudCk7Cj4gKwlyYl9pbnNlcnRfYXVnbWVu dGVkX2NhY2hlZCgmbm9kZS0+cmIsICZtbS0+aW50ZXJ2YWxfdHJlZSwgbGVmdG1vc3QsCj4gKwkJ CQkgICAmZHJtX21tX2ludGVydmFsX3RyZWVfYXVnbWVudCk7Cj4gIH0KPiAgCj4gICNkZWZpbmUg UkJfSU5TRVJUKHJvb3QsIG1lbWJlciwgZXhwcikgZG8geyBcCj4gQEAgLTU3Nyw3ICs1ODAsNyBA QCB2b2lkIGRybV9tbV9yZXBsYWNlX25vZGUoc3RydWN0IGRybV9tbV9ub2RlICpvbGQsIHN0cnVj dCBkcm1fbW1fbm9kZSAqbmV3KQo+ICAJKm5ldyA9ICpvbGQ7Cj4gIAo+ICAJbGlzdF9yZXBsYWNl KCZvbGQtPm5vZGVfbGlzdCwgJm5ldy0+bm9kZV9saXN0KTsKPiAtCXJiX3JlcGxhY2Vfbm9kZSgm b2xkLT5yYiwgJm5ldy0+cmIsICZvbGQtPm1tLT5pbnRlcnZhbF90cmVlKTsKPiArCXJiX3JlcGxh Y2Vfbm9kZSgmb2xkLT5yYiwgJm5ldy0+cmIsICZvbGQtPm1tLT5pbnRlcnZhbF90cmVlLnJiX3Jv b3QpOwo+ICAKPiAgCWlmIChkcm1fbW1faG9sZV9mb2xsb3dzKG9sZCkpIHsKPiAgCQlsaXN0X3Jl cGxhY2UoJm9sZC0+aG9sZV9zdGFjaywgJm5ldy0+aG9sZV9zdGFjayk7Cj4gQEAgLTg2Myw3ICs4 NjYsNyBAQCB2b2lkIGRybV9tbV9pbml0KHN0cnVjdCBkcm1fbW0gKm1tLCB1NjQgc3RhcnQsIHU2 NCBzaXplKQo+ICAJbW0tPmNvbG9yX2FkanVzdCA9IE5VTEw7Cj4gIAo+ICAJSU5JVF9MSVNUX0hF QUQoJm1tLT5ob2xlX3N0YWNrKTsKPiAtCW1tLT5pbnRlcnZhbF90cmVlID0gUkJfUk9PVDsKPiAr CW1tLT5pbnRlcnZhbF90cmVlID0gUkJfUk9PVF9DQUNIRUQ7Cj4gIAltbS0+aG9sZXNfc2l6ZSA9 IFJCX1JPT1Q7Cj4gIAltbS0+aG9sZXNfYWRkciA9IFJCX1JPT1Q7Cj4gIAo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vZHJtX3ZtYV9tYW5hZ2VyLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJt X3ZtYV9tYW5hZ2VyLmMKPiBpbmRleCBkOTEwMGI1NjUxOTguLjI4ZjEyMjY1NzZmOCAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX3ZtYV9tYW5hZ2VyLmMKPiArKysgYi9kcml2ZXJz L2dwdS9kcm0vZHJtX3ZtYV9tYW5hZ2VyLmMKPiBAQCAtMTQ3LDcgKzE0Nyw3IEBAIHN0cnVjdCBk cm1fdm1hX29mZnNldF9ub2RlICpkcm1fdm1hX29mZnNldF9sb29rdXBfbG9ja2VkKHN0cnVjdCBk cm1fdm1hX29mZnNldF9tCj4gIAlzdHJ1Y3QgcmJfbm9kZSAqaXRlcjsKPiAgCXVuc2lnbmVkIGxv bmcgb2Zmc2V0Owo+ICAKPiAtCWl0ZXIgPSBtZ3ItPnZtX2FkZHJfc3BhY2VfbW0uaW50ZXJ2YWxf dHJlZS5yYl9ub2RlOwo+ICsJaXRlciA9IG1nci0+dm1fYWRkcl9zcGFjZV9tbS5pbnRlcnZhbF90 cmVlLnJiX3Jvb3QucmJfbm9kZTsKPiAgCWJlc3QgPSBOVUxMOwo+ICAKPiAgCXdoaWxlIChsaWtl bHkoaXRlcikpIHsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1f dXNlcnB0ci5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fdXNlcnB0ci5jCj4gaW5k ZXggY2NkMDllODQxOWY1Li43MWRkZGY2NmJhYWEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaTkxNV9nZW1fdXNlcnB0ci5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aTkxNV9nZW1fdXNlcnB0ci5jCj4gQEAgLTQ5LDcgKzQ5LDcgQEAgc3RydWN0IGk5MTVfbW11X25v dGlmaWVyIHsKPiAgCXNwaW5sb2NrX3QgbG9jazsKPiAgCXN0cnVjdCBobGlzdF9ub2RlIG5vZGU7 Cj4gIAlzdHJ1Y3QgbW11X25vdGlmaWVyIG1uOwo+IC0Jc3RydWN0IHJiX3Jvb3Qgb2JqZWN0czsK PiArCXN0cnVjdCByYl9yb290X2NhY2hlZCBvYmplY3RzOwo+ICAJc3RydWN0IHdvcmtxdWV1ZV9z dHJ1Y3QgKndxOwo+ICB9Owo+ICAKPiBAQCAtMTIzLDcgKzEyMyw3IEBAIHN0YXRpYyB2b2lkIGk5 MTVfZ2VtX3VzZXJwdHJfbW5faW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW11X25vdGlm aWVyICpfbW4sCj4gIAlzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlICppdDsKPiAgCUxJU1RfSEVB RChjYW5jZWxsZWQpOwo+ICAKPiAtCWlmIChSQl9FTVBUWV9ST09UKCZtbi0+b2JqZWN0cykpCj4g KwlpZiAoUkJfRU1QVFlfUk9PVCgmbW4tPm9iamVjdHMucmJfcm9vdCkpCj4gIAkJcmV0dXJuOwo+ ICAKPiAgCS8qIGludGVydmFsIHJhbmdlcyBhcmUgaW5jbHVzaXZlLCBidXQgaW52YWxpZGF0ZSBy YW5nZSBpcyBleGNsdXNpdmUgKi8KPiBAQCAtMTcyLDcgKzE3Miw3IEBAIGk5MTVfbW11X25vdGlm aWVyX2NyZWF0ZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKPiAgCj4gIAlzcGluX2xvY2tfaW5pdCgm bW4tPmxvY2spOwo+ICAJbW4tPm1uLm9wcyA9ICZpOTE1X2dlbV91c2VycHRyX25vdGlmaWVyOwo+ IC0JbW4tPm9iamVjdHMgPSBSQl9ST09UOwo+ICsJbW4tPm9iamVjdHMgPSBSQl9ST09UX0NBQ0hF RDsKPiAgCW1uLT53cSA9IGFsbG9jX3dvcmtxdWV1ZSgiaTkxNS11c2VycHRyLXJlbGVhc2UiLCBX UV9VTkJPVU5ELCAwKTsKPiAgCWlmIChtbi0+d3EgPT0gTlVMTCkgewo+ICAJCWtmcmVlKG1uKTsK PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaCBiL2RyaXZlcnMv Z3B1L2RybS9yYWRlb24vcmFkZW9uLmgKPiBpbmRleCA1MDA4ZjNkNGNjY2MuLjEwZDBkZDE0Njgw OCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbi5oCj4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb24uaAo+IEBAIC05MjQsNyArOTI0LDcgQEAgc3Ry dWN0IHJhZGVvbl92bV9pZCB7Cj4gIHN0cnVjdCByYWRlb25fdm0gewo+ICAJc3RydWN0IG11dGV4 CQltdXRleDsKPiAgCj4gLQlzdHJ1Y3QgcmJfcm9vdAkJdmE7Cj4gKwlzdHJ1Y3QgcmJfcm9vdF9j YWNoZWQJdmE7Cj4gIAo+ICAJLyogcHJvdGVjdGluZyBpbnZhbGlkYXRlZCBhbmQgZnJlZWQgKi8K PiAgCXNwaW5sb2NrX3QJCXN0YXR1c19sb2NrOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vcmFkZW9uL3JhZGVvbl9tbi5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fbW4u Ywo+IGluZGV4IDg5NmYyY2Y1MWU0ZS4uMWQ2MjI4OGI3ZWUzIDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX21uLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFk ZW9uL3JhZGVvbl9tbi5jCj4gQEAgLTUwLDcgKzUwLDcgQEAgc3RydWN0IHJhZGVvbl9tbiB7Cj4g IAo+ICAJLyogb2JqZWN0cyBwcm90ZWN0ZWQgYnkgbG9jayAqLwo+ICAJc3RydWN0IG11dGV4CQls b2NrOwo+IC0Jc3RydWN0IHJiX3Jvb3QJCW9iamVjdHM7Cj4gKwlzdHJ1Y3QgcmJfcm9vdF9jYWNo ZWQJb2JqZWN0czsKPiAgfTsKPiAgCj4gIHN0cnVjdCByYWRlb25fbW5fbm9kZSB7Cj4gQEAgLTc1 LDggKzc1LDggQEAgc3RhdGljIHZvaWQgcmFkZW9uX21uX2Rlc3Ryb3koc3RydWN0IHdvcmtfc3Ry dWN0ICp3b3JrKQo+ICAJbXV0ZXhfbG9jaygmcmRldi0+bW5fbG9jayk7Cj4gIAltdXRleF9sb2Nr KCZybW4tPmxvY2spOwo+ICAJaGFzaF9kZWwoJnJtbi0+bm9kZSk7Cj4gLQlyYnRyZWVfcG9zdG9y ZGVyX2Zvcl9lYWNoX2VudHJ5X3NhZmUobm9kZSwgbmV4dF9ub2RlLCAmcm1uLT5vYmplY3RzLAo+ IC0JCQkJCSAgICAgaXQucmIpIHsKPiArCXJidHJlZV9wb3N0b3JkZXJfZm9yX2VhY2hfZW50cnlf c2FmZShub2RlLCBuZXh0X25vZGUsCj4gKwkJCQkJICAgICAmcm1uLT5vYmplY3RzLnJiX3Jvb3Qs IGl0LnJiKSB7Cj4gIAo+ICAJCWludGVydmFsX3RyZWVfcmVtb3ZlKCZub2RlLT5pdCwgJnJtbi0+ b2JqZWN0cyk7Cj4gIAkJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGJvLCBuZXh0X2JvLCAmbm9k ZS0+Ym9zLCBtbl9saXN0KSB7Cj4gQEAgLTIwNSw3ICsyMDUsNyBAQCBzdGF0aWMgc3RydWN0IHJh ZGVvbl9tbiAqcmFkZW9uX21uX2dldChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldikKPiAgCXJt bi0+bW0gPSBtbTsKPiAgCXJtbi0+bW4ub3BzID0gJnJhZGVvbl9tbl9vcHM7Cj4gIAltdXRleF9p bml0KCZybW4tPmxvY2spOwo+IC0Jcm1uLT5vYmplY3RzID0gUkJfUk9PVDsKPiArCXJtbi0+b2Jq ZWN0cyA9IFJCX1JPT1RfQ0FDSEVEOwo+ICAJCj4gIAlyID0gX19tbXVfbm90aWZpZXJfcmVnaXN0 ZXIoJnJtbi0+bW4sIG1tKTsKPiAgCWlmIChyKQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vcmFkZW9uL3JhZGVvbl92bS5jIGIvZHJpdmVycy9ncHUvZHJtL3JhZGVvbi9yYWRlb25fdm0u Ywo+IGluZGV4IDVmNjgyNDU1NzlhMy4uZjQ0Nzc3YTZjMmU4IDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX3ZtLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcmFk ZW9uL3JhZGVvbl92bS5jCj4gQEAgLTExODUsNyArMTE4NSw3IEBAIGludCByYWRlb25fdm1faW5p dChzdHJ1Y3QgcmFkZW9uX2RldmljZSAqcmRldiwgc3RydWN0IHJhZGVvbl92bSAqdm0pCj4gIAkJ dm0tPmlkc1tpXS5sYXN0X2lkX3VzZSA9IE5VTEw7Cj4gIAl9Cj4gIAltdXRleF9pbml0KCZ2bS0+ bXV0ZXgpOwo+IC0Jdm0tPnZhID0gUkJfUk9PVDsKPiArCXZtLT52YSA9IFJCX1JPT1RfQ0FDSEVE Owo+ICAJc3Bpbl9sb2NrX2luaXQoJnZtLT5zdGF0dXNfbG9jayk7Cj4gIAlJTklUX0xJU1RfSEVB RCgmdm0tPmludmFsaWRhdGVkKTsKPiAgCUlOSVRfTElTVF9IRUFEKCZ2bS0+ZnJlZWQpOwo+IEBA IC0xMjMyLDEwICsxMjMyLDExIEBAIHZvaWQgcmFkZW9uX3ZtX2Zpbmkoc3RydWN0IHJhZGVvbl9k ZXZpY2UgKnJkZXYsIHN0cnVjdCByYWRlb25fdm0gKnZtKQo+ICAJc3RydWN0IHJhZGVvbl9ib192 YSAqYm9fdmEsICp0bXA7Cj4gIAlpbnQgaSwgcjsKPiAgCj4gLQlpZiAoIVJCX0VNUFRZX1JPT1Qo JnZtLT52YSkpIHsKPiArCWlmICghUkJfRU1QVFlfUk9PVCgmdm0tPnZhLnJiX3Jvb3QpKSB7Cj4g IAkJZGV2X2VycihyZGV2LT5kZXYsICJzdGlsbCBhY3RpdmUgYm8gaW5zaWRlIHZtXG4iKTsKPiAg CX0KPiAtCXJidHJlZV9wb3N0b3JkZXJfZm9yX2VhY2hfZW50cnlfc2FmZShib192YSwgdG1wLCAm dm0tPnZhLCBpdC5yYikgewo+ICsJcmJ0cmVlX3Bvc3RvcmRlcl9mb3JfZWFjaF9lbnRyeV9zYWZl KGJvX3ZhLCB0bXAsCj4gKwkJCQkJICAgICAmdm0tPnZhLnJiX3Jvb3QsIGl0LnJiKSB7Cj4gIAkJ aW50ZXJ2YWxfdHJlZV9yZW1vdmUoJmJvX3ZhLT5pdCwgJnZtLT52YSk7Cj4gIAkJciA9IHJhZGVv bl9ib19yZXNlcnZlKGJvX3ZhLT5ibywgZmFsc2UpOwo+ICAJCWlmICghcikgewo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91bWVtX3JidHJlZS5jIGIvZHJpdmVycy9pbmZp bmliYW5kL2NvcmUvdW1lbV9yYnRyZWUuYwo+IGluZGV4IGQxNzY1OTdiNGQ3OC4uZmM4MDE5MjBl MzQxIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL3VtZW1fcmJ0cmVlLmMK PiArKysgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91bWVtX3JidHJlZS5jCj4gQEAgLTcyLDcg KzcyLDcgQEAgSU5URVJWQUxfVFJFRV9ERUZJTkUoc3RydWN0IHVtZW1fb2RwX25vZGUsIHJiLCB1 NjQsIF9fc3VidHJlZV9sYXN0LAo+ICAvKiBAbGFzdCBpcyBub3QgYSBwYXJ0IG9mIHRoZSBpbnRl cnZhbC4gU2VlIGNvbW1lbnQgZm9yIGZ1bmN0aW9uCj4gICAqIG5vZGVfbGFzdC4KPiAgICovCj4g LWludCByYnRfaWJfdW1lbV9mb3JfZWFjaF9pbl9yYW5nZShzdHJ1Y3QgcmJfcm9vdCAqcm9vdCwK PiAraW50IHJidF9pYl91bWVtX2Zvcl9lYWNoX2luX3JhbmdlKHN0cnVjdCByYl9yb290X2NhY2hl ZCAqcm9vdCwKPiAgCQkJCSAgdTY0IHN0YXJ0LCB1NjQgbGFzdCwKPiAgCQkJCSAgdW1lbV9jYWxs X2JhY2sgY2IsCj4gIAkJCQkgIHZvaWQgKmNvb2tpZSkKPiBAQCAtOTUsNyArOTUsNyBAQCBpbnQg cmJ0X2liX3VtZW1fZm9yX2VhY2hfaW5fcmFuZ2Uoc3RydWN0IHJiX3Jvb3QgKnJvb3QsCj4gIH0K PiAgRVhQT1JUX1NZTUJPTChyYnRfaWJfdW1lbV9mb3JfZWFjaF9pbl9yYW5nZSk7Cj4gIAo+IC1z dHJ1Y3QgaWJfdW1lbV9vZHAgKnJidF9pYl91bWVtX2xvb2t1cChzdHJ1Y3QgcmJfcm9vdCAqcm9v dCwKPiArc3RydWN0IGliX3VtZW1fb2RwICpyYnRfaWJfdW1lbV9sb29rdXAoc3RydWN0IHJiX3Jv b3RfY2FjaGVkICpyb290LAo+ICAJCQkJICAgICAgIHU2NCBhZGRyLCB1NjQgbGVuZ3RoKQo+ICB7 Cj4gIAlzdHJ1Y3QgdW1lbV9vZHBfbm9kZSAqbm9kZTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9p bmZpbmliYW5kL2NvcmUvdXZlcmJzX2NtZC5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdXZl cmJzX2NtZC5jCj4gaW5kZXggM2Y1NWQxOGEzNzkxLi41MzIxYzZhZTJjMGMgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdXZlcmJzX2NtZC5jCj4gKysrIGIvZHJpdmVycy9p bmZpbmliYW5kL2NvcmUvdXZlcmJzX2NtZC5jCj4gQEAgLTExNyw3ICsxMTcsNyBAQCBzc2l6ZV90 IGliX3V2ZXJic19nZXRfY29udGV4dChzdHJ1Y3QgaWJfdXZlcmJzX2ZpbGUgKmZpbGUsCj4gIAl1 Y29udGV4dC0+Y2xvc2luZyA9IDA7Cj4gIAo+ICAjaWZkZWYgQ09ORklHX0lORklOSUJBTkRfT05f REVNQU5EX1BBR0lORwo+IC0JdWNvbnRleHQtPnVtZW1fdHJlZSA9IFJCX1JPT1Q7Cj4gKwl1Y29u dGV4dC0+dW1lbV90cmVlID0gUkJfUk9PVF9DQUNIRUQ7Cj4gIAlpbml0X3J3c2VtKCZ1Y29udGV4 dC0+dW1lbV9yd3NlbSk7Cj4gIAl1Y29udGV4dC0+b2RwX21yc19jb3VudCA9IDA7Cj4gIAlJTklU X0xJU1RfSEVBRCgmdWNvbnRleHQtPm5vX3ByaXZhdGVfY291bnRlcnMpOwo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaGZpMS9tbXVfcmIuYyBiL2RyaXZlcnMvaW5maW5pYmFu ZC9ody9oZmkxL21tdV9yYi5jCj4gaW5kZXggZDQxZmQ4N2EzOWYyLi41YjY2MjZmOGZlYjYgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2hmaTEvbW11X3JiLmMKPiArKysgYi9k cml2ZXJzL2luZmluaWJhbmQvaHcvaGZpMS9tbXVfcmIuYwo+IEBAIC01NCw3ICs1NCw3IEBACj4g IAo+ICBzdHJ1Y3QgbW11X3JiX2hhbmRsZXIgewo+ICAJc3RydWN0IG1tdV9ub3RpZmllciBtbjsK PiAtCXN0cnVjdCByYl9yb290IHJvb3Q7Cj4gKwlzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgcm9vdDsK PiAgCXZvaWQgKm9wc19hcmc7Cj4gIAlzcGlubG9ja190IGxvY2s7ICAgICAgICAvKiBwcm90ZWN0 IHRoZSBSQiB0cmVlICovCj4gIAlzdHJ1Y3QgbW11X3JiX29wcyAqb3BzOwo+IEBAIC0xMTEsNyAr MTExLDcgQEAgaW50IGhmaTFfbW11X3JiX3JlZ2lzdGVyKHZvaWQgKm9wc19hcmcsIHN0cnVjdCBt bV9zdHJ1Y3QgKm1tLAo+ICAJaWYgKCFoYW5kbHIpCj4gIAkJcmV0dXJuIC1FTk9NRU07Cj4gIAo+ IC0JaGFuZGxyLT5yb290ID0gUkJfUk9PVDsKPiArCWhhbmRsci0+cm9vdCA9IFJCX1JPT1RfQ0FD SEVEOwo+ICAJaGFuZGxyLT5vcHMgPSBvcHM7Cj4gIAloYW5kbHItPm9wc19hcmcgPSBvcHNfYXJn Owo+ICAJSU5JVF9ITElTVF9OT0RFKCZoYW5kbHItPm1uLmhsaXN0KTsKPiBAQCAtMTUyLDkgKzE1 Miw5IEBAIHZvaWQgaGZpMV9tbXVfcmJfdW5yZWdpc3RlcihzdHJ1Y3QgbW11X3JiX2hhbmRsZXIg KmhhbmRsZXIpCj4gIAlJTklUX0xJU1RfSEVBRCgmZGVsX2xpc3QpOwo+ICAKPiAgCXNwaW5fbG9j a19pcnFzYXZlKCZoYW5kbGVyLT5sb2NrLCBmbGFncyk7Cj4gLQl3aGlsZSAoKG5vZGUgPSByYl9m aXJzdCgmaGFuZGxlci0+cm9vdCkpKSB7Cj4gKwl3aGlsZSAoKG5vZGUgPSByYl9maXJzdF9jYWNo ZWQoJmhhbmRsZXItPnJvb3QpKSkgewo+ICAJCXJibm9kZSA9IHJiX2VudHJ5KG5vZGUsIHN0cnVj dCBtbXVfcmJfbm9kZSwgbm9kZSk7Cj4gLQkJcmJfZXJhc2Uobm9kZSwgJmhhbmRsZXItPnJvb3Qp Owo+ICsJCXJiX2VyYXNlX2NhY2hlZChub2RlLCAmaGFuZGxlci0+cm9vdCk7Cj4gIAkJLyogbW92 ZSBmcm9tIExSVSBsaXN0IHRvIGRlbGV0ZSBsaXN0ICovCj4gIAkJbGlzdF9tb3ZlKCZyYm5vZGUt Pmxpc3QsICZkZWxfbGlzdCk7Cj4gIAl9Cj4gQEAgLTMxMSw3ICszMTEsNyBAQCBzdGF0aWMgdm9p ZCBtbXVfbm90aWZpZXJfbWVtX2ludmFsaWRhdGUoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCj4g IHsKPiAgCXN0cnVjdCBtbXVfcmJfaGFuZGxlciAqaGFuZGxlciA9Cj4gIAkJY29udGFpbmVyX29m KG1uLCBzdHJ1Y3QgbW11X3JiX2hhbmRsZXIsIG1uKTsKPiAtCXN0cnVjdCByYl9yb290ICpyb290 ID0gJmhhbmRsZXItPnJvb3Q7Cj4gKwlzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgKnJvb3QgPSAmaGFu ZGxlci0+cm9vdDsKPiAgCXN0cnVjdCBtbXVfcmJfbm9kZSAqbm9kZSwgKnB0ciA9IE5VTEw7Cj4g IAl1bnNpZ25lZCBsb25nIGZsYWdzOwo+ICAJYm9vbCBhZGRlZCA9IGZhbHNlOwo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvdXNuaWMvdXNuaWNfdWlvbS5jIGIvZHJpdmVycy9p bmZpbmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb20uYwo+IGluZGV4IGM0OWRiN2MzMzk3OS4uNDM4 MWMwYTlhODczIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody91c25pYy91c25p Y191aW9tLmMKPiArKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvdXNuaWMvdXNuaWNfdWlvbS5j Cj4gQEAgLTIyNyw3ICsyMjcsNyBAQCBzdGF0aWMgdm9pZCBfX3VzbmljX3Vpb21fcmVnX3JlbGVh c2Uoc3RydWN0IHVzbmljX3Vpb21fcGQgKnBkLAo+ICAJdnBuX2xhc3QgPSB2cG5fc3RhcnQgKyBu cGFnZXMgLSAxOwo+ICAKPiAgCXNwaW5fbG9jaygmcGQtPmxvY2spOwo+IC0JdXNuaWNfdWlvbV9y ZW1vdmVfaW50ZXJ2YWwoJnBkLT5yYl9yb290LCB2cG5fc3RhcnQsCj4gKwl1c25pY191aW9tX3Jl bW92ZV9pbnRlcnZhbCgmcGQtPnJvb3QsIHZwbl9zdGFydCwKPiAgCQkJCQl2cG5fbGFzdCwgJnJt X2ludGVydmFscyk7Cj4gIAl1c25pY191aW9tX3VubWFwX3NvcnRlZF9pbnRlcnZhbHMoJnJtX2lu dGVydmFscywgcGQpOwo+ICAKPiBAQCAtMzc5LDcgKzM3OSw3IEBAIHN0cnVjdCB1c25pY191aW9t X3JlZyAqdXNuaWNfdWlvbV9yZWdfZ2V0KHN0cnVjdCB1c25pY191aW9tX3BkICpwZCwKPiAgCWVy ciA9IHVzbmljX3Vpb21fZ2V0X2ludGVydmFsc19kaWZmKHZwbl9zdGFydCwgdnBuX2xhc3QsCj4g IAkJCQkJCSh3cml0YWJsZSkgPyBJT01NVV9XUklURSA6IDAsCj4gIAkJCQkJCUlPTU1VX1dSSVRF LAo+IC0JCQkJCQkmcGQtPnJiX3Jvb3QsCj4gKwkJCQkJCSZwZC0+cm9vdCwKPiAgCQkJCQkJJnNv cnRlZF9kaWZmX2ludGVydmFscyk7Cj4gIAlpZiAoZXJyKSB7Cj4gIAkJdXNuaWNfZXJyKCJGYWls ZWQgZGlzam9pbnQgaW50ZXJ2YWwgdnBuIFsweCVseCwweCVseF0gZXJyICVkXG4iLAo+IEBAIC0z OTUsNyArMzk1LDcgQEAgc3RydWN0IHVzbmljX3Vpb21fcmVnICp1c25pY191aW9tX3JlZ19nZXQo c3RydWN0IHVzbmljX3Vpb21fcGQgKnBkLAo+ICAKPiAgCX0KPiAgCj4gLQllcnIgPSB1c25pY191 aW9tX2luc2VydF9pbnRlcnZhbCgmcGQtPnJiX3Jvb3QsIHZwbl9zdGFydCwgdnBuX2xhc3QsCj4g KwllcnIgPSB1c25pY191aW9tX2luc2VydF9pbnRlcnZhbCgmcGQtPnJvb3QsIHZwbl9zdGFydCwg dnBuX2xhc3QsCj4gIAkJCQkJKHdyaXRhYmxlKSA/IElPTU1VX1dSSVRFIDogMCk7Cj4gIAlpZiAo ZXJyKSB7Cj4gIAkJdXNuaWNfZXJyKCJGYWlsZWQgaW5zZXJ0IGludGVydmFsIHZwbiBbMHglbHgs MHglbHhdIGVyciAlZFxuIiwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3Vz bmljL3VzbmljX3Vpb20uaCBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody91c25pYy91c25pY191aW9t LmgKPiBpbmRleCA0NWNhN2MxNjEzYTcuLjQzMWVmZTQxNDNmNCAxMDA2NDQKPiAtLS0gYS9kcml2 ZXJzL2luZmluaWJhbmQvaHcvdXNuaWMvdXNuaWNfdWlvbS5oCj4gKysrIGIvZHJpdmVycy9pbmZp bmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb20uaAo+IEBAIC01NSw3ICs1NSw3IEBAIHN0cnVjdCB1 c25pY191aW9tX2RldiB7Cj4gIHN0cnVjdCB1c25pY191aW9tX3BkIHsKPiAgCXN0cnVjdCBpb21t dV9kb21haW4JCSpkb21haW47Cj4gIAlzcGlubG9ja190CQkJbG9jazsKPiAtCXN0cnVjdCByYl9y b290CQkJcmJfcm9vdDsKPiArCXN0cnVjdCByYl9yb290X2NhY2hlZAkJcm9vdDsKPiAgCXN0cnVj dCBsaXN0X2hlYWQJCWRldnM7Cj4gIAlpbnQJCQkJZGV2X2NudDsKPiAgfTsKPiBkaWZmIC0tZ2l0 IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb21faW50ZXJ2YWxfdHJlZS5j IGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb21faW50ZXJ2YWxfdHJlZS5j Cj4gaW5kZXggNDJiNGI0YzRlNDUyLi5kMzk5NTIzMjA2YzcgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9pbmZpbmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb21faW50ZXJ2YWxfdHJlZS5jCj4gKysrIGIv ZHJpdmVycy9pbmZpbmliYW5kL2h3L3VzbmljL3VzbmljX3Vpb21faW50ZXJ2YWxfdHJlZS5jCj4g QEAgLTEwMCw5ICsxMDAsOSBAQCBzdGF0aWMgaW50IGludGVydmFsX2NtcCh2b2lkICpwcml2LCBz dHJ1Y3QgbGlzdF9oZWFkICphLCBzdHJ1Y3QgbGlzdF9oZWFkICpiKQo+ICB9Cj4gIAo+ICBzdGF0 aWMgdm9pZAo+IC1maW5kX2ludGVydmFsc19pbnRlcnNlY3Rpb25fc29ydGVkKHN0cnVjdCByYl9y b290ICpyb290LCB1bnNpZ25lZCBsb25nIHN0YXJ0LAo+IC0JCQkJCXVuc2lnbmVkIGxvbmcgbGFz dCwKPiAtCQkJCQlzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0KQo+ICtmaW5kX2ludGVydmFsc19pbnRl cnNlY3Rpb25fc29ydGVkKHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9vdCwKPiArCQkJCSAgIHVu c2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGFzdCwKPiArCQkJCSAgIHN0cnVjdCBs aXN0X2hlYWQgKmxpc3QpCj4gIHsKPiAgCXN0cnVjdCB1c25pY191aW9tX2ludGVydmFsX25vZGUg Km5vZGU7Cj4gIAo+IEBAIC0xMTgsNyArMTE4LDcgQEAgZmluZF9pbnRlcnZhbHNfaW50ZXJzZWN0 aW9uX3NvcnRlZChzdHJ1Y3QgcmJfcm9vdCAqcm9vdCwgdW5zaWduZWQgbG9uZyBzdGFydCwKPiAg Cj4gIGludCB1c25pY191aW9tX2dldF9pbnRlcnZhbHNfZGlmZih1bnNpZ25lZCBsb25nIHN0YXJ0 LCB1bnNpZ25lZCBsb25nIGxhc3QsCj4gIAkJCQkJaW50IGZsYWdzLCBpbnQgZmxhZ19tYXNrLAo+ IC0JCQkJCXN0cnVjdCByYl9yb290ICpyb290LAo+ICsJCQkJCXN0cnVjdCByYl9yb290X2NhY2hl ZCAqcm9vdCwKPiAgCQkJCQlzdHJ1Y3QgbGlzdF9oZWFkICpkaWZmX3NldCkKPiAgewo+ICAJc3Ry dWN0IHVzbmljX3Vpb21faW50ZXJ2YWxfbm9kZSAqaW50ZXJ2YWwsICp0bXA7Cj4gQEAgLTE3NSw3 ICsxNzUsNyBAQCB2b2lkIHVzbmljX3Vpb21fcHV0X2ludGVydmFsX3NldChzdHJ1Y3QgbGlzdF9o ZWFkICppbnRlcnZhbHMpCj4gIAkJa2ZyZWUoaW50ZXJ2YWwpOwo+ICB9Cj4gIAo+IC1pbnQgdXNu aWNfdWlvbV9pbnNlcnRfaW50ZXJ2YWwoc3RydWN0IHJiX3Jvb3QgKnJvb3QsIHVuc2lnbmVkIGxv bmcgc3RhcnQsCj4gK2ludCB1c25pY191aW9tX2luc2VydF9pbnRlcnZhbChzdHJ1Y3QgcmJfcm9v dF9jYWNoZWQgKnJvb3QsIHVuc2lnbmVkIGxvbmcgc3RhcnQsCj4gIAkJCQl1bnNpZ25lZCBsb25n IGxhc3QsIGludCBmbGFncykKPiAgewo+ICAJc3RydWN0IHVzbmljX3Vpb21faW50ZXJ2YWxfbm9k ZSAqaW50ZXJ2YWwsICp0bXA7Cj4gQEAgLTI0Niw4ICsyNDYsOSBAQCBpbnQgdXNuaWNfdWlvbV9p bnNlcnRfaW50ZXJ2YWwoc3RydWN0IHJiX3Jvb3QgKnJvb3QsIHVuc2lnbmVkIGxvbmcgc3RhcnQs Cj4gIAlyZXR1cm4gZXJyOwo+ICB9Cj4gIAo+IC12b2lkIHVzbmljX3Vpb21fcmVtb3ZlX2ludGVy dmFsKHN0cnVjdCByYl9yb290ICpyb290LCB1bnNpZ25lZCBsb25nIHN0YXJ0LAo+IC0JCQkJdW5z aWduZWQgbG9uZyBsYXN0LCBzdHJ1Y3QgbGlzdF9oZWFkICpyZW1vdmVkKQo+ICt2b2lkIHVzbmlj X3Vpb21fcmVtb3ZlX2ludGVydmFsKHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9vdCwKPiArCQkJ CXVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGFzdCwKPiArCQkJCXN0cnVjdCBs aXN0X2hlYWQgKnJlbW92ZWQpCj4gIHsKPiAgCXN0cnVjdCB1c25pY191aW9tX2ludGVydmFsX25v ZGUgKmludGVydmFsOwo+ICAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3Vz bmljL3VzbmljX3Vpb21faW50ZXJ2YWxfdHJlZS5oIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3Vz bmljL3VzbmljX3Vpb21faW50ZXJ2YWxfdHJlZS5oCj4gaW5kZXggYzBiMGI4NzZhYjkwLi4xZDdm YzMyMjZiY2EgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L3VzbmljL3Vzbmlj X3Vpb21faW50ZXJ2YWxfdHJlZS5oCj4gKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L3Vzbmlj L3VzbmljX3Vpb21faW50ZXJ2YWxfdHJlZS5oCj4gQEAgLTQ4LDEyICs0OCwxMiBAQCBzdHJ1Y3Qg dXNuaWNfdWlvbV9pbnRlcnZhbF9ub2RlIHsKPiAgCj4gIGV4dGVybiB2b2lkCj4gIHVzbmljX3Vp b21faW50ZXJ2YWxfdHJlZV9pbnNlcnQoc3RydWN0IHVzbmljX3Vpb21faW50ZXJ2YWxfbm9kZSAq bm9kZSwKPiAtCQkJCQlzdHJ1Y3QgcmJfcm9vdCAqcm9vdCk7Cj4gKwkJCQkJc3RydWN0IHJiX3Jv b3RfY2FjaGVkICpyb290KTsKPiAgZXh0ZXJuIHZvaWQKPiAgdXNuaWNfdWlvbV9pbnRlcnZhbF90 cmVlX3JlbW92ZShzdHJ1Y3QgdXNuaWNfdWlvbV9pbnRlcnZhbF9ub2RlICpub2RlLAo+IC0JCQkJ CXN0cnVjdCByYl9yb290ICpyb290KTsKPiArCQkJCQlzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgKnJv b3QpOwo+ICBleHRlcm4gc3RydWN0IHVzbmljX3Vpb21faW50ZXJ2YWxfbm9kZSAqCj4gLXVzbmlj X3Vpb21faW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KHN0cnVjdCByYl9yb290ICpyb290LAo+ICt1 c25pY191aW9tX2ludGVydmFsX3RyZWVfaXRlcl9maXJzdChzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQg KnJvb3QsCj4gIAkJCQkJdW5zaWduZWQgbG9uZyBzdGFydCwKPiAgCQkJCQl1bnNpZ25lZCBsb25n IGxhc3QpOwo+ICBleHRlcm4gc3RydWN0IHVzbmljX3Vpb21faW50ZXJ2YWxfbm9kZSAqCj4gQEAg LTYzLDcgKzYzLDcgQEAgdXNuaWNfdWlvbV9pbnRlcnZhbF90cmVlX2l0ZXJfbmV4dChzdHJ1Y3Qg dXNuaWNfdWlvbV9pbnRlcnZhbF9ub2RlICpub2RlLAo+ICAgKiBJbnNlcnRzIHtzdGFydC4uLmxh c3R9IGludG8ge3Jvb3R9LiAgSWYgdGhlcmUgYXJlIG92ZXJsYXBzLAo+ICAgKiBub2RlcyB3aWxs IGJlIGJyb2tlbiB1cCBhbmQgbWVyZ2VkCj4gICAqLwo+IC1pbnQgdXNuaWNfdWlvbV9pbnNlcnRf aW50ZXJ2YWwoc3RydWN0IHJiX3Jvb3QgKnJvb3QsCj4gK2ludCB1c25pY191aW9tX2luc2VydF9p bnRlcnZhbChzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgKnJvb3QsCj4gIAkJCQl1bnNpZ25lZCBsb25n IHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxhc3QsCj4gIAkJCQlpbnQgZmxhZ3MpOwo+ICAvKgo+IEBA IC03MSw3ICs3MSw3IEBAIGludCB1c25pY191aW9tX2luc2VydF9pbnRlcnZhbChzdHJ1Y3QgcmJf cm9vdCAqcm9vdCwKPiAgICogJ3JlbW92ZWQuJyBUaGUgY2FsbGVyIGlzIHJlc3BvbnNpYmlsZSBm b3IgZnJlZWluZyBtZW1vcnkgb2Ygbm9kZXMgaW4KPiAgICogJ3JlbW92ZWQuJwo+ICAgKi8KPiAt dm9pZCB1c25pY191aW9tX3JlbW92ZV9pbnRlcnZhbChzdHJ1Y3QgcmJfcm9vdCAqcm9vdCwKPiAr dm9pZCB1c25pY191aW9tX3JlbW92ZV9pbnRlcnZhbChzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgKnJv b3QsCj4gIAkJCQl1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxhc3QsCj4gIAkJ CQlzdHJ1Y3QgbGlzdF9oZWFkICpyZW1vdmVkKTsKPiAgLyoKPiBAQCAtODEsNyArODEsNyBAQCB2 b2lkIHVzbmljX3Vpb21fcmVtb3ZlX2ludGVydmFsKHN0cnVjdCByYl9yb290ICpyb290LAo+ICBp bnQgdXNuaWNfdWlvbV9nZXRfaW50ZXJ2YWxzX2RpZmYodW5zaWduZWQgbG9uZyBzdGFydCwKPiAg CQkJCQl1bnNpZ25lZCBsb25nIGxhc3QsIGludCBmbGFncywKPiAgCQkJCQlpbnQgZmxhZ19tYXNr LAo+IC0JCQkJCXN0cnVjdCByYl9yb290ICpyb290LAo+ICsJCQkJCXN0cnVjdCByYl9yb290X2Nh Y2hlZCAqcm9vdCwKPiAgCQkJCQlzdHJ1Y3QgbGlzdF9oZWFkICpkaWZmX3NldCk7Cj4gIC8qIENh bGwgdGhpcyB0byBmcmVlIGRpZmZfc2V0IHJldHVybmVkIGJ5IHVzbmljX3Vpb21fZ2V0X2ludGVy dmFsc19kaWZmICovCj4gIHZvaWQgdXNuaWNfdWlvbV9wdXRfaW50ZXJ2YWxfc2V0KHN0cnVjdCBs aXN0X2hlYWQgKmludGVydmFscyk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmhvc3Qvdmhvc3Qu YyBiL2RyaXZlcnMvdmhvc3Qvdmhvc3QuYwo+IGluZGV4IGU0NjEzYTNjMzYyZC4uODhkYzIxNGRl MDY4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvdmhvc3Qvdmhvc3QuYwo+ICsrKyBiL2RyaXZlcnMv dmhvc3Qvdmhvc3QuYwo+IEBAIC0xMjcyLDcgKzEyNzIsNyBAQCBzdGF0aWMgc3RydWN0IHZob3N0 X3VtZW0gKnZob3N0X3VtZW1fYWxsb2Modm9pZCkKPiAgCWlmICghdW1lbSkKPiAgCQlyZXR1cm4g TlVMTDsKPiAgCj4gLQl1bWVtLT51bWVtX3RyZWUgPSBSQl9ST09UOwo+ICsJdW1lbS0+dW1lbV90 cmVlID0gUkJfUk9PVF9DQUNIRUQ7Cj4gIAl1bWVtLT5udW1lbSA9IDA7Cj4gIAlJTklUX0xJU1Rf SEVBRCgmdW1lbS0+dW1lbV9saXN0KTsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmhvc3Qv dmhvc3QuaCBiL2RyaXZlcnMvdmhvc3Qvdmhvc3QuaAo+IGluZGV4IGY3MjA5NTg2OGI5My4uYTAy NzhiYTZhOGI0IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvdmhvc3Qvdmhvc3QuaAo+ICsrKyBiL2Ry aXZlcnMvdmhvc3Qvdmhvc3QuaAo+IEBAIC03MSw3ICs3MSw3IEBAIHN0cnVjdCB2aG9zdF91bWVt X25vZGUgewo+ICB9Owo+ICAKPiAgc3RydWN0IHZob3N0X3VtZW0gewo+IC0Jc3RydWN0IHJiX3Jv b3QgdW1lbV90cmVlOwo+ICsJc3RydWN0IHJiX3Jvb3RfY2FjaGVkIHVtZW1fdHJlZTsKPiAgCXN0 cnVjdCBsaXN0X2hlYWQgdW1lbV9saXN0Owo+ICAJaW50IG51bWVtOwo+ICB9Owo+IGRpZmYgLS1n aXQgYS9mcy9odWdldGxiZnMvaW5vZGUuYyBiL2ZzL2h1Z2V0bGJmcy9pbm9kZS5jCj4gaW5kZXgg MjhkMjc1M2JlMDk0Li5lNjFiOTFlNmFkZjQgMTAwNjQ0Cj4gLS0tIGEvZnMvaHVnZXRsYmZzL2lu b2RlLmMKPiArKysgYi9mcy9odWdldGxiZnMvaW5vZGUuYwo+IEBAIC0zMzQsNyArMzM0LDcgQEAg c3RhdGljIHZvaWQgcmVtb3ZlX2h1Z2VfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPiAgfQo+ICAK PiAgc3RhdGljIHZvaWQKPiAtaHVnZXRsYl92bWRlbGV0ZV9saXN0KHN0cnVjdCByYl9yb290ICpy b290LCBwZ29mZl90IHN0YXJ0LCBwZ29mZl90IGVuZCkKPiAraHVnZXRsYl92bWRlbGV0ZV9saXN0 KHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9vdCwgcGdvZmZfdCBzdGFydCwgcGdvZmZfdCBlbmQp Cj4gIHsKPiAgCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hOwo+ICAKPiBAQCAtNTE0LDcgKzUx NCw3IEBAIHN0YXRpYyBpbnQgaHVnZXRsYl92bXRydW5jYXRlKHN0cnVjdCBpbm9kZSAqaW5vZGUs IGxvZmZfdCBvZmZzZXQpCj4gIAo+ICAJaV9zaXplX3dyaXRlKGlub2RlLCBvZmZzZXQpOwo+ICAJ aV9tbWFwX2xvY2tfd3JpdGUobWFwcGluZyk7Cj4gLQlpZiAoIVJCX0VNUFRZX1JPT1QoJm1hcHBp bmctPmlfbW1hcCkpCj4gKwlpZiAoIVJCX0VNUFRZX1JPT1QoJm1hcHBpbmctPmlfbW1hcC5yYl9y b290KSkKPiAgCQlodWdldGxiX3ZtZGVsZXRlX2xpc3QoJm1hcHBpbmctPmlfbW1hcCwgcGdvZmYs IDApOwo+ICAJaV9tbWFwX3VubG9ja193cml0ZShtYXBwaW5nKTsKPiAgCXJlbW92ZV9pbm9kZV9o dWdlcGFnZXMoaW5vZGUsIG9mZnNldCwgTExPTkdfTUFYKTsKPiBAQCAtNTM5LDcgKzUzOSw3IEBA IHN0YXRpYyBsb25nIGh1Z2V0bGJmc19wdW5jaF9ob2xlKHN0cnVjdCBpbm9kZSAqaW5vZGUsIGxv ZmZfdCBvZmZzZXQsIGxvZmZfdCBsZW4pCj4gIAo+ICAJCWlub2RlX2xvY2soaW5vZGUpOwo+ICAJ CWlfbW1hcF9sb2NrX3dyaXRlKG1hcHBpbmcpOwo+IC0JCWlmICghUkJfRU1QVFlfUk9PVCgmbWFw cGluZy0+aV9tbWFwKSkKPiArCQlpZiAoIVJCX0VNUFRZX1JPT1QoJm1hcHBpbmctPmlfbW1hcC5y Yl9yb290KSkKPiAgCQkJaHVnZXRsYl92bWRlbGV0ZV9saXN0KCZtYXBwaW5nLT5pX21tYXAsCj4g IAkJCQkJCWhvbGVfc3RhcnQgPj4gUEFHRV9TSElGVCwKPiAgCQkJCQkJaG9sZV9lbmQgID4+IFBB R0VfU0hJRlQpOwo+IGRpZmYgLS1naXQgYS9mcy9pbm9kZS5jIGIvZnMvaW5vZGUuYwo+IGluZGV4 IDUwMzcwNTk5ZTM3MS4uNWRkYjgwOGVhOTM0IDEwMDY0NAo+IC0tLSBhL2ZzL2lub2RlLmMKPiAr KysgYi9mcy9pbm9kZS5jCj4gQEAgLTM1Myw3ICszNTMsNyBAQCB2b2lkIGFkZHJlc3Nfc3BhY2Vf aW5pdF9vbmNlKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nKQo+ICAJaW5pdF9yd3NlbSgm bWFwcGluZy0+aV9tbWFwX3J3c2VtKTsKPiAgCUlOSVRfTElTVF9IRUFEKCZtYXBwaW5nLT5wcml2 YXRlX2xpc3QpOwo+ICAJc3Bpbl9sb2NrX2luaXQoJm1hcHBpbmctPnByaXZhdGVfbG9jayk7Cj4g LQltYXBwaW5nLT5pX21tYXAgPSBSQl9ST09UOwo+ICsJbWFwcGluZy0+aV9tbWFwID0gUkJfUk9P VF9DQUNIRUQ7Cj4gIH0KPiAgRVhQT1JUX1NZTUJPTChhZGRyZXNzX3NwYWNlX2luaXRfb25jZSk7 Cj4gIAo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fbW0uaCBiL2luY2x1ZGUvZHJtL2Ry bV9tbS5oCj4gaW5kZXggNDliMjkyZTk4ZmVjLi44ZDEwZmM5NzgwMWMgMTAwNjQ0Cj4gLS0tIGEv aW5jbHVkZS9kcm0vZHJtX21tLmgKPiArKysgYi9pbmNsdWRlL2RybS9kcm1fbW0uaAo+IEBAIC0x NzIsNyArMTcyLDcgQEAgc3RydWN0IGRybV9tbSB7Cj4gIAkgKiBhY2NvcmRpbmcgdG8gdGhlIChp bmNyZWFzaW5nKSBzdGFydCBhZGRyZXNzIG9mIHRoZSBtZW1vcnkgbm9kZS4gKi8KPiAgCXN0cnVj dCBkcm1fbW1fbm9kZSBoZWFkX25vZGU7Cj4gIAkvKiBLZWVwIGFuIGludGVydmFsX3RyZWUgZm9y IGZhc3QgbG9va3VwIG9mIGRybV9tbV9ub2RlcyBieSBhZGRyZXNzLiAqLwo+IC0Jc3RydWN0IHJi X3Jvb3QgaW50ZXJ2YWxfdHJlZTsKPiArCXN0cnVjdCByYl9yb290X2NhY2hlZCBpbnRlcnZhbF90 cmVlOwo+ICAJc3RydWN0IHJiX3Jvb3QgaG9sZXNfc2l6ZTsKPiAgCXN0cnVjdCByYl9yb290IGhv bGVzX2FkZHI7Cj4gIAo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2ZzLmggYi9pbmNsdWRl L2xpbnV4L2ZzLmgKPiBpbmRleCBlZDg3OTgyNTU4NzIuLmQxZDUyMWM1MDI1YiAxMDA2NDQKPiAt LS0gYS9pbmNsdWRlL2xpbnV4L2ZzLmgKPiArKysgYi9pbmNsdWRlL2xpbnV4L2ZzLmgKPiBAQCAt MzkyLDcgKzM5Miw3IEBAIHN0cnVjdCBhZGRyZXNzX3NwYWNlIHsKPiAgCXN0cnVjdCByYWRpeF90 cmVlX3Jvb3QJcGFnZV90cmVlOwkvKiByYWRpeCB0cmVlIG9mIGFsbCBwYWdlcyAqLwo+ICAJc3Bp bmxvY2tfdAkJdHJlZV9sb2NrOwkvKiBhbmQgbG9jayBwcm90ZWN0aW5nIGl0ICovCj4gIAlhdG9t aWNfdAkJaV9tbWFwX3dyaXRhYmxlOy8qIGNvdW50IFZNX1NIQVJFRCBtYXBwaW5ncyAqLwo+IC0J c3RydWN0IHJiX3Jvb3QJCWlfbW1hcDsJCS8qIHRyZWUgb2YgcHJpdmF0ZSBhbmQgc2hhcmVkIG1h cHBpbmdzICovCj4gKwlzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQJaV9tbWFwOwkJLyogdHJlZSBvZiBw cml2YXRlIGFuZCBzaGFyZWQgbWFwcGluZ3MgKi8KPiAgCXN0cnVjdCByd19zZW1hcGhvcmUJaV9t bWFwX3J3c2VtOwkvKiBwcm90ZWN0IHRyZWUsIGNvdW50LCBsaXN0ICovCj4gIAkvKiBQcm90ZWN0 ZWQgYnkgdHJlZV9sb2NrIHRvZ2V0aGVyIHdpdGggdGhlIHJhZGl4IHRyZWUgKi8KPiAgCXVuc2ln bmVkIGxvbmcJCW5ycGFnZXM7CS8qIG51bWJlciBvZiB0b3RhbCBwYWdlcyAqLwo+IEBAIC00ODYs NyArNDg2LDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGlfbW1hcF91bmxvY2tfcmVhZChzdHJ1Y3Qg YWRkcmVzc19zcGFjZSAqbWFwcGluZykKPiAgICovCj4gIHN0YXRpYyBpbmxpbmUgaW50IG1hcHBp bmdfbWFwcGVkKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nKQo+ICB7Cj4gLQlyZXR1cm4J IVJCX0VNUFRZX1JPT1QoJm1hcHBpbmctPmlfbW1hcCk7Cj4gKwlyZXR1cm4JIVJCX0VNUFRZX1JP T1QoJm1hcHBpbmctPmlfbW1hcC5yYl9yb290KTsKPiAgfQo+ICAKPiAgLyoKPiBkaWZmIC0tZ2l0 IGEvaW5jbHVkZS9saW51eC9pbnRlcnZhbF90cmVlLmggYi9pbmNsdWRlL2xpbnV4L2ludGVydmFs X3RyZWUuaAo+IGluZGV4IDcyNDU1NmFhM2M5NS4uMjAyZWUxMjgzZjRiIDEwMDY0NAo+IC0tLSBh L2luY2x1ZGUvbGludXgvaW50ZXJ2YWxfdHJlZS5oCj4gKysrIGIvaW5jbHVkZS9saW51eC9pbnRl cnZhbF90cmVlLmgKPiBAQCAtMTEsMTMgKzExLDE1IEBAIHN0cnVjdCBpbnRlcnZhbF90cmVlX25v ZGUgewo+ICB9Owo+ICAKPiAgZXh0ZXJuIHZvaWQKPiAtaW50ZXJ2YWxfdHJlZV9pbnNlcnQoc3Ry dWN0IGludGVydmFsX3RyZWVfbm9kZSAqbm9kZSwgc3RydWN0IHJiX3Jvb3QgKnJvb3QpOwo+ICtp bnRlcnZhbF90cmVlX2luc2VydChzdHJ1Y3QgaW50ZXJ2YWxfdHJlZV9ub2RlICpub2RlLAo+ICsJ CSAgICAgc3RydWN0IHJiX3Jvb3RfY2FjaGVkICpyb290KTsKPiAgCj4gIGV4dGVybiB2b2lkCj4g LWludGVydmFsX3RyZWVfcmVtb3ZlKHN0cnVjdCBpbnRlcnZhbF90cmVlX25vZGUgKm5vZGUsIHN0 cnVjdCByYl9yb290ICpyb290KTsKPiAraW50ZXJ2YWxfdHJlZV9yZW1vdmUoc3RydWN0IGludGVy dmFsX3RyZWVfbm9kZSAqbm9kZSwKPiArCQkgICAgIHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9v dCk7Cj4gIAo+ICBleHRlcm4gc3RydWN0IGludGVydmFsX3RyZWVfbm9kZSAqCj4gLWludGVydmFs X3RyZWVfaXRlcl9maXJzdChzdHJ1Y3QgcmJfcm9vdCAqcm9vdCwKPiAraW50ZXJ2YWxfdHJlZV9p dGVyX2ZpcnN0KHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9vdCwKPiAgCQkJIHVuc2lnbmVkIGxv bmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGFzdCk7Cj4gIAo+ICBleHRlcm4gc3RydWN0IGludGVy dmFsX3RyZWVfbm9kZSAqCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaW50ZXJ2YWxfdHJl ZV9nZW5lcmljLmggYi9pbmNsdWRlL2xpbnV4L2ludGVydmFsX3RyZWVfZ2VuZXJpYy5oCj4gaW5k ZXggNTgzNzBlMTg2MmFkLi5mMDk2NDIzYzhjYmQgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51 eC9pbnRlcnZhbF90cmVlX2dlbmVyaWMuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvaW50ZXJ2YWxf dHJlZV9nZW5lcmljLmgKPiBAQCAtNjUsMTEgKzY1LDEzIEBAIFJCX0RFQ0xBUkVfQ0FMTEJBQ0tT KHN0YXRpYywgSVRQUkVGSVggIyMgX2F1Z21lbnQsIElUU1RSVUNULCBJVFJCLAkgICAgICBcCj4g IAkJCQkJCQkJCSAgICAgIFwKPiAgLyogSW5zZXJ0IC8gcmVtb3ZlIGludGVydmFsIG5vZGVzIGZy b20gdGhlIHRyZWUgKi8JCQkgICAgICBcCj4gIAkJCQkJCQkJCSAgICAgIFwKPiAtSVRTVEFUSUMg dm9pZCBJVFBSRUZJWCAjIyBfaW5zZXJ0KElUU1RSVUNUICpub2RlLCBzdHJ1Y3QgcmJfcm9vdCAq cm9vdCkJICAgICAgXAo+ICtJVFNUQVRJQyB2b2lkIElUUFJFRklYICMjIF9pbnNlcnQoSVRTVFJV Q1QgKm5vZGUsCQkJICAgICAgXAo+ICsJCQkJICBzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgKnJvb3Qp CSAJICAgICAgXAo+ICB7CQkJCQkJCQkJICAgICAgXAo+IC0Jc3RydWN0IHJiX25vZGUgKipsaW5r ID0gJnJvb3QtPnJiX25vZGUsICpyYl9wYXJlbnQgPSBOVUxMOwkgICAgICBcCj4gKwlzdHJ1Y3Qg cmJfbm9kZSAqKmxpbmsgPSAmcm9vdC0+cmJfcm9vdC5yYl9ub2RlLCAqcmJfcGFyZW50ID0gTlVM TDsgICAgXAo+ICAJSVRUWVBFIHN0YXJ0ID0gSVRTVEFSVChub2RlKSwgbGFzdCA9IElUTEFTVChu b2RlKTsJCSAgICAgIFwKPiAgCUlUU1RSVUNUICpwYXJlbnQ7CQkJCQkJICAgICAgXAo+ICsJYm9v bCBsZWZ0bW9zdCA9IHRydWU7CQkJCQkJICAgICAgXAo+ICAJCQkJCQkJCQkgICAgICBcCj4gIAl3 aGlsZSAoKmxpbmspIHsJCQkJCQkJICAgICAgXAo+ICAJCXJiX3BhcmVudCA9ICpsaW5rOwkJCQkJ ICAgICAgXAo+IEBAIC03OCwxOCArODAsMjIgQEAgSVRTVEFUSUMgdm9pZCBJVFBSRUZJWCAjIyBf aW5zZXJ0KElUU1RSVUNUICpub2RlLCBzdHJ1Y3QgcmJfcm9vdCAqcm9vdCkJICAgICAgXAo+ICAJ CQlwYXJlbnQtPklUU1VCVFJFRSA9IGxhc3Q7CQkJICAgICAgXAo+ICAJCWlmIChzdGFydCA8IElU U1RBUlQocGFyZW50KSkJCQkJICAgICAgXAo+ICAJCQlsaW5rID0gJnBhcmVudC0+SVRSQi5yYl9s ZWZ0OwkJCSAgICAgIFwKPiAtCQllbHNlCQkJCQkJCSAgICAgIFwKPiArCQllbHNlIHsJCQkJCQkJ ICAgICAgXAo+ICAJCQlsaW5rID0gJnBhcmVudC0+SVRSQi5yYl9yaWdodDsJCQkgICAgICBcCj4g KwkJCWxlZnRtb3N0ID0gZmFsc2U7CQkJCSAgICAgIFwKPiArCQl9CQkJCQkJCSAgICAgIFwKPiAg CX0JCQkJCQkJCSAgICAgIFwKPiAgCQkJCQkJCQkJICAgICAgXAo+ICAJbm9kZS0+SVRTVUJUUkVF ID0gbGFzdDsJCQkJCQkgICAgICBcCj4gIAlyYl9saW5rX25vZGUoJm5vZGUtPklUUkIsIHJiX3Bh cmVudCwgbGluayk7CQkJICAgICAgXAo+IC0JcmJfaW5zZXJ0X2F1Z21lbnRlZCgmbm9kZS0+SVRS Qiwgcm9vdCwgJklUUFJFRklYICMjIF9hdWdtZW50KTsJICAgICAgXAo+ICsJcmJfaW5zZXJ0X2F1 Z21lbnRlZF9jYWNoZWQoJm5vZGUtPklUUkIsIHJvb3QsCQkJICAgICAgXAo+ICsJCQkJICAgbGVm dG1vc3QsICZJVFBSRUZJWCAjIyBfYXVnbWVudCk7CSAgICAgIFwKPiAgfQkJCQkJCQkJCSAgICAg IFwKPiAgCQkJCQkJCQkJICAgICAgXAo+IC1JVFNUQVRJQyB2b2lkIElUUFJFRklYICMjIF9yZW1v dmUoSVRTVFJVQ1QgKm5vZGUsIHN0cnVjdCByYl9yb290ICpyb290KQkgICAgICBcCj4gK0lUU1RB VElDIHZvaWQgSVRQUkVGSVggIyMgX3JlbW92ZShJVFNUUlVDVCAqbm9kZSwJCQkgICAgICBcCj4g KwkJCQkgIHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9vdCkJCSAgICAgIFwKPiAgewkJCQkJCQkJ CSAgICAgIFwKPiAtCXJiX2VyYXNlX2F1Z21lbnRlZCgmbm9kZS0+SVRSQiwgcm9vdCwgJklUUFJF RklYICMjIF9hdWdtZW50KTsJICAgICAgXAo+ICsJcmJfZXJhc2VfYXVnbWVudGVkX2NhY2hlZCgm bm9kZS0+SVRSQiwgcm9vdCwgJklUUFJFRklYICMjIF9hdWdtZW50KTsgIFwKPiAgfQkJCQkJCQkJ CSAgICAgIFwKPiAgCQkJCQkJCQkJICAgICAgXAo+ICAvKgkJCQkJCQkJCSAgICAgIFwKPiBAQCAt MTQwLDE1ICsxNDYsMzUgQEAgSVRQUkVGSVggIyMgX3N1YnRyZWVfc2VhcmNoKElUU1RSVUNUICpu b2RlLCBJVFRZUEUgc3RhcnQsIElUVFlQRSBsYXN0KQkgICAgICBcCj4gIH0JCQkJCQkJCQkgICAg ICBcCj4gIAkJCQkJCQkJCSAgICAgIFwKPiAgSVRTVEFUSUMgSVRTVFJVQ1QgKgkJCQkJCQkgICAg ICBcCj4gLUlUUFJFRklYICMjIF9pdGVyX2ZpcnN0KHN0cnVjdCByYl9yb290ICpyb290LCBJVFRZ UEUgc3RhcnQsIElUVFlQRSBsYXN0KSAgICAgIFwKPiArSVRQUkVGSVggIyMgX2l0ZXJfZmlyc3Qo c3RydWN0IHJiX3Jvb3RfY2FjaGVkICpyb290LAkJCSAgICAgIFwKPiArCQkJSVRUWVBFIHN0YXJ0 LCBJVFRZUEUgbGFzdCkJCQkgICAgICBcCj4gIHsJCQkJCQkJCQkgICAgICBcCj4gLQlJVFNUUlVD VCAqbm9kZTsJCQkJCQkJICAgICAgXAo+ICsJSVRTVFJVQ1QgKm5vZGUsICpsZWZ0bW9zdDsJCQkJ CSAgICAgIFwKPiAgCQkJCQkJCQkJICAgICAgXAo+IC0JaWYgKCFyb290LT5yYl9ub2RlKQkJCQkJ CSAgICAgIFwKPiArCWlmICghcm9vdC0+cmJfcm9vdC5yYl9ub2RlKQkJCQkJICAgICAgXAo+ICAJ CXJldHVybiBOVUxMOwkJCQkJCSAgICAgIFwKPiAtCW5vZGUgPSByYl9lbnRyeShyb290LT5yYl9u b2RlLCBJVFNUUlVDVCwgSVRSQik7CQkJICAgICAgXAo+ICsJCQkJCQkJCQkgICAgICBcCj4gKwkv KgkJCQkJCQkJICAgICAgXAo+ICsJICogRmFzdHBhdGggcmFuZ2UgaW50ZXJzZWN0aW9uL292ZXJs YXAgYmV0d2VlbiBBOiBbYTAsIGExXSBhbmQJICAgICAgXAo+ICsJICogQjogW2IwLCBiMV0gaXMg Z2l2ZW4gYnk6CQkJCQkgICAgICBcCj4gKwkgKgkJCQkJCQkJICAgICAgXAo+ICsJICogICAgICAg ICBhMCA8PSBiMSAmJiBiMCA8PSBhMQkJCQkJICAgICAgXAo+ICsJICoJCQkJCQkJCSAgICAgIFwK PiArCSAqICAuLi4gd2hlcmUgQSBob2xkcyB0aGUgbG9jayByYW5nZSBhbmQgQiBob2xkcyB0aGUg c21hbGxlc3QJICAgICAgXAo+ICsJICogJ3N0YXJ0JyBhbmQgbGFyZ2VzdCAnbGFzdCcgaW4gdGhl IHRyZWUuIEZvciB0aGUgbGF0ZXIsIHdlCSAgICAgIFwKPiArCSAqIHJlbHkgb24gdGhlIHJvb3Qg bm9kZSwgd2hpY2ggYnkgYXVnbWVudGVkIGludGVydmFsIHRyZWUJICAgICAgXAo+ICsJICogcHJv cGVydHksIGhvbGRzIHRoZSBsYXJnZXN0IHZhbHVlIGluIGl0cyBsYXN0LWluLXN1YnRyZWUuCSAg ICAgIFwKPiArCSAqIFRoaXMgYWxsb3dzIG1pdGlnYXRpbmcgc29tZSBvZiB0aGUgdHJlZSB3YWxr IG92ZXJoZWFkIGZvcgkgICAgICBcCj4gKwkgKiBmb3Igbm9uLWludGVyc2VjdGluZyByYW5nZXMs IG1haW50YWluZWQgYW5kIGNvbnN1bHRlZCBpbiBPKDEpLiAgICAgXAo+ICsJICovCQkJCQkJCQkg ICAgICBcCj4gKwlub2RlID0gcmJfZW50cnkocm9vdC0+cmJfcm9vdC5yYl9ub2RlLCBJVFNUUlVD VCwgSVRSQik7CQkgICAgICBcCj4gIAlpZiAobm9kZS0+SVRTVUJUUkVFIDwgc3RhcnQpCQkJCQkg ICAgICBcCj4gIAkJcmV0dXJuIE5VTEw7CQkJCQkJICAgICAgXAo+ICsJCQkJCQkJCQkgICAgICBc Cj4gKwlsZWZ0bW9zdCA9IHJiX2VudHJ5KHJvb3QtPnJiX2xlZnRtb3N0LCBJVFNUUlVDVCwgSVRS Qik7CQkgICAgICBcCj4gKwlpZiAoSVRTVEFSVChsZWZ0bW9zdCkgPiBsYXN0KQkJCQkJICAgICAg XAo+ICsJCXJldHVybiBOVUxMOwkJCQkJCSAgICAgIFwKPiArCQkJCQkJCQkJICAgICAgXAo+ICAJ cmV0dXJuIElUUFJFRklYICMjIF9zdWJ0cmVlX3NlYXJjaChub2RlLCBzdGFydCwgbGFzdCk7CQkg ICAgICBcCj4gIH0JCQkJCQkJCQkgICAgICBcCj4gIAkJCQkJCQkJCSAgICAgIFwKPiBkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9tbS5oIGIvaW5jbHVkZS9saW51eC9tbS5oCj4gaW5kZXggNDZi OWFjNWU4NTY5Li4zYTI2NTJlZmJiZmIgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC9tbS5o Cj4gKysrIGIvaW5jbHVkZS9saW51eC9tbS5oCj4gQEAgLTE5OTIsMTMgKzE5OTIsMTMgQEAgZXh0 ZXJuIGludCBub21tdV9zaHJpbmtfaW5vZGVfbWFwcGluZ3Moc3RydWN0IGlub2RlICosIHNpemVf dCwgc2l6ZV90KTsKPiAgCj4gIC8qIGludGVydmFsX3RyZWUuYyAqLwo+ICB2b2lkIHZtYV9pbnRl cnZhbF90cmVlX2luc2VydChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKm5vZGUsCj4gLQkJCSAgICAg IHN0cnVjdCByYl9yb290ICpyb290KTsKPiArCQkJICAgICAgc3RydWN0IHJiX3Jvb3RfY2FjaGVk ICpyb290KTsKPiAgdm9pZCB2bWFfaW50ZXJ2YWxfdHJlZV9pbnNlcnRfYWZ0ZXIoc3RydWN0IHZt X2FyZWFfc3RydWN0ICpub2RlLAo+ICAJCQkJICAgIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqcHJl diwKPiAtCQkJCSAgICBzdHJ1Y3QgcmJfcm9vdCAqcm9vdCk7Cj4gKwkJCQkgICAgc3RydWN0IHJi X3Jvb3RfY2FjaGVkICpyb290KTsKPiAgdm9pZCB2bWFfaW50ZXJ2YWxfdHJlZV9yZW1vdmUoc3Ry dWN0IHZtX2FyZWFfc3RydWN0ICpub2RlLAo+IC0JCQkgICAgICBzdHJ1Y3QgcmJfcm9vdCAqcm9v dCk7Cj4gLXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hX2ludGVydmFsX3RyZWVfaXRlcl9maXJz dChzdHJ1Y3QgcmJfcm9vdCAqcm9vdCwKPiArCQkJICAgICAgc3RydWN0IHJiX3Jvb3RfY2FjaGVk ICpyb290KTsKPiArc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWFfaW50ZXJ2YWxfdHJlZV9pdGVy X2ZpcnN0KHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9vdCwKPiAgCQkJCXVuc2lnbmVkIGxvbmcg c3RhcnQsIHVuc2lnbmVkIGxvbmcgbGFzdCk7Cj4gIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1h X2ludGVydmFsX3RyZWVfaXRlcl9uZXh0KHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqbm9kZSwKPiAg CQkJCXVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGFzdCk7Cj4gQEAgLTIwMDgs MTEgKzIwMDgsMTIgQEAgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWFfaW50ZXJ2YWxfdHJlZV9p dGVyX25leHQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICpub2RlLAo+ICAJICAgICB2bWE7IHZtYSA9 IHZtYV9pbnRlcnZhbF90cmVlX2l0ZXJfbmV4dCh2bWEsIHN0YXJ0LCBsYXN0KSkKPiAgCj4gIHZv aWQgYW5vbl92bWFfaW50ZXJ2YWxfdHJlZV9pbnNlcnQoc3RydWN0IGFub25fdm1hX2NoYWluICpu b2RlLAo+IC0JCQkJICAgc3RydWN0IHJiX3Jvb3QgKnJvb3QpOwo+ICsJCQkJICAgc3RydWN0IHJi X3Jvb3RfY2FjaGVkICpyb290KTsKPiAgdm9pZCBhbm9uX3ZtYV9pbnRlcnZhbF90cmVlX3JlbW92 ZShzdHJ1Y3QgYW5vbl92bWFfY2hhaW4gKm5vZGUsCj4gLQkJCQkgICBzdHJ1Y3QgcmJfcm9vdCAq cm9vdCk7Cj4gLXN0cnVjdCBhbm9uX3ZtYV9jaGFpbiAqYW5vbl92bWFfaW50ZXJ2YWxfdHJlZV9p dGVyX2ZpcnN0KAo+IC0Jc3RydWN0IHJiX3Jvb3QgKnJvb3QsIHVuc2lnbmVkIGxvbmcgc3RhcnQs IHVuc2lnbmVkIGxvbmcgbGFzdCk7Cj4gKwkJCQkgICBzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgKnJv b3QpOwo+ICtzdHJ1Y3QgYW5vbl92bWFfY2hhaW4gKgo+ICthbm9uX3ZtYV9pbnRlcnZhbF90cmVl X2l0ZXJfZmlyc3Qoc3RydWN0IHJiX3Jvb3RfY2FjaGVkICpyb290LAo+ICsJCQkJICB1bnNpZ25l ZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxhc3QpOwo+ICBzdHJ1Y3QgYW5vbl92bWFfY2hh aW4gKmFub25fdm1hX2ludGVydmFsX3RyZWVfaXRlcl9uZXh0KAo+ICAJc3RydWN0IGFub25fdm1h X2NoYWluICpub2RlLCB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxhc3QpOwo+ ICAjaWZkZWYgQ09ORklHX0RFQlVHX1ZNX1JCCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgv cm1hcC5oIGIvaW5jbHVkZS9saW51eC9ybWFwLmgKPiBpbmRleCA0M2VmMmMzMGNiMGYuLjIyYzI5 OGM2Y2MyNiAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L3JtYXAuaAo+ICsrKyBiL2luY2x1 ZGUvbGludXgvcm1hcC5oCj4gQEAgLTU1LDcgKzU1LDkgQEAgc3RydWN0IGFub25fdm1hIHsKPiAg CSAqIGlzIHNlcmlhbGl6ZWQgYnkgYSBzeXN0ZW0gd2lkZSBsb2NrIG9ubHkgdmlzaWJsZSB0bwo+ ICAJICogbW1fdGFrZV9hbGxfbG9ja3MoKSAobW1fYWxsX2xvY2tzX211dGV4KS4KPiAgCSAqLwo+ IC0Jc3RydWN0IHJiX3Jvb3QgcmJfcm9vdDsJLyogSW50ZXJ2YWwgdHJlZSBvZiBwcml2YXRlICJy ZWxhdGVkIiB2bWFzICovCj4gKwo+ICsJLyogSW50ZXJ2YWwgdHJlZSBvZiBwcml2YXRlICJyZWxh dGVkIiB2bWFzICovCj4gKwlzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgcmJfcm9vdDsKPiAgfTsKPiAg Cj4gIC8qCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvcmRtYS9pYl91bWVtX29kcC5oIGIvaW5jbHVk ZS9yZG1hL2liX3VtZW1fb2RwLmgKPiBpbmRleCBmYjY3NTU0YWFiZDYuLjVlYjdmNWJjODI0OCAx MDA2NDQKPiAtLS0gYS9pbmNsdWRlL3JkbWEvaWJfdW1lbV9vZHAuaAo+ICsrKyBiL2luY2x1ZGUv cmRtYS9pYl91bWVtX29kcC5oCj4gQEAgLTExMSwyMiArMTExLDI1IEBAIGludCBpYl91bWVtX29k cF9tYXBfZG1hX3BhZ2VzKHN0cnVjdCBpYl91bWVtICp1bWVtLCB1NjQgc3RhcnRfb2Zmc2V0LCB1 NjQgYmNudCwKPiAgdm9pZCBpYl91bWVtX29kcF91bm1hcF9kbWFfcGFnZXMoc3RydWN0IGliX3Vt ZW0gKnVtZW0sIHU2NCBzdGFydF9vZmZzZXQsCj4gIAkJCQkgdTY0IGJvdW5kKTsKPiAgCj4gLXZv aWQgcmJ0X2liX3VtZW1faW5zZXJ0KHN0cnVjdCB1bWVtX29kcF9ub2RlICpub2RlLCBzdHJ1Y3Qg cmJfcm9vdCAqcm9vdCk7Cj4gLXZvaWQgcmJ0X2liX3VtZW1fcmVtb3ZlKHN0cnVjdCB1bWVtX29k cF9ub2RlICpub2RlLCBzdHJ1Y3QgcmJfcm9vdCAqcm9vdCk7Cj4gK3ZvaWQgcmJ0X2liX3VtZW1f aW5zZXJ0KHN0cnVjdCB1bWVtX29kcF9ub2RlICpub2RlLAo+ICsJCQlzdHJ1Y3QgcmJfcm9vdF9j YWNoZWQgKnJvb3QpOwo+ICt2b2lkIHJidF9pYl91bWVtX3JlbW92ZShzdHJ1Y3QgdW1lbV9vZHBf bm9kZSAqbm9kZSwKPiArCQkJc3RydWN0IHJiX3Jvb3RfY2FjaGVkICpyb290KTsKPiAgdHlwZWRl ZiBpbnQgKCp1bWVtX2NhbGxfYmFjaykoc3RydWN0IGliX3VtZW0gKml0ZW0sIHU2NCBzdGFydCwg dTY0IGVuZCwKPiAgCQkJICAgICAgdm9pZCAqY29va2llKTsKPiAgLyoKPiAgICogQ2FsbCB0aGUg Y2FsbGJhY2sgb24gZWFjaCBpYl91bWVtIGluIHRoZSByYW5nZS4gUmV0dXJucyB0aGUgbG9naWNh bCBvciBvZgo+ICAgKiB0aGUgcmV0dXJuIHZhbHVlcyBvZiB0aGUgZnVuY3Rpb25zIGNhbGxlZC4K PiAgICovCj4gLWludCByYnRfaWJfdW1lbV9mb3JfZWFjaF9pbl9yYW5nZShzdHJ1Y3QgcmJfcm9v dCAqcm9vdCwgdTY0IHN0YXJ0LCB1NjQgZW5kLAo+ICtpbnQgcmJ0X2liX3VtZW1fZm9yX2VhY2hf aW5fcmFuZ2Uoc3RydWN0IHJiX3Jvb3RfY2FjaGVkICpyb290LAo+ICsJCQkJICB1NjQgc3RhcnQs IHU2NCBlbmQsCj4gIAkJCQkgIHVtZW1fY2FsbF9iYWNrIGNiLCB2b2lkICpjb29raWUpOwo+ICAK PiAgLyoKPiAgICogRmluZCBmaXJzdCByZWdpb24gaW50ZXJzZWN0aW5nIHdpdGggYWRkcmVzcyBy YW5nZS4KPiAgICogUmV0dXJuIE5VTEwgaWYgbm90IGZvdW5kCj4gICAqLwo+IC1zdHJ1Y3QgaWJf dW1lbV9vZHAgKnJidF9pYl91bWVtX2xvb2t1cChzdHJ1Y3QgcmJfcm9vdCAqcm9vdCwKPiArc3Ry dWN0IGliX3VtZW1fb2RwICpyYnRfaWJfdW1lbV9sb29rdXAoc3RydWN0IHJiX3Jvb3RfY2FjaGVk ICpyb290LAo+ICAJCQkJICAgICAgIHU2NCBhZGRyLCB1NjQgbGVuZ3RoKTsKPiAgCj4gIHN0YXRp YyBpbmxpbmUgaW50IGliX3VtZW1fbW11X25vdGlmaWVyX3JldHJ5KHN0cnVjdCBpYl91bWVtICpp dGVtLAo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL3JkbWEvaWJfdmVyYnMuaCBiL2luY2x1ZGUvcmRt YS9pYl92ZXJicy5oCj4gaW5kZXggNTkzYWQyNjQwZDJmLi44MTY2NTQ4MGE0YWIgMTAwNjQ0Cj4g LS0tIGEvaW5jbHVkZS9yZG1hL2liX3ZlcmJzLmgKPiArKysgYi9pbmNsdWRlL3JkbWEvaWJfdmVy YnMuaAo+IEBAIC0xNDIwLDcgKzE0MjAsNyBAQCBzdHJ1Y3QgaWJfdWNvbnRleHQgewo+ICAKPiAg CXN0cnVjdCBwaWQgICAgICAgICAgICAgKnRnaWQ7Cj4gICNpZmRlZiBDT05GSUdfSU5GSU5JQkFO RF9PTl9ERU1BTkRfUEFHSU5HCj4gLQlzdHJ1Y3QgcmJfcm9vdCAgICAgIHVtZW1fdHJlZTsKPiAr CXN0cnVjdCByYl9yb290X2NhY2hlZCAgIHVtZW1fdHJlZTsKPiAgCS8qCj4gIAkgKiBQcm90ZWN0 cyAudW1lbV9yYnJvb3QgYW5kIHRyZWUsIGFzIHdlbGwgYXMgb2RwX21yc19jb3VudCBhbmQKPiAg CSAqIG1tdSBub3RpZmllcnMgcmVnaXN0cmF0aW9uLgo+IGRpZmYgLS1naXQgYS9saWIvaW50ZXJ2 YWxfdHJlZV90ZXN0LmMgYi9saWIvaW50ZXJ2YWxfdHJlZV90ZXN0LmMKPiBpbmRleCBkZjQ5NWZl ODE0MjEuLjBlMzQzZmQyOTU3MCAxMDA2NDQKPiAtLS0gYS9saWIvaW50ZXJ2YWxfdHJlZV90ZXN0 LmMKPiArKysgYi9saWIvaW50ZXJ2YWxfdHJlZV90ZXN0LmMKPiBAQCAtMTksMTQgKzE5LDE0IEBA IF9fcGFyYW0oYm9vbCwgc2VhcmNoX2FsbCwgZmFsc2UsICJTZWFyY2hlcyB3aWxsIGl0ZXJhdGUg YWxsIG5vZGVzIGluIHRoZSB0cmVlIik7Cj4gIAo+ICBfX3BhcmFtKHVpbnQsIG1heF9lbmRwb2lu dCwgfjAsICJMYXJnZXN0IHZhbHVlIGZvciB0aGUgaW50ZXJ2YWwncyBlbmRwb2ludCIpOwo+ICAK PiAtc3RhdGljIHN0cnVjdCByYl9yb290IHJvb3QgPSBSQl9ST09UOwo+ICtzdGF0aWMgc3RydWN0 IHJiX3Jvb3RfY2FjaGVkIHJvb3QgPSBSQl9ST09UX0NBQ0hFRDsKPiAgc3RhdGljIHN0cnVjdCBp bnRlcnZhbF90cmVlX25vZGUgKm5vZGVzID0gTlVMTDsKPiAgc3RhdGljIHUzMiAqcXVlcmllcyA9 IE5VTEw7Cj4gIAo+ICBzdGF0aWMgc3RydWN0IHJuZF9zdGF0ZSBybmQ7Cj4gIAo+ICBzdGF0aWMg aW5saW5lIHVuc2lnbmVkIGxvbmcKPiAtc2VhcmNoKHN0cnVjdCByYl9yb290ICpyb290LCB1bnNp Z25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxhc3QpCj4gK3NlYXJjaChzdHJ1Y3QgcmJf cm9vdF9jYWNoZWQgKnJvb3QsIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgbGFz dCkKPiAgewo+ICAJc3RydWN0IGludGVydmFsX3RyZWVfbm9kZSAqbm9kZTsKPiAgCXVuc2lnbmVk IGxvbmcgcmVzdWx0cyA9IDA7Cj4gZGlmZiAtLWdpdCBhL21tL2ludGVydmFsX3RyZWUuYyBiL21t L2ludGVydmFsX3RyZWUuYwo+IGluZGV4IGYyYzI0OTI2ODFiZi4uYjQ3NjY0MzU4Nzk2IDEwMDY0 NAo+IC0tLSBhL21tL2ludGVydmFsX3RyZWUuYwo+ICsrKyBiL21tL2ludGVydmFsX3RyZWUuYwo+ IEBAIC0yOCw3ICsyOCw3IEBAIElOVEVSVkFMX1RSRUVfREVGSU5FKHN0cnVjdCB2bV9hcmVhX3N0 cnVjdCwgc2hhcmVkLnJiLAo+ICAvKiBJbnNlcnQgbm9kZSBpbW1lZGlhdGVseSBhZnRlciBwcmV2 IGluIHRoZSBpbnRlcnZhbCB0cmVlICovCj4gIHZvaWQgdm1hX2ludGVydmFsX3RyZWVfaW5zZXJ0 X2FmdGVyKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqbm9kZSwKPiAgCQkJCSAgICBzdHJ1Y3Qgdm1f YXJlYV9zdHJ1Y3QgKnByZXYsCj4gLQkJCQkgICAgc3RydWN0IHJiX3Jvb3QgKnJvb3QpCj4gKwkJ CQkgICAgc3RydWN0IHJiX3Jvb3RfY2FjaGVkICpyb290KQo+ICB7Cj4gIAlzdHJ1Y3QgcmJfbm9k ZSAqKmxpbms7Cj4gIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnBhcmVudDsKPiBAQCAtNTUsNyAr NTUsNyBAQCB2b2lkIHZtYV9pbnRlcnZhbF90cmVlX2luc2VydF9hZnRlcihzdHJ1Y3Qgdm1fYXJl YV9zdHJ1Y3QgKm5vZGUsCj4gIAo+ICAJbm9kZS0+c2hhcmVkLnJiX3N1YnRyZWVfbGFzdCA9IGxh c3Q7Cj4gIAlyYl9saW5rX25vZGUoJm5vZGUtPnNoYXJlZC5yYiwgJnBhcmVudC0+c2hhcmVkLnJi LCBsaW5rKTsKPiAtCXJiX2luc2VydF9hdWdtZW50ZWQoJm5vZGUtPnNoYXJlZC5yYiwgcm9vdCwK PiArCXJiX2luc2VydF9hdWdtZW50ZWQoJm5vZGUtPnNoYXJlZC5yYiwgJnJvb3QtPnJiX3Jvb3Qs Cj4gIAkJCSAgICAmdm1hX2ludGVydmFsX3RyZWVfYXVnbWVudCk7Cj4gIH0KPiAgCj4gQEAgLTc0 LDcgKzc0LDcgQEAgSU5URVJWQUxfVFJFRV9ERUZJTkUoc3RydWN0IGFub25fdm1hX2NoYWluLCBy YiwgdW5zaWduZWQgbG9uZywgcmJfc3VidHJlZV9sYXN0LAo+ICAJCSAgICAgc3RhdGljIGlubGlu ZSwgX19hbm9uX3ZtYV9pbnRlcnZhbF90cmVlKQo+ICAKPiAgdm9pZCBhbm9uX3ZtYV9pbnRlcnZh bF90cmVlX2luc2VydChzdHJ1Y3QgYW5vbl92bWFfY2hhaW4gKm5vZGUsCj4gLQkJCQkgICBzdHJ1 Y3QgcmJfcm9vdCAqcm9vdCkKPiArCQkJCSAgIHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9vdCkK PiAgewo+ICAjaWZkZWYgQ09ORklHX0RFQlVHX1ZNX1JCCj4gIAlub2RlLT5jYWNoZWRfdm1hX3N0 YXJ0ID0gYXZjX3N0YXJ0X3Bnb2ZmKG5vZGUpOwo+IEBAIC04NCwxMyArODQsMTMgQEAgdm9pZCBh bm9uX3ZtYV9pbnRlcnZhbF90cmVlX2luc2VydChzdHJ1Y3QgYW5vbl92bWFfY2hhaW4gKm5vZGUs Cj4gIH0KPiAgCj4gIHZvaWQgYW5vbl92bWFfaW50ZXJ2YWxfdHJlZV9yZW1vdmUoc3RydWN0IGFu b25fdm1hX2NoYWluICpub2RlLAo+IC0JCQkJICAgc3RydWN0IHJiX3Jvb3QgKnJvb3QpCj4gKwkJ CQkgICBzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgKnJvb3QpCj4gIHsKPiAgCV9fYW5vbl92bWFfaW50 ZXJ2YWxfdHJlZV9yZW1vdmUobm9kZSwgcm9vdCk7Cj4gIH0KPiAgCj4gIHN0cnVjdCBhbm9uX3Zt YV9jaGFpbiAqCj4gLWFub25fdm1hX2ludGVydmFsX3RyZWVfaXRlcl9maXJzdChzdHJ1Y3QgcmJf cm9vdCAqcm9vdCwKPiArYW5vbl92bWFfaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KHN0cnVjdCBy Yl9yb290X2NhY2hlZCAqcm9vdCwKPiAgCQkJCSAgdW5zaWduZWQgbG9uZyBmaXJzdCwgdW5zaWdu ZWQgbG9uZyBsYXN0KQo+ICB7Cj4gIAlyZXR1cm4gX19hbm9uX3ZtYV9pbnRlcnZhbF90cmVlX2l0 ZXJfZmlyc3Qocm9vdCwgZmlyc3QsIGxhc3QpOwo+IGRpZmYgLS1naXQgYS9tbS9tZW1vcnkuYyBi L21tL21lbW9yeS5jCj4gaW5kZXggMGU1MTdiZTkxYTg5Li4zM2NiNzlmNzMzOTQgMTAwNjQ0Cj4g LS0tIGEvbW0vbWVtb3J5LmMKPiArKysgYi9tbS9tZW1vcnkuYwo+IEBAIC0yNTkzLDcgKzI1OTMs NyBAQCBzdGF0aWMgdm9pZCB1bm1hcF9tYXBwaW5nX3JhbmdlX3ZtYShzdHJ1Y3Qgdm1fYXJlYV9z dHJ1Y3QgKnZtYSwKPiAgCXphcF9wYWdlX3JhbmdlX3NpbmdsZSh2bWEsIHN0YXJ0X2FkZHIsIGVu ZF9hZGRyIC0gc3RhcnRfYWRkciwgZGV0YWlscyk7Cj4gIH0KPiAgCj4gLXN0YXRpYyBpbmxpbmUg dm9pZCB1bm1hcF9tYXBwaW5nX3JhbmdlX3RyZWUoc3RydWN0IHJiX3Jvb3QgKnJvb3QsCj4gK3N0 YXRpYyBpbmxpbmUgdm9pZCB1bm1hcF9tYXBwaW5nX3JhbmdlX3RyZWUoc3RydWN0IHJiX3Jvb3Rf Y2FjaGVkICpyb290LAo+ICAJCQkJCSAgICBzdHJ1Y3QgemFwX2RldGFpbHMgKmRldGFpbHMpCj4g IHsKPiAgCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hOwo+IEBAIC0yNjU3LDcgKzI2NTcsNyBA QCB2b2lkIHVubWFwX21hcHBpbmdfcmFuZ2Uoc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmcs Cj4gIAkJZGV0YWlscy5sYXN0X2luZGV4ID0gVUxPTkdfTUFYOwo+ICAKPiAgCWlfbW1hcF9sb2Nr X3dyaXRlKG1hcHBpbmcpOwo+IC0JaWYgKHVubGlrZWx5KCFSQl9FTVBUWV9ST09UKCZtYXBwaW5n LT5pX21tYXApKSkKPiArCWlmICh1bmxpa2VseSghUkJfRU1QVFlfUk9PVCgmbWFwcGluZy0+aV9t bWFwLnJiX3Jvb3QpKSkKPiAgCQl1bm1hcF9tYXBwaW5nX3JhbmdlX3RyZWUoJm1hcHBpbmctPmlf bW1hcCwgJmRldGFpbHMpOwo+ICAJaV9tbWFwX3VubG9ja193cml0ZShtYXBwaW5nKTsKPiAgfQo+ IGRpZmYgLS1naXQgYS9tbS9tbWFwLmMgYi9tbS9tbWFwLmMKPiBpbmRleCBmMTllZmNmNzU0MTgu LjgxMjFjNzBkZjk2ZiAxMDA2NDQKPiAtLS0gYS9tbS9tbWFwLmMKPiArKysgYi9tbS9tbWFwLmMK PiBAQCAtNjg0LDcgKzY4NCw3IEBAIGludCBfX3ZtYV9hZGp1c3Qoc3RydWN0IHZtX2FyZWFfc3Ry dWN0ICp2bWEsIHVuc2lnbmVkIGxvbmcgc3RhcnQsCj4gIAlzdHJ1Y3QgbW1fc3RydWN0ICptbSA9 IHZtYS0+dm1fbW07Cj4gIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKm5leHQgPSB2bWEtPnZtX25l eHQsICpvcmlnX3ZtYSA9IHZtYTsKPiAgCXN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nID0g TlVMTDsKPiAtCXN0cnVjdCByYl9yb290ICpyb290ID0gTlVMTDsKPiArCXN0cnVjdCByYl9yb290 X2NhY2hlZCAqcm9vdCA9IE5VTEw7Cj4gIAlzdHJ1Y3QgYW5vbl92bWEgKmFub25fdm1hID0gTlVM TDsKPiAgCXN0cnVjdCBmaWxlICpmaWxlID0gdm1hLT52bV9maWxlOwo+ICAJYm9vbCBzdGFydF9j aGFuZ2VkID0gZmFsc2UsIGVuZF9jaGFuZ2VkID0gZmFsc2U7Cj4gQEAgLTMzMTQsNyArMzMxNCw3 IEBAIHN0YXRpYyBERUZJTkVfTVVURVgobW1fYWxsX2xvY2tzX211dGV4KTsKPiAgCj4gIHN0YXRp YyB2b2lkIHZtX2xvY2tfYW5vbl92bWEoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHN0cnVjdCBhbm9u X3ZtYSAqYW5vbl92bWEpCj4gIHsKPiAtCWlmICghdGVzdF9iaXQoMCwgKHVuc2lnbmVkIGxvbmcg KikgJmFub25fdm1hLT5yb290LT5yYl9yb290LnJiX25vZGUpKSB7Cj4gKwlpZiAoIXRlc3RfYml0 KDAsICh1bnNpZ25lZCBsb25nICopICZhbm9uX3ZtYS0+cmJfcm9vdC5yYl9yb290LnJiX25vZGUp KSB7Cj4gIAkJLyoKPiAgCQkgKiBUaGUgTFNCIG9mIGhlYWQubmV4dCBjYW4ndCBjaGFuZ2UgZnJv bSB1bmRlciB1cwo+ICAJCSAqIGJlY2F1c2Ugd2UgaG9sZCB0aGUgbW1fYWxsX2xvY2tzX211dGV4 Lgo+IEBAIC0zMzMwLDcgKzMzMzAsNyBAQCBzdGF0aWMgdm9pZCB2bV9sb2NrX2Fub25fdm1hKHN0 cnVjdCBtbV9zdHJ1Y3QgKm1tLCBzdHJ1Y3QgYW5vbl92bWEgKmFub25fdm1hKQo+ICAJCSAqIGFu b25fdm1hLT5yb290LT5yd3NlbS4KPiAgCQkgKi8KPiAgCQlpZiAoX190ZXN0X2FuZF9zZXRfYml0 KDAsICh1bnNpZ25lZCBsb25nICopCj4gLQkJCQkgICAgICAgJmFub25fdm1hLT5yb290LT5yYl9y b290LnJiX25vZGUpKQo+ICsJCQkJICAgICAgICZhbm9uX3ZtYS0+cm9vdC0+cmJfcm9vdC5yYl9y b290LnJiX25vZGUpKQo+ICAJCQlCVUcoKTsKPiAgCX0KPiAgfQo+IEBAIC0zNDMyLDcgKzM0MzIs NyBAQCBpbnQgbW1fdGFrZV9hbGxfbG9ja3Moc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gIAo+ICBz dGF0aWMgdm9pZCB2bV91bmxvY2tfYW5vbl92bWEoc3RydWN0IGFub25fdm1hICphbm9uX3ZtYSkK PiAgewo+IC0JaWYgKHRlc3RfYml0KDAsICh1bnNpZ25lZCBsb25nICopICZhbm9uX3ZtYS0+cm9v dC0+cmJfcm9vdC5yYl9ub2RlKSkgewo+ICsJaWYgKHRlc3RfYml0KDAsICh1bnNpZ25lZCBsb25n ICopICZhbm9uX3ZtYS0+cm9vdC0+cmJfcm9vdC5yYl9yb290LnJiX25vZGUpKSB7Cj4gIAkJLyoK PiAgCQkgKiBUaGUgTFNCIG9mIGhlYWQubmV4dCBjYW4ndCBjaGFuZ2UgdG8gMCBmcm9tIHVuZGVy Cj4gIAkJICogdXMgYmVjYXVzZSB3ZSBob2xkIHRoZSBtbV9hbGxfbG9ja3NfbXV0ZXguCj4gQEAg LTM0NDYsNyArMzQ0Niw3IEBAIHN0YXRpYyB2b2lkIHZtX3VubG9ja19hbm9uX3ZtYShzdHJ1Y3Qg YW5vbl92bWEgKmFub25fdm1hKQo+ICAJCSAqIGFub25fdm1hLT5yb290LT5yd3NlbS4KPiAgCQkg Ki8KPiAgCQlpZiAoIV9fdGVzdF9hbmRfY2xlYXJfYml0KDAsICh1bnNpZ25lZCBsb25nICopCj4g LQkJCQkJICAmYW5vbl92bWEtPnJvb3QtPnJiX3Jvb3QucmJfbm9kZSkpCj4gKwkJCQkJICAmYW5v bl92bWEtPnJvb3QtPnJiX3Jvb3QucmJfcm9vdC5yYl9ub2RlKSkKPiAgCQkJQlVHKCk7Cj4gIAkJ YW5vbl92bWFfdW5sb2NrX3dyaXRlKGFub25fdm1hKTsKPiAgCX0KPiBkaWZmIC0tZ2l0IGEvbW0v cm1hcC5jIGIvbW0vcm1hcC5jCj4gaW5kZXggY2VkMTRmMWFmNmRjLi5hZDQ3OWU1ZTA4MWQgMTAw NjQ0Cj4gLS0tIGEvbW0vcm1hcC5jCj4gKysrIGIvbW0vcm1hcC5jCj4gQEAgLTM5MCw3ICszOTAs NyBAQCB2b2lkIHVubGlua19hbm9uX3ZtYXMoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCj4g IAkJICogTGVhdmUgZW1wdHkgYW5vbl92bWFzIG9uIHRoZSBsaXN0IC0gd2UnbGwgbmVlZAo+ICAJ CSAqIHRvIGZyZWUgdGhlbSBvdXRzaWRlIHRoZSBsb2NrLgo+ICAJCSAqLwo+IC0JCWlmIChSQl9F TVBUWV9ST09UKCZhbm9uX3ZtYS0+cmJfcm9vdCkpIHsKPiArCQlpZiAoUkJfRU1QVFlfUk9PVCgm YW5vbl92bWEtPnJiX3Jvb3QucmJfcm9vdCkpIHsKPiAgCQkJYW5vbl92bWEtPnBhcmVudC0+ZGVn cmVlLS07Cj4gIAkJCWNvbnRpbnVlOwo+ICAJCX0KPiBAQCAtNDI0LDcgKzQyNCw3IEBAIHN0YXRp YyB2b2lkIGFub25fdm1hX2N0b3Iodm9pZCAqZGF0YSkKPiAgCj4gIAlpbml0X3J3c2VtKCZhbm9u X3ZtYS0+cndzZW0pOwo+ICAJYXRvbWljX3NldCgmYW5vbl92bWEtPnJlZmNvdW50LCAwKTsKPiAt CWFub25fdm1hLT5yYl9yb290ID0gUkJfUk9PVDsKPiArCWFub25fdm1hLT5yYl9yb290ID0gUkJf Uk9PVF9DQUNIRUQ7Cj4gIH0KPiAgCj4gIHZvaWQgX19pbml0IGFub25fdm1hX2luaXQodm9pZCkK PiAtLSAKPiAyLjEyLjAKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRl dmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752006AbdHARQp (ORCPT ); Tue, 1 Aug 2017 13:16:45 -0400 Received: from mx1.redhat.com ([209.132.183.28]:50202 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751860AbdHARQk (ORCPT ); Tue, 1 Aug 2017 13:16:40 -0400 DMARC-Filter: OpenDMARC Filter v1.3.2 mx1.redhat.com 3D576151780 Authentication-Results: ext-mx06.extmail.prod.ext.phx2.redhat.com; dmarc=none (p=none dis=none) header.from=redhat.com Authentication-Results: ext-mx06.extmail.prod.ext.phx2.redhat.com; spf=fail smtp.mailfrom=mst@redhat.com Date: Tue, 1 Aug 2017 20:16:37 +0300 From: "Michael S. Tsirkin" To: Davidlohr Bueso Cc: akpm@linux-foundation.org, mingo@kernel.org, peterz@infradead.org, jack@suse.cz, torvalds@linux-foundation.org, kirill.shutemov@linux.intel.com, hch@infradead.org, ldufour@linux.vnet.ibm.com, mhocko@suse.com, mgorman@techsingularity.net, linux-kernel@vger.kernel.org, David Airlie , dri-devel@lists.freedesktop.org, Jason Wang , Doug Ledford , Christian Benvenuti , linux-rdma@vger.kernel.org, Davidlohr Bueso Subject: Re: [PATCH 11/17] lib/interval_tree: fast overlap detection Message-ID: <20170801201628-mutt-send-email-mst@kernel.org> References: <20170719014603.19029-1-dave@stgolabs.net> <20170719014603.19029-12-dave@stgolabs.net> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20170719014603.19029-12-dave@stgolabs.net> X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.30]); Tue, 01 Aug 2017 17:16:40 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, Jul 18, 2017 at 06:45:57PM -0700, Davidlohr Bueso wrote: > Allow interval trees to quickly check for overlaps to avoid > unnecesary tree lookups in interval_tree_iter_first(). > > As of this patch, all interval tree flavors will require > using a 'rb_root_cached' such that we can have the leftmost > node easily available. While most users will make use of this > feature, those with special functions (in addition to the generic > insert, delete, search calls) will avoid using the cached > option as they can do funky things with insertions -- for example, > vma_interval_tree_insert_after(). > > Cc: David Airlie > Cc: dri-devel@lists.freedesktop.org > Cc: "Michael S. Tsirkin" > Cc: Jason Wang > Cc: Doug Ledford > Cc: Christian Benvenuti > Cc: linux-rdma@vger.kernel.org > Acked-by: Christian König > Acked-by: Peter Zijlstra (Intel) > Signed-off-by: Davidlohr Bueso For vhost bits: Acked-by: Michael S. Tsirkin > --- > drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c | 8 ++-- > drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c | 7 ++-- > drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h | 2 +- > drivers/gpu/drm/drm_mm.c | 19 +++++---- > drivers/gpu/drm/drm_vma_manager.c | 2 +- > drivers/gpu/drm/i915/i915_gem_userptr.c | 6 +-- > drivers/gpu/drm/radeon/radeon.h | 2 +- > drivers/gpu/drm/radeon/radeon_mn.c | 8 ++-- > drivers/gpu/drm/radeon/radeon_vm.c | 7 ++-- > drivers/infiniband/core/umem_rbtree.c | 4 +- > drivers/infiniband/core/uverbs_cmd.c | 2 +- > drivers/infiniband/hw/hfi1/mmu_rb.c | 10 ++--- > drivers/infiniband/hw/usnic/usnic_uiom.c | 6 +-- > drivers/infiniband/hw/usnic/usnic_uiom.h | 2 +- > .../infiniband/hw/usnic/usnic_uiom_interval_tree.c | 15 +++---- > .../infiniband/hw/usnic/usnic_uiom_interval_tree.h | 12 +++--- > drivers/vhost/vhost.c | 2 +- > drivers/vhost/vhost.h | 2 +- > fs/hugetlbfs/inode.c | 6 +-- > fs/inode.c | 2 +- > include/drm/drm_mm.h | 2 +- > include/linux/fs.h | 4 +- > include/linux/interval_tree.h | 8 ++-- > include/linux/interval_tree_generic.h | 46 +++++++++++++++++----- > include/linux/mm.h | 17 ++++---- > include/linux/rmap.h | 4 +- > include/rdma/ib_umem_odp.h | 11 ++++-- > include/rdma/ib_verbs.h | 2 +- > lib/interval_tree_test.c | 4 +- > mm/interval_tree.c | 10 ++--- > mm/memory.c | 4 +- > mm/mmap.c | 10 ++--- > mm/rmap.c | 4 +- > 33 files changed, 145 insertions(+), 105 deletions(-) > > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c > index 38f739fb727b..3f8aef21b9a6 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c > @@ -51,7 +51,7 @@ struct amdgpu_mn { > > /* objects protected by lock */ > struct mutex lock; > - struct rb_root objects; > + struct rb_root_cached objects; > }; > > struct amdgpu_mn_node { > @@ -76,8 +76,8 @@ static void amdgpu_mn_destroy(struct work_struct *work) > mutex_lock(&adev->mn_lock); > mutex_lock(&rmn->lock); > hash_del(&rmn->node); > - rbtree_postorder_for_each_entry_safe(node, next_node, &rmn->objects, > - it.rb) { > + rbtree_postorder_for_each_entry_safe(node, next_node, > + &rmn->objects.rb_root, it.rb) { > list_for_each_entry_safe(bo, next_bo, &node->bos, mn_list) { > bo->mn = NULL; > list_del_init(&bo->mn_list); > @@ -252,7 +252,7 @@ static struct amdgpu_mn *amdgpu_mn_get(struct amdgpu_device *adev) > rmn->mm = mm; > rmn->mn.ops = &amdgpu_mn_ops; > mutex_init(&rmn->lock); > - rmn->objects = RB_ROOT; > + rmn->objects = RB_ROOT_CACHED; > > r = __mmu_notifier_register(&rmn->mn, mm); > if (r) > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c > index 5795f81369f0..f872e2179bbd 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c > @@ -2405,7 +2405,7 @@ int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm, > int r, i; > u64 flags; > > - vm->va = RB_ROOT; > + vm->va = RB_ROOT_CACHED; > vm->client_id = atomic64_inc_return(&adev->vm_manager.client_counter); > for (i = 0; i < AMDGPU_MAX_VMHUBS; i++) > vm->reserved_vmid[i] = NULL; > @@ -2512,10 +2512,11 @@ void amdgpu_vm_fini(struct amdgpu_device *adev, struct amdgpu_vm *vm) > > amd_sched_entity_fini(vm->entity.sched, &vm->entity); > > - if (!RB_EMPTY_ROOT(&vm->va)) { > + if (!RB_EMPTY_ROOT(&vm->va.rb_root)) { > dev_err(adev->dev, "still active bo inside vm\n"); > } > - rbtree_postorder_for_each_entry_safe(mapping, tmp, &vm->va, rb) { > + rbtree_postorder_for_each_entry_safe(mapping, tmp, > + &vm->va.rb_root, rb) { > list_del(&mapping->list); > amdgpu_vm_it_remove(mapping, &vm->va); > kfree(mapping); > diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h > index 936f158bc5ec..ebffc1253f85 100644 > --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h > +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h > @@ -106,7 +106,7 @@ struct amdgpu_vm_pt { > > struct amdgpu_vm { > /* tree of virtual addresses mapped */ > - struct rb_root va; > + struct rb_root_cached va; > > /* protecting invalidated */ > spinlock_t status_lock; > diff --git a/drivers/gpu/drm/drm_mm.c b/drivers/gpu/drm/drm_mm.c > index f794089d30ac..61a1c8ea74bc 100644 > --- a/drivers/gpu/drm/drm_mm.c > +++ b/drivers/gpu/drm/drm_mm.c > @@ -169,7 +169,7 @@ INTERVAL_TREE_DEFINE(struct drm_mm_node, rb, > struct drm_mm_node * > __drm_mm_interval_first(const struct drm_mm *mm, u64 start, u64 last) > { > - return drm_mm_interval_tree_iter_first((struct rb_root *)&mm->interval_tree, > + return drm_mm_interval_tree_iter_first((struct rb_root_cached *)&mm->interval_tree, > start, last) ?: (struct drm_mm_node *)&mm->head_node; > } > EXPORT_SYMBOL(__drm_mm_interval_first); > @@ -180,6 +180,7 @@ static void drm_mm_interval_tree_add_node(struct drm_mm_node *hole_node, > struct drm_mm *mm = hole_node->mm; > struct rb_node **link, *rb; > struct drm_mm_node *parent; > + bool leftmost = true; > > node->__subtree_last = LAST(node); > > @@ -196,9 +197,10 @@ static void drm_mm_interval_tree_add_node(struct drm_mm_node *hole_node, > > rb = &hole_node->rb; > link = &hole_node->rb.rb_right; > + leftmost = false; > } else { > rb = NULL; > - link = &mm->interval_tree.rb_node; > + link = &mm->interval_tree.rb_root.rb_node; > } > > while (*link) { > @@ -208,14 +210,15 @@ static void drm_mm_interval_tree_add_node(struct drm_mm_node *hole_node, > parent->__subtree_last = node->__subtree_last; > if (node->start < parent->start) > link = &parent->rb.rb_left; > - else > + else { > link = &parent->rb.rb_right; > + leftmost = true; > + } > } > > rb_link_node(&node->rb, rb, link); > - rb_insert_augmented(&node->rb, > - &mm->interval_tree, > - &drm_mm_interval_tree_augment); > + rb_insert_augmented_cached(&node->rb, &mm->interval_tree, leftmost, > + &drm_mm_interval_tree_augment); > } > > #define RB_INSERT(root, member, expr) do { \ > @@ -577,7 +580,7 @@ void drm_mm_replace_node(struct drm_mm_node *old, struct drm_mm_node *new) > *new = *old; > > list_replace(&old->node_list, &new->node_list); > - rb_replace_node(&old->rb, &new->rb, &old->mm->interval_tree); > + rb_replace_node(&old->rb, &new->rb, &old->mm->interval_tree.rb_root); > > if (drm_mm_hole_follows(old)) { > list_replace(&old->hole_stack, &new->hole_stack); > @@ -863,7 +866,7 @@ void drm_mm_init(struct drm_mm *mm, u64 start, u64 size) > mm->color_adjust = NULL; > > INIT_LIST_HEAD(&mm->hole_stack); > - mm->interval_tree = RB_ROOT; > + mm->interval_tree = RB_ROOT_CACHED; > mm->holes_size = RB_ROOT; > mm->holes_addr = RB_ROOT; > > diff --git a/drivers/gpu/drm/drm_vma_manager.c b/drivers/gpu/drm/drm_vma_manager.c > index d9100b565198..28f1226576f8 100644 > --- a/drivers/gpu/drm/drm_vma_manager.c > +++ b/drivers/gpu/drm/drm_vma_manager.c > @@ -147,7 +147,7 @@ struct drm_vma_offset_node *drm_vma_offset_lookup_locked(struct drm_vma_offset_m > struct rb_node *iter; > unsigned long offset; > > - iter = mgr->vm_addr_space_mm.interval_tree.rb_node; > + iter = mgr->vm_addr_space_mm.interval_tree.rb_root.rb_node; > best = NULL; > > while (likely(iter)) { > diff --git a/drivers/gpu/drm/i915/i915_gem_userptr.c b/drivers/gpu/drm/i915/i915_gem_userptr.c > index ccd09e8419f5..71dddf66baaa 100644 > --- a/drivers/gpu/drm/i915/i915_gem_userptr.c > +++ b/drivers/gpu/drm/i915/i915_gem_userptr.c > @@ -49,7 +49,7 @@ struct i915_mmu_notifier { > spinlock_t lock; > struct hlist_node node; > struct mmu_notifier mn; > - struct rb_root objects; > + struct rb_root_cached objects; > struct workqueue_struct *wq; > }; > > @@ -123,7 +123,7 @@ static void i915_gem_userptr_mn_invalidate_range_start(struct mmu_notifier *_mn, > struct interval_tree_node *it; > LIST_HEAD(cancelled); > > - if (RB_EMPTY_ROOT(&mn->objects)) > + if (RB_EMPTY_ROOT(&mn->objects.rb_root)) > return; > > /* interval ranges are inclusive, but invalidate range is exclusive */ > @@ -172,7 +172,7 @@ i915_mmu_notifier_create(struct mm_struct *mm) > > spin_lock_init(&mn->lock); > mn->mn.ops = &i915_gem_userptr_notifier; > - mn->objects = RB_ROOT; > + mn->objects = RB_ROOT_CACHED; > mn->wq = alloc_workqueue("i915-userptr-release", WQ_UNBOUND, 0); > if (mn->wq == NULL) { > kfree(mn); > diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h > index 5008f3d4cccc..10d0dd146808 100644 > --- a/drivers/gpu/drm/radeon/radeon.h > +++ b/drivers/gpu/drm/radeon/radeon.h > @@ -924,7 +924,7 @@ struct radeon_vm_id { > struct radeon_vm { > struct mutex mutex; > > - struct rb_root va; > + struct rb_root_cached va; > > /* protecting invalidated and freed */ > spinlock_t status_lock; > diff --git a/drivers/gpu/drm/radeon/radeon_mn.c b/drivers/gpu/drm/radeon/radeon_mn.c > index 896f2cf51e4e..1d62288b7ee3 100644 > --- a/drivers/gpu/drm/radeon/radeon_mn.c > +++ b/drivers/gpu/drm/radeon/radeon_mn.c > @@ -50,7 +50,7 @@ struct radeon_mn { > > /* objects protected by lock */ > struct mutex lock; > - struct rb_root objects; > + struct rb_root_cached objects; > }; > > struct radeon_mn_node { > @@ -75,8 +75,8 @@ static void radeon_mn_destroy(struct work_struct *work) > mutex_lock(&rdev->mn_lock); > mutex_lock(&rmn->lock); > hash_del(&rmn->node); > - rbtree_postorder_for_each_entry_safe(node, next_node, &rmn->objects, > - it.rb) { > + rbtree_postorder_for_each_entry_safe(node, next_node, > + &rmn->objects.rb_root, it.rb) { > > interval_tree_remove(&node->it, &rmn->objects); > list_for_each_entry_safe(bo, next_bo, &node->bos, mn_list) { > @@ -205,7 +205,7 @@ static struct radeon_mn *radeon_mn_get(struct radeon_device *rdev) > rmn->mm = mm; > rmn->mn.ops = &radeon_mn_ops; > mutex_init(&rmn->lock); > - rmn->objects = RB_ROOT; > + rmn->objects = RB_ROOT_CACHED; > > r = __mmu_notifier_register(&rmn->mn, mm); > if (r) > diff --git a/drivers/gpu/drm/radeon/radeon_vm.c b/drivers/gpu/drm/radeon/radeon_vm.c > index 5f68245579a3..f44777a6c2e8 100644 > --- a/drivers/gpu/drm/radeon/radeon_vm.c > +++ b/drivers/gpu/drm/radeon/radeon_vm.c > @@ -1185,7 +1185,7 @@ int radeon_vm_init(struct radeon_device *rdev, struct radeon_vm *vm) > vm->ids[i].last_id_use = NULL; > } > mutex_init(&vm->mutex); > - vm->va = RB_ROOT; > + vm->va = RB_ROOT_CACHED; > spin_lock_init(&vm->status_lock); > INIT_LIST_HEAD(&vm->invalidated); > INIT_LIST_HEAD(&vm->freed); > @@ -1232,10 +1232,11 @@ void radeon_vm_fini(struct radeon_device *rdev, struct radeon_vm *vm) > struct radeon_bo_va *bo_va, *tmp; > int i, r; > > - if (!RB_EMPTY_ROOT(&vm->va)) { > + if (!RB_EMPTY_ROOT(&vm->va.rb_root)) { > dev_err(rdev->dev, "still active bo inside vm\n"); > } > - rbtree_postorder_for_each_entry_safe(bo_va, tmp, &vm->va, it.rb) { > + rbtree_postorder_for_each_entry_safe(bo_va, tmp, > + &vm->va.rb_root, it.rb) { > interval_tree_remove(&bo_va->it, &vm->va); > r = radeon_bo_reserve(bo_va->bo, false); > if (!r) { > diff --git a/drivers/infiniband/core/umem_rbtree.c b/drivers/infiniband/core/umem_rbtree.c > index d176597b4d78..fc801920e341 100644 > --- a/drivers/infiniband/core/umem_rbtree.c > +++ b/drivers/infiniband/core/umem_rbtree.c > @@ -72,7 +72,7 @@ INTERVAL_TREE_DEFINE(struct umem_odp_node, rb, u64, __subtree_last, > /* @last is not a part of the interval. See comment for function > * node_last. > */ > -int rbt_ib_umem_for_each_in_range(struct rb_root *root, > +int rbt_ib_umem_for_each_in_range(struct rb_root_cached *root, > u64 start, u64 last, > umem_call_back cb, > void *cookie) > @@ -95,7 +95,7 @@ int rbt_ib_umem_for_each_in_range(struct rb_root *root, > } > EXPORT_SYMBOL(rbt_ib_umem_for_each_in_range); > > -struct ib_umem_odp *rbt_ib_umem_lookup(struct rb_root *root, > +struct ib_umem_odp *rbt_ib_umem_lookup(struct rb_root_cached *root, > u64 addr, u64 length) > { > struct umem_odp_node *node; > diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c > index 3f55d18a3791..5321c6ae2c0c 100644 > --- a/drivers/infiniband/core/uverbs_cmd.c > +++ b/drivers/infiniband/core/uverbs_cmd.c > @@ -117,7 +117,7 @@ ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file, > ucontext->closing = 0; > > #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING > - ucontext->umem_tree = RB_ROOT; > + ucontext->umem_tree = RB_ROOT_CACHED; > init_rwsem(&ucontext->umem_rwsem); > ucontext->odp_mrs_count = 0; > INIT_LIST_HEAD(&ucontext->no_private_counters); > diff --git a/drivers/infiniband/hw/hfi1/mmu_rb.c b/drivers/infiniband/hw/hfi1/mmu_rb.c > index d41fd87a39f2..5b6626f8feb6 100644 > --- a/drivers/infiniband/hw/hfi1/mmu_rb.c > +++ b/drivers/infiniband/hw/hfi1/mmu_rb.c > @@ -54,7 +54,7 @@ > > struct mmu_rb_handler { > struct mmu_notifier mn; > - struct rb_root root; > + struct rb_root_cached root; > void *ops_arg; > spinlock_t lock; /* protect the RB tree */ > struct mmu_rb_ops *ops; > @@ -111,7 +111,7 @@ int hfi1_mmu_rb_register(void *ops_arg, struct mm_struct *mm, > if (!handlr) > return -ENOMEM; > > - handlr->root = RB_ROOT; > + handlr->root = RB_ROOT_CACHED; > handlr->ops = ops; > handlr->ops_arg = ops_arg; > INIT_HLIST_NODE(&handlr->mn.hlist); > @@ -152,9 +152,9 @@ void hfi1_mmu_rb_unregister(struct mmu_rb_handler *handler) > INIT_LIST_HEAD(&del_list); > > spin_lock_irqsave(&handler->lock, flags); > - while ((node = rb_first(&handler->root))) { > + while ((node = rb_first_cached(&handler->root))) { > rbnode = rb_entry(node, struct mmu_rb_node, node); > - rb_erase(node, &handler->root); > + rb_erase_cached(node, &handler->root); > /* move from LRU list to delete list */ > list_move(&rbnode->list, &del_list); > } > @@ -311,7 +311,7 @@ static void mmu_notifier_mem_invalidate(struct mmu_notifier *mn, > { > struct mmu_rb_handler *handler = > container_of(mn, struct mmu_rb_handler, mn); > - struct rb_root *root = &handler->root; > + struct rb_root_cached *root = &handler->root; > struct mmu_rb_node *node, *ptr = NULL; > unsigned long flags; > bool added = false; > diff --git a/drivers/infiniband/hw/usnic/usnic_uiom.c b/drivers/infiniband/hw/usnic/usnic_uiom.c > index c49db7c33979..4381c0a9a873 100644 > --- a/drivers/infiniband/hw/usnic/usnic_uiom.c > +++ b/drivers/infiniband/hw/usnic/usnic_uiom.c > @@ -227,7 +227,7 @@ static void __usnic_uiom_reg_release(struct usnic_uiom_pd *pd, > vpn_last = vpn_start + npages - 1; > > spin_lock(&pd->lock); > - usnic_uiom_remove_interval(&pd->rb_root, vpn_start, > + usnic_uiom_remove_interval(&pd->root, vpn_start, > vpn_last, &rm_intervals); > usnic_uiom_unmap_sorted_intervals(&rm_intervals, pd); > > @@ -379,7 +379,7 @@ struct usnic_uiom_reg *usnic_uiom_reg_get(struct usnic_uiom_pd *pd, > err = usnic_uiom_get_intervals_diff(vpn_start, vpn_last, > (writable) ? IOMMU_WRITE : 0, > IOMMU_WRITE, > - &pd->rb_root, > + &pd->root, > &sorted_diff_intervals); > if (err) { > usnic_err("Failed disjoint interval vpn [0x%lx,0x%lx] err %d\n", > @@ -395,7 +395,7 @@ struct usnic_uiom_reg *usnic_uiom_reg_get(struct usnic_uiom_pd *pd, > > } > > - err = usnic_uiom_insert_interval(&pd->rb_root, vpn_start, vpn_last, > + err = usnic_uiom_insert_interval(&pd->root, vpn_start, vpn_last, > (writable) ? IOMMU_WRITE : 0); > if (err) { > usnic_err("Failed insert interval vpn [0x%lx,0x%lx] err %d\n", > diff --git a/drivers/infiniband/hw/usnic/usnic_uiom.h b/drivers/infiniband/hw/usnic/usnic_uiom.h > index 45ca7c1613a7..431efe4143f4 100644 > --- a/drivers/infiniband/hw/usnic/usnic_uiom.h > +++ b/drivers/infiniband/hw/usnic/usnic_uiom.h > @@ -55,7 +55,7 @@ struct usnic_uiom_dev { > struct usnic_uiom_pd { > struct iommu_domain *domain; > spinlock_t lock; > - struct rb_root rb_root; > + struct rb_root_cached root; > struct list_head devs; > int dev_cnt; > }; > diff --git a/drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.c b/drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.c > index 42b4b4c4e452..d399523206c7 100644 > --- a/drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.c > +++ b/drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.c > @@ -100,9 +100,9 @@ static int interval_cmp(void *priv, struct list_head *a, struct list_head *b) > } > > static void > -find_intervals_intersection_sorted(struct rb_root *root, unsigned long start, > - unsigned long last, > - struct list_head *list) > +find_intervals_intersection_sorted(struct rb_root_cached *root, > + unsigned long start, unsigned long last, > + struct list_head *list) > { > struct usnic_uiom_interval_node *node; > > @@ -118,7 +118,7 @@ find_intervals_intersection_sorted(struct rb_root *root, unsigned long start, > > int usnic_uiom_get_intervals_diff(unsigned long start, unsigned long last, > int flags, int flag_mask, > - struct rb_root *root, > + struct rb_root_cached *root, > struct list_head *diff_set) > { > struct usnic_uiom_interval_node *interval, *tmp; > @@ -175,7 +175,7 @@ void usnic_uiom_put_interval_set(struct list_head *intervals) > kfree(interval); > } > > -int usnic_uiom_insert_interval(struct rb_root *root, unsigned long start, > +int usnic_uiom_insert_interval(struct rb_root_cached *root, unsigned long start, > unsigned long last, int flags) > { > struct usnic_uiom_interval_node *interval, *tmp; > @@ -246,8 +246,9 @@ int usnic_uiom_insert_interval(struct rb_root *root, unsigned long start, > return err; > } > > -void usnic_uiom_remove_interval(struct rb_root *root, unsigned long start, > - unsigned long last, struct list_head *removed) > +void usnic_uiom_remove_interval(struct rb_root_cached *root, > + unsigned long start, unsigned long last, > + struct list_head *removed) > { > struct usnic_uiom_interval_node *interval; > > diff --git a/drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.h b/drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.h > index c0b0b876ab90..1d7fc3226bca 100644 > --- a/drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.h > +++ b/drivers/infiniband/hw/usnic/usnic_uiom_interval_tree.h > @@ -48,12 +48,12 @@ struct usnic_uiom_interval_node { > > extern void > usnic_uiom_interval_tree_insert(struct usnic_uiom_interval_node *node, > - struct rb_root *root); > + struct rb_root_cached *root); > extern void > usnic_uiom_interval_tree_remove(struct usnic_uiom_interval_node *node, > - struct rb_root *root); > + struct rb_root_cached *root); > extern struct usnic_uiom_interval_node * > -usnic_uiom_interval_tree_iter_first(struct rb_root *root, > +usnic_uiom_interval_tree_iter_first(struct rb_root_cached *root, > unsigned long start, > unsigned long last); > extern struct usnic_uiom_interval_node * > @@ -63,7 +63,7 @@ usnic_uiom_interval_tree_iter_next(struct usnic_uiom_interval_node *node, > * Inserts {start...last} into {root}. If there are overlaps, > * nodes will be broken up and merged > */ > -int usnic_uiom_insert_interval(struct rb_root *root, > +int usnic_uiom_insert_interval(struct rb_root_cached *root, > unsigned long start, unsigned long last, > int flags); > /* > @@ -71,7 +71,7 @@ int usnic_uiom_insert_interval(struct rb_root *root, > * 'removed.' The caller is responsibile for freeing memory of nodes in > * 'removed.' > */ > -void usnic_uiom_remove_interval(struct rb_root *root, > +void usnic_uiom_remove_interval(struct rb_root_cached *root, > unsigned long start, unsigned long last, > struct list_head *removed); > /* > @@ -81,7 +81,7 @@ void usnic_uiom_remove_interval(struct rb_root *root, > int usnic_uiom_get_intervals_diff(unsigned long start, > unsigned long last, int flags, > int flag_mask, > - struct rb_root *root, > + struct rb_root_cached *root, > struct list_head *diff_set); > /* Call this to free diff_set returned by usnic_uiom_get_intervals_diff */ > void usnic_uiom_put_interval_set(struct list_head *intervals); > diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c > index e4613a3c362d..88dc214de068 100644 > --- a/drivers/vhost/vhost.c > +++ b/drivers/vhost/vhost.c > @@ -1272,7 +1272,7 @@ static struct vhost_umem *vhost_umem_alloc(void) > if (!umem) > return NULL; > > - umem->umem_tree = RB_ROOT; > + umem->umem_tree = RB_ROOT_CACHED; > umem->numem = 0; > INIT_LIST_HEAD(&umem->umem_list); > > diff --git a/drivers/vhost/vhost.h b/drivers/vhost/vhost.h > index f72095868b93..a0278ba6a8b4 100644 > --- a/drivers/vhost/vhost.h > +++ b/drivers/vhost/vhost.h > @@ -71,7 +71,7 @@ struct vhost_umem_node { > }; > > struct vhost_umem { > - struct rb_root umem_tree; > + struct rb_root_cached umem_tree; > struct list_head umem_list; > int numem; > }; > diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c > index 28d2753be094..e61b91e6adf4 100644 > --- a/fs/hugetlbfs/inode.c > +++ b/fs/hugetlbfs/inode.c > @@ -334,7 +334,7 @@ static void remove_huge_page(struct page *page) > } > > static void > -hugetlb_vmdelete_list(struct rb_root *root, pgoff_t start, pgoff_t end) > +hugetlb_vmdelete_list(struct rb_root_cached *root, pgoff_t start, pgoff_t end) > { > struct vm_area_struct *vma; > > @@ -514,7 +514,7 @@ static int hugetlb_vmtruncate(struct inode *inode, loff_t offset) > > i_size_write(inode, offset); > i_mmap_lock_write(mapping); > - if (!RB_EMPTY_ROOT(&mapping->i_mmap)) > + if (!RB_EMPTY_ROOT(&mapping->i_mmap.rb_root)) > hugetlb_vmdelete_list(&mapping->i_mmap, pgoff, 0); > i_mmap_unlock_write(mapping); > remove_inode_hugepages(inode, offset, LLONG_MAX); > @@ -539,7 +539,7 @@ static long hugetlbfs_punch_hole(struct inode *inode, loff_t offset, loff_t len) > > inode_lock(inode); > i_mmap_lock_write(mapping); > - if (!RB_EMPTY_ROOT(&mapping->i_mmap)) > + if (!RB_EMPTY_ROOT(&mapping->i_mmap.rb_root)) > hugetlb_vmdelete_list(&mapping->i_mmap, > hole_start >> PAGE_SHIFT, > hole_end >> PAGE_SHIFT); > diff --git a/fs/inode.c b/fs/inode.c > index 50370599e371..5ddb808ea934 100644 > --- a/fs/inode.c > +++ b/fs/inode.c > @@ -353,7 +353,7 @@ void address_space_init_once(struct address_space *mapping) > init_rwsem(&mapping->i_mmap_rwsem); > INIT_LIST_HEAD(&mapping->private_list); > spin_lock_init(&mapping->private_lock); > - mapping->i_mmap = RB_ROOT; > + mapping->i_mmap = RB_ROOT_CACHED; > } > EXPORT_SYMBOL(address_space_init_once); > > diff --git a/include/drm/drm_mm.h b/include/drm/drm_mm.h > index 49b292e98fec..8d10fc97801c 100644 > --- a/include/drm/drm_mm.h > +++ b/include/drm/drm_mm.h > @@ -172,7 +172,7 @@ struct drm_mm { > * according to the (increasing) start address of the memory node. */ > struct drm_mm_node head_node; > /* Keep an interval_tree for fast lookup of drm_mm_nodes by address. */ > - struct rb_root interval_tree; > + struct rb_root_cached interval_tree; > struct rb_root holes_size; > struct rb_root holes_addr; > > diff --git a/include/linux/fs.h b/include/linux/fs.h > index ed8798255872..d1d521c5025b 100644 > --- a/include/linux/fs.h > +++ b/include/linux/fs.h > @@ -392,7 +392,7 @@ struct address_space { > struct radix_tree_root page_tree; /* radix tree of all pages */ > spinlock_t tree_lock; /* and lock protecting it */ > atomic_t i_mmap_writable;/* count VM_SHARED mappings */ > - struct rb_root i_mmap; /* tree of private and shared mappings */ > + struct rb_root_cached i_mmap; /* tree of private and shared mappings */ > struct rw_semaphore i_mmap_rwsem; /* protect tree, count, list */ > /* Protected by tree_lock together with the radix tree */ > unsigned long nrpages; /* number of total pages */ > @@ -486,7 +486,7 @@ static inline void i_mmap_unlock_read(struct address_space *mapping) > */ > static inline int mapping_mapped(struct address_space *mapping) > { > - return !RB_EMPTY_ROOT(&mapping->i_mmap); > + return !RB_EMPTY_ROOT(&mapping->i_mmap.rb_root); > } > > /* > diff --git a/include/linux/interval_tree.h b/include/linux/interval_tree.h > index 724556aa3c95..202ee1283f4b 100644 > --- a/include/linux/interval_tree.h > +++ b/include/linux/interval_tree.h > @@ -11,13 +11,15 @@ struct interval_tree_node { > }; > > extern void > -interval_tree_insert(struct interval_tree_node *node, struct rb_root *root); > +interval_tree_insert(struct interval_tree_node *node, > + struct rb_root_cached *root); > > extern void > -interval_tree_remove(struct interval_tree_node *node, struct rb_root *root); > +interval_tree_remove(struct interval_tree_node *node, > + struct rb_root_cached *root); > > extern struct interval_tree_node * > -interval_tree_iter_first(struct rb_root *root, > +interval_tree_iter_first(struct rb_root_cached *root, > unsigned long start, unsigned long last); > > extern struct interval_tree_node * > diff --git a/include/linux/interval_tree_generic.h b/include/linux/interval_tree_generic.h > index 58370e1862ad..f096423c8cbd 100644 > --- a/include/linux/interval_tree_generic.h > +++ b/include/linux/interval_tree_generic.h > @@ -65,11 +65,13 @@ RB_DECLARE_CALLBACKS(static, ITPREFIX ## _augment, ITSTRUCT, ITRB, \ > \ > /* Insert / remove interval nodes from the tree */ \ > \ > -ITSTATIC void ITPREFIX ## _insert(ITSTRUCT *node, struct rb_root *root) \ > +ITSTATIC void ITPREFIX ## _insert(ITSTRUCT *node, \ > + struct rb_root_cached *root) \ > { \ > - struct rb_node **link = &root->rb_node, *rb_parent = NULL; \ > + struct rb_node **link = &root->rb_root.rb_node, *rb_parent = NULL; \ > ITTYPE start = ITSTART(node), last = ITLAST(node); \ > ITSTRUCT *parent; \ > + bool leftmost = true; \ > \ > while (*link) { \ > rb_parent = *link; \ > @@ -78,18 +80,22 @@ ITSTATIC void ITPREFIX ## _insert(ITSTRUCT *node, struct rb_root *root) \ > parent->ITSUBTREE = last; \ > if (start < ITSTART(parent)) \ > link = &parent->ITRB.rb_left; \ > - else \ > + else { \ > link = &parent->ITRB.rb_right; \ > + leftmost = false; \ > + } \ > } \ > \ > node->ITSUBTREE = last; \ > rb_link_node(&node->ITRB, rb_parent, link); \ > - rb_insert_augmented(&node->ITRB, root, &ITPREFIX ## _augment); \ > + rb_insert_augmented_cached(&node->ITRB, root, \ > + leftmost, &ITPREFIX ## _augment); \ > } \ > \ > -ITSTATIC void ITPREFIX ## _remove(ITSTRUCT *node, struct rb_root *root) \ > +ITSTATIC void ITPREFIX ## _remove(ITSTRUCT *node, \ > + struct rb_root_cached *root) \ > { \ > - rb_erase_augmented(&node->ITRB, root, &ITPREFIX ## _augment); \ > + rb_erase_augmented_cached(&node->ITRB, root, &ITPREFIX ## _augment); \ > } \ > \ > /* \ > @@ -140,15 +146,35 @@ ITPREFIX ## _subtree_search(ITSTRUCT *node, ITTYPE start, ITTYPE last) \ > } \ > \ > ITSTATIC ITSTRUCT * \ > -ITPREFIX ## _iter_first(struct rb_root *root, ITTYPE start, ITTYPE last) \ > +ITPREFIX ## _iter_first(struct rb_root_cached *root, \ > + ITTYPE start, ITTYPE last) \ > { \ > - ITSTRUCT *node; \ > + ITSTRUCT *node, *leftmost; \ > \ > - if (!root->rb_node) \ > + if (!root->rb_root.rb_node) \ > return NULL; \ > - node = rb_entry(root->rb_node, ITSTRUCT, ITRB); \ > + \ > + /* \ > + * Fastpath range intersection/overlap between A: [a0, a1] and \ > + * B: [b0, b1] is given by: \ > + * \ > + * a0 <= b1 && b0 <= a1 \ > + * \ > + * ... where A holds the lock range and B holds the smallest \ > + * 'start' and largest 'last' in the tree. For the later, we \ > + * rely on the root node, which by augmented interval tree \ > + * property, holds the largest value in its last-in-subtree. \ > + * This allows mitigating some of the tree walk overhead for \ > + * for non-intersecting ranges, maintained and consulted in O(1). \ > + */ \ > + node = rb_entry(root->rb_root.rb_node, ITSTRUCT, ITRB); \ > if (node->ITSUBTREE < start) \ > return NULL; \ > + \ > + leftmost = rb_entry(root->rb_leftmost, ITSTRUCT, ITRB); \ > + if (ITSTART(leftmost) > last) \ > + return NULL; \ > + \ > return ITPREFIX ## _subtree_search(node, start, last); \ > } \ > \ > diff --git a/include/linux/mm.h b/include/linux/mm.h > index 46b9ac5e8569..3a2652efbbfb 100644 > --- a/include/linux/mm.h > +++ b/include/linux/mm.h > @@ -1992,13 +1992,13 @@ extern int nommu_shrink_inode_mappings(struct inode *, size_t, size_t); > > /* interval_tree.c */ > void vma_interval_tree_insert(struct vm_area_struct *node, > - struct rb_root *root); > + struct rb_root_cached *root); > void vma_interval_tree_insert_after(struct vm_area_struct *node, > struct vm_area_struct *prev, > - struct rb_root *root); > + struct rb_root_cached *root); > void vma_interval_tree_remove(struct vm_area_struct *node, > - struct rb_root *root); > -struct vm_area_struct *vma_interval_tree_iter_first(struct rb_root *root, > + struct rb_root_cached *root); > +struct vm_area_struct *vma_interval_tree_iter_first(struct rb_root_cached *root, > unsigned long start, unsigned long last); > struct vm_area_struct *vma_interval_tree_iter_next(struct vm_area_struct *node, > unsigned long start, unsigned long last); > @@ -2008,11 +2008,12 @@ struct vm_area_struct *vma_interval_tree_iter_next(struct vm_area_struct *node, > vma; vma = vma_interval_tree_iter_next(vma, start, last)) > > void anon_vma_interval_tree_insert(struct anon_vma_chain *node, > - struct rb_root *root); > + struct rb_root_cached *root); > void anon_vma_interval_tree_remove(struct anon_vma_chain *node, > - struct rb_root *root); > -struct anon_vma_chain *anon_vma_interval_tree_iter_first( > - struct rb_root *root, unsigned long start, unsigned long last); > + struct rb_root_cached *root); > +struct anon_vma_chain * > +anon_vma_interval_tree_iter_first(struct rb_root_cached *root, > + unsigned long start, unsigned long last); > struct anon_vma_chain *anon_vma_interval_tree_iter_next( > struct anon_vma_chain *node, unsigned long start, unsigned long last); > #ifdef CONFIG_DEBUG_VM_RB > diff --git a/include/linux/rmap.h b/include/linux/rmap.h > index 43ef2c30cb0f..22c298c6cc26 100644 > --- a/include/linux/rmap.h > +++ b/include/linux/rmap.h > @@ -55,7 +55,9 @@ struct anon_vma { > * is serialized by a system wide lock only visible to > * mm_take_all_locks() (mm_all_locks_mutex). > */ > - struct rb_root rb_root; /* Interval tree of private "related" vmas */ > + > + /* Interval tree of private "related" vmas */ > + struct rb_root_cached rb_root; > }; > > /* > diff --git a/include/rdma/ib_umem_odp.h b/include/rdma/ib_umem_odp.h > index fb67554aabd6..5eb7f5bc8248 100644 > --- a/include/rdma/ib_umem_odp.h > +++ b/include/rdma/ib_umem_odp.h > @@ -111,22 +111,25 @@ int ib_umem_odp_map_dma_pages(struct ib_umem *umem, u64 start_offset, u64 bcnt, > void ib_umem_odp_unmap_dma_pages(struct ib_umem *umem, u64 start_offset, > u64 bound); > > -void rbt_ib_umem_insert(struct umem_odp_node *node, struct rb_root *root); > -void rbt_ib_umem_remove(struct umem_odp_node *node, struct rb_root *root); > +void rbt_ib_umem_insert(struct umem_odp_node *node, > + struct rb_root_cached *root); > +void rbt_ib_umem_remove(struct umem_odp_node *node, > + struct rb_root_cached *root); > typedef int (*umem_call_back)(struct ib_umem *item, u64 start, u64 end, > void *cookie); > /* > * Call the callback on each ib_umem in the range. Returns the logical or of > * the return values of the functions called. > */ > -int rbt_ib_umem_for_each_in_range(struct rb_root *root, u64 start, u64 end, > +int rbt_ib_umem_for_each_in_range(struct rb_root_cached *root, > + u64 start, u64 end, > umem_call_back cb, void *cookie); > > /* > * Find first region intersecting with address range. > * Return NULL if not found > */ > -struct ib_umem_odp *rbt_ib_umem_lookup(struct rb_root *root, > +struct ib_umem_odp *rbt_ib_umem_lookup(struct rb_root_cached *root, > u64 addr, u64 length); > > static inline int ib_umem_mmu_notifier_retry(struct ib_umem *item, > diff --git a/include/rdma/ib_verbs.h b/include/rdma/ib_verbs.h > index 593ad2640d2f..81665480a4ab 100644 > --- a/include/rdma/ib_verbs.h > +++ b/include/rdma/ib_verbs.h > @@ -1420,7 +1420,7 @@ struct ib_ucontext { > > struct pid *tgid; > #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING > - struct rb_root umem_tree; > + struct rb_root_cached umem_tree; > /* > * Protects .umem_rbroot and tree, as well as odp_mrs_count and > * mmu notifiers registration. > diff --git a/lib/interval_tree_test.c b/lib/interval_tree_test.c > index df495fe81421..0e343fd29570 100644 > --- a/lib/interval_tree_test.c > +++ b/lib/interval_tree_test.c > @@ -19,14 +19,14 @@ __param(bool, search_all, false, "Searches will iterate all nodes in the tree"); > > __param(uint, max_endpoint, ~0, "Largest value for the interval's endpoint"); > > -static struct rb_root root = RB_ROOT; > +static struct rb_root_cached root = RB_ROOT_CACHED; > static struct interval_tree_node *nodes = NULL; > static u32 *queries = NULL; > > static struct rnd_state rnd; > > static inline unsigned long > -search(struct rb_root *root, unsigned long start, unsigned long last) > +search(struct rb_root_cached *root, unsigned long start, unsigned long last) > { > struct interval_tree_node *node; > unsigned long results = 0; > diff --git a/mm/interval_tree.c b/mm/interval_tree.c > index f2c2492681bf..b47664358796 100644 > --- a/mm/interval_tree.c > +++ b/mm/interval_tree.c > @@ -28,7 +28,7 @@ INTERVAL_TREE_DEFINE(struct vm_area_struct, shared.rb, > /* Insert node immediately after prev in the interval tree */ > void vma_interval_tree_insert_after(struct vm_area_struct *node, > struct vm_area_struct *prev, > - struct rb_root *root) > + struct rb_root_cached *root) > { > struct rb_node **link; > struct vm_area_struct *parent; > @@ -55,7 +55,7 @@ void vma_interval_tree_insert_after(struct vm_area_struct *node, > > node->shared.rb_subtree_last = last; > rb_link_node(&node->shared.rb, &parent->shared.rb, link); > - rb_insert_augmented(&node->shared.rb, root, > + rb_insert_augmented(&node->shared.rb, &root->rb_root, > &vma_interval_tree_augment); > } > > @@ -74,7 +74,7 @@ INTERVAL_TREE_DEFINE(struct anon_vma_chain, rb, unsigned long, rb_subtree_last, > static inline, __anon_vma_interval_tree) > > void anon_vma_interval_tree_insert(struct anon_vma_chain *node, > - struct rb_root *root) > + struct rb_root_cached *root) > { > #ifdef CONFIG_DEBUG_VM_RB > node->cached_vma_start = avc_start_pgoff(node); > @@ -84,13 +84,13 @@ void anon_vma_interval_tree_insert(struct anon_vma_chain *node, > } > > void anon_vma_interval_tree_remove(struct anon_vma_chain *node, > - struct rb_root *root) > + struct rb_root_cached *root) > { > __anon_vma_interval_tree_remove(node, root); > } > > struct anon_vma_chain * > -anon_vma_interval_tree_iter_first(struct rb_root *root, > +anon_vma_interval_tree_iter_first(struct rb_root_cached *root, > unsigned long first, unsigned long last) > { > return __anon_vma_interval_tree_iter_first(root, first, last); > diff --git a/mm/memory.c b/mm/memory.c > index 0e517be91a89..33cb79f73394 100644 > --- a/mm/memory.c > +++ b/mm/memory.c > @@ -2593,7 +2593,7 @@ static void unmap_mapping_range_vma(struct vm_area_struct *vma, > zap_page_range_single(vma, start_addr, end_addr - start_addr, details); > } > > -static inline void unmap_mapping_range_tree(struct rb_root *root, > +static inline void unmap_mapping_range_tree(struct rb_root_cached *root, > struct zap_details *details) > { > struct vm_area_struct *vma; > @@ -2657,7 +2657,7 @@ void unmap_mapping_range(struct address_space *mapping, > details.last_index = ULONG_MAX; > > i_mmap_lock_write(mapping); > - if (unlikely(!RB_EMPTY_ROOT(&mapping->i_mmap))) > + if (unlikely(!RB_EMPTY_ROOT(&mapping->i_mmap.rb_root))) > unmap_mapping_range_tree(&mapping->i_mmap, &details); > i_mmap_unlock_write(mapping); > } > diff --git a/mm/mmap.c b/mm/mmap.c > index f19efcf75418..8121c70df96f 100644 > --- a/mm/mmap.c > +++ b/mm/mmap.c > @@ -684,7 +684,7 @@ int __vma_adjust(struct vm_area_struct *vma, unsigned long start, > struct mm_struct *mm = vma->vm_mm; > struct vm_area_struct *next = vma->vm_next, *orig_vma = vma; > struct address_space *mapping = NULL; > - struct rb_root *root = NULL; > + struct rb_root_cached *root = NULL; > struct anon_vma *anon_vma = NULL; > struct file *file = vma->vm_file; > bool start_changed = false, end_changed = false; > @@ -3314,7 +3314,7 @@ static DEFINE_MUTEX(mm_all_locks_mutex); > > static void vm_lock_anon_vma(struct mm_struct *mm, struct anon_vma *anon_vma) > { > - if (!test_bit(0, (unsigned long *) &anon_vma->root->rb_root.rb_node)) { > + if (!test_bit(0, (unsigned long *) &anon_vma->rb_root.rb_root.rb_node)) { > /* > * The LSB of head.next can't change from under us > * because we hold the mm_all_locks_mutex. > @@ -3330,7 +3330,7 @@ static void vm_lock_anon_vma(struct mm_struct *mm, struct anon_vma *anon_vma) > * anon_vma->root->rwsem. > */ > if (__test_and_set_bit(0, (unsigned long *) > - &anon_vma->root->rb_root.rb_node)) > + &anon_vma->root->rb_root.rb_root.rb_node)) > BUG(); > } > } > @@ -3432,7 +3432,7 @@ int mm_take_all_locks(struct mm_struct *mm) > > static void vm_unlock_anon_vma(struct anon_vma *anon_vma) > { > - if (test_bit(0, (unsigned long *) &anon_vma->root->rb_root.rb_node)) { > + if (test_bit(0, (unsigned long *) &anon_vma->root->rb_root.rb_root.rb_node)) { > /* > * The LSB of head.next can't change to 0 from under > * us because we hold the mm_all_locks_mutex. > @@ -3446,7 +3446,7 @@ static void vm_unlock_anon_vma(struct anon_vma *anon_vma) > * anon_vma->root->rwsem. > */ > if (!__test_and_clear_bit(0, (unsigned long *) > - &anon_vma->root->rb_root.rb_node)) > + &anon_vma->root->rb_root.rb_root.rb_node)) > BUG(); > anon_vma_unlock_write(anon_vma); > } > diff --git a/mm/rmap.c b/mm/rmap.c > index ced14f1af6dc..ad479e5e081d 100644 > --- a/mm/rmap.c > +++ b/mm/rmap.c > @@ -390,7 +390,7 @@ void unlink_anon_vmas(struct vm_area_struct *vma) > * Leave empty anon_vmas on the list - we'll need > * to free them outside the lock. > */ > - if (RB_EMPTY_ROOT(&anon_vma->rb_root)) { > + if (RB_EMPTY_ROOT(&anon_vma->rb_root.rb_root)) { > anon_vma->parent->degree--; > continue; > } > @@ -424,7 +424,7 @@ static void anon_vma_ctor(void *data) > > init_rwsem(&anon_vma->rwsem); > atomic_set(&anon_vma->refcount, 0); > - anon_vma->rb_root = RB_ROOT; > + anon_vma->rb_root = RB_ROOT_CACHED; > } > > void __init anon_vma_init(void) > -- > 2.12.0