From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jerome Glisse Subject: Re: [PATCH hmm 15/15] mm/hmm: remove hmm_mirror and related Date: Mon, 21 Oct 2019 14:38:24 -0400 Message-ID: <20191021183824.GE3177@redhat.com> References: <20191015181242.8343-1-jgg@ziepe.ca> <20191015181242.8343-16-jgg@ziepe.ca> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20191015181242.8343-16-jgg-uk2M96/98Pc@public.gmane.org> Content-Disposition: inline List-Id: Discussion list for AMD gfx List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: Jason Gunthorpe Cc: Andrea Arcangeli , Ralph Campbell , linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, John Hubbard , Felix.Kuehling-5C7GfCeVMHo@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-mm-Bw31MaZKKs3YtjvyW6yDsg@public.gmane.org, Jason Gunthorpe , amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Ben Skeggs T24gVHVlLCBPY3QgMTUsIDIwMTkgYXQgMDM6MTI6NDJQTSAtMDMwMCwgSmFzb24gR3VudGhvcnBl IHdyb3RlOgo+IEZyb206IEphc29uIEd1bnRob3JwZSA8amdnQG1lbGxhbm94LmNvbT4KPiAKPiBU aGUgb25seSB0d28gdXNlcnMgb2YgdGhpcyBhcmUgbm93IGNvbnZlcnRlZCB0byB1c2UgbW11X3Jh bmdlX25vdGlmaWVyLAo+IGRlbGV0ZSBhbGwgdGhlIGNvZGUgYW5kIHVwZGF0ZSBobW0ucnN0LgoK SSBndWVzcyBpIHNob3VsZCBwb2ludCBvdXQgdGhhdCB0aGUgcmVhc29ucyBmb3IgaG1tX21pcnJv ciBhbmQgaG1tCndhcyBmb3I6CiAgICAxKSBNYXliZSBkZWZpbmUgYSBjb21tb24gQVBJIGZvciB1 c2Vyc3BhY2UgdG8gcHJvdmlkZSBtZW1vcnkKICAgICAgIHBsYWNlbWVudCBoaW50cyAoTlVNQSBm b3IgR1BVKQogICAgMikgbXVsdGktZGV2aWNlcyBzaGFyaW5nIHNhbWUgbWlycm9yIHBhZ2UgdGFi bGUKCkJ1dCBzdXBwb3J0IGZvciBtdWx0aS1HUFUgaW4gbm91dmVhdSBpcyB3YXkgYmVoaW5kIGFu ZCBpIGd1ZXNzIHN1Y2gKb3B0aW1pemF0aW9uIHdpbGwgaGF2ZSB0byByZS1tYXRlcmlhbGl6ZSB3 aGF0IGlzIG5lY2Vzc2FyeSBvbmNlIHRoYXQKaGFwcGVucy4KCk5vdGUgdGhpcyBwYXRjaCBzaG91 bGQgYWxzbyB1cGRhdGUga2VybmVsL2ZvcmsuYyBhbmQgdGhlIG1tX3N0cnVjdApkZWZpbml0aW9u IEFGQUlDVC4gV2l0aCB0aG9zZSBjaGFuZ2VzIHlvdSBjYW4gYWRkIG15OgoKUmV2aWV3ZWQtYnk6 IErDqXLDtG1lIEdsaXNzZSA8amdsaXNzZUByZWRoYXQuY29tPgoKPiAKPiBTaWduZWQtb2ZmLWJ5 OiBKYXNvbiBHdW50aG9ycGUgPGpnZ0BtZWxsYW5veC5jb20+Cj4gLS0tCj4gIERvY3VtZW50YXRp b24vdm0vaG1tLnJzdCB8IDEwNSArKysrLS0tLS0tLS0tLS0KPiAgaW5jbHVkZS9saW51eC9obW0u aCAgICAgIHwgMTgzICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiAgbW0vS2NvbmZpZyAgICAg ICAgICAgICAgIHwgICAxIC0KPiAgbW0vaG1tLmMgICAgICAgICAgICAgICAgIHwgMjg0ICstLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ICA0IGZpbGVzIGNoYW5nZWQsIDMz IGluc2VydGlvbnMoKyksIDU0MCBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvRG9jdW1l bnRhdGlvbi92bS9obW0ucnN0IGIvRG9jdW1lbnRhdGlvbi92bS9obW0ucnN0Cj4gaW5kZXggMGE1 OTYwYmVjY2Y3NmQuLmEyNDc2NDMwMzVjNGUyIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24v dm0vaG1tLnJzdAo+ICsrKyBiL0RvY3VtZW50YXRpb24vdm0vaG1tLnJzdAo+IEBAIC0xNDcsNDkg KzE0NywxNiBAQCBBZGRyZXNzIHNwYWNlIG1pcnJvcmluZyBpbXBsZW1lbnRhdGlvbiBhbmQgQVBJ Cj4gIEFkZHJlc3Mgc3BhY2UgbWlycm9yaW5nJ3MgbWFpbiBvYmplY3RpdmUgaXMgdG8gYWxsb3cg ZHVwbGljYXRpb24gb2YgYSByYW5nZSBvZgo+ICBDUFUgcGFnZSB0YWJsZSBpbnRvIGEgZGV2aWNl IHBhZ2UgdGFibGU7IEhNTSBoZWxwcyBrZWVwIGJvdGggc3luY2hyb25pemVkLiBBCj4gIGRldmlj ZSBkcml2ZXIgdGhhdCB3YW50cyB0byBtaXJyb3IgYSBwcm9jZXNzIGFkZHJlc3Mgc3BhY2UgbXVz dCBzdGFydCB3aXRoIHRoZQo+IC1yZWdpc3RyYXRpb24gb2YgYW4gaG1tX21pcnJvciBzdHJ1Y3Q6 Ogo+IC0KPiAtIGludCBobW1fbWlycm9yX3JlZ2lzdGVyKHN0cnVjdCBobW1fbWlycm9yICptaXJy b3IsCj4gLSAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSk7Cj4g LQo+IC1UaGUgbWlycm9yIHN0cnVjdCBoYXMgYSBzZXQgb2YgY2FsbGJhY2tzIHRoYXQgYXJlIHVz ZWQKPiAtdG8gcHJvcGFnYXRlIENQVSBwYWdlIHRhYmxlczo6Cj4gLQo+IC0gc3RydWN0IGhtbV9t aXJyb3Jfb3BzIHsKPiAtICAgICAvKiByZWxlYXNlKCkgLSByZWxlYXNlIGhtbV9taXJyb3IKPiAt ICAgICAgKgo+IC0gICAgICAqIEBtaXJyb3I6IHBvaW50ZXIgdG8gc3RydWN0IGhtbV9taXJyb3IK PiAtICAgICAgKgo+IC0gICAgICAqIFRoaXMgaXMgY2FsbGVkIHdoZW4gdGhlIG1tX3N0cnVjdCBp cyBiZWluZyByZWxlYXNlZC4gIFRoZSBjYWxsYmFjawo+IC0gICAgICAqIG11c3QgZW5zdXJlIHRo YXQgYWxsIGFjY2VzcyB0byBhbnkgcGFnZXMgb2J0YWluZWQgZnJvbSB0aGlzIG1pcnJvcgo+IC0g ICAgICAqIGlzIGhhbHRlZCBiZWZvcmUgdGhlIGNhbGxiYWNrIHJldHVybnMuIEFsbCBmdXR1cmUg YWNjZXNzIHNob3VsZAo+IC0gICAgICAqIGZhdWx0Lgo+IC0gICAgICAqLwo+IC0gICAgIHZvaWQg KCpyZWxlYXNlKShzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yKTsKPiAtCj4gLSAgICAgLyogc3lu Y19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMoKSAtIHN5bmNocm9uaXplIHBhZ2UgdGFibGVzCj4gLSAg ICAgICoKPiAtICAgICAgKiBAbWlycm9yOiBwb2ludGVyIHRvIHN0cnVjdCBobW1fbWlycm9yCj4g LSAgICAgICogQHVwZGF0ZTogdXBkYXRlIGluZm9ybWF0aW9uIChzZWUgc3RydWN0IG1tdV9ub3Rp Zmllcl9yYW5nZSkKPiAtICAgICAgKiBSZXR1cm46IC1FQUdBSU4gaWYgdXBkYXRlLmJsb2NrYWJs ZSBmYWxzZSBhbmQgY2FsbGJhY2sgbmVlZCB0bwo+IC0gICAgICAqICAgICAgICAgYmxvY2ssIDAg b3RoZXJ3aXNlLgo+IC0gICAgICAqCj4gLSAgICAgICogVGhpcyBjYWxsYmFjayB1bHRpbWF0ZWx5 IG9yaWdpbmF0ZXMgZnJvbSBtbXVfbm90aWZpZXJzIHdoZW4gdGhlIENQVQo+IC0gICAgICAqIHBh Z2UgdGFibGUgaXMgdXBkYXRlZC4gVGhlIGRldmljZSBkcml2ZXIgbXVzdCB1cGRhdGUgaXRzIHBh Z2UgdGFibGUKPiAtICAgICAgKiBpbiByZXNwb25zZSB0byB0aGlzIGNhbGxiYWNrLiBUaGUgdXBk YXRlIGFyZ3VtZW50IHRlbGxzIHdoYXQgYWN0aW9uCj4gLSAgICAgICogdG8gcGVyZm9ybS4KPiAt ICAgICAgKgo+IC0gICAgICAqIFRoZSBkZXZpY2UgZHJpdmVyIG11c3Qgbm90IHJldHVybiBmcm9t IHRoaXMgY2FsbGJhY2sgdW50aWwgdGhlIGRldmljZQo+IC0gICAgICAqIHBhZ2UgdGFibGVzIGFy ZSBjb21wbGV0ZWx5IHVwZGF0ZWQgKFRMQnMgZmx1c2hlZCwgZXRjKTsgdGhpcyBpcyBhCj4gLSAg ICAgICogc3luY2hyb25vdXMgY2FsbC4KPiAtICAgICAgKi8KPiAtICAgICBpbnQgKCpzeW5jX2Nw dV9kZXZpY2VfcGFnZXRhYmxlcykoc3RydWN0IGhtbV9taXJyb3IgKm1pcnJvciwKPiAtICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3Qgc3RydWN0IGhtbV91cGRhdGUg KnVwZGF0ZSk7Cj4gLSB9Owo+IC0KPiAtVGhlIGRldmljZSBkcml2ZXIgbXVzdCBwZXJmb3JtIHRo ZSB1cGRhdGUgYWN0aW9uIHRvIHRoZSByYW5nZSAobWFyayByYW5nZQo+IC1yZWFkIG9ubHksIG9y IGZ1bGx5IHVubWFwLCBldGMuKS4gVGhlIGRldmljZSBtdXN0IGNvbXBsZXRlIHRoZSB1cGRhdGUg YmVmb3JlCj4gLXRoZSBkcml2ZXIgY2FsbGJhY2sgcmV0dXJucy4KPiArcmVnaXN0cmF0aW9uIG9m IGEgbW11X3JhbmdlX25vdGlmaWVyOjoKPiArCj4gKyBtcm4tPm9wcyA9ICZkcml2ZXJfb3BzOwo+ ICsgaW50IG1tdV9yYW5nZV9ub3RpZmllcl9pbnNlcnQoc3RydWN0IG1tdV9yYW5nZV9ub3RpZmll ciAqbXJuLAo+ICsJCQkgICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGxl bmd0aCwKPiArCQkJICAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0pOwo+ICsKPiArRHVyaW5nIHRo ZSBkcml2ZXJfb3BzLT5pbnZhbGlkYXRlKCkgY2FsbGJhY2sgdGhlIGRldmljZSBkcml2ZXIgbXVz dCBwZXJmb3JtCj4gK3RoZSB1cGRhdGUgYWN0aW9uIHRvIHRoZSByYW5nZSAobWFyayByYW5nZSBy ZWFkIG9ubHksIG9yIGZ1bGx5IHVubWFwLAo+ICtldGMuKS4gVGhlIGRldmljZSBtdXN0IGNvbXBs ZXRlIHRoZSB1cGRhdGUgYmVmb3JlIHRoZSBkcml2ZXIgY2FsbGJhY2sgcmV0dXJucy4KPiAgCj4g IFdoZW4gdGhlIGRldmljZSBkcml2ZXIgd2FudHMgdG8gcG9wdWxhdGUgYSByYW5nZSBvZiB2aXJ0 dWFsIGFkZHJlc3NlcywgaXQgY2FuCj4gIHVzZTo6Cj4gQEAgLTIxNiw3MCArMTgzLDQ2IEBAIFRo ZSB1c2FnZSBwYXR0ZXJuIGlzOjoKPiAgICAgICAgc3RydWN0IGhtbV9yYW5nZSByYW5nZTsKPiAg ICAgICAgLi4uCj4gIAo+ICsgICAgICByYW5nZS5ub3RpZmllciA9ICZtcm47Cj4gICAgICAgIHJh bmdlLnN0YXJ0ID0gLi4uOwo+ICAgICAgICByYW5nZS5lbmQgPSAuLi47Cj4gICAgICAgIHJhbmdl LnBmbnMgPSAuLi47Cj4gICAgICAgIHJhbmdlLmZsYWdzID0gLi4uOwo+ICAgICAgICByYW5nZS52 YWx1ZXMgPSAuLi47Cj4gICAgICAgIHJhbmdlLnBmbl9zaGlmdCA9IC4uLjsKPiAtICAgICAgaG1t X3JhbmdlX3JlZ2lzdGVyKCZyYW5nZSwgbWlycm9yKTsKPiAgCj4gLSAgICAgIC8qCj4gLSAgICAg ICAqIEp1c3Qgd2FpdCBmb3IgcmFuZ2UgdG8gYmUgdmFsaWQsIHNhZmUgdG8gaWdub3JlIHJldHVy biB2YWx1ZSBhcyB3ZQo+IC0gICAgICAgKiB3aWxsIHVzZSB0aGUgcmV0dXJuIHZhbHVlIG9mIGht bV9yYW5nZV9mYXVsdCgpIGJlbG93IHVuZGVyIHRoZQo+IC0gICAgICAgKiBtbWFwX3NlbSB0byBh c2NlcnRhaW4gdGhlIHZhbGlkaXR5IG9mIHRoZSByYW5nZS4KPiAtICAgICAgICovCj4gLSAgICAg IGhtbV9yYW5nZV93YWl0X3VudGlsX3ZhbGlkKCZyYW5nZSwgVElNRU9VVF9JTl9NU0VDKTsKPiAr ICAgICAgaWYgKCFtbWdldF9ub3RfemVybyhtcm4tPm5vdGlmaWVyLm1tKSkKPiArICAgICAgICAg IHJldHVybiAtRUZBVUxUOwo+ICAKPiAgIGFnYWluOgo+ICsgICAgICByYW5nZS5ub3RpZmllcl9z ZXEgPSBtbXVfcmFuZ2VfcmVhZF9iZWdpbigmbXJuKTsKPiAgICAgICAgZG93bl9yZWFkKCZtbS0+ bW1hcF9zZW0pOwo+ICAgICAgICByZXQgPSBobW1fcmFuZ2VfZmF1bHQoJnJhbmdlLCBITU1fUkFO R0VfU05BUFNIT1QpOwo+ICAgICAgICBpZiAocmV0KSB7Cj4gICAgICAgICAgICB1cF9yZWFkKCZt bS0+bW1hcF9zZW0pOwo+IC0gICAgICAgICAgaWYgKHJldCA9PSAtRUJVU1kpIHsKPiAtICAgICAg ICAgICAgLyoKPiAtICAgICAgICAgICAgICogTm8gbmVlZCB0byBjaGVjayBobW1fcmFuZ2Vfd2Fp dF91bnRpbF92YWxpZCgpIHJldHVybiB2YWx1ZQo+IC0gICAgICAgICAgICAgKiBvbiByZXRyeSB3 ZSB3aWxsIGdldCBwcm9wZXIgZXJyb3Igd2l0aCBobW1fcmFuZ2VfZmF1bHQoKQo+IC0gICAgICAg ICAgICAgKi8KPiAtICAgICAgICAgICAgaG1tX3JhbmdlX3dhaXRfdW50aWxfdmFsaWQoJnJhbmdl LCBUSU1FT1VUX0lOX01TRUMpOwo+IC0gICAgICAgICAgICBnb3RvIGFnYWluOwo+IC0gICAgICAg ICAgfQo+IC0gICAgICAgICAgaG1tX3JhbmdlX3VucmVnaXN0ZXIoJnJhbmdlKTsKPiArICAgICAg ICAgIGlmIChyZXQgPT0gLUVCVVNZKQo+ICsgICAgICAgICAgICAgICAgIGdvdG8gYWdhaW47Cj4g ICAgICAgICAgICByZXR1cm4gcmV0Owo+ICAgICAgICB9Cj4gKyAgICAgIHVwX3JlYWQoJm1tLT5t bWFwX3NlbSk7Cj4gKwo+ICAgICAgICB0YWtlX2xvY2soZHJpdmVyLT51cGRhdGUpOwo+IC0gICAg ICBpZiAoIWhtbV9yYW5nZV92YWxpZCgmcmFuZ2UpKSB7Cj4gKyAgICAgIGlmIChtbXVfcmFuZ2Vf cmVhZF9yZXRyeSgmbXJuLCByYW5nZS5ub3RpZmllcl9zZXEpIHsKPiAgICAgICAgICAgIHJlbGVh c2VfbG9jayhkcml2ZXItPnVwZGF0ZSk7Cj4gLSAgICAgICAgICB1cF9yZWFkKCZtbS0+bW1hcF9z ZW0pOwo+ICAgICAgICAgICAgZ290byBhZ2FpbjsKPiAgICAgICAgfQo+ICAKPiAtICAgICAgLy8g VXNlIHBmbnMgYXJyYXkgY29udGVudCB0byB1cGRhdGUgZGV2aWNlIHBhZ2UgdGFibGUKPiArICAg ICAgLyogVXNlIHBmbnMgYXJyYXkgY29udGVudCB0byB1cGRhdGUgZGV2aWNlIHBhZ2UgdGFibGUs Cj4gKyAgICAgICAqIHVuZGVyIHRoZSB1cGRhdGUgbG9jayAqLwo+ICAKPiAtICAgICAgaG1tX3Jh bmdlX3VucmVnaXN0ZXIoJnJhbmdlKTsKPiAgICAgICAgcmVsZWFzZV9sb2NrKGRyaXZlci0+dXBk YXRlKTsKPiAtICAgICAgdXBfcmVhZCgmbW0tPm1tYXBfc2VtKTsKPiAgICAgICAgcmV0dXJuIDA7 Cj4gICB9Cj4gIAo+ICBUaGUgZHJpdmVyLT51cGRhdGUgbG9jayBpcyB0aGUgc2FtZSBsb2NrIHRo YXQgdGhlIGRyaXZlciB0YWtlcyBpbnNpZGUgaXRzCj4gLXN5bmNfY3B1X2RldmljZV9wYWdldGFi bGVzKCkgY2FsbGJhY2suIFRoYXQgbG9jayBtdXN0IGJlIGhlbGQgYmVmb3JlIGNhbGxpbmcKPiAt aG1tX3JhbmdlX3ZhbGlkKCkgdG8gYXZvaWQgYW55IHJhY2Ugd2l0aCBhIGNvbmN1cnJlbnQgQ1BV IHBhZ2UgdGFibGUgdXBkYXRlLgo+IC0KPiAtSE1NIGltcGxlbWVudHMgYWxsIHRoaXMgb24gdG9w IG9mIHRoZSBtbXVfbm90aWZpZXIgQVBJIGJlY2F1c2Ugd2Ugd2FudGVkIGEKPiAtc2ltcGxlciBB UEkgYW5kIGFsc28gdG8gYmUgYWJsZSB0byBwZXJmb3JtIG9wdGltaXphdGlvbnMgbGF0dGVyIG9u IGxpa2UgZG9pbmcKPiAtY29uY3VycmVudCBkZXZpY2UgdXBkYXRlcyBpbiBtdWx0aS1kZXZpY2Vz IHNjZW5hcmlvLgo+IC0KPiAtSE1NIGFsc28gc2VydmVzIGFzIGFuIGltcGVkYW5jZSBtaXNtYXRj aCBiZXR3ZWVuIGhvdyBDUFUgcGFnZSB0YWJsZSB1cGRhdGVzCj4gLWFyZSBkb25lIChieSBDUFUg d3JpdGUgdG8gdGhlIHBhZ2UgdGFibGUgYW5kIFRMQiBmbHVzaGVzKSBhbmQgaG93IGRldmljZXMK PiAtdXBkYXRlIHRoZWlyIG93biBwYWdlIHRhYmxlLiBEZXZpY2UgdXBkYXRlcyBhcmUgYSBtdWx0 aS1zdGVwIHByb2Nlc3MuIEZpcnN0LAo+IC1hcHByb3ByaWF0ZSBjb21tYW5kcyBhcmUgd3JpdHRl biB0byBhIGJ1ZmZlciwgdGhlbiB0aGlzIGJ1ZmZlciBpcyBzY2hlZHVsZWQgZm9yCj4gLWV4ZWN1 dGlvbiBvbiB0aGUgZGV2aWNlLiBJdCBpcyBvbmx5IG9uY2UgdGhlIGRldmljZSBoYXMgZXhlY3V0 ZWQgY29tbWFuZHMgaW4KPiAtdGhlIGJ1ZmZlciB0aGF0IHRoZSB1cGRhdGUgaXMgZG9uZS4gQ3Jl YXRpbmcgYW5kIHNjaGVkdWxpbmcgdGhlIHVwZGF0ZSBjb21tYW5kCj4gLWJ1ZmZlciBjYW4gaGFw cGVuIGNvbmN1cnJlbnRseSBmb3IgbXVsdGlwbGUgZGV2aWNlcy4gV2FpdGluZyBmb3IgZWFjaCBk ZXZpY2UgdG8KPiAtcmVwb3J0IGNvbW1hbmRzIGFzIGV4ZWN1dGVkIGlzIHNlcmlhbGl6ZWQgKHRo ZXJlIGlzIG5vIHBvaW50IGluIGRvaW5nIHRoaXMKPiAtY29uY3VycmVudGx5KS4KPiAtCj4gK2lu dmFsaWRhdGUoKSBjYWxsYmFjay4gVGhhdCBsb2NrIG11c3QgYmUgaGVsZCBiZWZvcmUgY2FsbGlu Zwo+ICttbXVfcmFuZ2VfcmVhZF9yZXRyeSgpIHRvIGF2b2lkIGFueSByYWNlIHdpdGggYSBjb25j dXJyZW50IENQVSBwYWdlIHRhYmxlCj4gK3VwZGF0ZS4KPiAgCj4gIExldmVyYWdlIGRlZmF1bHRf ZmxhZ3MgYW5kIHBmbl9mbGFnc19tYXNrCj4gID09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaG1tLmggYi9pbmNsdWRl L2xpbnV4L2htbS5oCj4gaW5kZXggMjY2NmViMDhhNDA2MTUuLmI0YWY1MTczNTIzMjMyIDEwMDY0 NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvaG1tLmgKPiArKysgYi9pbmNsdWRlL2xpbnV4L2htbS5o Cj4gQEAgLTY4LDI5ICs2OCw2IEBACj4gICNpbmNsdWRlIDxsaW51eC9jb21wbGV0aW9uLmg+Cj4g ICNpbmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KPiAgCj4gLQo+IC0vKgo+IC0gKiBzdHJ1 Y3QgaG1tIC0gSE1NIHBlciBtbSBzdHJ1Y3QKPiAtICoKPiAtICogQG1tOiBtbSBzdHJ1Y3QgdGhp cyBITU0gc3RydWN0IGlzIGJvdW5kIHRvCj4gLSAqIEBsb2NrOiBsb2NrIHByb3RlY3RpbmcgcmFu Z2VzIGxpc3QKPiAtICogQHJhbmdlczogbGlzdCBvZiByYW5nZSBiZWluZyBzbmFwc2hvdHRlZAo+ IC0gKiBAbWlycm9yczogbGlzdCBvZiBtaXJyb3JzIGZvciB0aGlzIG1tCj4gLSAqIEBtbXVfbm90 aWZpZXI6IG1tdSBub3RpZmllciB0byB0cmFjayB1cGRhdGVzIHRvIENQVSBwYWdlIHRhYmxlCj4g LSAqIEBtaXJyb3JzX3NlbTogcmVhZC93cml0ZSBzZW1hcGhvcmUgcHJvdGVjdGluZyB0aGUgbWly cm9ycyBsaXN0Cj4gLSAqIEB3cTogd2FpdCBxdWV1ZSBmb3IgdXNlciB3YWl0aW5nIG9uIGEgcmFu Z2UgaW52YWxpZGF0aW9uCj4gLSAqIEBub3RpZmllcnM6IGNvdW50IG9mIGFjdGl2ZSBtbXUgbm90 aWZpZXJzCj4gLSAqLwo+IC1zdHJ1Y3QgaG1tIHsKPiAtCXN0cnVjdCBtbXVfbm90aWZpZXIJbW11 X25vdGlmaWVyOwo+IC0Jc3BpbmxvY2tfdAkJcmFuZ2VzX2xvY2s7Cj4gLQlzdHJ1Y3QgbGlzdF9o ZWFkCXJhbmdlczsKPiAtCXN0cnVjdCBsaXN0X2hlYWQJbWlycm9yczsKPiAtCXN0cnVjdCByd19z ZW1hcGhvcmUJbWlycm9yc19zZW07Cj4gLQl3YWl0X3F1ZXVlX2hlYWRfdAl3cTsKPiAtCWxvbmcJ CQlub3RpZmllcnM7Cj4gLX07Cj4gLQo+ICAvKgo+ICAgKiBobW1fcGZuX2ZsYWdfZSAtIEhNTSBm bGFnIGVudW1zCj4gICAqCj4gQEAgLTE0Myw5ICsxMjAsOCBAQCBlbnVtIGhtbV9wZm5fdmFsdWVf ZSB7Cj4gIC8qCj4gICAqIHN0cnVjdCBobW1fcmFuZ2UgLSB0cmFjayBpbnZhbGlkYXRpb24gbG9j ayBvbiB2aXJ0dWFsIGFkZHJlc3MgcmFuZ2UKPiAgICoKPiAtICogQG5vdGlmaWVyOiBhbiBvcHRp b25hbCBtbXVfcmFuZ2Vfbm90aWZpZXIKPiAtICogQG5vdGlmaWVyX3NlcTogd2hlbiBub3RpZmll ciBpcyB1c2VkIHRoaXMgaXMgdGhlIHJlc3VsdCBvZgo+IC0gKiAgICAgICAgICAgICAgICBtbXVf cmFuZ2VfcmVhZF9iZWdpbigpCj4gKyAqIEBub3RpZmllcjogYSBtbXVfcmFuZ2Vfbm90aWZpZXIg dGhhdCBpbmNsdWRlcyB0aGUgc3RhcnQvZW5kCj4gKyAqIEBub3RpZmllcl9zZXE6IHJlc3VsdCBv ZiBtbXVfcmFuZ2VfcmVhZF9iZWdpbigpCj4gICAqIEBobW06IHRoZSBjb3JlIEhNTSBzdHJ1Y3R1 cmUgdGhpcyByYW5nZSBpcyBhY3RpdmUgYWdhaW5zdAo+ICAgKiBAdm1hOiB0aGUgdm0gYXJlYSBz dHJ1Y3QgZm9yIHRoZSByYW5nZQo+ICAgKiBAbGlzdDogYWxsIHJhbmdlIGxvY2sgYXJlIG9uIGEg bGlzdAo+IEBAIC0xNjIsOCArMTM4LDYgQEAgZW51bSBobW1fcGZuX3ZhbHVlX2Ugewo+ICBzdHJ1 Y3QgaG1tX3JhbmdlIHsKPiAgCXN0cnVjdCBtbXVfcmFuZ2Vfbm90aWZpZXIgKm5vdGlmaWVyOwo+ ICAJdW5zaWduZWQgbG9uZwkJbm90aWZpZXJfc2VxOwo+IC0Jc3RydWN0IGhtbQkJKmhtbTsKPiAt CXN0cnVjdCBsaXN0X2hlYWQJbGlzdDsKPiAgCXVuc2lnbmVkIGxvbmcJCXN0YXJ0Owo+ICAJdW5z aWduZWQgbG9uZwkJZW5kOwo+ICAJdWludDY0X3QJCSpwZm5zOwo+IEBAIC0xNzIsMzIgKzE0Niw4 IEBAIHN0cnVjdCBobW1fcmFuZ2Ugewo+ICAJdWludDY0X3QJCWRlZmF1bHRfZmxhZ3M7Cj4gIAl1 aW50NjRfdAkJcGZuX2ZsYWdzX21hc2s7Cj4gIAl1aW50OF90CQkJcGZuX3NoaWZ0Owo+IC0JYm9v bAkJCXZhbGlkOwo+ICB9Owo+ICAKPiAtLyoKPiAtICogaG1tX3JhbmdlX3dhaXRfdW50aWxfdmFs aWQoKSAtIHdhaXQgZm9yIHJhbmdlIHRvIGJlIHZhbGlkCj4gLSAqIEByYW5nZTogcmFuZ2UgYWZm ZWN0ZWQgYnkgaW52YWxpZGF0aW9uIHRvIHdhaXQgb24KPiAtICogQHRpbWVvdXQ6IHRpbWUgb3V0 IGZvciB3YWl0IGluIG1zIChpZSBhYm9ydCB3YWl0IGFmdGVyIHRoYXQgcGVyaW9kIG9mIHRpbWUp Cj4gLSAqIFJldHVybjogdHJ1ZSBpZiB0aGUgcmFuZ2UgaXMgdmFsaWQsIGZhbHNlIG90aGVyd2lz ZS4KPiAtICovCj4gLXN0YXRpYyBpbmxpbmUgYm9vbCBobW1fcmFuZ2Vfd2FpdF91bnRpbF92YWxp ZChzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSwKPiAtCQkJCQkgICAgICB1bnNpZ25lZCBsb25nIHRp bWVvdXQpCj4gLXsKPiAtCXJldHVybiB3YWl0X2V2ZW50X3RpbWVvdXQocmFuZ2UtPmhtbS0+d3Es IHJhbmdlLT52YWxpZCwKPiAtCQkJCSAgbXNlY3NfdG9famlmZmllcyh0aW1lb3V0KSkgIT0gMDsK PiAtfQo+IC0KPiAtLyoKPiAtICogaG1tX3JhbmdlX3ZhbGlkKCkgLSB0ZXN0IGlmIGEgcmFuZ2Ug aXMgdmFsaWQgb3Igbm90Cj4gLSAqIEByYW5nZTogcmFuZ2UKPiAtICogUmV0dXJuOiB0cnVlIGlm IHRoZSByYW5nZSBpcyB2YWxpZCwgZmFsc2Ugb3RoZXJ3aXNlLgo+IC0gKi8KPiAtc3RhdGljIGlu bGluZSBib29sIGhtbV9yYW5nZV92YWxpZChzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSkKPiAtewo+ IC0JcmV0dXJuIHJhbmdlLT52YWxpZDsKPiAtfQo+IC0KPiAgLyoKPiAgICogaG1tX2RldmljZV9l bnRyeV90b19wYWdlKCkgLSByZXR1cm4gc3RydWN0IHBhZ2UgcG9pbnRlZCB0byBieSBhIGRldmlj ZSBlbnRyeQo+ICAgKiBAcmFuZ2U6IHJhbmdlIHVzZSB0byBkZWNvZGUgZGV2aWNlIGVudHJ5IHZh bHVlCj4gQEAgLTI2NywxMTEgKzIxNyw2IEBAIHN0YXRpYyBpbmxpbmUgdWludDY0X3QgaG1tX2Rl dmljZV9lbnRyeV9mcm9tX3Bmbihjb25zdCBzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSwKPiAgCQly YW5nZS0+ZmxhZ3NbSE1NX1BGTl9WQUxJRF07Cj4gIH0KPiAgCj4gLS8qCj4gLSAqIE1pcnJvcmlu ZzogaG93IHRvIHN5bmNocm9uaXplIGRldmljZSBwYWdlIHRhYmxlIHdpdGggQ1BVIHBhZ2UgdGFi bGUuCj4gLSAqCj4gLSAqIEEgZGV2aWNlIGRyaXZlciB0aGF0IGlzIHBhcnRpY2lwYXRpbmcgaW4g SE1NIG1pcnJvcmluZyBtdXN0IGFsd2F5cwo+IC0gKiBzeW5jaHJvbml6ZSB3aXRoIENQVSBwYWdl IHRhYmxlIHVwZGF0ZXMuIEZvciB0aGlzLCBkZXZpY2UgZHJpdmVycyBjYW4gZWl0aGVyCj4gLSAq IGRpcmVjdGx5IHVzZSBtbXVfbm90aWZpZXIgQVBJcyBvciB0aGV5IGNhbiB1c2UgdGhlIGhtbV9t aXJyb3IgQVBJLiBEZXZpY2UKPiAtICogZHJpdmVycyBjYW4gZGVjaWRlIHRvIHJlZ2lzdGVyIG9u ZSBtaXJyb3IgcGVyIGRldmljZSBwZXIgcHJvY2Vzcywgb3IganVzdAo+IC0gKiBvbmUgbWlycm9y IHBlciBwcm9jZXNzIGZvciBhIGdyb3VwIG9mIGRldmljZXMuIFRoZSBwYXR0ZXJuIGlzOgo+IC0g Kgo+IC0gKiAgICAgIGludCBkZXZpY2VfYmluZF9hZGRyZXNzX3NwYWNlKC4uLiwgc3RydWN0IG1t X3N0cnVjdCAqbW0sIC4uLikKPiAtICogICAgICB7Cj4gLSAqICAgICAgICAgIHN0cnVjdCBkZXZp Y2VfYWRkcmVzc19zcGFjZSAqZGFzOwo+IC0gKgo+IC0gKiAgICAgICAgICAvLyBEZXZpY2UgZHJp dmVyIHNwZWNpZmljIGluaXRpYWxpemF0aW9uLCBhbmQgYWxsb2NhdGlvbiBvZiBkYXMKPiAtICog ICAgICAgICAgLy8gd2hpY2ggY29udGFpbnMgYW4gaG1tX21pcnJvciBzdHJ1Y3QgYXMgb25lIG9m IGl0cyBmaWVsZHMuCj4gLSAqICAgICAgICAgIC4uLgo+IC0gKgo+IC0gKiAgICAgICAgICByZXQg PSBobW1fbWlycm9yX3JlZ2lzdGVyKCZkYXMtPm1pcnJvciwgbW0sICZkZXZpY2VfbWlycm9yX29w cyk7Cj4gLSAqICAgICAgICAgIGlmIChyZXQpIHsKPiAtICogICAgICAgICAgICAgIC8vIENsZWFu dXAgb24gZXJyb3IKPiAtICogICAgICAgICAgICAgIHJldHVybiByZXQ7Cj4gLSAqICAgICAgICAg IH0KPiAtICoKPiAtICogICAgICAgICAgLy8gT3RoZXIgZGV2aWNlIGRyaXZlciBzcGVjaWZpYyBp bml0aWFsaXphdGlvbgo+IC0gKiAgICAgICAgICAuLi4KPiAtICogICAgICB9Cj4gLSAqCj4gLSAq IE9uY2UgYW4gaG1tX21pcnJvciBpcyByZWdpc3RlcmVkIGZvciBhbiBhZGRyZXNzIHNwYWNlLCB0 aGUgZGV2aWNlIGRyaXZlcgo+IC0gKiB3aWxsIGdldCBjYWxsYmFja3MgdGhyb3VnaCBzeW5jX2Nw dV9kZXZpY2VfcGFnZXRhYmxlcygpIG9wZXJhdGlvbiAoc2VlCj4gLSAqIGhtbV9taXJyb3Jfb3Bz IHN0cnVjdCkuCj4gLSAqCj4gLSAqIERldmljZSBkcml2ZXIgbXVzdCBub3QgZnJlZSB0aGUgc3Ry dWN0IGNvbnRhaW5pbmcgdGhlIGhtbV9taXJyb3Igc3RydWN0Cj4gLSAqIGJlZm9yZSBjYWxsaW5n IGhtbV9taXJyb3JfdW5yZWdpc3RlcigpLiBUaGUgZXhwZWN0ZWQgdXNhZ2UgaXMgdG8gZG8gdGhh dCB3aGVuCj4gLSAqIHRoZSBkZXZpY2UgZHJpdmVyIGlzIHVuYmluZGluZyBmcm9tIGFuIGFkZHJl c3Mgc3BhY2UuCj4gLSAqCj4gLSAqCj4gLSAqICAgICAgdm9pZCBkZXZpY2VfdW5iaW5kX2FkZHJl c3Nfc3BhY2Uoc3RydWN0IGRldmljZV9hZGRyZXNzX3NwYWNlICpkYXMpCj4gLSAqICAgICAgewo+ IC0gKiAgICAgICAgICAvLyBEZXZpY2UgZHJpdmVyIHNwZWNpZmljIGNsZWFudXAKPiAtICogICAg ICAgICAgLi4uCj4gLSAqCj4gLSAqICAgICAgICAgIGhtbV9taXJyb3JfdW5yZWdpc3RlcigmZGFz LT5taXJyb3IpOwo+IC0gKgo+IC0gKiAgICAgICAgICAvLyBPdGhlciBkZXZpY2UgZHJpdmVyIHNw ZWNpZmljIGNsZWFudXAsIGFuZCBub3cgZGFzIGNhbiBiZSBmcmVlZAo+IC0gKiAgICAgICAgICAu Li4KPiAtICogICAgICB9Cj4gLSAqLwo+IC0KPiAtc3RydWN0IGhtbV9taXJyb3I7Cj4gLQo+IC0v Kgo+IC0gKiBzdHJ1Y3QgaG1tX21pcnJvcl9vcHMgLSBITU0gbWlycm9yIGRldmljZSBvcGVyYXRp b25zIGNhbGxiYWNrCj4gLSAqCj4gLSAqIEB1cGRhdGU6IGNhbGxiYWNrIHRvIHVwZGF0ZSByYW5n ZSBvbiBhIGRldmljZQo+IC0gKi8KPiAtc3RydWN0IGhtbV9taXJyb3Jfb3BzIHsKPiAtCS8qIHJl bGVhc2UoKSAtIHJlbGVhc2UgaG1tX21pcnJvcgo+IC0JICoKPiAtCSAqIEBtaXJyb3I6IHBvaW50 ZXIgdG8gc3RydWN0IGhtbV9taXJyb3IKPiAtCSAqCj4gLQkgKiBUaGlzIGlzIGNhbGxlZCB3aGVu IHRoZSBtbV9zdHJ1Y3QgaXMgYmVpbmcgcmVsZWFzZWQuICBUaGUgY2FsbGJhY2sKPiAtCSAqIG11 c3QgZW5zdXJlIHRoYXQgYWxsIGFjY2VzcyB0byBhbnkgcGFnZXMgb2J0YWluZWQgZnJvbSB0aGlz IG1pcnJvcgo+IC0JICogaXMgaGFsdGVkIGJlZm9yZSB0aGUgY2FsbGJhY2sgcmV0dXJucy4gQWxs IGZ1dHVyZSBhY2Nlc3Mgc2hvdWxkCj4gLQkgKiBmYXVsdC4KPiAtCSAqLwo+IC0Jdm9pZCAoKnJl bGVhc2UpKHN0cnVjdCBobW1fbWlycm9yICptaXJyb3IpOwo+IC0KPiAtCS8qIHN5bmNfY3B1X2Rl dmljZV9wYWdldGFibGVzKCkgLSBzeW5jaHJvbml6ZSBwYWdlIHRhYmxlcwo+IC0JICoKPiAtCSAq IEBtaXJyb3I6IHBvaW50ZXIgdG8gc3RydWN0IGhtbV9taXJyb3IKPiAtCSAqIEB1cGRhdGU6IHVw ZGF0ZSBpbmZvcm1hdGlvbiAoc2VlIHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UpCj4gLQkgKiBS ZXR1cm46IC1FQUdBSU4gaWYgbW11X25vdGlmaWVyX3JhbmdlX2Jsb2NrYWJsZSh1cGRhdGUpIGlz IGZhbHNlCj4gLQkgKiBhbmQgY2FsbGJhY2sgbmVlZHMgdG8gYmxvY2ssIDAgb3RoZXJ3aXNlLgo+ IC0JICoKPiAtCSAqIFRoaXMgY2FsbGJhY2sgdWx0aW1hdGVseSBvcmlnaW5hdGVzIGZyb20gbW11 X25vdGlmaWVycyB3aGVuIHRoZSBDUFUKPiAtCSAqIHBhZ2UgdGFibGUgaXMgdXBkYXRlZC4gVGhl IGRldmljZSBkcml2ZXIgbXVzdCB1cGRhdGUgaXRzIHBhZ2UgdGFibGUKPiAtCSAqIGluIHJlc3Bv bnNlIHRvIHRoaXMgY2FsbGJhY2suIFRoZSB1cGRhdGUgYXJndW1lbnQgdGVsbHMgd2hhdCBhY3Rp b24KPiAtCSAqIHRvIHBlcmZvcm0uCj4gLQkgKgo+IC0JICogVGhlIGRldmljZSBkcml2ZXIgbXVz dCBub3QgcmV0dXJuIGZyb20gdGhpcyBjYWxsYmFjayB1bnRpbCB0aGUgZGV2aWNlCj4gLQkgKiBw YWdlIHRhYmxlcyBhcmUgY29tcGxldGVseSB1cGRhdGVkIChUTEJzIGZsdXNoZWQsIGV0Yyk7IHRo aXMgaXMgYQo+IC0JICogc3luY2hyb25vdXMgY2FsbC4KPiAtCSAqLwo+IC0JaW50ICgqc3luY19j cHVfZGV2aWNlX3BhZ2V0YWJsZXMpKAo+IC0JCXN0cnVjdCBobW1fbWlycm9yICptaXJyb3IsCj4g LQkJY29uc3Qgc3RydWN0IG1tdV9ub3RpZmllcl9yYW5nZSAqdXBkYXRlKTsKPiAtfTsKPiAtCj4g LS8qCj4gLSAqIHN0cnVjdCBobW1fbWlycm9yIC0gbWlycm9yIHN0cnVjdCBmb3IgYSBkZXZpY2Ug ZHJpdmVyCj4gLSAqCj4gLSAqIEBobW06IHBvaW50ZXIgdG8gc3RydWN0IGhtbSAod2hpY2ggaXMg dW5pcXVlIHBlciBtbV9zdHJ1Y3QpCj4gLSAqIEBvcHM6IGRldmljZSBkcml2ZXIgY2FsbGJhY2sg Zm9yIEhNTSBtaXJyb3Igb3BlcmF0aW9ucwo+IC0gKiBAbGlzdDogZm9yIGxpc3Qgb2YgbWlycm9y cyBvZiBhIGdpdmVuIG1tCj4gLSAqCj4gLSAqIEVhY2ggYWRkcmVzcyBzcGFjZSAobW1fc3RydWN0 KSBiZWluZyBtaXJyb3JlZCBieSBhIGRldmljZSBtdXN0IHJlZ2lzdGVyIG9uZQo+IC0gKiBpbnN0 YW5jZSBvZiBhbiBobW1fbWlycm9yIHN0cnVjdCB3aXRoIEhNTS4gSE1NIHdpbGwgdHJhY2sgdGhl IGxpc3Qgb2YgYWxsCj4gLSAqIG1pcnJvcnMgZm9yIGVhY2ggbW1fc3RydWN0Lgo+IC0gKi8KPiAt c3RydWN0IGhtbV9taXJyb3Igewo+IC0Jc3RydWN0IGhtbQkJCSpobW07Cj4gLQljb25zdCBzdHJ1 Y3QgaG1tX21pcnJvcl9vcHMJKm9wczsKPiAtCXN0cnVjdCBsaXN0X2hlYWQJCWxpc3Q7Cj4gLX07 Cj4gLQo+ICAvKgo+ICAgKiBSZXRyeSBmYXVsdCBpZiBub24tYmxvY2tpbmcsIGRyb3AgbW1hcF9z ZW0gYW5kIHJldHVybiAtRUFHQUlOIGluIHRoYXQgY2FzZS4KPiAgICovCj4gQEAgLTM4MSwxNSAr MjI2LDkgQEAgc3RydWN0IGhtbV9taXJyb3Igewo+ICAjZGVmaW5lIEhNTV9GQVVMVF9TTkFQU0hP VAkJKDEgPDwgMSkKPiAgCj4gICNpZmRlZiBDT05GSUdfSE1NX01JUlJPUgo+IC1pbnQgaG1tX21p cnJvcl9yZWdpc3RlcihzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yLCBzdHJ1Y3QgbW1fc3RydWN0 ICptbSk7Cj4gLXZvaWQgaG1tX21pcnJvcl91bnJlZ2lzdGVyKHN0cnVjdCBobW1fbWlycm9yICpt aXJyb3IpOwo+IC0KPiAgLyoKPiAgICogUGxlYXNlIHNlZSBEb2N1bWVudGF0aW9uL3ZtL2htbS5y c3QgZm9yIGhvdyB0byB1c2UgdGhlIHJhbmdlIEFQSS4KPiAgICovCj4gLWludCBobW1fcmFuZ2Vf cmVnaXN0ZXIoc3RydWN0IGhtbV9yYW5nZSAqcmFuZ2UsIHN0cnVjdCBobW1fbWlycm9yICptaXJy b3IpOwo+IC12b2lkIGhtbV9yYW5nZV91bnJlZ2lzdGVyKHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdl KTsKPiAtCj4gIGxvbmcgaG1tX3JhbmdlX2ZhdWx0KHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdlLCB1 bnNpZ25lZCBpbnQgZmxhZ3MpOwo+ICAKPiAgbG9uZyBobW1fcmFuZ2VfZG1hX21hcChzdHJ1Y3Qg aG1tX3JhbmdlICpyYW5nZSwKPiBAQCAtNDAxLDI0ICsyNDAsNiBAQCBsb25nIGhtbV9yYW5nZV9k bWFfdW5tYXAoc3RydWN0IGhtbV9yYW5nZSAqcmFuZ2UsCj4gIAkJCSBkbWFfYWRkcl90ICpkYWRk cnMsCj4gIAkJCSBib29sIGRpcnR5KTsKPiAgI2Vsc2UKPiAtaW50IGhtbV9taXJyb3JfcmVnaXN0 ZXIoc3RydWN0IGhtbV9taXJyb3IgKm1pcnJvciwgc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gLXsK PiAtCXJldHVybiAtRU9QTk9UU1VQUDsKPiAtfQo+IC0KPiAtdm9pZCBobW1fbWlycm9yX3VucmVn aXN0ZXIoc3RydWN0IGhtbV9taXJyb3IgKm1pcnJvcikKPiAtewo+IC19Cj4gLQo+IC1pbnQgaG1t X3JhbmdlX3JlZ2lzdGVyKHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdlLCBzdHJ1Y3QgaG1tX21pcnJv ciAqbWlycm9yKQo+IC17Cj4gLQlyZXR1cm4gLUVPUE5PVFNVUFA7Cj4gLX0KPiAtCj4gLXZvaWQg aG1tX3JhbmdlX3VucmVnaXN0ZXIoc3RydWN0IGhtbV9yYW5nZSAqcmFuZ2UpCj4gLXsKPiAtfQo+ IC0KPiAgc3RhdGljIGlubGluZSBsb25nIGhtbV9yYW5nZV9mYXVsdChzdHJ1Y3QgaG1tX3Jhbmdl ICpyYW5nZSwgdW5zaWduZWQgaW50IGZsYWdzKQo+ICB7Cj4gIAlyZXR1cm4gLUVPUE5PVFNVUFA7 Cj4gZGlmZiAtLWdpdCBhL21tL0tjb25maWcgYi9tbS9LY29uZmlnCj4gaW5kZXggZDBiNTA0NmQ5 YWVmZmQuLmUzOGZmMWQ1OTY4ZGJmIDEwMDY0NAo+IC0tLSBhL21tL0tjb25maWcKPiArKysgYi9t bS9LY29uZmlnCj4gQEAgLTY3NSw3ICs2NzUsNiBAQCBjb25maWcgREVWX1BBR0VNQVBfT1BTCj4g IGNvbmZpZyBITU1fTUlSUk9SCj4gIAlib29sCj4gIAlkZXBlbmRzIG9uIE1NVQo+IC0JZGVwZW5k cyBvbiBNTVVfTk9USUZJRVIKPiAgCj4gIGNvbmZpZyBERVZJQ0VfUFJJVkFURQo+ICAJYm9vbCAi VW5hZGRyZXNzYWJsZSBkZXZpY2UgbWVtb3J5IChHUFUgbWVtb3J5LCAuLi4pIgo+IGRpZmYgLS1n aXQgYS9tbS9obW0uYyBiL21tL2htbS5jCj4gaW5kZXggMjJhYzM1OTU3NzFmZWIuLjc1ZDE1YTgy MGUxODJlIDEwMDY0NAo+IC0tLSBhL21tL2htbS5jCj4gKysrIGIvbW0vaG1tLmMKPiBAQCAtMjYs MTkzICsyNiw2IEBACj4gICNpbmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4KPiAgI2luY2x1 ZGUgPGxpbnV4L21lbW9yeV9ob3RwbHVnLmg+Cj4gIAo+IC1zdGF0aWMgc3RydWN0IG1tdV9ub3Rp ZmllciAqaG1tX2FsbG9jX25vdGlmaWVyKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQo+IC17Cj4gLQlz dHJ1Y3QgaG1tICpobW07Cj4gLQo+IC0JaG1tID0ga3phbGxvYyhzaXplb2YoKmhtbSksIEdGUF9L RVJORUwpOwo+IC0JaWYgKCFobW0pCj4gLQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7Cj4gLQo+ IC0JaW5pdF93YWl0cXVldWVfaGVhZCgmaG1tLT53cSk7Cj4gLQlJTklUX0xJU1RfSEVBRCgmaG1t LT5taXJyb3JzKTsKPiAtCWluaXRfcndzZW0oJmhtbS0+bWlycm9yc19zZW0pOwo+IC0JSU5JVF9M SVNUX0hFQUQoJmhtbS0+cmFuZ2VzKTsKPiAtCXNwaW5fbG9ja19pbml0KCZobW0tPnJhbmdlc19s b2NrKTsKPiAtCWhtbS0+bm90aWZpZXJzID0gMDsKPiAtCXJldHVybiAmaG1tLT5tbXVfbm90aWZp ZXI7Cj4gLX0KPiAtCj4gLXN0YXRpYyB2b2lkIGhtbV9mcmVlX25vdGlmaWVyKHN0cnVjdCBtbXVf bm90aWZpZXIgKm1uKQo+IC17Cj4gLQlzdHJ1Y3QgaG1tICpobW0gPSBjb250YWluZXJfb2YobW4s IHN0cnVjdCBobW0sIG1tdV9ub3RpZmllcik7Cj4gLQo+IC0JV0FSTl9PTighbGlzdF9lbXB0eSgm aG1tLT5yYW5nZXMpKTsKPiAtCVdBUk5fT04oIWxpc3RfZW1wdHkoJmhtbS0+bWlycm9ycykpOwo+ IC0Ja2ZyZWUoaG1tKTsKPiAtfQo+IC0KPiAtc3RhdGljIHZvaWQgaG1tX3JlbGVhc2Uoc3RydWN0 IG1tdV9ub3RpZmllciAqbW4sIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQo+IC17Cj4gLQlzdHJ1Y3Qg aG1tICpobW0gPSBjb250YWluZXJfb2YobW4sIHN0cnVjdCBobW0sIG1tdV9ub3RpZmllcik7Cj4g LQlzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yOwo+IC0KPiAtCS8qCj4gLQkgKiBTaW5jZSBobW1f cmFuZ2VfcmVnaXN0ZXIoKSBob2xkcyB0aGUgbW1nZXQoKSBsb2NrIGhtbV9yZWxlYXNlKCkgaXMK PiAtCSAqIHByZXZlbnRlZCBhcyBsb25nIGFzIGEgcmFuZ2UgZXhpc3RzLgo+IC0JICovCj4gLQlX QVJOX09OKCFsaXN0X2VtcHR5X2NhcmVmdWwoJmhtbS0+cmFuZ2VzKSk7Cj4gLQo+IC0JZG93bl9y ZWFkKCZobW0tPm1pcnJvcnNfc2VtKTsKPiAtCWxpc3RfZm9yX2VhY2hfZW50cnkobWlycm9yLCAm aG1tLT5taXJyb3JzLCBsaXN0KSB7Cj4gLQkJLyoKPiAtCQkgKiBOb3RlOiBUaGUgZHJpdmVyIGlz IG5vdCBhbGxvd2VkIHRvIHRyaWdnZXIKPiAtCQkgKiBobW1fbWlycm9yX3VucmVnaXN0ZXIoKSBm cm9tIHRoaXMgdGhyZWFkLgo+IC0JCSAqLwo+IC0JCWlmIChtaXJyb3ItPm9wcy0+cmVsZWFzZSkK PiAtCQkJbWlycm9yLT5vcHMtPnJlbGVhc2UobWlycm9yKTsKPiAtCX0KPiAtCXVwX3JlYWQoJmht bS0+bWlycm9yc19zZW0pOwo+IC19Cj4gLQo+IC1zdGF0aWMgdm9pZCBub3RpZmllcnNfZGVjcmVt ZW50KHN0cnVjdCBobW0gKmhtbSkKPiAtewo+IC0JdW5zaWduZWQgbG9uZyBmbGFnczsKPiAtCj4g LQlzcGluX2xvY2tfaXJxc2F2ZSgmaG1tLT5yYW5nZXNfbG9jaywgZmxhZ3MpOwo+IC0JaG1tLT5u b3RpZmllcnMtLTsKPiAtCWlmICghaG1tLT5ub3RpZmllcnMpIHsKPiAtCQlzdHJ1Y3QgaG1tX3Jh bmdlICpyYW5nZTsKPiAtCj4gLQkJbGlzdF9mb3JfZWFjaF9lbnRyeShyYW5nZSwgJmhtbS0+cmFu Z2VzLCBsaXN0KSB7Cj4gLQkJCWlmIChyYW5nZS0+dmFsaWQpCj4gLQkJCQljb250aW51ZTsKPiAt CQkJcmFuZ2UtPnZhbGlkID0gdHJ1ZTsKPiAtCQl9Cj4gLQkJd2FrZV91cF9hbGwoJmhtbS0+d3Ep Owo+IC0JfQo+IC0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaG1tLT5yYW5nZXNfbG9jaywgZmxh Z3MpOwo+IC19Cj4gLQo+IC1zdGF0aWMgaW50IGhtbV9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0 cnVjdCBtbXVfbm90aWZpZXIgKm1uLAo+IC0JCQljb25zdCBzdHJ1Y3QgbW11X25vdGlmaWVyX3Jh bmdlICpucmFuZ2UpCj4gLXsKPiAtCXN0cnVjdCBobW0gKmhtbSA9IGNvbnRhaW5lcl9vZihtbiwg c3RydWN0IGhtbSwgbW11X25vdGlmaWVyKTsKPiAtCXN0cnVjdCBobW1fbWlycm9yICptaXJyb3I7 Cj4gLQlzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZTsKPiAtCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4g LQlpbnQgcmV0ID0gMDsKPiAtCj4gLQlzcGluX2xvY2tfaXJxc2F2ZSgmaG1tLT5yYW5nZXNfbG9j aywgZmxhZ3MpOwo+IC0JaG1tLT5ub3RpZmllcnMrKzsKPiAtCWxpc3RfZm9yX2VhY2hfZW50cnko cmFuZ2UsICZobW0tPnJhbmdlcywgbGlzdCkgewo+IC0JCWlmIChucmFuZ2UtPmVuZCA8IHJhbmdl LT5zdGFydCB8fCBucmFuZ2UtPnN0YXJ0ID49IHJhbmdlLT5lbmQpCj4gLQkJCWNvbnRpbnVlOwo+ IC0KPiAtCQlyYW5nZS0+dmFsaWQgPSBmYWxzZTsKPiAtCX0KPiAtCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoJmhtbS0+cmFuZ2VzX2xvY2ssIGZsYWdzKTsKPiAtCj4gLQlpZiAobW11X25vdGlmaWVy X3JhbmdlX2Jsb2NrYWJsZShucmFuZ2UpKQo+IC0JCWRvd25fcmVhZCgmaG1tLT5taXJyb3JzX3Nl bSk7Cj4gLQllbHNlIGlmICghZG93bl9yZWFkX3RyeWxvY2soJmhtbS0+bWlycm9yc19zZW0pKSB7 Cj4gLQkJcmV0ID0gLUVBR0FJTjsKPiAtCQlnb3RvIG91dDsKPiAtCX0KPiAtCj4gLQlsaXN0X2Zv cl9lYWNoX2VudHJ5KG1pcnJvciwgJmhtbS0+bWlycm9ycywgbGlzdCkgewo+IC0JCWludCByYzsK PiAtCj4gLQkJcmMgPSBtaXJyb3ItPm9wcy0+c3luY19jcHVfZGV2aWNlX3BhZ2V0YWJsZXMobWly cm9yLCBucmFuZ2UpOwo+IC0JCWlmIChyYykgewo+IC0JCQlpZiAoV0FSTl9PTihtbXVfbm90aWZp ZXJfcmFuZ2VfYmxvY2thYmxlKG5yYW5nZSkgfHwKPiAtCQkJICAgIHJjICE9IC1FQUdBSU4pKQo+ IC0JCQkJY29udGludWU7Cj4gLQkJCXJldCA9IC1FQUdBSU47Cj4gLQkJCWJyZWFrOwo+IC0JCX0K PiAtCX0KPiAtCXVwX3JlYWQoJmhtbS0+bWlycm9yc19zZW0pOwo+IC0KPiAtb3V0Ogo+IC0JaWYg KHJldCkKPiAtCQlub3RpZmllcnNfZGVjcmVtZW50KGhtbSk7Cj4gLQlyZXR1cm4gcmV0Owo+IC19 Cj4gLQo+IC1zdGF0aWMgdm9pZCBobW1faW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9u b3RpZmllciAqbW4sCj4gLQkJCWNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfcmFuZ2UgKm5yYW5n ZSkKPiAtewo+IC0Jc3RydWN0IGhtbSAqaG1tID0gY29udGFpbmVyX29mKG1uLCBzdHJ1Y3QgaG1t LCBtbXVfbm90aWZpZXIpOwo+IC0KPiAtCW5vdGlmaWVyc19kZWNyZW1lbnQoaG1tKTsKPiAtfQo+ IC0KPiAtc3RhdGljIGNvbnN0IHN0cnVjdCBtbXVfbm90aWZpZXJfb3BzIGhtbV9tbXVfbm90aWZp ZXJfb3BzID0gewo+IC0JLnJlbGVhc2UJCT0gaG1tX3JlbGVhc2UsCj4gLQkuaW52YWxpZGF0ZV9y YW5nZV9zdGFydAk9IGhtbV9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0LAo+IC0JLmludmFsaWRhdGVf cmFuZ2VfZW5kCT0gaG1tX2ludmFsaWRhdGVfcmFuZ2VfZW5kLAo+IC0JLmFsbG9jX25vdGlmaWVy CQk9IGhtbV9hbGxvY19ub3RpZmllciwKPiAtCS5mcmVlX25vdGlmaWVyCQk9IGhtbV9mcmVlX25v dGlmaWVyLAo+IC19Owo+IC0KPiAtLyoKPiAtICogaG1tX21pcnJvcl9yZWdpc3RlcigpIC0gcmVn aXN0ZXIgYSBtaXJyb3IgYWdhaW5zdCBhbiBtbQo+IC0gKgo+IC0gKiBAbWlycm9yOiBuZXcgbWly cm9yIHN0cnVjdCB0byByZWdpc3Rlcgo+IC0gKiBAbW06IG1tIHRvIHJlZ2lzdGVyIGFnYWluc3QK PiAtICogUmV0dXJuOiAwIG9uIHN1Y2Nlc3MsIC1FTk9NRU0gaWYgbm8gbWVtb3J5LCAtRUlOVkFM IGlmIGludmFsaWQgYXJndW1lbnRzCj4gLSAqCj4gLSAqIFRvIHN0YXJ0IG1pcnJvcmluZyBhIHBy b2Nlc3MgYWRkcmVzcyBzcGFjZSwgdGhlIGRldmljZSBkcml2ZXIgbXVzdCByZWdpc3Rlcgo+IC0g KiBhbiBITU0gbWlycm9yIHN0cnVjdC4KPiAtICoKPiAtICogVGhlIGNhbGxlciBjYW5ub3QgdW5y ZWdpc3RlciB0aGUgaG1tX21pcnJvciB3aGlsZSBhbnkgcmFuZ2VzIGFyZQo+IC0gKiByZWdpc3Rl cmVkLgo+IC0gKgo+IC0gKiBDYWxsZXJzIHVzaW5nIHRoaXMgZnVuY3Rpb24gbXVzdCBwdXQgYSBj YWxsIHRvIG1tdV9ub3RpZmllcl9zeW5jaHJvbml6ZSgpCj4gLSAqIGluIHRoZWlyIG1vZHVsZSBl eGl0IGZ1bmN0aW9ucy4KPiAtICovCj4gLWludCBobW1fbWlycm9yX3JlZ2lzdGVyKHN0cnVjdCBo bW1fbWlycm9yICptaXJyb3IsIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQo+IC17Cj4gLQlzdHJ1Y3Qg bW11X25vdGlmaWVyICptbjsKPiAtCj4gLQlsb2NrZGVwX2Fzc2VydF9oZWxkX3dyaXRlKCZtbS0+ bW1hcF9zZW0pOwo+IC0KPiAtCS8qIFNhbml0eSBjaGVjayAqLwo+IC0JaWYgKCFtbSB8fCAhbWly cm9yIHx8ICFtaXJyb3ItPm9wcykKPiAtCQlyZXR1cm4gLUVJTlZBTDsKPiAtCj4gLQltbiA9IG1t dV9ub3RpZmllcl9nZXRfbG9ja2VkKCZobW1fbW11X25vdGlmaWVyX29wcywgbW0pOwo+IC0JaWYg KElTX0VSUihtbikpCj4gLQkJcmV0dXJuIFBUUl9FUlIobW4pOwo+IC0JbWlycm9yLT5obW0gPSBj b250YWluZXJfb2YobW4sIHN0cnVjdCBobW0sIG1tdV9ub3RpZmllcik7Cj4gLQo+IC0JZG93bl93 cml0ZSgmbWlycm9yLT5obW0tPm1pcnJvcnNfc2VtKTsKPiAtCWxpc3RfYWRkKCZtaXJyb3ItPmxp c3QsICZtaXJyb3ItPmhtbS0+bWlycm9ycyk7Cj4gLQl1cF93cml0ZSgmbWlycm9yLT5obW0tPm1p cnJvcnNfc2VtKTsKPiAtCj4gLQlyZXR1cm4gMDsKPiAtfQo+IC1FWFBPUlRfU1lNQk9MKGhtbV9t aXJyb3JfcmVnaXN0ZXIpOwo+IC0KPiAtLyoKPiAtICogaG1tX21pcnJvcl91bnJlZ2lzdGVyKCkg LSB1bnJlZ2lzdGVyIGEgbWlycm9yCj4gLSAqCj4gLSAqIEBtaXJyb3I6IG1pcnJvciBzdHJ1Y3Qg dG8gdW5yZWdpc3Rlcgo+IC0gKgo+IC0gKiBTdG9wIG1pcnJvcmluZyBhIHByb2Nlc3MgYWRkcmVz cyBzcGFjZSwgYW5kIGNsZWFudXAuCj4gLSAqLwo+IC12b2lkIGhtbV9taXJyb3JfdW5yZWdpc3Rl cihzdHJ1Y3QgaG1tX21pcnJvciAqbWlycm9yKQo+IC17Cj4gLQlzdHJ1Y3QgaG1tICpobW0gPSBt aXJyb3ItPmhtbTsKPiAtCj4gLQlkb3duX3dyaXRlKCZobW0tPm1pcnJvcnNfc2VtKTsKPiAtCWxp c3RfZGVsKCZtaXJyb3ItPmxpc3QpOwo+IC0JdXBfd3JpdGUoJmhtbS0+bWlycm9yc19zZW0pOwo+ IC0JbW11X25vdGlmaWVyX3B1dCgmaG1tLT5tbXVfbm90aWZpZXIpOwo+IC19Cj4gLUVYUE9SVF9T WU1CT0woaG1tX21pcnJvcl91bnJlZ2lzdGVyKTsKPiAtCj4gIHN0cnVjdCBobW1fdm1hX3dhbGsg ewo+ICAJc3RydWN0IGhtbV9yYW5nZQkqcmFuZ2U7Cj4gIAlzdHJ1Y3QgZGV2X3BhZ2VtYXAJKnBn bWFwOwo+IEBAIC03NzksODcgKzU5Miw2IEBAIHN0YXRpYyB2b2lkIGhtbV9wZm5zX2NsZWFyKHN0 cnVjdCBobW1fcmFuZ2UgKnJhbmdlLAo+ICAJCSpwZm5zID0gcmFuZ2UtPnZhbHVlc1tITU1fUEZO X05PTkVdOwo+ICB9Cj4gIAo+IC0vKgo+IC0gKiBobW1fcmFuZ2VfcmVnaXN0ZXIoKSAtIHN0YXJ0 IHRyYWNraW5nIGNoYW5nZSB0byBDUFUgcGFnZSB0YWJsZSBvdmVyIGEgcmFuZ2UKPiAtICogQHJh bmdlOiByYW5nZQo+IC0gKiBAbW06IHRoZSBtbSBzdHJ1Y3QgZm9yIHRoZSByYW5nZSBvZiB2aXJ0 dWFsIGFkZHJlc3MKPiAtICoKPiAtICogUmV0dXJuOiAwIG9uIHN1Y2Nlc3MsIC1FRkFVTFQgaWYg dGhlIGFkZHJlc3Mgc3BhY2UgaXMgbm8gbG9uZ2VyIHZhbGlkCj4gLSAqCj4gLSAqIFRyYWNrIHVw ZGF0ZXMgdG8gdGhlIENQVSBwYWdlIHRhYmxlIHNlZSBpbmNsdWRlL2xpbnV4L2htbS5oCj4gLSAq Lwo+IC1pbnQgaG1tX3JhbmdlX3JlZ2lzdGVyKHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdlLCBzdHJ1 Y3QgaG1tX21pcnJvciAqbWlycm9yKQo+IC17Cj4gLQlzdHJ1Y3QgaG1tICpobW0gPSBtaXJyb3It PmhtbTsKPiAtCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4gLQo+IC0JcmFuZ2UtPnZhbGlkID0gZmFs c2U7Cj4gLQlyYW5nZS0+aG1tID0gTlVMTDsKPiAtCj4gLQlpZiAoKHJhbmdlLT5zdGFydCAmIChQ QUdFX1NJWkUgLSAxKSkgfHwgKHJhbmdlLT5lbmQgJiAoUEFHRV9TSVpFIC0gMSkpKQo+IC0JCXJl dHVybiAtRUlOVkFMOwo+IC0JaWYgKHJhbmdlLT5zdGFydCA+PSByYW5nZS0+ZW5kKQo+IC0JCXJl dHVybiAtRUlOVkFMOwo+IC0KPiAtCS8qIFByZXZlbnQgaG1tX3JlbGVhc2UoKSBmcm9tIHJ1bm5p bmcgd2hpbGUgdGhlIHJhbmdlIGlzIHZhbGlkICovCj4gLQlpZiAoIW1tZ2V0X25vdF96ZXJvKGht bS0+bW11X25vdGlmaWVyLm1tKSkKPiAtCQlyZXR1cm4gLUVGQVVMVDsKPiAtCj4gLQkvKiBJbml0 aWFsaXplIHJhbmdlIHRvIHRyYWNrIENQVSBwYWdlIHRhYmxlIHVwZGF0ZXMuICovCj4gLQlzcGlu X2xvY2tfaXJxc2F2ZSgmaG1tLT5yYW5nZXNfbG9jaywgZmxhZ3MpOwo+IC0KPiAtCXJhbmdlLT5o bW0gPSBobW07Cj4gLQlsaXN0X2FkZCgmcmFuZ2UtPmxpc3QsICZobW0tPnJhbmdlcyk7Cj4gLQo+ IC0JLyoKPiAtCSAqIElmIHRoZXJlIGFyZSBhbnkgY29uY3VycmVudCBub3RpZmllcnMgd2UgaGF2 ZSB0byB3YWl0IGZvciB0aGVtIGZvcgo+IC0JICogdGhlIHJhbmdlIHRvIGJlIHZhbGlkIChzZWUg aG1tX3JhbmdlX3dhaXRfdW50aWxfdmFsaWQoKSkuCj4gLQkgKi8KPiAtCWlmICghaG1tLT5ub3Rp ZmllcnMpCj4gLQkJcmFuZ2UtPnZhbGlkID0gdHJ1ZTsKPiAtCXNwaW5fdW5sb2NrX2lycXJlc3Rv cmUoJmhtbS0+cmFuZ2VzX2xvY2ssIGZsYWdzKTsKPiAtCj4gLQlyZXR1cm4gMDsKPiAtfQo+IC1F WFBPUlRfU1lNQk9MKGhtbV9yYW5nZV9yZWdpc3Rlcik7Cj4gLQo+IC0vKgo+IC0gKiBobW1fcmFu Z2VfdW5yZWdpc3RlcigpIC0gc3RvcCB0cmFja2luZyBjaGFuZ2UgdG8gQ1BVIHBhZ2UgdGFibGUg b3ZlciBhIHJhbmdlCj4gLSAqIEByYW5nZTogcmFuZ2UKPiAtICoKPiAtICogUmFuZ2Ugc3RydWN0 IGlzIHVzZWQgdG8gdHJhY2sgdXBkYXRlcyB0byB0aGUgQ1BVIHBhZ2UgdGFibGUgYWZ0ZXIgYSBj YWxsIHRvCj4gLSAqIGhtbV9yYW5nZV9yZWdpc3RlcigpLiBTZWUgaW5jbHVkZS9saW51eC9obW0u aCBmb3IgaG93IHRvIHVzZSBpdC4KPiAtICovCj4gLXZvaWQgaG1tX3JhbmdlX3VucmVnaXN0ZXIo c3RydWN0IGhtbV9yYW5nZSAqcmFuZ2UpCj4gLXsKPiAtCXN0cnVjdCBobW0gKmhtbSA9IHJhbmdl LT5obW07Cj4gLQl1bnNpZ25lZCBsb25nIGZsYWdzOwo+IC0KPiAtCXNwaW5fbG9ja19pcnFzYXZl KCZobW0tPnJhbmdlc19sb2NrLCBmbGFncyk7Cj4gLQlsaXN0X2RlbF9pbml0KCZyYW5nZS0+bGlz dCk7Cj4gLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZobW0tPnJhbmdlc19sb2NrLCBmbGFncyk7 Cj4gLQo+IC0JLyogRHJvcCByZWZlcmVuY2UgdGFrZW4gYnkgaG1tX3JhbmdlX3JlZ2lzdGVyKCkg Ki8KPiAtCW1tcHV0KGhtbS0+bW11X25vdGlmaWVyLm1tKTsKPiAtCj4gLQkvKgo+IC0JICogVGhl IHJhbmdlIGlzIG5vdyBpbnZhbGlkIGFuZCB0aGUgcmVmIG9uIHRoZSBobW0gaXMgZHJvcHBlZCwg c28KPiAtCSAqIHBvaXNvbiB0aGUgcG9pbnRlci4gIExlYXZlIG90aGVyIGZpZWxkcyBpbiBwbGFj ZSwgZm9yIHRoZSBjYWxsZXIncwo+IC0JICogdXNlLgo+IC0JICovCj4gLQlyYW5nZS0+dmFsaWQg PSBmYWxzZTsKPiAtCW1lbXNldCgmcmFuZ2UtPmhtbSwgUE9JU09OX0lOVVNFLCBzaXplb2YocmFu Z2UtPmhtbSkpOwo+IC19Cj4gLUVYUE9SVF9TWU1CT0woaG1tX3JhbmdlX3VucmVnaXN0ZXIpOwo+ IC0KPiAtc3RhdGljIGJvb2wgbmVlZHNfcmV0cnkoc3RydWN0IGhtbV9yYW5nZSAqcmFuZ2UpCj4g LXsKPiAtCWlmIChyYW5nZS0+bm90aWZpZXIpCj4gLQkJcmV0dXJuIG1tdV9yYW5nZV9jaGVja19y ZXRyeShyYW5nZS0+bm90aWZpZXIsCj4gLQkJCQkJICAgICByYW5nZS0+bm90aWZpZXJfc2VxKTsK PiAtCXJldHVybiAhcmFuZ2UtPnZhbGlkOwo+IC19Cj4gLQo+ICBzdGF0aWMgY29uc3Qgc3RydWN0 IG1tX3dhbGtfb3BzIGhtbV93YWxrX29wcyA9IHsKPiAgCS5wdWRfZW50cnkJPSBobW1fdm1hX3dh bGtfcHVkLAo+ICAJLnBtZF9lbnRyeQk9IGhtbV92bWFfd2Fsa19wbWQsCj4gQEAgLTkwMCwyMCAr NjMyLDE1IEBAIGxvbmcgaG1tX3JhbmdlX2ZhdWx0KHN0cnVjdCBobW1fcmFuZ2UgKnJhbmdlLCB1 bnNpZ25lZCBpbnQgZmxhZ3MpCj4gIAljb25zdCB1bnNpZ25lZCBsb25nIGRldmljZV92bWEgPSBW TV9JTyB8IFZNX1BGTk1BUCB8IFZNX01JWEVETUFQOwo+ICAJdW5zaWduZWQgbG9uZyBzdGFydCA9 IHJhbmdlLT5zdGFydCwgZW5kOwo+ICAJc3RydWN0IGhtbV92bWFfd2FsayBobW1fdm1hX3dhbGs7 Cj4gLQlzdHJ1Y3QgbW1fc3RydWN0ICptbTsKPiArCXN0cnVjdCBtbV9zdHJ1Y3QgKm1tID0gcmFu Z2UtPm5vdGlmaWVyLT5tbTsKPiAgCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hOwo+ICAJaW50 IHJldDsKPiAgCj4gLQlpZiAocmFuZ2UtPm5vdGlmaWVyKQo+IC0JCW1tID0gcmFuZ2UtPm5vdGlm aWVyLT5tbTsKPiAtCWVsc2UKPiAtCQltbSA9IHJhbmdlLT5obW0tPm1tdV9ub3RpZmllci5tbTsK PiAtCj4gIAlsb2NrZGVwX2Fzc2VydF9oZWxkKCZtbS0+bW1hcF9zZW0pOwo+ICAKPiAgCWRvIHsK PiAgCQkvKiBJZiByYW5nZSBpcyBubyBsb25nZXIgdmFsaWQgZm9yY2UgcmV0cnkuICovCj4gLQkJ aWYgKG5lZWRzX3JldHJ5KHJhbmdlKSkKPiArCQlpZiAobW11X3JhbmdlX2NoZWNrX3JldHJ5KHJh bmdlLT5ub3RpZmllciwgcmFuZ2UtPm5vdGlmaWVyX3NlcSkpCj4gIAkJCXJldHVybiAtRUJVU1k7 Cj4gIAo+ICAJCXZtYSA9IGZpbmRfdm1hKG1tLCBzdGFydCk7Cj4gQEAgLTk0Niw3ICs2NzMsOSBA QCBsb25nIGhtbV9yYW5nZV9mYXVsdChzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSwgdW5zaWduZWQg aW50IGZsYWdzKQo+ICAJCQlzdGFydCA9IGhtbV92bWFfd2Fsay5sYXN0Owo+ICAKPiAgCQkJLyog S2VlcCB0cnlpbmcgd2hpbGUgdGhlIHJhbmdlIGlzIHZhbGlkLiAqLwo+IC0JCX0gd2hpbGUgKHJl dCA9PSAtRUJVU1kgJiYgIW5lZWRzX3JldHJ5KHJhbmdlKSk7Cj4gKwkJfSB3aGlsZSAocmV0ID09 IC1FQlVTWSAmJgo+ICsJCQkgIW1tdV9yYW5nZV9jaGVja19yZXRyeShyYW5nZS0+bm90aWZpZXIs Cj4gKwkJCQkJCXJhbmdlLT5ub3RpZmllcl9zZXEpKTsKPiAgCj4gIAkJaWYgKHJldCkgewo+ICAJ CQl1bnNpZ25lZCBsb25nIGk7Cj4gQEAgLTEwMDQsNyArNzMzLDggQEAgbG9uZyBobW1fcmFuZ2Vf ZG1hX21hcChzdHJ1Y3QgaG1tX3JhbmdlICpyYW5nZSwgc3RydWN0IGRldmljZSAqZGV2aWNlLAo+ ICAJCQljb250aW51ZTsKPiAgCj4gIAkJLyogQ2hlY2sgaWYgcmFuZ2UgaXMgYmVpbmcgaW52YWxp ZGF0ZWQgKi8KPiAtCQlpZiAobmVlZHNfcmV0cnkocmFuZ2UpKSB7Cj4gKwkJaWYgKG1tdV9yYW5n ZV9jaGVja19yZXRyeShyYW5nZS0+bm90aWZpZXIsCj4gKwkJCQkJICByYW5nZS0+bm90aWZpZXJf c2VxKSkgewo+ICAJCQlyZXQgPSAtRUJVU1k7Cj4gIAkJCWdvdG8gdW5tYXA7Cj4gIAkJfQo+IC0t IAo+IDIuMjMuMAo+IAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KYW1kLWdmeCBtYWlsaW5nIGxpc3QKYW1kLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcK aHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9hbWQtZ2Z4 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 48845CA9EB0 for ; Mon, 21 Oct 2019 18:38:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 03BA32084C for ; Mon, 21 Oct 2019 18:38:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="c7kuMLoR" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727767AbfJUSij (ORCPT ); Mon, 21 Oct 2019 14:38:39 -0400 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:39490 "EHLO us-smtp-delivery-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1727211AbfJUSij (ORCPT ); Mon, 21 Oct 2019 14:38:39 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1571683116; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Oe6n9GNO3tq7+Ws0m2nz5EXI0lFRurAPgB7xY0bHjcg=; b=c7kuMLoR8osAsq5Iiv8SWWfO0EelNVUhEf3L+gl7fp5ZcCf0Sbk3/EQlcsVOwZQZwdOM5Z qTtBHUEePyAJrzUWLYUh1Z+BDCTstmVx90gTzKHjVzPwfWHH8bJaCE+Fc5XCFPGC6PiqnK vhcNwwtyZIXCfOc61VhZgKktOEaNXyI= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-297-Eb7EqaHZP567Hpt9ExBGXg-1; Mon, 21 Oct 2019 14:38:30 -0400 Received: from smtp.corp.redhat.com (int-mx04.intmail.prod.int.phx2.redhat.com [10.5.11.14]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id A09EA1800D79; Mon, 21 Oct 2019 18:38:28 +0000 (UTC) Received: from redhat.com (unknown [10.20.6.178]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 199FD5DA2C; Mon, 21 Oct 2019 18:38:26 +0000 (UTC) Date: Mon, 21 Oct 2019 14:38:24 -0400 From: Jerome Glisse To: Jason Gunthorpe Cc: Ralph Campbell , John Hubbard , Felix.Kuehling@amd.com, linux-rdma@vger.kernel.org, linux-mm@kvack.org, Andrea Arcangeli , dri-devel@lists.freedesktop.org, amd-gfx@lists.freedesktop.org, Ben Skeggs , Jason Gunthorpe Subject: Re: [PATCH hmm 15/15] mm/hmm: remove hmm_mirror and related Message-ID: <20191021183824.GE3177@redhat.com> References: <20191015181242.8343-1-jgg@ziepe.ca> <20191015181242.8343-16-jgg@ziepe.ca> MIME-Version: 1.0 In-Reply-To: <20191015181242.8343-16-jgg@ziepe.ca> User-Agent: Mutt/1.12.1 (2019-06-15) X-Scanned-By: MIMEDefang 2.79 on 10.5.11.14 X-MC-Unique: Eb7EqaHZP567Hpt9ExBGXg-1 X-Mimecast-Spam-Score: 0 Content-Type: text/plain; charset=WINDOWS-1252 Content-Transfer-Encoding: quoted-printable Content-Disposition: inline Sender: linux-rdma-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-rdma@vger.kernel.org On Tue, Oct 15, 2019 at 03:12:42PM -0300, Jason Gunthorpe wrote: > From: Jason Gunthorpe >=20 > The only two users of this are now converted to use mmu_range_notifier, > delete all the code and update hmm.rst. I guess i should point out that the reasons for hmm_mirror and hmm was for: 1) Maybe define a common API for userspace to provide memory placement hints (NUMA for GPU) 2) multi-devices sharing same mirror page table But support for multi-GPU in nouveau is way behind and i guess such optimization will have to re-materialize what is necessary once that happens. Note this patch should also update kernel/fork.c and the mm_struct definition AFAICT. With those changes you can add my: Reviewed-by: J=E9r=F4me Glisse >=20 > Signed-off-by: Jason Gunthorpe > --- > Documentation/vm/hmm.rst | 105 ++++----------- > include/linux/hmm.h | 183 +------------------------ > mm/Kconfig | 1 - > mm/hmm.c | 284 +-------------------------------------- > 4 files changed, 33 insertions(+), 540 deletions(-) >=20 > diff --git a/Documentation/vm/hmm.rst b/Documentation/vm/hmm.rst > index 0a5960beccf76d..a247643035c4e2 100644 > --- a/Documentation/vm/hmm.rst > +++ b/Documentation/vm/hmm.rst > @@ -147,49 +147,16 @@ Address space mirroring implementation and API > Address space mirroring's main objective is to allow duplication of a ra= nge of > CPU page table into a device page table; HMM helps keep both synchronize= d. A > device driver that wants to mirror a process address space must start wi= th the > -registration of an hmm_mirror struct:: > - > - int hmm_mirror_register(struct hmm_mirror *mirror, > - struct mm_struct *mm); > - > -The mirror struct has a set of callbacks that are used > -to propagate CPU page tables:: > - > - struct hmm_mirror_ops { > - /* release() - release hmm_mirror > - * > - * @mirror: pointer to struct hmm_mirror > - * > - * This is called when the mm_struct is being released. The callba= ck > - * must ensure that all access to any pages obtained from this mirr= or > - * is halted before the callback returns. All future access should > - * fault. > - */ > - void (*release)(struct hmm_mirror *mirror); > - > - /* sync_cpu_device_pagetables() - synchronize page tables > - * > - * @mirror: pointer to struct hmm_mirror > - * @update: update information (see struct mmu_notifier_range) > - * Return: -EAGAIN if update.blockable false and callback need to > - * block, 0 otherwise. > - * > - * This callback ultimately originates from mmu_notifiers when the = CPU > - * page table is updated. The device driver must update its page ta= ble > - * in response to this callback. The update argument tells what act= ion > - * to perform. > - * > - * The device driver must not return from this callback until the d= evice > - * page tables are completely updated (TLBs flushed, etc); this is = a > - * synchronous call. > - */ > - int (*sync_cpu_device_pagetables)(struct hmm_mirror *mirror, > - const struct hmm_update *update); > - }; > - > -The device driver must perform the update action to the range (mark rang= e > -read only, or fully unmap, etc.). The device must complete the update be= fore > -the driver callback returns. > +registration of a mmu_range_notifier:: > + > + mrn->ops =3D &driver_ops; > + int mmu_range_notifier_insert(struct mmu_range_notifier *mrn, > +=09=09=09 unsigned long start, unsigned long length, > +=09=09=09 struct mm_struct *mm); > + > +During the driver_ops->invalidate() callback the device driver must perf= orm > +the update action to the range (mark range read only, or fully unmap, > +etc.). The device must complete the update before the driver callback re= turns. > =20 > When the device driver wants to populate a range of virtual addresses, i= t can > use:: > @@ -216,70 +183,46 @@ The usage pattern is:: > struct hmm_range range; > ... > =20 > + range.notifier =3D &mrn; > range.start =3D ...; > range.end =3D ...; > range.pfns =3D ...; > range.flags =3D ...; > range.values =3D ...; > range.pfn_shift =3D ...; > - hmm_range_register(&range, mirror); > =20 > - /* > - * Just wait for range to be valid, safe to ignore return value as= we > - * will use the return value of hmm_range_fault() below under the > - * mmap_sem to ascertain the validity of the range. > - */ > - hmm_range_wait_until_valid(&range, TIMEOUT_IN_MSEC); > + if (!mmget_not_zero(mrn->notifier.mm)) > + return -EFAULT; > =20 > again: > + range.notifier_seq =3D mmu_range_read_begin(&mrn); > down_read(&mm->mmap_sem); > ret =3D hmm_range_fault(&range, HMM_RANGE_SNAPSHOT); > if (ret) { > up_read(&mm->mmap_sem); > - if (ret =3D=3D -EBUSY) { > - /* > - * No need to check hmm_range_wait_until_valid() return valu= e > - * on retry we will get proper error with hmm_range_fault() > - */ > - hmm_range_wait_until_valid(&range, TIMEOUT_IN_MSEC); > - goto again; > - } > - hmm_range_unregister(&range); > + if (ret =3D=3D -EBUSY) > + goto again; > return ret; > } > + up_read(&mm->mmap_sem); > + > take_lock(driver->update); > - if (!hmm_range_valid(&range)) { > + if (mmu_range_read_retry(&mrn, range.notifier_seq) { > release_lock(driver->update); > - up_read(&mm->mmap_sem); > goto again; > } > =20 > - // Use pfns array content to update device page table > + /* Use pfns array content to update device page table, > + * under the update lock */ > =20 > - hmm_range_unregister(&range); > release_lock(driver->update); > - up_read(&mm->mmap_sem); > return 0; > } > =20 > The driver->update lock is the same lock that the driver takes inside it= s > -sync_cpu_device_pagetables() callback. That lock must be held before cal= ling > -hmm_range_valid() to avoid any race with a concurrent CPU page table upd= ate. > - > -HMM implements all this on top of the mmu_notifier API because we wanted= a > -simpler API and also to be able to perform optimizations latter on like = doing > -concurrent device updates in multi-devices scenario. > - > -HMM also serves as an impedance mismatch between how CPU page table upda= tes > -are done (by CPU write to the page table and TLB flushes) and how device= s > -update their own page table. Device updates are a multi-step process. Fi= rst, > -appropriate commands are written to a buffer, then this buffer is schedu= led for > -execution on the device. It is only once the device has executed command= s in > -the buffer that the update is done. Creating and scheduling the update c= ommand > -buffer can happen concurrently for multiple devices. Waiting for each de= vice to > -report commands as executed is serialized (there is no point in doing th= is > -concurrently). > - > +invalidate() callback. That lock must be held before calling > +mmu_range_read_retry() to avoid any race with a concurrent CPU page tabl= e > +update. > =20 > Leverage default_flags and pfn_flags_mask > =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D > diff --git a/include/linux/hmm.h b/include/linux/hmm.h > index 2666eb08a40615..b4af5173523232 100644 > --- a/include/linux/hmm.h > +++ b/include/linux/hmm.h > @@ -68,29 +68,6 @@ > #include > #include > =20 > - > -/* > - * struct hmm - HMM per mm struct > - * > - * @mm: mm struct this HMM struct is bound to > - * @lock: lock protecting ranges list > - * @ranges: list of range being snapshotted > - * @mirrors: list of mirrors for this mm > - * @mmu_notifier: mmu notifier to track updates to CPU page table > - * @mirrors_sem: read/write semaphore protecting the mirrors list > - * @wq: wait queue for user waiting on a range invalidation > - * @notifiers: count of active mmu notifiers > - */ > -struct hmm { > -=09struct mmu_notifier=09mmu_notifier; > -=09spinlock_t=09=09ranges_lock; > -=09struct list_head=09ranges; > -=09struct list_head=09mirrors; > -=09struct rw_semaphore=09mirrors_sem; > -=09wait_queue_head_t=09wq; > -=09long=09=09=09notifiers; > -}; > - > /* > * hmm_pfn_flag_e - HMM flag enums > * > @@ -143,9 +120,8 @@ enum hmm_pfn_value_e { > /* > * struct hmm_range - track invalidation lock on virtual address range > * > - * @notifier: an optional mmu_range_notifier > - * @notifier_seq: when notifier is used this is the result of > - * mmu_range_read_begin() > + * @notifier: a mmu_range_notifier that includes the start/end > + * @notifier_seq: result of mmu_range_read_begin() > * @hmm: the core HMM structure this range is active against > * @vma: the vm area struct for the range > * @list: all range lock are on a list > @@ -162,8 +138,6 @@ enum hmm_pfn_value_e { > struct hmm_range { > =09struct mmu_range_notifier *notifier; > =09unsigned long=09=09notifier_seq; > -=09struct hmm=09=09*hmm; > -=09struct list_head=09list; > =09unsigned long=09=09start; > =09unsigned long=09=09end; > =09uint64_t=09=09*pfns; > @@ -172,32 +146,8 @@ struct hmm_range { > =09uint64_t=09=09default_flags; > =09uint64_t=09=09pfn_flags_mask; > =09uint8_t=09=09=09pfn_shift; > -=09bool=09=09=09valid; > }; > =20 > -/* > - * hmm_range_wait_until_valid() - wait for range to be valid > - * @range: range affected by invalidation to wait on > - * @timeout: time out for wait in ms (ie abort wait after that period of= time) > - * Return: true if the range is valid, false otherwise. > - */ > -static inline bool hmm_range_wait_until_valid(struct hmm_range *range, > -=09=09=09=09=09 unsigned long timeout) > -{ > -=09return wait_event_timeout(range->hmm->wq, range->valid, > -=09=09=09=09 msecs_to_jiffies(timeout)) !=3D 0; > -} > - > -/* > - * hmm_range_valid() - test if a range is valid or not > - * @range: range > - * Return: true if the range is valid, false otherwise. > - */ > -static inline bool hmm_range_valid(struct hmm_range *range) > -{ > -=09return range->valid; > -} > - > /* > * hmm_device_entry_to_page() - return struct page pointed to by a devic= e entry > * @range: range use to decode device entry value > @@ -267,111 +217,6 @@ static inline uint64_t hmm_device_entry_from_pfn(co= nst struct hmm_range *range, > =09=09range->flags[HMM_PFN_VALID]; > } > =20 > -/* > - * Mirroring: how to synchronize device page table with CPU page table. > - * > - * A device driver that is participating in HMM mirroring must always > - * synchronize with CPU page table updates. For this, device drivers can= either > - * directly use mmu_notifier APIs or they can use the hmm_mirror API. De= vice > - * drivers can decide to register one mirror per device per process, or = just > - * one mirror per process for a group of devices. The pattern is: > - * > - * int device_bind_address_space(..., struct mm_struct *mm, ...) > - * { > - * struct device_address_space *das; > - * > - * // Device driver specific initialization, and allocation of = das > - * // which contains an hmm_mirror struct as one of its fields. > - * ... > - * > - * ret =3D hmm_mirror_register(&das->mirror, mm, &device_mirror= _ops); > - * if (ret) { > - * // Cleanup on error > - * return ret; > - * } > - * > - * // Other device driver specific initialization > - * ... > - * } > - * > - * Once an hmm_mirror is registered for an address space, the device dri= ver > - * will get callbacks through sync_cpu_device_pagetables() operation (se= e > - * hmm_mirror_ops struct). > - * > - * Device driver must not free the struct containing the hmm_mirror stru= ct > - * before calling hmm_mirror_unregister(). The expected usage is to do t= hat when > - * the device driver is unbinding from an address space. > - * > - * > - * void device_unbind_address_space(struct device_address_space *da= s) > - * { > - * // Device driver specific cleanup > - * ... > - * > - * hmm_mirror_unregister(&das->mirror); > - * > - * // Other device driver specific cleanup, and now das can be = freed > - * ... > - * } > - */ > - > -struct hmm_mirror; > - > -/* > - * struct hmm_mirror_ops - HMM mirror device operations callback > - * > - * @update: callback to update range on a device > - */ > -struct hmm_mirror_ops { > -=09/* release() - release hmm_mirror > -=09 * > -=09 * @mirror: pointer to struct hmm_mirror > -=09 * > -=09 * This is called when the mm_struct is being released. The callback > -=09 * must ensure that all access to any pages obtained from this mirror > -=09 * is halted before the callback returns. All future access should > -=09 * fault. > -=09 */ > -=09void (*release)(struct hmm_mirror *mirror); > - > -=09/* sync_cpu_device_pagetables() - synchronize page tables > -=09 * > -=09 * @mirror: pointer to struct hmm_mirror > -=09 * @update: update information (see struct mmu_notifier_range) > -=09 * Return: -EAGAIN if mmu_notifier_range_blockable(update) is false > -=09 * and callback needs to block, 0 otherwise. > -=09 * > -=09 * This callback ultimately originates from mmu_notifiers when the CP= U > -=09 * page table is updated. The device driver must update its page tabl= e > -=09 * in response to this callback. The update argument tells what actio= n > -=09 * to perform. > -=09 * > -=09 * The device driver must not return from this callback until the dev= ice > -=09 * page tables are completely updated (TLBs flushed, etc); this is a > -=09 * synchronous call. > -=09 */ > -=09int (*sync_cpu_device_pagetables)( > -=09=09struct hmm_mirror *mirror, > -=09=09const struct mmu_notifier_range *update); > -}; > - > -/* > - * struct hmm_mirror - mirror struct for a device driver > - * > - * @hmm: pointer to struct hmm (which is unique per mm_struct) > - * @ops: device driver callback for HMM mirror operations > - * @list: for list of mirrors of a given mm > - * > - * Each address space (mm_struct) being mirrored by a device must regist= er one > - * instance of an hmm_mirror struct with HMM. HMM will track the list of= all > - * mirrors for each mm_struct. > - */ > -struct hmm_mirror { > -=09struct hmm=09=09=09*hmm; > -=09const struct hmm_mirror_ops=09*ops; > -=09struct list_head=09=09list; > -}; > - > /* > * Retry fault if non-blocking, drop mmap_sem and return -EAGAIN in that= case. > */ > @@ -381,15 +226,9 @@ struct hmm_mirror { > #define HMM_FAULT_SNAPSHOT=09=09(1 << 1) > =20 > #ifdef CONFIG_HMM_MIRROR > -int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm)= ; > -void hmm_mirror_unregister(struct hmm_mirror *mirror); > - > /* > * Please see Documentation/vm/hmm.rst for how to use the range API. > */ > -int hmm_range_register(struct hmm_range *range, struct hmm_mirror *mirro= r); > -void hmm_range_unregister(struct hmm_range *range); > - > long hmm_range_fault(struct hmm_range *range, unsigned int flags); > =20 > long hmm_range_dma_map(struct hmm_range *range, > @@ -401,24 +240,6 @@ long hmm_range_dma_unmap(struct hmm_range *range, > =09=09=09 dma_addr_t *daddrs, > =09=09=09 bool dirty); > #else > -int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm) > -{ > -=09return -EOPNOTSUPP; > -} > - > -void hmm_mirror_unregister(struct hmm_mirror *mirror) > -{ > -} > - > -int hmm_range_register(struct hmm_range *range, struct hmm_mirror *mirro= r) > -{ > -=09return -EOPNOTSUPP; > -} > - > -void hmm_range_unregister(struct hmm_range *range) > -{ > -} > - > static inline long hmm_range_fault(struct hmm_range *range, unsigned int= flags) > { > =09return -EOPNOTSUPP; > diff --git a/mm/Kconfig b/mm/Kconfig > index d0b5046d9aeffd..e38ff1d5968dbf 100644 > --- a/mm/Kconfig > +++ b/mm/Kconfig > @@ -675,7 +675,6 @@ config DEV_PAGEMAP_OPS > config HMM_MIRROR > =09bool > =09depends on MMU > -=09depends on MMU_NOTIFIER > =20 > config DEVICE_PRIVATE > =09bool "Unaddressable device memory (GPU memory, ...)" > diff --git a/mm/hmm.c b/mm/hmm.c > index 22ac3595771feb..75d15a820e182e 100644 > --- a/mm/hmm.c > +++ b/mm/hmm.c > @@ -26,193 +26,6 @@ > #include > #include > =20 > -static struct mmu_notifier *hmm_alloc_notifier(struct mm_struct *mm) > -{ > -=09struct hmm *hmm; > - > -=09hmm =3D kzalloc(sizeof(*hmm), GFP_KERNEL); > -=09if (!hmm) > -=09=09return ERR_PTR(-ENOMEM); > - > -=09init_waitqueue_head(&hmm->wq); > -=09INIT_LIST_HEAD(&hmm->mirrors); > -=09init_rwsem(&hmm->mirrors_sem); > -=09INIT_LIST_HEAD(&hmm->ranges); > -=09spin_lock_init(&hmm->ranges_lock); > -=09hmm->notifiers =3D 0; > -=09return &hmm->mmu_notifier; > -} > - > -static void hmm_free_notifier(struct mmu_notifier *mn) > -{ > -=09struct hmm *hmm =3D container_of(mn, struct hmm, mmu_notifier); > - > -=09WARN_ON(!list_empty(&hmm->ranges)); > -=09WARN_ON(!list_empty(&hmm->mirrors)); > -=09kfree(hmm); > -} > - > -static void hmm_release(struct mmu_notifier *mn, struct mm_struct *mm) > -{ > -=09struct hmm *hmm =3D container_of(mn, struct hmm, mmu_notifier); > -=09struct hmm_mirror *mirror; > - > -=09/* > -=09 * Since hmm_range_register() holds the mmget() lock hmm_release() is > -=09 * prevented as long as a range exists. > -=09 */ > -=09WARN_ON(!list_empty_careful(&hmm->ranges)); > - > -=09down_read(&hmm->mirrors_sem); > -=09list_for_each_entry(mirror, &hmm->mirrors, list) { > -=09=09/* > -=09=09 * Note: The driver is not allowed to trigger > -=09=09 * hmm_mirror_unregister() from this thread. > -=09=09 */ > -=09=09if (mirror->ops->release) > -=09=09=09mirror->ops->release(mirror); > -=09} > -=09up_read(&hmm->mirrors_sem); > -} > - > -static void notifiers_decrement(struct hmm *hmm) > -{ > -=09unsigned long flags; > - > -=09spin_lock_irqsave(&hmm->ranges_lock, flags); > -=09hmm->notifiers--; > -=09if (!hmm->notifiers) { > -=09=09struct hmm_range *range; > - > -=09=09list_for_each_entry(range, &hmm->ranges, list) { > -=09=09=09if (range->valid) > -=09=09=09=09continue; > -=09=09=09range->valid =3D true; > -=09=09} > -=09=09wake_up_all(&hmm->wq); > -=09} > -=09spin_unlock_irqrestore(&hmm->ranges_lock, flags); > -} > - > -static int hmm_invalidate_range_start(struct mmu_notifier *mn, > -=09=09=09const struct mmu_notifier_range *nrange) > -{ > -=09struct hmm *hmm =3D container_of(mn, struct hmm, mmu_notifier); > -=09struct hmm_mirror *mirror; > -=09struct hmm_range *range; > -=09unsigned long flags; > -=09int ret =3D 0; > - > -=09spin_lock_irqsave(&hmm->ranges_lock, flags); > -=09hmm->notifiers++; > -=09list_for_each_entry(range, &hmm->ranges, list) { > -=09=09if (nrange->end < range->start || nrange->start >=3D range->end) > -=09=09=09continue; > - > -=09=09range->valid =3D false; > -=09} > -=09spin_unlock_irqrestore(&hmm->ranges_lock, flags); > - > -=09if (mmu_notifier_range_blockable(nrange)) > -=09=09down_read(&hmm->mirrors_sem); > -=09else if (!down_read_trylock(&hmm->mirrors_sem)) { > -=09=09ret =3D -EAGAIN; > -=09=09goto out; > -=09} > - > -=09list_for_each_entry(mirror, &hmm->mirrors, list) { > -=09=09int rc; > - > -=09=09rc =3D mirror->ops->sync_cpu_device_pagetables(mirror, nrange); > -=09=09if (rc) { > -=09=09=09if (WARN_ON(mmu_notifier_range_blockable(nrange) || > -=09=09=09 rc !=3D -EAGAIN)) > -=09=09=09=09continue; > -=09=09=09ret =3D -EAGAIN; > -=09=09=09break; > -=09=09} > -=09} > -=09up_read(&hmm->mirrors_sem); > - > -out: > -=09if (ret) > -=09=09notifiers_decrement(hmm); > -=09return ret; > -} > - > -static void hmm_invalidate_range_end(struct mmu_notifier *mn, > -=09=09=09const struct mmu_notifier_range *nrange) > -{ > -=09struct hmm *hmm =3D container_of(mn, struct hmm, mmu_notifier); > - > -=09notifiers_decrement(hmm); > -} > - > -static const struct mmu_notifier_ops hmm_mmu_notifier_ops =3D { > -=09.release=09=09=3D hmm_release, > -=09.invalidate_range_start=09=3D hmm_invalidate_range_start, > -=09.invalidate_range_end=09=3D hmm_invalidate_range_end, > -=09.alloc_notifier=09=09=3D hmm_alloc_notifier, > -=09.free_notifier=09=09=3D hmm_free_notifier, > -}; > - > -/* > - * hmm_mirror_register() - register a mirror against an mm > - * > - * @mirror: new mirror struct to register > - * @mm: mm to register against > - * Return: 0 on success, -ENOMEM if no memory, -EINVAL if invalid argume= nts > - * > - * To start mirroring a process address space, the device driver must re= gister > - * an HMM mirror struct. > - * > - * The caller cannot unregister the hmm_mirror while any ranges are > - * registered. > - * > - * Callers using this function must put a call to mmu_notifier_synchroni= ze() > - * in their module exit functions. > - */ > -int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm) > -{ > -=09struct mmu_notifier *mn; > - > -=09lockdep_assert_held_write(&mm->mmap_sem); > - > -=09/* Sanity check */ > -=09if (!mm || !mirror || !mirror->ops) > -=09=09return -EINVAL; > - > -=09mn =3D mmu_notifier_get_locked(&hmm_mmu_notifier_ops, mm); > -=09if (IS_ERR(mn)) > -=09=09return PTR_ERR(mn); > -=09mirror->hmm =3D container_of(mn, struct hmm, mmu_notifier); > - > -=09down_write(&mirror->hmm->mirrors_sem); > -=09list_add(&mirror->list, &mirror->hmm->mirrors); > -=09up_write(&mirror->hmm->mirrors_sem); > - > -=09return 0; > -} > -EXPORT_SYMBOL(hmm_mirror_register); > - > -/* > - * hmm_mirror_unregister() - unregister a mirror > - * > - * @mirror: mirror struct to unregister > - * > - * Stop mirroring a process address space, and cleanup. > - */ > -void hmm_mirror_unregister(struct hmm_mirror *mirror) > -{ > -=09struct hmm *hmm =3D mirror->hmm; > - > -=09down_write(&hmm->mirrors_sem); > -=09list_del(&mirror->list); > -=09up_write(&hmm->mirrors_sem); > -=09mmu_notifier_put(&hmm->mmu_notifier); > -} > -EXPORT_SYMBOL(hmm_mirror_unregister); > - > struct hmm_vma_walk { > =09struct hmm_range=09*range; > =09struct dev_pagemap=09*pgmap; > @@ -779,87 +592,6 @@ static void hmm_pfns_clear(struct hmm_range *range, > =09=09*pfns =3D range->values[HMM_PFN_NONE]; > } > =20 > -/* > - * hmm_range_register() - start tracking change to CPU page table over a= range > - * @range: range > - * @mm: the mm struct for the range of virtual address > - * > - * Return: 0 on success, -EFAULT if the address space is no longer valid > - * > - * Track updates to the CPU page table see include/linux/hmm.h > - */ > -int hmm_range_register(struct hmm_range *range, struct hmm_mirror *mirro= r) > -{ > -=09struct hmm *hmm =3D mirror->hmm; > -=09unsigned long flags; > - > -=09range->valid =3D false; > -=09range->hmm =3D NULL; > - > -=09if ((range->start & (PAGE_SIZE - 1)) || (range->end & (PAGE_SIZE - 1)= )) > -=09=09return -EINVAL; > -=09if (range->start >=3D range->end) > -=09=09return -EINVAL; > - > -=09/* Prevent hmm_release() from running while the range is valid */ > -=09if (!mmget_not_zero(hmm->mmu_notifier.mm)) > -=09=09return -EFAULT; > - > -=09/* Initialize range to track CPU page table updates. */ > -=09spin_lock_irqsave(&hmm->ranges_lock, flags); > - > -=09range->hmm =3D hmm; > -=09list_add(&range->list, &hmm->ranges); > - > -=09/* > -=09 * If there are any concurrent notifiers we have to wait for them for > -=09 * the range to be valid (see hmm_range_wait_until_valid()). > -=09 */ > -=09if (!hmm->notifiers) > -=09=09range->valid =3D true; > -=09spin_unlock_irqrestore(&hmm->ranges_lock, flags); > - > -=09return 0; > -} > -EXPORT_SYMBOL(hmm_range_register); > - > -/* > - * hmm_range_unregister() - stop tracking change to CPU page table over = a range > - * @range: range > - * > - * Range struct is used to track updates to the CPU page table after a c= all to > - * hmm_range_register(). See include/linux/hmm.h for how to use it. > - */ > -void hmm_range_unregister(struct hmm_range *range) > -{ > -=09struct hmm *hmm =3D range->hmm; > -=09unsigned long flags; > - > -=09spin_lock_irqsave(&hmm->ranges_lock, flags); > -=09list_del_init(&range->list); > -=09spin_unlock_irqrestore(&hmm->ranges_lock, flags); > - > -=09/* Drop reference taken by hmm_range_register() */ > -=09mmput(hmm->mmu_notifier.mm); > - > -=09/* > -=09 * The range is now invalid and the ref on the hmm is dropped, so > -=09 * poison the pointer. Leave other fields in place, for the caller's > -=09 * use. > -=09 */ > -=09range->valid =3D false; > -=09memset(&range->hmm, POISON_INUSE, sizeof(range->hmm)); > -} > -EXPORT_SYMBOL(hmm_range_unregister); > - > -static bool needs_retry(struct hmm_range *range) > -{ > -=09if (range->notifier) > -=09=09return mmu_range_check_retry(range->notifier, > -=09=09=09=09=09 range->notifier_seq); > -=09return !range->valid; > -} > - > static const struct mm_walk_ops hmm_walk_ops =3D { > =09.pud_entry=09=3D hmm_vma_walk_pud, > =09.pmd_entry=09=3D hmm_vma_walk_pmd, > @@ -900,20 +632,15 @@ long hmm_range_fault(struct hmm_range *range, unsig= ned int flags) > =09const unsigned long device_vma =3D VM_IO | VM_PFNMAP | VM_MIXEDMAP; > =09unsigned long start =3D range->start, end; > =09struct hmm_vma_walk hmm_vma_walk; > -=09struct mm_struct *mm; > +=09struct mm_struct *mm =3D range->notifier->mm; > =09struct vm_area_struct *vma; > =09int ret; > =20 > -=09if (range->notifier) > -=09=09mm =3D range->notifier->mm; > -=09else > -=09=09mm =3D range->hmm->mmu_notifier.mm; > - > =09lockdep_assert_held(&mm->mmap_sem); > =20 > =09do { > =09=09/* If range is no longer valid force retry. */ > -=09=09if (needs_retry(range)) > +=09=09if (mmu_range_check_retry(range->notifier, range->notifier_seq)) > =09=09=09return -EBUSY; > =20 > =09=09vma =3D find_vma(mm, start); > @@ -946,7 +673,9 @@ long hmm_range_fault(struct hmm_range *range, unsigne= d int flags) > =09=09=09start =3D hmm_vma_walk.last; > =20 > =09=09=09/* Keep trying while the range is valid. */ > -=09=09} while (ret =3D=3D -EBUSY && !needs_retry(range)); > +=09=09} while (ret =3D=3D -EBUSY && > +=09=09=09 !mmu_range_check_retry(range->notifier, > +=09=09=09=09=09=09range->notifier_seq)); > =20 > =09=09if (ret) { > =09=09=09unsigned long i; > @@ -1004,7 +733,8 @@ long hmm_range_dma_map(struct hmm_range *range, stru= ct device *device, > =09=09=09continue; > =20 > =09=09/* Check if range is being invalidated */ > -=09=09if (needs_retry(range)) { > +=09=09if (mmu_range_check_retry(range->notifier, > +=09=09=09=09=09 range->notifier_seq)) { > =09=09=09ret =3D -EBUSY; > =09=09=09goto unmap; > =09=09} > --=20 > 2.23.0 >=20