From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jerome Glisse Subject: Re: [PATCH 2/9] mm: Add an apply_to_pfn_range interface Date: Fri, 12 Apr 2019 17:07:43 -0400 Message-ID: <20190412210743.GA19252@redhat.com> References: <20190412160338.64994-1-thellstrom@vmware.com> <20190412160338.64994-3-thellstrom@vmware.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mx1.redhat.com (mx1.redhat.com [209.132.183.28]) by gabe.freedesktop.org (Postfix) with ESMTPS id CB77689A20 for ; Fri, 12 Apr 2019 21:07:49 +0000 (UTC) Content-Disposition: inline In-Reply-To: <20190412160338.64994-3-thellstrom@vmware.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Thomas Hellstrom Cc: Michal Hocko , Rik van Riel , Peter Zijlstra , Will Deacon , "linux-kernel@vger.kernel.org" , Matthew Wilcox , "linux-mm@kvack.org" , Minchan Kim , Linux-graphics-maintainer , "dri-devel@lists.freedesktop.org" , Huang Ying , Andrew Morton , Souptick Joarder List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBBcHIgMTIsIDIwMTkgYXQgMDQ6MDQ6MThQTSArMDAwMCwgVGhvbWFzIEhlbGxzdHJv bSB3cm90ZToKPiBUaGlzIGlzIGJhc2ljYWxseSBhcHBseV90b19wYWdlX3JhbmdlIHdpdGggYWRk ZWQgZnVuY3Rpb25hbGl0eToKPiBBbGxvY2F0aW5nIG1pc3NpbmcgcGFydHMgb2YgdGhlIHBhZ2Ug dGFibGUgYmVjb21lcyBvcHRpb25hbCwgd2hpY2gKPiBtZWFucyB0aGF0IHRoZSBmdW5jdGlvbiBj YW4gYmUgZ3VhcmFudGVlZCBub3QgdG8gZXJyb3IgaWYgYWxsb2NhdGlvbgo+IGlzIGRpc2FibGVk LiBBbHNvIHBhc3Npbmcgb2YgdGhlIGNsb3N1cmUgc3RydWN0IGFuZCBjYWxsYmFjayBmdW5jdGlv bgo+IGJlY29tZXMgZGlmZmVyZW50IGFuZCBtb3JlIGluIGxpbmUgd2l0aCBob3cgdGhpbmdzIGFy ZSBkb25lIGVsc2V3aGVyZS4KPiAKPiBGaW5hbGx5IHdlIGtlZXAgYXBwbHlfdG9fcGFnZV9yYW5n ZSBhcyBhIHdyYXBwZXIgYXJvdW5kIGFwcGx5X3RvX3Bmbl9yYW5nZQo+IAo+IFRoZSByZWFzb24g Zm9yIG5vdCB1c2luZyB0aGUgcGFnZS13YWxrIGNvZGUgaXMgdGhhdCB3ZSB3YW50IHRvIHBlcmZv cm0KPiB0aGUgcGFnZS13YWxrIG9uIHZtYXMgcG9pbnRpbmcgdG8gYW4gYWRkcmVzcyBzcGFjZSB3 aXRob3V0IHJlcXVpcmluZyB0aGUKPiBtbWFwX3NlbSB0byBiZSBoZWxkIHJhdGhlciB0aGFuZCBv biB2bWFzIGJlbG9uZ2luZyB0byBhIHByb2Nlc3Mgd2l0aCB0aGUKPiBtbWFwX3NlbSBoZWxkLgo+ IAo+IE5vdGFibGUgY2hhbmdlcyBzaW5jZSBSRkM6Cj4gRG9uJ3QgZXhwb3J0IGFwcGx5X3RvX3Bm biByYW5nZS4KPiAKPiBDYzogQW5kcmV3IE1vcnRvbiA8YWtwbUBsaW51eC1mb3VuZGF0aW9uLm9y Zz4KPiBDYzogTWF0dGhldyBXaWxjb3ggPHdpbGx5QGluZnJhZGVhZC5vcmc+Cj4gQ2M6IFdpbGwg RGVhY29uIDx3aWxsLmRlYWNvbkBhcm0uY29tPgo+IENjOiBQZXRlciBaaWpsc3RyYSA8cGV0ZXJ6 QGluZnJhZGVhZC5vcmc+Cj4gQ2M6IFJpayB2YW4gUmllbCA8cmllbEBzdXJyaWVsLmNvbT4KPiBD YzogTWluY2hhbiBLaW0gPG1pbmNoYW5Aa2VybmVsLm9yZz4KPiBDYzogTWljaGFsIEhvY2tvIDxt aG9ja29Ac3VzZS5jb20+Cj4gQ2M6IEh1YW5nIFlpbmcgPHlpbmcuaHVhbmdAaW50ZWwuY29tPgo+ IENjOiBTb3VwdGljayBKb2FyZGVyIDxqcmRyLmxpbnV4QGdtYWlsLmNvbT4KPiBDYzogIkrDqXLD tG1lIEdsaXNzZSIgPGpnbGlzc2VAcmVkaGF0LmNvbT4KPiBDYzogbGludXgtbW1Aa3ZhY2sub3Jn Cj4gQ2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPiBTaWduZWQtb2ZmLWJ5OiBUaG9t YXMgSGVsbHN0cm9tIDx0aGVsbHN0cm9tQHZtd2FyZS5jb20+Cj4gLS0tCj4gIGluY2x1ZGUvbGlu dXgvbW0uaCB8ICAxMCArKysrCj4gIG1tL21lbW9yeS5jICAgICAgICB8IDEzMCArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0KPiAgMiBmaWxlcyBjaGFuZ2VkLCAx MDggaW5zZXJ0aW9ucygrKSwgMzIgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2luY2x1 ZGUvbGludXgvbW0uaCBiL2luY2x1ZGUvbGludXgvbW0uaAo+IGluZGV4IDgwYmI2NDA4ZmU3My4u YjdkZDRkZGQ2ZWZiIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvbW0uaAo+ICsrKyBiL2lu Y2x1ZGUvbGludXgvbW0uaAo+IEBAIC0yNjMyLDYgKzI2MzIsMTYgQEAgdHlwZWRlZiBpbnQgKCpw dGVfZm5fdCkocHRlX3QgKnB0ZSwgcGd0YWJsZV90IHRva2VuLCB1bnNpZ25lZCBsb25nIGFkZHIs Cj4gIGV4dGVybiBpbnQgYXBwbHlfdG9fcGFnZV9yYW5nZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwg dW5zaWduZWQgbG9uZyBhZGRyZXNzLAo+ICAJCQkgICAgICAgdW5zaWduZWQgbG9uZyBzaXplLCBw dGVfZm5fdCBmbiwgdm9pZCAqZGF0YSk7Cj4gIAo+ICtzdHJ1Y3QgcGZuX3JhbmdlX2FwcGx5Owo+ ICt0eXBlZGVmIGludCAoKnB0ZXJfZm5fdCkocHRlX3QgKnB0ZSwgcGd0YWJsZV90IHRva2VuLCB1 bnNpZ25lZCBsb25nIGFkZHIsCj4gKwkJCSBzdHJ1Y3QgcGZuX3JhbmdlX2FwcGx5ICpjbG9zdXJl KTsKPiArc3RydWN0IHBmbl9yYW5nZV9hcHBseSB7Cj4gKwlzdHJ1Y3QgbW1fc3RydWN0ICptbTsK PiArCXB0ZXJfZm5fdCBwdGVmbjsKPiArCXVuc2lnbmVkIGludCBhbGxvYzsKPiArfTsKPiArZXh0 ZXJuIGludCBhcHBseV90b19wZm5fcmFuZ2Uoc3RydWN0IHBmbl9yYW5nZV9hcHBseSAqY2xvc3Vy ZSwKPiArCQkJICAgICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzLCB1bnNpZ25lZCBsb25nIHNpemUp Owo+ICAKPiAgI2lmZGVmIENPTkZJR19QQUdFX1BPSVNPTklORwo+ICBleHRlcm4gYm9vbCBwYWdl X3BvaXNvbmluZ19lbmFibGVkKHZvaWQpOwo+IGRpZmYgLS1naXQgYS9tbS9tZW1vcnkuYyBiL21t L21lbW9yeS5jCj4gaW5kZXggYTk1YjRhM2IxYWUyLi42MGQ2NzE1ODk2NGYgMTAwNjQ0Cj4gLS0t IGEvbW0vbWVtb3J5LmMKPiArKysgYi9tbS9tZW1vcnkuYwo+IEBAIC0xOTM4LDE4ICsxOTM4LDE3 IEBAIGludCB2bV9pb21hcF9tZW1vcnkoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHBoeXNf YWRkcl90IHN0YXJ0LCB1bnNpZ25lZCBsb25nCj4gIH0KPiAgRVhQT1JUX1NZTUJPTCh2bV9pb21h cF9tZW1vcnkpOwo+ICAKPiAtc3RhdGljIGludCBhcHBseV90b19wdGVfcmFuZ2Uoc3RydWN0IG1t X3N0cnVjdCAqbW0sIHBtZF90ICpwbWQsCj4gLQkJCQkgICAgIHVuc2lnbmVkIGxvbmcgYWRkciwg dW5zaWduZWQgbG9uZyBlbmQsCj4gLQkJCQkgICAgIHB0ZV9mbl90IGZuLCB2b2lkICpkYXRhKQo+ ICtzdGF0aWMgaW50IGFwcGx5X3RvX3B0ZV9yYW5nZShzdHJ1Y3QgcGZuX3JhbmdlX2FwcGx5ICpj bG9zdXJlLCBwbWRfdCAqcG1kLAo+ICsJCQkgICAgICB1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2ln bmVkIGxvbmcgZW5kKQo+ICB7Cj4gIAlwdGVfdCAqcHRlOwo+ICAJaW50IGVycjsKPiAgCXBndGFi bGVfdCB0b2tlbjsKPiAgCXNwaW5sb2NrX3QgKnVuaW5pdGlhbGl6ZWRfdmFyKHB0bCk7Cj4gIAo+ IC0JcHRlID0gKG1tID09ICZpbml0X21tKSA/Cj4gKwlwdGUgPSAoY2xvc3VyZS0+bW0gPT0gJmlu aXRfbW0pID8KPiAgCQlwdGVfYWxsb2Nfa2VybmVsKHBtZCwgYWRkcikgOgo+IC0JCXB0ZV9hbGxv Y19tYXBfbG9jayhtbSwgcG1kLCBhZGRyLCAmcHRsKTsKPiArCQlwdGVfYWxsb2NfbWFwX2xvY2so Y2xvc3VyZS0+bW0sIHBtZCwgYWRkciwgJnB0bCk7Cj4gIAlpZiAoIXB0ZSkKPiAgCQlyZXR1cm4g LUVOT01FTTsKPiAgCj4gQEAgLTE5NjAsODYgKzE5NTksMTA3IEBAIHN0YXRpYyBpbnQgYXBwbHlf dG9fcHRlX3JhbmdlKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwbWRfdCAqcG1kLAo+ICAJdG9rZW4g PSBwbWRfcGd0YWJsZSgqcG1kKTsKPiAgCj4gIAlkbyB7Cj4gLQkJZXJyID0gZm4ocHRlKyssIHRv a2VuLCBhZGRyLCBkYXRhKTsKPiArCQllcnIgPSBjbG9zdXJlLT5wdGVmbihwdGUrKywgdG9rZW4s IGFkZHIsIGNsb3N1cmUpOwo+ICAJCWlmIChlcnIpCj4gIAkJCWJyZWFrOwo+ICAJfSB3aGlsZSAo YWRkciArPSBQQUdFX1NJWkUsIGFkZHIgIT0gZW5kKTsKPiAgCj4gIAlhcmNoX2xlYXZlX2xhenlf bW11X21vZGUoKTsKPiAgCj4gLQlpZiAobW0gIT0gJmluaXRfbW0pCj4gKwlpZiAoY2xvc3VyZS0+ bW0gIT0gJmluaXRfbW0pCj4gIAkJcHRlX3VubWFwX3VubG9jayhwdGUtMSwgcHRsKTsKPiAgCXJl dHVybiBlcnI7Cj4gIH0KPiAgCj4gLXN0YXRpYyBpbnQgYXBwbHlfdG9fcG1kX3JhbmdlKHN0cnVj dCBtbV9zdHJ1Y3QgKm1tLCBwdWRfdCAqcHVkLAo+IC0JCQkJICAgICB1bnNpZ25lZCBsb25nIGFk ZHIsIHVuc2lnbmVkIGxvbmcgZW5kLAo+IC0JCQkJICAgICBwdGVfZm5fdCBmbiwgdm9pZCAqZGF0 YSkKPiArc3RhdGljIGludCBhcHBseV90b19wbWRfcmFuZ2Uoc3RydWN0IHBmbl9yYW5nZV9hcHBs eSAqY2xvc3VyZSwgcHVkX3QgKnB1ZCwKPiArCQkJICAgICAgdW5zaWduZWQgbG9uZyBhZGRyLCB1 bnNpZ25lZCBsb25nIGVuZCkKPiAgewo+ICAJcG1kX3QgKnBtZDsKPiAgCXVuc2lnbmVkIGxvbmcg bmV4dDsKPiAtCWludCBlcnI7Cj4gKwlpbnQgZXJyID0gMDsKPiAgCj4gIAlCVUdfT04ocHVkX2h1 Z2UoKnB1ZCkpOwo+ICAKPiAtCXBtZCA9IHBtZF9hbGxvYyhtbSwgcHVkLCBhZGRyKTsKPiArCXBt ZCA9IHBtZF9hbGxvYyhjbG9zdXJlLT5tbSwgcHVkLCBhZGRyKTsKPiAgCWlmICghcG1kKQo+ICAJ CXJldHVybiAtRU5PTUVNOwo+ICsKPiAgCWRvIHsKPiAgCQluZXh0ID0gcG1kX2FkZHJfZW5kKGFk ZHIsIGVuZCk7Cj4gLQkJZXJyID0gYXBwbHlfdG9fcHRlX3JhbmdlKG1tLCBwbWQsIGFkZHIsIG5l eHQsIGZuLCBkYXRhKTsKPiArCQlpZiAoIWNsb3N1cmUtPmFsbG9jICYmIHBtZF9ub25lX29yX2Ns ZWFyX2JhZChwbWQpKQo+ICsJCQljb250aW51ZTsKPiArCQllcnIgPSBhcHBseV90b19wdGVfcmFu Z2UoY2xvc3VyZSwgcG1kLCBhZGRyLCBuZXh0KTsKPiAgCQlpZiAoZXJyKQo+ICAJCQlicmVhazsK PiAgCX0gd2hpbGUgKHBtZCsrLCBhZGRyID0gbmV4dCwgYWRkciAhPSBlbmQpOwo+ICAJcmV0dXJu IGVycjsKPiAgfQo+ICAKPiAtc3RhdGljIGludCBhcHBseV90b19wdWRfcmFuZ2Uoc3RydWN0IG1t X3N0cnVjdCAqbW0sIHA0ZF90ICpwNGQsCj4gLQkJCQkgICAgIHVuc2lnbmVkIGxvbmcgYWRkciwg dW5zaWduZWQgbG9uZyBlbmQsCj4gLQkJCQkgICAgIHB0ZV9mbl90IGZuLCB2b2lkICpkYXRhKQo+ ICtzdGF0aWMgaW50IGFwcGx5X3RvX3B1ZF9yYW5nZShzdHJ1Y3QgcGZuX3JhbmdlX2FwcGx5ICpj bG9zdXJlLCBwNGRfdCAqcDRkLAo+ICsJCQkgICAgICB1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2ln bmVkIGxvbmcgZW5kKQo+ICB7Cj4gIAlwdWRfdCAqcHVkOwo+ICAJdW5zaWduZWQgbG9uZyBuZXh0 Owo+IC0JaW50IGVycjsKPiArCWludCBlcnIgPSAwOwo+ICAKPiAtCXB1ZCA9IHB1ZF9hbGxvYyht bSwgcDRkLCBhZGRyKTsKPiArCXB1ZCA9IHB1ZF9hbGxvYyhjbG9zdXJlLT5tbSwgcDRkLCBhZGRy KTsKPiAgCWlmICghcHVkKQo+ICAJCXJldHVybiAtRU5PTUVNOwo+ICsKPiAgCWRvIHsKPiAgCQlu ZXh0ID0gcHVkX2FkZHJfZW5kKGFkZHIsIGVuZCk7Cj4gLQkJZXJyID0gYXBwbHlfdG9fcG1kX3Jh bmdlKG1tLCBwdWQsIGFkZHIsIG5leHQsIGZuLCBkYXRhKTsKPiArCQlpZiAoIWNsb3N1cmUtPmFs bG9jICYmIHB1ZF9ub25lX29yX2NsZWFyX2JhZChwdWQpKQo+ICsJCQljb250aW51ZTsKPiArCQll cnIgPSBhcHBseV90b19wbWRfcmFuZ2UoY2xvc3VyZSwgcHVkLCBhZGRyLCBuZXh0KTsKPiAgCQlp ZiAoZXJyKQo+ICAJCQlicmVhazsKPiAgCX0gd2hpbGUgKHB1ZCsrLCBhZGRyID0gbmV4dCwgYWRk ciAhPSBlbmQpOwo+ICAJcmV0dXJuIGVycjsKPiAgfQo+ICAKPiAtc3RhdGljIGludCBhcHBseV90 b19wNGRfcmFuZ2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHBnZF90ICpwZ2QsCj4gLQkJCQkgICAg IHVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgbG9uZyBlbmQsCj4gLQkJCQkgICAgIHB0ZV9m bl90IGZuLCB2b2lkICpkYXRhKQo+ICtzdGF0aWMgaW50IGFwcGx5X3RvX3A0ZF9yYW5nZShzdHJ1 Y3QgcGZuX3JhbmdlX2FwcGx5ICpjbG9zdXJlLCBwZ2RfdCAqcGdkLAo+ICsJCQkgICAgICB1bnNp Z25lZCBsb25nIGFkZHIsIHVuc2lnbmVkIGxvbmcgZW5kKQo+ICB7Cj4gIAlwNGRfdCAqcDRkOwo+ ICAJdW5zaWduZWQgbG9uZyBuZXh0Owo+IC0JaW50IGVycjsKPiArCWludCBlcnIgPSAwOwo+ICAK PiAtCXA0ZCA9IHA0ZF9hbGxvYyhtbSwgcGdkLCBhZGRyKTsKPiArCXA0ZCA9IHA0ZF9hbGxvYyhj bG9zdXJlLT5tbSwgcGdkLCBhZGRyKTsKPiAgCWlmICghcDRkKQo+ICAJCXJldHVybiAtRU5PTUVN Owo+ICsKPiAgCWRvIHsKPiAgCQluZXh0ID0gcDRkX2FkZHJfZW5kKGFkZHIsIGVuZCk7Cj4gLQkJ ZXJyID0gYXBwbHlfdG9fcHVkX3JhbmdlKG1tLCBwNGQsIGFkZHIsIG5leHQsIGZuLCBkYXRhKTsK PiArCQlpZiAoIWNsb3N1cmUtPmFsbG9jICYmIHA0ZF9ub25lX29yX2NsZWFyX2JhZChwNGQpKQo+ ICsJCQljb250aW51ZTsKPiArCQllcnIgPSBhcHBseV90b19wdWRfcmFuZ2UoY2xvc3VyZSwgcDRk LCBhZGRyLCBuZXh0KTsKPiAgCQlpZiAoZXJyKQo+ICAJCQlicmVhazsKPiAgCX0gd2hpbGUgKHA0 ZCsrLCBhZGRyID0gbmV4dCwgYWRkciAhPSBlbmQpOwo+ICAJcmV0dXJuIGVycjsKPiAgfQo+ICAK PiAtLyoKPiAtICogU2NhbiBhIHJlZ2lvbiBvZiB2aXJ0dWFsIG1lbW9yeSwgZmlsbGluZyBpbiBw YWdlIHRhYmxlcyBhcyBuZWNlc3NhcnkKPiAtICogYW5kIGNhbGxpbmcgYSBwcm92aWRlZCBmdW5j dGlvbiBvbiBlYWNoIGxlYWYgcGFnZSB0YWJsZS4KPiArLyoqCj4gKyAqIGFwcGx5X3RvX3Bmbl9y YW5nZSAtIFNjYW4gYSByZWdpb24gb2YgdmlydHVhbCBtZW1vcnksIGNhbGxpbmcgYSBwcm92aWRl ZAo+ICsgKiBmdW5jdGlvbiBvbiBlYWNoIGxlYWYgcGFnZSB0YWJsZSBlbnRyeQo+ICsgKiBAY2xv c3VyZTogRGV0YWlscyBhYm91dCBob3cgdG8gc2NhbiBhbmQgd2hhdCBmdW5jdGlvbiB0byBhcHBs eQo+ICsgKiBAYWRkcjogU3RhcnQgdmlydHVhbCBhZGRyZXNzCj4gKyAqIEBzaXplOiBTaXplIG9m IHRoZSByZWdpb24KPiArICoKPiArICogSWYgQGNsb3N1cmUtPmFsbG9jIGlzIHNldCB0byAxLCB0 aGUgZnVuY3Rpb24gd2lsbCBmaWxsIGluIHRoZSBwYWdlIHRhYmxlCj4gKyAqIGFzIG5lY2Vzc2Fy eS4gT3RoZXJ3aXNlIGl0IHdpbGwgc2tpcCBub24tcHJlc2VudCBwYXJ0cy4KPiArICogTm90ZTog VGhlIGNhbGxlciBtdXN0IGVuc3VyZSB0aGF0IHRoZSByYW5nZSBkb2VzIG5vdCBjb250YWluIGh1 Z2UgcGFnZXMuCj4gKyAqIFRoZSBjYWxsZXIgbXVzdCBhbHNvIGFzc3VyZSB0aGF0IHRoZSBwcm9w ZXIgbW11X25vdGlmaWVyIGZ1bmN0aW9ucyBhcmUKPiArICogY2FsbGVkLiBFaXRoZXIgaW4gdGhl IHB0ZSBsZWFmIGZ1bmN0aW9uIG9yIGJlZm9yZSBhbmQgYWZ0ZXIgdGhlIGNhbGwgdG8KPiArICog YXBwbHlfdG9fcGZuX3JhbmdlLgoKVGhpcyBpcyB3cm9uZyB0aGVyZSBzaG91bGQgYmUgYSBiaWcg RkFUIHdhcm5pbmcgdGhhdCB0aGlzIGNhbiBvbmx5IGJlIHVzZQphZ2FpbnN0IG1tYXAgb2YgZGV2 aWNlIGZpbGUuIFRoZSBwYWdlIHRhYmxlIHdhbGtpbmcgYWJvdmUgaXMgYnJva2VuIGZvcgp2YXJp b3VzIHRoaW5nIHlvdSBtaWdodCBmaW5kIGluIGFueSBvdGhlciB2bWEgbGlrZSBUSFAsIGRldmlj ZSBwdGUsIGh1Z2V0bGJmcywKLi4uCgpBbHNvIHRoZSBtbXUgbm90aWZpZXIgY2FuIG5vdCBiZSBj YWxsIGZyb20gdGhlIHBmbiBjYWxsYmFjayBhcyB0aGF0IGNhbGxiYWNrCmhhcHBlbnMgdW5kZXIg cGFnZSB0YWJsZSBsb2NrICh0aGUgY2hhbmdlX3B0ZSBub3RpZmllciBjYWxsYmFjayBpcyB1c2Vs ZXNzCmFuZCBub3QgZW5vdWdoKS4gU28gaXQgX211c3RfIGhhcHBlbiBhcm91bmQgdGhlIGNhbGwg dG8gYXBwbHlfdG9fcGZuX3JhbmdlCgphcHBseV90b19wYWdlX3JhbmdlIHdhcyByZWFsbHkgbm90 IG1lYW50IHRvIGJlIHVzZSBpbiB0aGF0IHdheSAuLi4gaXQgd2FzIG5vdApmb3IgcmVndWxhciB2 bWEuCgpVc2luZyB0aGlzIGZ1bmN0aW9uIGZvciBhbnl0aGluZyBlbHNlIGlzIGRhbmdlcm91cyBh bmQgaGF2aW5nIGl0cyB1c2VzIHNwcmVhZAptb3JlIGluY3JlYXNlIHRoYXQgcmlzay4gU28gdGhl cmUgbXVzdCBiZSBhIGJpZyBGQVQgd2FybmluZyBzYXlpbmcgdGhhdCB5b3UKc2hvdWxkIG5vdCB1 c2UgdGhpcyBsaWdodGx5IGFuZCB0aGF0IGl0IHNob3VsZCBvbmx5IGJlIG9ubHkgb24gbW1hcCBv ZiBkZXZpY2UKZmlsZS4KCgo+ICsgKgo+ICsgKiBSZXR1cm5zOiBaZXJvIG9uIHN1Y2Nlc3MuIElm IHRoZSBwcm92aWRlZCBmdW5jdGlvbiByZXR1cm5zIGEgbm9uLXplcm8gc3RhdHVzLAo+ICsgKiB0 aGUgcGFnZSB0YWJsZSB3YWxrIHdpbGwgdGVybWluYXRlIGFuZCB0aGF0IHN0YXR1cyB3aWxsIGJl IHJldHVybmVkLgo+ICsgKiBJZiBAY2xvc3VyZS0+YWxsb2MgaXMgc2V0IHRvIDEsIHRoZW4gdGhp cyBmdW5jdGlvbiBtYXkgYWxzbyByZXR1cm4gbWVtb3J5Cj4gKyAqIGFsbG9jYXRpb24gZXJyb3Jz IGFyaXNpbmcgZnJvbSBhbGxvY2F0aW5nIHBhZ2UgdGFibGUgbWVtb3J5Lgo+ICAgKi8KPiAtaW50 IGFwcGx5X3RvX3BhZ2VfcmFuZ2Uoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHVuc2lnbmVkIGxvbmcg YWRkciwKPiAtCQkJdW5zaWduZWQgbG9uZyBzaXplLCBwdGVfZm5fdCBmbiwgdm9pZCAqZGF0YSkK PiAraW50IGFwcGx5X3RvX3Bmbl9yYW5nZShzdHJ1Y3QgcGZuX3JhbmdlX2FwcGx5ICpjbG9zdXJl LAo+ICsJCSAgICAgICB1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2lnbmVkIGxvbmcgc2l6ZSkKPiAg ewo+ICAJcGdkX3QgKnBnZDsKPiAgCXVuc2lnbmVkIGxvbmcgbmV4dDsKPiBAQCAtMjA0OSwxNiAr MjA2OSw2MiBAQCBpbnQgYXBwbHlfdG9fcGFnZV9yYW5nZShzdHJ1Y3QgbW1fc3RydWN0ICptbSwg dW5zaWduZWQgbG9uZyBhZGRyLAo+ICAJaWYgKFdBUk5fT04oYWRkciA+PSBlbmQpKQo+ICAJCXJl dHVybiAtRUlOVkFMOwo+ICAKPiAtCXBnZCA9IHBnZF9vZmZzZXQobW0sIGFkZHIpOwo+ICsJcGdk ID0gcGdkX29mZnNldChjbG9zdXJlLT5tbSwgYWRkcik7Cj4gIAlkbyB7Cj4gIAkJbmV4dCA9IHBn ZF9hZGRyX2VuZChhZGRyLCBlbmQpOwo+IC0JCWVyciA9IGFwcGx5X3RvX3A0ZF9yYW5nZShtbSwg cGdkLCBhZGRyLCBuZXh0LCBmbiwgZGF0YSk7Cj4gKwkJaWYgKCFjbG9zdXJlLT5hbGxvYyAmJiBw Z2Rfbm9uZV9vcl9jbGVhcl9iYWQocGdkKSkKPiArCQkJY29udGludWU7Cj4gKwkJZXJyID0gYXBw bHlfdG9fcDRkX3JhbmdlKGNsb3N1cmUsIHBnZCwgYWRkciwgbmV4dCk7Cj4gIAkJaWYgKGVycikK PiAgCQkJYnJlYWs7Cj4gIAl9IHdoaWxlIChwZ2QrKywgYWRkciA9IG5leHQsIGFkZHIgIT0gZW5k KTsKPiAgCj4gIAlyZXR1cm4gZXJyOwo+ICB9Cj4gKwo+ICsvKioKPiArICogc3RydWN0IHBhZ2Vf cmFuZ2VfYXBwbHkgLSBDbG9zdXJlIHN0cnVjdHVyZSBmb3IgYXBwbHlfdG9fcGFnZV9yYW5nZSgp Cj4gKyAqIEBwdGVyOiBUaGUgYmFzZSBjbG9zdXJlIHN0cnVjdHVyZSB3ZSBkZXJpdmUgZnJvbQo+ ICsgKiBAZm46IFRoZSBsZWFmIHB0ZSBmdW5jdGlvbiB0byBjYWxsCj4gKyAqIEBkYXRhOiBUaGUg bGVhZiBwdGUgZnVuY3Rpb24gY2xvc3VyZQo+ICsgKi8KPiArc3RydWN0IHBhZ2VfcmFuZ2VfYXBw bHkgewo+ICsJc3RydWN0IHBmbl9yYW5nZV9hcHBseSBwdGVyOwo+ICsJcHRlX2ZuX3QgZm47Cj4g Kwl2b2lkICpkYXRhOwo+ICt9Owo+ICsKPiArLyoKPiArICogQ2FsbGJhY2sgd3JhcHBlciB0byBl bmFibGUgdXNlIG9mIGFwcGx5X3RvX3Bmbl9yYW5nZSBmb3IKPiArICogdGhlIGFwcGx5X3RvX3Bh Z2VfcmFuZ2UgaW50ZXJmYWNlCj4gKyAqLwo+ICtzdGF0aWMgaW50IGFwcGx5X3RvX3BhZ2VfcmFu Z2Vfd3JhcHBlcihwdGVfdCAqcHRlLCBwZ3RhYmxlX3QgdG9rZW4sCj4gKwkJCQkgICAgICAgdW5z aWduZWQgbG9uZyBhZGRyLAo+ICsJCQkJICAgICAgIHN0cnVjdCBwZm5fcmFuZ2VfYXBwbHkgKnB0 ZXIpCj4gK3sKPiArCXN0cnVjdCBwYWdlX3JhbmdlX2FwcGx5ICpwcmEgPQo+ICsJCWNvbnRhaW5l cl9vZihwdGVyLCB0eXBlb2YoKnByYSksIHB0ZXIpOwo+ICsKPiArCXJldHVybiBwcmEtPmZuKHB0 ZSwgdG9rZW4sIGFkZHIsIHByYS0+ZGF0YSk7Cj4gK30KPiArCj4gKy8qCj4gKyAqIFNjYW4gYSBy ZWdpb24gb2YgdmlydHVhbCBtZW1vcnksIGZpbGxpbmcgaW4gcGFnZSB0YWJsZXMgYXMgbmVjZXNz YXJ5Cj4gKyAqIGFuZCBjYWxsaW5nIGEgcHJvdmlkZWQgZnVuY3Rpb24gb24gZWFjaCBsZWFmIHBh Z2UgdGFibGUuCj4gKyAqLwoKSXQgd291bGQgYmUgZ29vZCB0byBpbXByb3ZlIHRoYXQgY29tbWVu dCB0b28gYW5kIG1ha2UgaXQgYSB3YXJuaW5nIG9mCkRPIE5PVCBVU0UgISBUSElTIElTIE5PVCBT QUZFIE9OIFJFR1VMQVIgVk1BICEKCj4gK2ludCBhcHBseV90b19wYWdlX3JhbmdlKHN0cnVjdCBt bV9zdHJ1Y3QgKm1tLCB1bnNpZ25lZCBsb25nIGFkZHIsCj4gKwkJCXVuc2lnbmVkIGxvbmcgc2l6 ZSwgcHRlX2ZuX3QgZm4sIHZvaWQgKmRhdGEpCj4gK3sKPiArCXN0cnVjdCBwYWdlX3JhbmdlX2Fw cGx5IHByYSA9IHsKPiArCQkucHRlciA9IHsubW0gPSBtbSwKPiArCQkJIC5hbGxvYyA9IDEsCj4g KwkJCSAucHRlZm4gPSBhcHBseV90b19wYWdlX3JhbmdlX3dyYXBwZXIgfSwKPiArCQkuZm4gPSBm biwKPiArCQkuZGF0YSA9IGRhdGEKPiArCX07Cj4gKwo+ICsJcmV0dXJuIGFwcGx5X3RvX3Bmbl9y YW5nZSgmcHJhLnB0ZXIsIGFkZHIsIHNpemUpOwo+ICt9Cj4gIEVYUE9SVF9TWU1CT0xfR1BMKGFw cGx5X3RvX3BhZ2VfcmFuZ2UpOwo+ICAKPiAgLyoKPiAtLSAKPiAyLjIwLjEKPiAKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcg bGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRl c2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs 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.5 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_MUTT 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 2F817C282CE for ; Fri, 12 Apr 2019 21:07:52 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id D1788218FF for ; Fri, 12 Apr 2019 21:07:51 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D1788218FF Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=redhat.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 5F46C6B0277; Fri, 12 Apr 2019 17:07:51 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 57D226B0278; Fri, 12 Apr 2019 17:07:51 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 41DEB6B0279; Fri, 12 Apr 2019 17:07:51 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from mail-qt1-f198.google.com (mail-qt1-f198.google.com [209.85.160.198]) by kanga.kvack.org (Postfix) with ESMTP id 1A6F86B0277 for ; Fri, 12 Apr 2019 17:07:51 -0400 (EDT) Received: by mail-qt1-f198.google.com with SMTP id g48so9994909qtk.19 for ; Fri, 12 Apr 2019 14:07:51 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-original-authentication-results:x-gm-message-state:date:from:to :cc:subject:message-id:references:mime-version:content-disposition :content-transfer-encoding:in-reply-to:user-agent; bh=a/OCSr8XaqUkI5aiV7QusERIfjmAwBR/pe3c/zK+q1A=; b=WNZviPajysHWPaduTDkLrbitSUOCanxzOwrtDsyZUHBRa/UHp5uFBF0z+BUsWzZSqG CjH3S0J/jFjZiZluKF7Q1+jxe9yZd6LSHPWE7xJszMUXyOh/54ey4Ua2QnNBWwyL4ejM jWDEEQ8pRbkkWQa1HY/WwgRdylP+aPtK+C6mPMajJA0EMLH+DQZZq/kxDjjPgqaTZES6 ZNqzu//Jft5KAKFObsqp0X01ulLHEoXntdT8WGyAxzLMV8TsLs1MenXes3omfwGOh605 d4bHClHWYKu96pDFH/h+zK3L0xlwLBsB4k2jGD7+AlCvIAL8YmxcgYIyeo2U6bNTH+yA 4dzg== X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of jglisse@redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=jglisse@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com X-Gm-Message-State: APjAAAU+B2YLNPNN9gz2VNDGQy6FU6GuIAWXW8nqd53z4xxIfSOo7bI1 D9FnQWJnK3aH6WDQoG6eN2LQEEk1eqvCeK5nzBGgUR5xGwKbMTTQdo9TtXg7polKW4RO4NNBq/U DouTJB741+oFJ7DMbYFECa4dD//8f+lglXVGWP7HklTJHbOCl/2Ex1H4DKqDDCfjUtw== X-Received: by 2002:a37:8d44:: with SMTP id p65mr44870251qkd.151.1555103270861; Fri, 12 Apr 2019 14:07:50 -0700 (PDT) X-Google-Smtp-Source: APXvYqyWymWhggIOcHac9AAfnM2/k5OndlvxcdXkXLCk18SEoV7l+Ga1LEGaDzUhTsToZfiENV+f X-Received: by 2002:a37:8d44:: with SMTP id p65mr44870188qkd.151.1555103270006; Fri, 12 Apr 2019 14:07:50 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1555103270; cv=none; d=google.com; s=arc-20160816; b=Ytv36pV7rF212wJgS8cjgzaPydL62Kj1aUobw32ANVpjavsPFUAl17YO6ZHsf3wplA amLXyNsg02Pqr4cAOiCwZSyIrXe4jelyXATxgnsLXbH0+65f5MHn6LPIh9WXiVdLqSdF tujPvtmfDZg1A9Y/qD7px+NXQcxhvkMiZ4/OndIRwk/HIlAV9Qitv6xqa6VM5cbJClas tShM0J7QgtXLijTZ7jkU0ovurtI7Ej2dF7eqtGQd8NAtxZUZlfvrRN9Y+qsH6wHmTHAj W+emH0nDOcU82gJpcJX8WNAezD4MhI/RnLFfwlZT/0oWIPKeLmrofd8aWD05Q7YVYEtP 8PKA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=user-agent:in-reply-to:content-transfer-encoding :content-disposition:mime-version:references:message-id:subject:cc :to:from:date; bh=a/OCSr8XaqUkI5aiV7QusERIfjmAwBR/pe3c/zK+q1A=; b=ib0caEIDxEG4sRzqoIu2I3Mq5uRaB/bN7K+d3F91kw9PH9dEK8GNN0snfbTquWAazj 9ffMhJTl6nn5RcjwgQtfSR+Lt9awSH0phqq+ahRd7tVfJpiCH3uLavfguS9fW6ynXy9a b9iuzPlM8JgPrNfV6w8wUP5XW+qI0TT80m5Ohs0tTqpV9btBgR4qe0Bi9Qcr3/e/845l 5ZEvGKrlcXONhir5ggsuytbgL9TBEVP8ex7PufvArNxalJoVzJ1pfx60ghgL6wALundD HWcH6xD6MQvaFR6/yvH1qnpW7rVFlSic1ldENMa9GZQjPi8+VjYzEv2fWJ0dNLnNIT64 k9Fw== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of jglisse@redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=jglisse@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from mx1.redhat.com (mx1.redhat.com. [209.132.183.28]) by mx.google.com with ESMTPS id u58si547835qte.185.2019.04.12.14.07.49 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 12 Apr 2019 14:07:49 -0700 (PDT) Received-SPF: pass (google.com: domain of jglisse@redhat.com designates 209.132.183.28 as permitted sender) client-ip=209.132.183.28; Authentication-Results: mx.google.com; spf=pass (google.com: domain of jglisse@redhat.com designates 209.132.183.28 as permitted sender) smtp.mailfrom=jglisse@redhat.com; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from smtp.corp.redhat.com (int-mx05.intmail.prod.int.phx2.redhat.com [10.5.11.15]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id ECAFC70008; Fri, 12 Apr 2019 21:07:48 +0000 (UTC) Received: from redhat.com (ovpn-125-94.rdu2.redhat.com [10.10.125.94]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 0D4135D6A9; Fri, 12 Apr 2019 21:07:46 +0000 (UTC) Date: Fri, 12 Apr 2019 17:07:43 -0400 From: Jerome Glisse To: Thomas Hellstrom Cc: "dri-devel@lists.freedesktop.org" , Linux-graphics-maintainer , "linux-kernel@vger.kernel.org" , Andrew Morton , Matthew Wilcox , Will Deacon , Peter Zijlstra , Rik van Riel , Minchan Kim , Michal Hocko , Huang Ying , Souptick Joarder , "linux-mm@kvack.org" Subject: Re: [PATCH 2/9] mm: Add an apply_to_pfn_range interface Message-ID: <20190412210743.GA19252@redhat.com> References: <20190412160338.64994-1-thellstrom@vmware.com> <20190412160338.64994-3-thellstrom@vmware.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20190412160338.64994-3-thellstrom@vmware.com> User-Agent: Mutt/1.11.3 (2019-02-01) X-Scanned-By: MIMEDefang 2.79 on 10.5.11.15 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.28]); Fri, 12 Apr 2019 21:07:49 +0000 (UTC) X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: On Fri, Apr 12, 2019 at 04:04:18PM +0000, Thomas Hellstrom wrote: > This is basically apply_to_page_range with added functionality: > Allocating missing parts of the page table becomes optional, which > means that the function can be guaranteed not to error if allocation > is disabled. Also passing of the closure struct and callback function > becomes different and more in line with how things are done elsewhere. > > Finally we keep apply_to_page_range as a wrapper around apply_to_pfn_range > > The reason for not using the page-walk code is that we want to perform > the page-walk on vmas pointing to an address space without requiring the > mmap_sem to be held rather thand on vmas belonging to a process with the > mmap_sem held. > > Notable changes since RFC: > Don't export apply_to_pfn range. > > Cc: Andrew Morton > Cc: Matthew Wilcox > Cc: Will Deacon > Cc: Peter Zijlstra > Cc: Rik van Riel > Cc: Minchan Kim > Cc: Michal Hocko > Cc: Huang Ying > Cc: Souptick Joarder > Cc: "Jérôme Glisse" > Cc: linux-mm@kvack.org > Cc: linux-kernel@vger.kernel.org > Signed-off-by: Thomas Hellstrom > --- > include/linux/mm.h | 10 ++++ > mm/memory.c | 130 ++++++++++++++++++++++++++++++++++----------- > 2 files changed, 108 insertions(+), 32 deletions(-) > > diff --git a/include/linux/mm.h b/include/linux/mm.h > index 80bb6408fe73..b7dd4ddd6efb 100644 > --- a/include/linux/mm.h > +++ b/include/linux/mm.h > @@ -2632,6 +2632,16 @@ typedef int (*pte_fn_t)(pte_t *pte, pgtable_t token, unsigned long addr, > extern int apply_to_page_range(struct mm_struct *mm, unsigned long address, > unsigned long size, pte_fn_t fn, void *data); > > +struct pfn_range_apply; > +typedef int (*pter_fn_t)(pte_t *pte, pgtable_t token, unsigned long addr, > + struct pfn_range_apply *closure); > +struct pfn_range_apply { > + struct mm_struct *mm; > + pter_fn_t ptefn; > + unsigned int alloc; > +}; > +extern int apply_to_pfn_range(struct pfn_range_apply *closure, > + unsigned long address, unsigned long size); > > #ifdef CONFIG_PAGE_POISONING > extern bool page_poisoning_enabled(void); > diff --git a/mm/memory.c b/mm/memory.c > index a95b4a3b1ae2..60d67158964f 100644 > --- a/mm/memory.c > +++ b/mm/memory.c > @@ -1938,18 +1938,17 @@ int vm_iomap_memory(struct vm_area_struct *vma, phys_addr_t start, unsigned long > } > EXPORT_SYMBOL(vm_iomap_memory); > > -static int apply_to_pte_range(struct mm_struct *mm, pmd_t *pmd, > - unsigned long addr, unsigned long end, > - pte_fn_t fn, void *data) > +static int apply_to_pte_range(struct pfn_range_apply *closure, pmd_t *pmd, > + unsigned long addr, unsigned long end) > { > pte_t *pte; > int err; > pgtable_t token; > spinlock_t *uninitialized_var(ptl); > > - pte = (mm == &init_mm) ? > + pte = (closure->mm == &init_mm) ? > pte_alloc_kernel(pmd, addr) : > - pte_alloc_map_lock(mm, pmd, addr, &ptl); > + pte_alloc_map_lock(closure->mm, pmd, addr, &ptl); > if (!pte) > return -ENOMEM; > > @@ -1960,86 +1959,107 @@ static int apply_to_pte_range(struct mm_struct *mm, pmd_t *pmd, > token = pmd_pgtable(*pmd); > > do { > - err = fn(pte++, token, addr, data); > + err = closure->ptefn(pte++, token, addr, closure); > if (err) > break; > } while (addr += PAGE_SIZE, addr != end); > > arch_leave_lazy_mmu_mode(); > > - if (mm != &init_mm) > + if (closure->mm != &init_mm) > pte_unmap_unlock(pte-1, ptl); > return err; > } > > -static int apply_to_pmd_range(struct mm_struct *mm, pud_t *pud, > - unsigned long addr, unsigned long end, > - pte_fn_t fn, void *data) > +static int apply_to_pmd_range(struct pfn_range_apply *closure, pud_t *pud, > + unsigned long addr, unsigned long end) > { > pmd_t *pmd; > unsigned long next; > - int err; > + int err = 0; > > BUG_ON(pud_huge(*pud)); > > - pmd = pmd_alloc(mm, pud, addr); > + pmd = pmd_alloc(closure->mm, pud, addr); > if (!pmd) > return -ENOMEM; > + > do { > next = pmd_addr_end(addr, end); > - err = apply_to_pte_range(mm, pmd, addr, next, fn, data); > + if (!closure->alloc && pmd_none_or_clear_bad(pmd)) > + continue; > + err = apply_to_pte_range(closure, pmd, addr, next); > if (err) > break; > } while (pmd++, addr = next, addr != end); > return err; > } > > -static int apply_to_pud_range(struct mm_struct *mm, p4d_t *p4d, > - unsigned long addr, unsigned long end, > - pte_fn_t fn, void *data) > +static int apply_to_pud_range(struct pfn_range_apply *closure, p4d_t *p4d, > + unsigned long addr, unsigned long end) > { > pud_t *pud; > unsigned long next; > - int err; > + int err = 0; > > - pud = pud_alloc(mm, p4d, addr); > + pud = pud_alloc(closure->mm, p4d, addr); > if (!pud) > return -ENOMEM; > + > do { > next = pud_addr_end(addr, end); > - err = apply_to_pmd_range(mm, pud, addr, next, fn, data); > + if (!closure->alloc && pud_none_or_clear_bad(pud)) > + continue; > + err = apply_to_pmd_range(closure, pud, addr, next); > if (err) > break; > } while (pud++, addr = next, addr != end); > return err; > } > > -static int apply_to_p4d_range(struct mm_struct *mm, pgd_t *pgd, > - unsigned long addr, unsigned long end, > - pte_fn_t fn, void *data) > +static int apply_to_p4d_range(struct pfn_range_apply *closure, pgd_t *pgd, > + unsigned long addr, unsigned long end) > { > p4d_t *p4d; > unsigned long next; > - int err; > + int err = 0; > > - p4d = p4d_alloc(mm, pgd, addr); > + p4d = p4d_alloc(closure->mm, pgd, addr); > if (!p4d) > return -ENOMEM; > + > do { > next = p4d_addr_end(addr, end); > - err = apply_to_pud_range(mm, p4d, addr, next, fn, data); > + if (!closure->alloc && p4d_none_or_clear_bad(p4d)) > + continue; > + err = apply_to_pud_range(closure, p4d, addr, next); > if (err) > break; > } while (p4d++, addr = next, addr != end); > return err; > } > > -/* > - * Scan a region of virtual memory, filling in page tables as necessary > - * and calling a provided function on each leaf page table. > +/** > + * apply_to_pfn_range - Scan a region of virtual memory, calling a provided > + * function on each leaf page table entry > + * @closure: Details about how to scan and what function to apply > + * @addr: Start virtual address > + * @size: Size of the region > + * > + * If @closure->alloc is set to 1, the function will fill in the page table > + * as necessary. Otherwise it will skip non-present parts. > + * Note: The caller must ensure that the range does not contain huge pages. > + * The caller must also assure that the proper mmu_notifier functions are > + * called. Either in the pte leaf function or before and after the call to > + * apply_to_pfn_range. This is wrong there should be a big FAT warning that this can only be use against mmap of device file. The page table walking above is broken for various thing you might find in any other vma like THP, device pte, hugetlbfs, ... Also the mmu notifier can not be call from the pfn callback as that callback happens under page table lock (the change_pte notifier callback is useless and not enough). So it _must_ happen around the call to apply_to_pfn_range apply_to_page_range was really not meant to be use in that way ... it was not for regular vma. Using this function for anything else is dangerous and having its uses spread more increase that risk. So there must be a big FAT warning saying that you should not use this lightly and that it should only be only on mmap of device file. > + * > + * Returns: Zero on success. If the provided function returns a non-zero status, > + * the page table walk will terminate and that status will be returned. > + * If @closure->alloc is set to 1, then this function may also return memory > + * allocation errors arising from allocating page table memory. > */ > -int apply_to_page_range(struct mm_struct *mm, unsigned long addr, > - unsigned long size, pte_fn_t fn, void *data) > +int apply_to_pfn_range(struct pfn_range_apply *closure, > + unsigned long addr, unsigned long size) > { > pgd_t *pgd; > unsigned long next; > @@ -2049,16 +2069,62 @@ int apply_to_page_range(struct mm_struct *mm, unsigned long addr, > if (WARN_ON(addr >= end)) > return -EINVAL; > > - pgd = pgd_offset(mm, addr); > + pgd = pgd_offset(closure->mm, addr); > do { > next = pgd_addr_end(addr, end); > - err = apply_to_p4d_range(mm, pgd, addr, next, fn, data); > + if (!closure->alloc && pgd_none_or_clear_bad(pgd)) > + continue; > + err = apply_to_p4d_range(closure, pgd, addr, next); > if (err) > break; > } while (pgd++, addr = next, addr != end); > > return err; > } > + > +/** > + * struct page_range_apply - Closure structure for apply_to_page_range() > + * @pter: The base closure structure we derive from > + * @fn: The leaf pte function to call > + * @data: The leaf pte function closure > + */ > +struct page_range_apply { > + struct pfn_range_apply pter; > + pte_fn_t fn; > + void *data; > +}; > + > +/* > + * Callback wrapper to enable use of apply_to_pfn_range for > + * the apply_to_page_range interface > + */ > +static int apply_to_page_range_wrapper(pte_t *pte, pgtable_t token, > + unsigned long addr, > + struct pfn_range_apply *pter) > +{ > + struct page_range_apply *pra = > + container_of(pter, typeof(*pra), pter); > + > + return pra->fn(pte, token, addr, pra->data); > +} > + > +/* > + * Scan a region of virtual memory, filling in page tables as necessary > + * and calling a provided function on each leaf page table. > + */ It would be good to improve that comment too and make it a warning of DO NOT USE ! THIS IS NOT SAFE ON REGULAR VMA ! > +int apply_to_page_range(struct mm_struct *mm, unsigned long addr, > + unsigned long size, pte_fn_t fn, void *data) > +{ > + struct page_range_apply pra = { > + .pter = {.mm = mm, > + .alloc = 1, > + .ptefn = apply_to_page_range_wrapper }, > + .fn = fn, > + .data = data > + }; > + > + return apply_to_pfn_range(&pra.pter, addr, size); > +} > EXPORT_SYMBOL_GPL(apply_to_page_range); > > /* > -- > 2.20.1 >