From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jerome Glisse Subject: Re: [RFC PATCH RESEND 3/3] mm: Add write-protect and clean utilities for address space ranges Date: Thu, 21 Mar 2019 17:07:48 -0400 Message-ID: <20190321210747.GC15074@redhat.com> References: <20190321132140.114878-1-thellstrom@vmware.com> <20190321132140.114878-4-thellstrom@vmware.com> <20190321141239.GD2904@redhat.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 3B63F89F19 for ; Thu, 21 Mar 2019 21:07:52 +0000 (UTC) Content-Disposition: inline In-Reply-To: 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: "mhocko@suse.com" , "minchan@kernel.org" , "peterz@infradead.org" , "dri-devel@lists.freedesktop.org" , "riel@surriel.com" , "will.deacon@arm.com" , "linux-kernel@vger.kernel.org" , "willy@infradead.org" , "linux-mm@kvack.org" , Linux-graphics-maintainer , "jrdr.linux@gmail.com" , "ying.huang@intel.com" , "akpm@linux-foundation.org" List-Id: dri-devel@lists.freedesktop.org T24gVGh1LCBNYXIgMjEsIDIwMTkgYXQgMDg6Mjk6MzFQTSArMDAwMCwgVGhvbWFzIEhlbGxzdHJv bSB3cm90ZToKPiBPbiBUaHUsIDIwMTktMDMtMjEgYXQgMTA6MTIgLTA0MDAsIEplcm9tZSBHbGlz c2Ugd3JvdGU6Cj4gPiBPbiBUaHUsIE1hciAyMSwgMjAxOSBhdCAwMToyMjo0MVBNICswMDAwLCBU aG9tYXMgSGVsbHN0cm9tIHdyb3RlOgo+ID4gPiBBZGQgdHdvIHV0aWxpdGllcyB0byBhKSB3cml0 ZS1wcm90ZWN0IGFuZCBiKSBjbGVhbiBhbGwgcHRlcwo+ID4gPiBwb2ludGluZyBpbnRvCj4gPiA+ IGEgcmFuZ2Ugb2YgYW4gYWRkcmVzcyBzcGFjZQo+ID4gPiBUaGUgdXRpbGl0aWVzIGFyZSBpbnRl bmRlZCB0byBhaWQgaW4gdHJhY2tpbmcgZGlydHkgcGFnZXMgKGVpdGhlcgo+ID4gPiBkcml2ZXIt YWxsb2NhdGVkIHN5c3RlbSBtZW1vcnkgb3IgcGNpIGRldmljZSBtZW1vcnkpLgo+ID4gPiBUaGUg d3JpdGUtcHJvdGVjdCB1dGlsaXR5IHNob3VsZCBiZSB1c2VkIGluIGNvbmp1bmN0aW9uIHdpdGgK PiA+ID4gcGFnZV9ta3dyaXRlKCkgYW5kIHBmbl9ta3dyaXRlKCkgdG8gdHJpZ2dlciB3cml0ZSBw YWdlLWZhdWx0cyBvbgo+ID4gPiBwYWdlCj4gPiA+IGFjY2Vzc2VzLiBUeXBpY2FsbHkgb25lIHdv dWxkIHdhbnQgdG8gdXNlIHRoaXMgb24gc3BhcnNlIGFjY2Vzc2VzCj4gPiA+IGludG8KPiA+ID4g bGFyZ2UgbWVtb3J5IHJlZ2lvbnMuIFRoZSBjbGVhbiB1dGlsaXR5IHNob3VsZCBiZSB1c2VkIHRv IHV0aWxpemUKPiA+ID4gaGFyZHdhcmUgZGlydHlpbmcgZnVuY3Rpb25hbGl0eSBhbmQgYXZvaWQg dGhlIG92ZXJoZWFkIG9mIHBhZ2UtCj4gPiA+IGZhdWx0cywKPiA+ID4gdHlwaWNhbGx5IG9uIGxh cmdlIGFjY2Vzc2VzIGludG8gc21hbGwgbWVtb3J5IHJlZ2lvbnMuCj4gPiAKPiA+IEFnYWluIHRo aXMgZG9lcyBub3QgdXNlIG1tdSBub3RpZmllciBhbmQgdGhlcmUgaXMgbm8gc2NhcnkgY29tbWVu dCB0bwo+ID4gZXhwbGFpbiB0aGUgdmVyeSBsaW1pdGVkIHVzZSBjYXNlIGl0IHNob3VsZCBiZSB1 c2UgZm9yIGllIG1tYXAgb2YgYQo+ID4gZGV2aWNlIGZpbGUgYW5kIG9ubHkgYnkgdGhlIGRldmlj ZSBkcml2ZXIuCj4gCj4gU2NhcnkgY29tbWVudCBhbmQgYXNzZXJ0cyB3aWxsIGJlIGFkZGVkLgo+ IAo+ID4gCj4gPiBVc2luZyBpdCBvdXNpZGUgb2YgdGhpcyB3b3VsZCBicmVhayBzb2Z0ZGlydHkg b3IgdHJpZ2dlciBmYWxzZSBDT1cgb3IKPiA+IG90aGVyIHNjYXJ5IHRoaW5nLgo+IAo+IFRoaXMg aXMgc29tZXRoaW5nIHRoYXQgc2hvdWxkIGNsZWFybHkgYmUgYXZvaWRlZCBpZiBhdCBhbGwgcG9z c2libGUuCj4gRmFsc2UgQ09XcyBjb3VsZCBiZSBhdm9pZGVkIGJ5IGFzc2VydGluZyB0aGF0IFZN QXMgYXJlIHNoYXJlZC4gSSBuZWVkCj4gdG8gbG9vayBkZWFwZXIgaW50byBzb2Z0ZGlydHksIGJ1 dCBub3RlIHRoYXQgdGhlIF9fbWt3cml0ZSAvIGRpcnR5IC8KPiBjbGVhbiBwYXR0ZXJuIGlzIGFs cmVhZHkgdXNlZCBpbiBhIHZlcnkgc2ltaWxhciB3YXkgaW4KPiBkcml2ZXJzL3ZpZGVvL2ZiX2Rl ZmlvLmMgYWx0aG91Z2ggaXQgb3BlcmF0ZXMgb25seSBvbiByZWFsIHBhZ2VzIG9uZSBhdAo+IGEg dGltZS4KCkl0IHNob3VsZCBqdXN0IGJlIGFsbG93IG9ubHkgZm9yIG1hcHBpbmcgb2YgZGV2aWNl IGZpbGUgZm9yIHdoaWNoIG5vbmUKb2YgdGhlIGFib3ZlIGFwcGx5IChzb2Z0ZGlydHksIENPVywg Li4uKS4KCj4gCj4gPiAKPiA+ID4gQ2M6IEFuZHJldyBNb3J0b24gPGFrcG1AbGludXgtZm91bmRh dGlvbi5vcmc+Cj4gPiA+IENjOiBNYXR0aGV3IFdpbGNveCA8d2lsbHlAaW5mcmFkZWFkLm9yZz4K PiA+ID4gQ2M6IFdpbGwgRGVhY29uIDx3aWxsLmRlYWNvbkBhcm0uY29tPgo+ID4gPiBDYzogUGV0 ZXIgWmlqbHN0cmEgPHBldGVyekBpbmZyYWRlYWQub3JnPgo+ID4gPiBDYzogUmlrIHZhbiBSaWVs IDxyaWVsQHN1cnJpZWwuY29tPgo+ID4gPiBDYzogTWluY2hhbiBLaW0gPG1pbmNoYW5Aa2VybmVs Lm9yZz4KPiA+ID4gQ2M6IE1pY2hhbCBIb2NrbyA8bWhvY2tvQHN1c2UuY29tPgo+ID4gPiBDYzog SHVhbmcgWWluZyA8eWluZy5odWFuZ0BpbnRlbC5jb20+Cj4gPiA+IENjOiBTb3VwdGljayBKb2Fy ZGVyIDxqcmRyLmxpbnV4QGdtYWlsLmNvbT4KPiA+ID4gQ2M6ICJKw6lyw7RtZSBHbGlzc2UiIDxq Z2xpc3NlQHJlZGhhdC5jb20+Cj4gPiA+IENjOiBsaW51eC1tbUBrdmFjay5vcmcKPiA+ID4gQ2M6 IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPiA+ID4gU2lnbmVkLW9mZi1ieTogVGhvbWFz IEhlbGxzdHJvbSA8dGhlbGxzdHJvbUB2bXdhcmUuY29tPgo+ID4gPiAtLS0KPiA+ID4gIGluY2x1 ZGUvbGludXgvbW0uaCAgfCAgIDkgKy0KPiA+ID4gIG1tL01ha2VmaWxlICAgICAgICAgfCAgIDIg Ky0KPiA+ID4gIG1tL2FwcGx5X2FzX3JhbmdlLmMgfCAyNTcKPiA+ID4gKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiA+ID4gIDMgZmlsZXMgY2hhbmdlZCwgMjY2 IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCj4gPiA+ICBjcmVhdGUgbW9kZSAxMDA2NDQg bW0vYXBwbHlfYXNfcmFuZ2UuYwo+ID4gPiAKPiA+ID4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGlu dXgvbW0uaCBiL2luY2x1ZGUvbGludXgvbW0uaAo+ID4gPiBpbmRleCBiN2RkNGRkZDZlZmIuLjYy ZjI0ZGQwYmZhMCAxMDA2NDQKPiA+ID4gLS0tIGEvaW5jbHVkZS9saW51eC9tbS5oCj4gPiA+ICsr KyBiL2luY2x1ZGUvbGludXgvbW0uaAo+ID4gPiBAQCAtMjY0Miw3ICsyNjQyLDE0IEBAIHN0cnVj dCBwZm5fcmFuZ2VfYXBwbHkgewo+ID4gPiAgfTsKPiA+ID4gIGV4dGVybiBpbnQgYXBwbHlfdG9f cGZuX3JhbmdlKHN0cnVjdCBwZm5fcmFuZ2VfYXBwbHkgKmNsb3N1cmUsCj4gPiA+ICAJCQkgICAg ICB1bnNpZ25lZCBsb25nIGFkZHJlc3MsIHVuc2lnbmVkIGxvbmcKPiA+ID4gc2l6ZSk7Cj4gPiA+ IC0KPiA+ID4gK3Vuc2lnbmVkIGxvbmcgYXBwbHlfYXNfd3Jwcm90ZWN0KHN0cnVjdCBhZGRyZXNz X3NwYWNlICptYXBwaW5nLAo+ID4gPiArCQkJCSBwZ29mZl90IGZpcnN0X2luZGV4LCBwZ29mZl90 IG5yKTsKPiA+ID4gK3Vuc2lnbmVkIGxvbmcgYXBwbHlfYXNfY2xlYW4oc3RydWN0IGFkZHJlc3Nf c3BhY2UgKm1hcHBpbmcsCj4gPiA+ICsJCQkgICAgIHBnb2ZmX3QgZmlyc3RfaW5kZXgsIHBnb2Zm X3QgbnIsCj4gPiA+ICsJCQkgICAgIHBnb2ZmX3QgYml0bWFwX3Bnb2ZmLAo+ID4gPiArCQkJICAg ICB1bnNpZ25lZCBsb25nICpiaXRtYXAsCj4gPiA+ICsJCQkgICAgIHBnb2ZmX3QgKnN0YXJ0LAo+ ID4gPiArCQkJICAgICBwZ29mZl90ICplbmQpOwo+ID4gPiAgI2lmZGVmIENPTkZJR19QQUdFX1BP SVNPTklORwo+ID4gPiAgZXh0ZXJuIGJvb2wgcGFnZV9wb2lzb25pbmdfZW5hYmxlZCh2b2lkKTsK PiA+ID4gIGV4dGVybiB2b2lkIGtlcm5lbF9wb2lzb25fcGFnZXMoc3RydWN0IHBhZ2UgKnBhZ2Us IGludCBudW1wYWdlcywKPiA+ID4gaW50IGVuYWJsZSk7Cj4gPiA+IGRpZmYgLS1naXQgYS9tbS9N YWtlZmlsZSBiL21tL01ha2VmaWxlCj4gPiA+IGluZGV4IGQyMTBjYzlkNmY4MC4uYTk0Yjc4ZjEy NjkyIDEwMDY0NAo+ID4gPiAtLS0gYS9tbS9NYWtlZmlsZQo+ID4gPiArKysgYi9tbS9NYWtlZmls ZQo+ID4gPiBAQCAtMzksNyArMzksNyBAQCBvYmoteQkJCTo9IGZpbGVtYXAubyBtZW1wb29sLm8K PiA+ID4gb29tX2tpbGwubyBmYWR2aXNlLm8gXAo+ID4gPiAgCQkJICAgbW1faW5pdC5vIG1tdV9j b250ZXh0Lm8gcGVyY3B1Lm8KPiA+ID4gc2xhYl9jb21tb24ubyBcCj4gPiA+ICAJCQkgICBjb21w YWN0aW9uLm8gdm1hY2FjaGUubyBcCj4gPiA+ICAJCQkgICBpbnRlcnZhbF90cmVlLm8gbGlzdF9s cnUubyB3b3JraW5nc2V0Lm8gXAo+ID4gPiAtCQkJICAgZGVidWcubyAkKG1tdS15KQo+ID4gPiAr CQkJICAgZGVidWcubyBhcHBseV9hc19yYW5nZS5vICQobW11LXkpCj4gPiA+ICAKPiA+ID4gIG9i ai15ICs9IGluaXQtbW0ubwo+ID4gPiAgb2JqLXkgKz0gbWVtYmxvY2subwo+ID4gPiBkaWZmIC0t Z2l0IGEvbW0vYXBwbHlfYXNfcmFuZ2UuYyBiL21tL2FwcGx5X2FzX3JhbmdlLmMKPiA+ID4gbmV3 IGZpbGUgbW9kZSAxMDA2NDQKPiA+ID4gaW5kZXggMDAwMDAwMDAwMDAwLi45ZjAzZTI3MmViZDAK PiA+ID4gLS0tIC9kZXYvbnVsbAo+ID4gPiArKysgYi9tbS9hcHBseV9hc19yYW5nZS5jCj4gPiA+ IEBAIC0wLDAgKzEsMjU3IEBACj4gPiA+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BM LTIuMAo+ID4gPiArI2luY2x1ZGUgPGxpbnV4L21tLmg+Cj4gPiA+ICsjaW5jbHVkZSA8bGludXgv bW1fdHlwZXMuaD4KPiA+ID4gKyNpbmNsdWRlIDxsaW51eC9odWdldGxiLmg+Cj4gPiA+ICsjaW5j bHVkZSA8bGludXgvYml0b3BzLmg+Cj4gPiA+ICsjaW5jbHVkZSA8YXNtL2NhY2hlZmx1c2guaD4K PiA+ID4gKyNpbmNsdWRlIDxhc20vdGxiZmx1c2guaD4KPiA+ID4gKwo+ID4gPiArLyoqCj4gPiA+ ICsgKiBzdHJ1Y3QgYXBwbHlfYXMgLSBDbG9zdXJlIHN0cnVjdHVyZSBmb3IgYXBwbHlfYXNfcmFu Z2UKPiA+ID4gKyAqIEBiYXNlOiBzdHJ1Y3QgcGZuX3JhbmdlX2FwcGx5IHdlIGRlcml2ZSBmcm9t Cj4gPiA+ICsgKiBAc3RhcnQ6IEFkZHJlc3Mgb2YgZmlyc3QgbW9kaWZpZWQgcHRlCj4gPiA+ICsg KiBAZW5kOiBBZGRyZXNzIG9mIGxhc3QgbW9kaWZpZWQgcHRlICsgMQo+ID4gPiArICogQHRvdGFs OiBUb3RhbCBudW1iZXIgb2YgbW9kaWZpZWQgcHRlcwo+ID4gPiArICogQHZtYTogUG9pbnRlciB0 byB0aGUgc3RydWN0IHZtX2FyZWFfc3RydWN0IHdlJ3JlIGN1cnJlbnRseQo+ID4gPiBvcGVyYXRp bmcgb24KPiA+ID4gKyAqIEBmbHVzaF9jYWNoZTogV2hldGhlciB0byBjYWxsIGEgY2FjaGUgZmx1 c2ggYmVmb3JlIG1vZGlmeWluZyBhCj4gPiA+IHB0ZQo+ID4gPiArICogQGZsdXNoX3RsYjogV2hl dGhlciB0byBmbHVzaCB0aGUgdGxiIGFmdGVyIG1vZGlmeWluZyBhIHB0ZQo+ID4gPiArICovCj4g PiA+ICtzdHJ1Y3QgYXBwbHlfYXMgewo+ID4gPiArCXN0cnVjdCBwZm5fcmFuZ2VfYXBwbHkgYmFz ZTsKPiA+ID4gKwl1bnNpZ25lZCBsb25nIHN0YXJ0LCBlbmQ7Cj4gPiA+ICsJdW5zaWduZWQgbG9u ZyB0b3RhbDsKPiA+ID4gKwljb25zdCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKPiA+ID4g Kwl1MzIgZmx1c2hfY2FjaGUgOiAxOwo+ID4gPiArCXUzMiBmbHVzaF90bGIgOiAxOwo+ID4gPiAr fTsKPiA+ID4gKwo+ID4gPiArLyoqCj4gPiA+ICsgKiBhcHBseV9wdF93cnByb3RlY3QgLSBMZWFm IHB0ZSBjYWxsYmFjayB0byB3cml0ZS1wcm90ZWN0IGEgcHRlCj4gPiA+ICsgKiBAcHRlOiBQb2lu dGVyIHRvIHRoZSBwdGUKPiA+ID4gKyAqIEB0b2tlbjogUGFnZSB0YWJsZSB0b2tlbiwgc2VlIGFw cGx5X3RvX3Bmbl9yYW5nZSgpCj4gPiA+ICsgKiBAYWRkcjogVGhlIHZpcnR1YWwgcGFnZSBhZGRy ZXNzCj4gPiA+ICsgKiBAY2xvc3VyZTogUG9pbnRlciB0byBhIHN0cnVjdCBwZm5fcmFuZ2VfYXBw bHkgZW1iZWRkZWQgaW4gYQo+ID4gPiArICogc3RydWN0IGFwcGx5X2FzCj4gPiA+ICsgKgo+ID4g PiArICogVGhlIGZ1bmN0aW9uIHdyaXRlLXByb3RlY3RzIGEgcHRlIGFuZCByZWNvcmRzIHRoZSBy YW5nZSBpbgo+ID4gPiArICogdmlydHVhbCBhZGRyZXNzIHNwYWNlIG9mIHRvdWNoZWQgcHRlcyBm b3IgZWZmaWNpZW50IFRMQgo+ID4gPiBmbHVzaGVzLgo+ID4gPiArICoKPiA+ID4gKyAqIFJldHVy bjogQWx3YXlzIHplcm8uCj4gPiA+ICsgKi8KPiA+ID4gK3N0YXRpYyBpbnQgYXBwbHlfcHRfd3Jw cm90ZWN0KHB0ZV90ICpwdGUsIHBndGFibGVfdCB0b2tlbiwKPiA+ID4gKwkJCSAgICAgIHVuc2ln bmVkIGxvbmcgYWRkciwKPiA+ID4gKwkJCSAgICAgIHN0cnVjdCBwZm5fcmFuZ2VfYXBwbHkgKmNs b3N1cmUpCj4gPiA+ICt7Cj4gPiA+ICsJc3RydWN0IGFwcGx5X2FzICphYXMgPSBjb250YWluZXJf b2YoY2xvc3VyZSwgdHlwZW9mKCphYXMpLAo+ID4gPiBiYXNlKTsKPiA+ID4gKwo+ID4gPiArCWlm IChwdGVfd3JpdGUoKnB0ZSkpIHsKPiA+ID4gKwkJc2V0X3B0ZV9hdChjbG9zdXJlLT5tbSwgYWRk ciwgcHRlLAo+ID4gPiBwdGVfd3Jwcm90ZWN0KCpwdGUpKTsKPiA+IAo+ID4gU28gdGhlcmUgaXMg bm8gZmx1c2hpbmcgaGVyZSwgZXZlbiBmb3IgeDk2IHRoaXMgaXMgd3JvbmcuIEl0Cj4gPiBzaG91 bGQgYmUgc29tZXRoaW5nIGxpa2U6Cj4gPiAgICAgcHRlcF9jbGVhcl9mbHVzaCgpCj4gPiAgICAg Zmx1c2hfY2FjaGVfcGFnZSgpIC8vIGlmIHB0ZSBpcyBwb2ludGluZyB0byBhIHJlZ3VsYXIgcGFn ZQo+ID4gICAgIHNldF9wdGVfYXQoKQo+ID4gICAgIHVwZGF0ZV9tbXVfY2FjaGUoKQo+ID4gCj4g Cj4gSGVyZSBjYWNoZSBmbHVzaGluZyBpcyBkb25lIGJlZm9yZSBhbnkgbGVhZiBmdW5jdGlvbiBp cyBjYWxsZWQuCj4gQWNjb3JkaW5nIHRvIDEpIHRoYXQgc2hvdWxkIGJlIGVxdWl2YWxlbnQsIGFs dGhvdWdoIGZsdXNoaW5nIGNhY2hlIGluCj4gdGhlIGxlYWYgZnVuY3Rpb24gaXMgcHJvYmFibHkg bW9yZSBlZmZpY2llbnQgZm9yIG1vc3QgdXNlIGNhc2VzLiBCb3RoCj4gdGhlc2UgZnVuY3Rpb25z IGFyZSBuby1vcHMgZm9yIGJvdGggeDg2IGFuZCBBUk02NCB3aGVyZSB0aGV5IG1vc3QKPiBsaWtl bHkgd2lsbCBiZSB1c2VkLi4uCj4gCj4gRm9yIHB0ZXBfY2xlYXJfZmx1c2goKSB0aGUgVExCIGZs dXNoaW5nIGlzIGhlcmUgaW5zdGVhZCBkZWZlcnJlZCB0bwo+IGFmdGVyIGFsbCBsZWFmIGZ1bmN0 aW9ucyBoYXZlIGJlZW4gY2FsbGVkLiBJdCBsb29rcyBsaWtlIGlmIHRoZSBQVEUgaXMKPiBkaXJ0 eSwgdGhlIFRMQiBoYXMgbm8gYnVzaW5lc3MgdG91Y2hpbmcgaXQgdW50aWwgdGhlbiBhbnl3YXks IGl0IHNob3VsZAo+IGJlIGhhcHB5IHdpdGggaXRzIGNhY2hlZCB2YWx1ZS4KPiAKPiBTaW5jZSBm bHVzaGluZyBhIHNpbmdsZSB0bGIgcGFnZSBpbnZvbHZlcyBhIGJyb2FkY2FzdCBhY3Jvc3MgYWxs IGNvcmVzLAo+IEkgYmVsaWV2ZSBmbHVzaGluZyBhIHJhbmdlIGlzIGEgcHJldHR5IGltcG9ydGFu dCBvcHRpbWl6YXRpb24uCgpSZWFkaW5nIHRoZSBjb2RlIGkgbWlzc2VkIHRoZSByYW5nZSBmbHVz aCBiZWxvdywgaXQgc2hvdWxkIGJlIG9rIGJ1dAp5b3Ugc2hvdWxkIGJlIHVzaW5nIHB0ZXBfbW9k aWZ5X3Byb3Rfc3RhcnQoKS9wdGVwX21vZGlmeV9wcm90X2NvbW1pdCgpCnBhdHRlcm4uIEkgdGhp bmsgc29tZSBhcmNoIGxpa2UgdG8gYmUgaW52b2x2ZSBpbiBwdGUgY2hhbmdlcyBhbmQgdGhlCjIg cGF0dGVybnMgc28gZmFyIGluIHRoZSBrZXJuZWwgKEFGQUlLKSBpcyBwdGVwX2NsZWFyX2ZsdXNo KCkgb3IgdGhlCnB0ZXBfbW9kaWZ5X3Byb3Rfc3RhcnQvL3B0ZXBfbW9kaWZ5X3Byb3RfY29tbWl0 IHNvIGkgYmVsaWV2ZSBpdCBpcwpiZXR0ZXIgdG8gc3RpY2sgdG8gb25lIG9mIHRob3NlIGluc3Rl YWQgb2YgaW50cm9kdWNpbmcgYSB0aGlyZCBvbmUuCgo+IAo+IEFsc28gZm9yIHVwZGF0ZV9tbXVf Y2FjaGUoKSB0aGUgaW1wcmVzc2lvbiBJIGdvdCBmcm9tIGl0cyBkb2NzIGlzIHRoYXQKPiBpdCBz aG91bGQgb25seSBiZSB1c2VkIHdoZW4gaW5jcmVhc2luZyBwdGUgcGVybWlzc2lvbnMsIGxpa2Ug aW4gZmF1bHQKPiBoYW5kbGVycywgbm90IHRoZSBvcHBvc2l0ZT8KCkkgdGhpbmsgc29tZSBhcmNo IHJlbHkgb24gaXQgZm9yIHNvbWV0aGluZyBlbHNlIGJ1dCBpZiB5b3UgdXNlIHRoZQpyYW5nZSBm bHVzaGluZyBwcm9wZXJseSB5b3Ugc2hvdWxkIG5vdCBuZWVkIGl0LgoKPiA+IAo+ID4gPiArCQlh YXMtPnRvdGFsKys7Cj4gPiA+ICsJCWlmIChhZGRyIDwgYWFzLT5zdGFydCkKPiA+ID4gKwkJCWFh cy0+c3RhcnQgPSBhZGRyOwo+ID4gPiArCQlpZiAoYWRkciArIFBBR0VfU0laRSA+IGFhcy0+ZW5k KQo+ID4gPiArCQkJYWFzLT5lbmQgPSBhZGRyICsgUEFHRV9TSVpFOwo+ID4gPiArCX0KPiA+ID4g Kwo+ID4gPiArCXJldHVybiAwOwo+ID4gPiArfQo+ID4gPiArCj4gPiA+ICsvKioKPiA+ID4gKyAq IHN0cnVjdCBhcHBseV9hc19jbGVhbiAtIENsb3N1cmUgc3RydWN0dXJlIGZvciBhcHBseV9hc19j bGVhbgo+ID4gPiArICogQGJhc2U6IHN0cnVjdCBhcHBseV9hcyB3ZSBkZXJpdmUgZnJvbQo+ID4g PiArICogQGJpdG1hcF9wZ29mZjogQWRkcmVzc19zcGFjZSBQYWdlIG9mZnNldCBvZiB0aGUgZmly c3QgYml0IGluCj4gPiA+IEBiaXRtYXAKPiA+ID4gKyAqIEBiaXRtYXA6IEJpdG1hcCB3aXRoIG9u ZSBiaXQgZm9yIGVhY2ggcGFnZSBvZmZzZXQgaW4gdGhlCj4gPiA+IGFkZHJlc3Nfc3BhY2UgcmFu Z2UKPiA+ID4gKyAqIGNvdmVyZWQuCj4gPiA+ICsgKiBAc3RhcnQ6IEFkZHJlc3Nfc3BhY2UgcGFn ZSBvZmZzZXQgb2YgZmlyc3QgbW9kaWZpZWQgcHRlCj4gPiA+ICsgKiBAZW5kOiBBZGRyZXNzX3Nw YWNlIHBhZ2Ugb2Zmc2V0IG9mIGxhc3QgbW9kaWZpZWQgcHRlCj4gPiA+ICsgKi8KPiA+ID4gK3N0 cnVjdCBhcHBseV9hc19jbGVhbiB7Cj4gPiA+ICsJc3RydWN0IGFwcGx5X2FzIGJhc2U7Cj4gPiA+ ICsJcGdvZmZfdCBiaXRtYXBfcGdvZmY7Cj4gPiA+ICsJdW5zaWduZWQgbG9uZyAqYml0bWFwOwo+ ID4gPiArCXBnb2ZmX3Qgc3RhcnQsIGVuZDsKPiA+ID4gK307Cj4gPiA+ICsKPiA+ID4gKy8qKgo+ ID4gPiArICogYXBwbHlfcHRfY2xlYW4gLSBMZWFmIHB0ZSBjYWxsYmFjayB0byBjbGVhbiBhIHB0 ZQo+ID4gPiArICogQHB0ZTogUG9pbnRlciB0byB0aGUgcHRlCj4gPiA+ICsgKiBAdG9rZW46IFBh Z2UgdGFibGUgdG9rZW4sIHNlZSBhcHBseV90b19wZm5fcmFuZ2UoKQo+ID4gPiArICogQGFkZHI6 IFRoZSB2aXJ0dWFsIHBhZ2UgYWRkcmVzcwo+ID4gPiArICogQGNsb3N1cmU6IFBvaW50ZXIgdG8g YSBzdHJ1Y3QgcGZuX3JhbmdlX2FwcGx5IGVtYmVkZGVkIGluIGEKPiA+ID4gKyAqIHN0cnVjdCBh cHBseV9hc19jbGVhbgo+ID4gPiArICoKPiA+ID4gKyAqIFRoZSBmdW5jdGlvbiBjbGVhbnMgYSBw dGUgYW5kIHJlY29yZHMgdGhlIHJhbmdlIGluCj4gPiA+ICsgKiB2aXJ0dWFsIGFkZHJlc3Mgc3Bh Y2Ugb2YgdG91Y2hlZCBwdGVzIGZvciBlZmZpY2llbnQgVExCCj4gPiA+IGZsdXNoZXMuCj4gPiA+ ICsgKiBJdCBhbHNvIHJlY29yZHMgZGlydHkgcHRlcyBpbiBhIGJpdG1hcCByZXByZXNlbnRpbmcg cGFnZQo+ID4gPiBvZmZzZXRzCj4gPiA+ICsgKiBpbiB0aGUgYWRkcmVzc19zcGFjZSwgYXMgd2Vs bCBhcyB0aGUgZmlyc3QgYW5kIGxhc3Qgb2YgdGhlIGJpdHMKPiA+ID4gKyAqIHRvdWNoZWQuCj4g PiA+ICsgKgo+ID4gPiArICogUmV0dXJuOiBBbHdheXMgemVyby4KPiA+ID4gKyAqLwo+ID4gPiAr c3RhdGljIGludCBhcHBseV9wdF9jbGVhbihwdGVfdCAqcHRlLCBwZ3RhYmxlX3QgdG9rZW4sCj4g PiA+ICsJCQkgIHVuc2lnbmVkIGxvbmcgYWRkciwKPiA+ID4gKwkJCSAgc3RydWN0IHBmbl9yYW5n ZV9hcHBseSAqY2xvc3VyZSkKPiA+ID4gK3sKPiA+ID4gKwlzdHJ1Y3QgYXBwbHlfYXMgKmFhcyA9 IGNvbnRhaW5lcl9vZihjbG9zdXJlLCB0eXBlb2YoKmFhcyksCj4gPiA+IGJhc2UpOwo+ID4gPiAr CXN0cnVjdCBhcHBseV9hc19jbGVhbiAqY2xlYW4gPSBjb250YWluZXJfb2YoYWFzLAo+ID4gPiB0 eXBlb2YoKmNsZWFuKSwgYmFzZSk7Cj4gPiA+ICsKPiA+ID4gKwlpZiAocHRlX2RpcnR5KCpwdGUp KSB7Cj4gPiA+ICsJCXBnb2ZmX3QgcGdvZmYgPSAoKGFkZHIgLSBhYXMtPnZtYS0+dm1fc3RhcnQp ID4+Cj4gPiA+IFBBR0VfU0hJRlQpICsKPiA+ID4gKwkJCWFhcy0+dm1hLT52bV9wZ29mZiAtIGNs ZWFuLT5iaXRtYXBfcGdvZmY7Cj4gPiA+ICsKPiA+ID4gKwkJc2V0X3B0ZV9hdChjbG9zdXJlLT5t bSwgYWRkciwgcHRlLCBwdGVfbWtjbGVhbigqcHRlKSk7Cj4gPiAKPiA+IENsZWFyaW5nIHRoZSBk aXJ0eSBiaXQgaXMgcmFjeSwgaXQgc2hvdWxkIGJlIGRvbmUgd2l0aCB3cml0ZSBwcm90ZWN0Cj4g PiBpbnN0ZWFkIGFzIHRoZSBkaXJ0eSBiaXQgY2FuIGJlIHNldCBhZ2FpbiBqdXN0IGFmdGVyIHlv dSBjbGVhciBpdC4KPiA+IFNvIGkgYW0gbm90IHN1cmUgd2hhdCBpcyB0aGUgdXNhZ2UgcGF0dGVy biB3aGVyZSB5b3Ugd2FudCB0byBjbGVhcgo+ID4gdGhhdCBiaXQgd2l0aG91dCB3cml0ZSBwcm90 ZWN0Lgo+IAo+IElmIGl0J3Mgc2V0IGFnYWluLCB0aGVuIGl0IHdpbGwgYmUgcGlja2VkIHVwIGF0 IHRoZSBuZXh0IEdQVSBjb21tYW5kCj4gc3VibWlzc2lvbiByZWZlcmVuY2luZyB0aGlzIHBhZ2Ug aS4gZS4gdGhlIG5leHQgcnVuIG9mIHRoaXMgZnVuY3Rpb24uCj4gV2hhdCB3ZSdyZSBhZnRlciBo ZXJlIGlzIHRvIGdldCB0byBhbGwgcGFnZXMgdGhhdCB3ZXJlIGRpcnRpZWQgKmJlZm9yZSoKPiB0 aGlzIGNhbGwuIFRoZSByYWNpbmVzcyBhbmQgcmVtZWR5IChpZiBkZXNpcmVkKSBpcyBtZW50aW9u ZWQgaW4gdGhlCj4gY29tbWVudHMgdG8gdGhlIGV4cG9ydGVkIGZ1bmN0aW9uIGJlbG93LiBUeXBp Y2FsbHkgdXNlcnMgd3JpdGUtcHJvdGVjdAo+IGJlZm9yZSBzY2FubmluZyBkaXJ0eSBiaXRzIG9u bHkgaWYgdHJhbnNpdGlvbmluZyB0byBta3dyaXRlLWRpcnR5aW5nLgo+IFRoZSBpbXBvcnRhbnQg dGhpbmcgaXMgdGhhdCB3ZSBkb24ndCBhY2NpZGVudGx5IGNsZWFyIGRpcnR5IGJpdHMKPiB3aXRo b3V0IHBpY2tpbmcgdGhlbSB1cC4KCkZhaXIgZW5vdWdoLgoKPiA+IAo+ID4gWW91IGFsc28gbmVl ZCBwcm9wZXIgcGFnZSBmbHVzaGluZyB3aXRoIGZsdXNoX2NhY2hlX3BhZ2UoKQo+ID4gCj4gPiA+ ICsJCWFhcy0+dG90YWwrKzsKPiA+ID4gKwkJaWYgKGFkZHIgPCBhYXMtPnN0YXJ0KQo+ID4gPiAr CQkJYWFzLT5zdGFydCA9IGFkZHI7Cj4gPiA+ICsJCWlmIChhZGRyICsgUEFHRV9TSVpFID4gYWFz LT5lbmQpCj4gPiA+ICsJCQlhYXMtPmVuZCA9IGFkZHIgKyBQQUdFX1NJWkU7Cj4gPiA+ICsKPiA+ ID4gKwkJX19zZXRfYml0KHBnb2ZmLCBjbGVhbi0+Yml0bWFwKTsKPiA+ID4gKwkJY2xlYW4tPnN0 YXJ0ID0gbWluKGNsZWFuLT5zdGFydCwgcGdvZmYpOwo+ID4gPiArCQljbGVhbi0+ZW5kID0gbWF4 KGNsZWFuLT5lbmQsIHBnb2ZmICsgMSk7Cj4gPiA+ICsJfQo+ID4gPiArCj4gPiA+ICsJcmV0dXJu IDA7Cj4gPiA+ICt9Cj4gPiA+ICsKPiA+ID4gKy8qKgo+ID4gPiArICogYXBwbHlfYXNfcmFuZ2Ug LSBBcHBseSBhIHB0ZSBjYWxsYmFjayB0byBhbGwgUFRFcyBwb2ludGluZyBpbnRvCj4gPiA+IGEg cmFuZ2UKPiA+ID4gKyAqIG9mIGFuIGFkZHJlc3Nfc3BhY2UuCj4gPiA+ICsgKiBAbWFwcGluZzog UG9pbnRlciB0byB0aGUgc3RydWN0IGFkZHJlc3Nfc3BhY2UKPiA+ID4gKyAqIEBhYXM6IENsb3N1 cmUgc3RydWN0dXJlCj4gPiA+ICsgKiBAZmlyc3RfaW5kZXg6IEZpcnN0IHBhZ2Ugb2Zmc2V0IGlu IHRoZSBhZGRyZXNzX3NwYWNlCj4gPiA+ICsgKiBAbnI6IE51bWJlciBvZiBpbmNyZW1lbnRhbCBw YWdlIG9mZnNldHMgdG8gY292ZXIKPiA+ID4gKyAqCj4gPiA+ICsgKiBSZXR1cm46IE51bWJlciBv ZiBwdGVzIHRvdWNoZWQuIE5vdGUgdGhhdCB0aGlzIG51bWJlciBtaWdodCBiZQo+ID4gPiBsYXJn ZXIKPiA+ID4gKyAqIHRoYW4gQG5yIGlmIHRoZXJlIGFyZSBvdmVybGFwcGluZyB2bWFzCj4gPiA+ ICsgKi8KPiA+IAo+ID4gVGhpcyBjb21tZW50IG5lZWQgdG8gYmUgX3NjYXJ5XyBpdCBzaG91bGQg b25seSBiZSB1c2UgZm9yIGRldmljZQo+ID4gZHJpdmVyCj4gPiB2bWEgaWUgZGV2aWNlIGRyaXZl ciBtYXBwaW5nLgo+ID4gCj4gPiA+ICtzdGF0aWMgdW5zaWduZWQgbG9uZyBhcHBseV9hc19yYW5n ZShzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZywKPiA+ID4gKwkJCQkgICAgc3RydWN0IGFw cGx5X2FzICphYXMsCj4gPiA+ICsJCQkJICAgIHBnb2ZmX3QgZmlyc3RfaW5kZXgsIHBnb2ZmX3Qg bnIpCj4gPiA+ICt7Cj4gPiA+ICsJc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWE7Cj4gPiA+ICsJ cGdvZmZfdCB2YmEsIHZlYSwgY2JhLCBjZWE7Cj4gPiA+ICsJdW5zaWduZWQgbG9uZyBzdGFydF9h ZGRyLCBlbmRfYWRkcjsKPiA+ID4gKwo+ID4gPiArCS8qIEZJWE1FOiBJcyBhIHJlYWQgbG9jayBz dWZmaWNpZW50IGhlcmU/ICovCj4gPiA+ICsJZG93bl93cml0ZSgmbWFwcGluZy0+aV9tbWFwX3J3 c2VtKTsKPiA+IAo+ID4gcmVhZCB3b3VsZCBiZSBzdWZmaWNpZW50IGFuZCB5b3Ugc2hvdWxkIHVz ZSBpX21tYXBfbG9ja19yZWFkKCkgbm90Cj4gPiB0aGUgZG93bl93cml0ZS9yZWFkIEFQSS4KPiA+ IAo+ID4gPiArCXZtYV9pbnRlcnZhbF90cmVlX2ZvcmVhY2godm1hLCAmbWFwcGluZy0+aV9tbWFw LCBmaXJzdF9pbmRleCwKPiA+ID4gKwkJZmlyc3RfaW5kZXggKyBuciAtIDEpIHsKPiA+ID4gKwkJ YWFzLT5iYXNlLm1tID0gdm1hLT52bV9tbTsKPiA+ID4gKwo+ID4gPiArCQkvKiBDbGlwIHRvIHRo ZSB2bWEgKi8KPiA+ID4gKwkJdmJhID0gdm1hLT52bV9wZ29mZjsKPiA+ID4gKwkJdmVhID0gdmJh ICsgdm1hX3BhZ2VzKHZtYSk7Cj4gPiA+ICsJCWNiYSA9IGZpcnN0X2luZGV4Owo+ID4gPiArCQlj YmEgPSBtYXgoY2JhLCB2YmEpOwo+ID4gPiArCQljZWEgPSBmaXJzdF9pbmRleCArIG5yOwo+ID4g PiArCQljZWEgPSBtaW4oY2VhLCB2ZWEpOwo+ID4gPiArCj4gPiA+ICsJCS8qIFRyYW5zbGF0ZSB0 byB2aXJ0dWFsIGFkZHJlc3MgKi8KPiA+ID4gKwkJc3RhcnRfYWRkciA9ICgoY2JhIC0gdmJhKSA8 PCBQQUdFX1NISUZUKSArIHZtYS0KPiA+ID4gPnZtX3N0YXJ0Owo+ID4gPiArCQllbmRfYWRkciA9 ICgoY2VhIC0gdmJhKSA8PCBQQUdFX1NISUZUKSArIHZtYS0+dm1fc3RhcnQ7Cj4gPiA+ICsKPiA+ ID4gKwkJLyoKPiA+ID4gKwkJICogVE9ETzogU2hvdWxkIGNhY2hlcyBiZSBmbHVzaGVkIGluZGl2 aWR1YWxseSBvbgo+ID4gPiBkZW1hbmQKPiA+ID4gKwkJICogaW4gdGhlIGxlYWYtcHRlIGNhbGxi YWNrcyBpbnN0ZWFkPyBUaGF0IGlzLCBob3cKPiA+ID4gKwkJICogY29zdGx5IGFyZSBpbnRlci1j b3JlIGludGVycnVwdHMgaW4gYW4gU01QIHN5c3RlbT8KPiA+ID4gKwkJICovCj4gPiA+ICsJCWlm IChhYXMtPmZsdXNoX2NhY2hlKQo+ID4gPiArCQkJZmx1c2hfY2FjaGVfcmFuZ2Uodm1hLCBzdGFy dF9hZGRyLCBlbmRfYWRkcik7Cj4gPiAKPiA+IGZsdXNoX2NhY2hlX3JhbmdlKCkgaXMgYSBub29w IG9uIG1vc3QgYXJjaGl0ZWN0dXJlIHdoYXQgeW91IHJlYWxseQo+ID4gbmVlZAo+ID4gaXMgcHJv cGVyIHBlciBwYWdlIGZsdXNoaW5nIHNlZSBhYm92ZS4KPiAKPiBGcm9tIHRoZSBkb2NzIDEpIHRo ZXkgYXJlIGludGVyY2hhbmdlYWJsZS4gQnV0IEkgd2lsbCBjaGFuZ2UgdG8gCj4gcGVyLXBhZ2Ug Y2FjaGUgZmx1c2hpbmcgYW55d2F5LgoKWWVhaCB5b3UgY2FuIGRvIGZsdXNoX2NhY2hlX3Jhbmdl KCkgaXQgaXMgZmluZS4KCkNoZWVycywKSsOpcsO0bWUKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vZHJpLWRldmVs 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 CC1C2C10F00 for ; Thu, 21 Mar 2019 21:07:54 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 7802721916 for ; Thu, 21 Mar 2019 21:07:54 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7802721916 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 319EA6B0003; Thu, 21 Mar 2019 17:07:54 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 2C9666B0006; Thu, 21 Mar 2019 17:07:54 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 1B95F6B0007; Thu, 21 Mar 2019 17:07:54 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from mail-qk1-f198.google.com (mail-qk1-f198.google.com [209.85.222.198]) by kanga.kvack.org (Postfix) with ESMTP id E9C3A6B0003 for ; Thu, 21 Mar 2019 17:07:53 -0400 (EDT) Received: by mail-qk1-f198.google.com with SMTP id o135so40331qke.11 for ; Thu, 21 Mar 2019 14:07:53 -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=NSXa3qu98Zyqw3M2FWx/Zu1ZLHDcJlgIpw7a7EZt0Io=; b=kd1tzYd+OGNrS2R3jNgd575NDaSREnlnnsNMYaN3pRJxzn0S5S8S9cdfGk48pw65zV 4XKojoAtkSzEXlCGMFmg2YxH0vpmD6n4220N/GFRDOZlgu/on1cB8ervDpExUznCxpZY nF7YDlVdsK+T4cj5sa5NO1s0fSLwphzlnWk5BByaW1SPWXqt4i6098AH1sc8ikSRMXUN brPQW3OhbLSloIXoNxaNztHPrlzednAdfkJarMYVTMAg3aSidyUhiLyfv8dDZTNKK12B t+apM9KJlSenO0+rNIkJA3IKMbJb0sWMD9ejJLdurY+RDftyjP1efedkI8ewXqh+bpAU 56Ow== 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: APjAAAVGT4Kk2TDY8waZRmxG7j12JHwlwHHCFc5PJAQPZQ6xnbrz+lzc 7YamWxfWQsHQDf+Dqym4ubTHNETRxFe/5xls+/k4CChYkKHiXxQTpZlBTeJCw3Ml9dzYAZeVJBw RC/BqVRKkipsszsfCQheNMRZThHXavFPwlgUjU9d3Q+ha3Xbt8WjBa8PiK0FuZNun4Q== X-Received: by 2002:a05:620a:1486:: with SMTP id w6mr4636664qkj.179.1553202473633; Thu, 21 Mar 2019 14:07:53 -0700 (PDT) X-Google-Smtp-Source: APXvYqyrowpkQeSNfzJvhinc+t+5uAa/uH/+nvX2YT06C+CewNn63rOWjynaF/ZmX6VPWQ6/e4Cy X-Received: by 2002:a05:620a:1486:: with SMTP id w6mr4636570qkj.179.1553202472475; Thu, 21 Mar 2019 14:07:52 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1553202472; cv=none; d=google.com; s=arc-20160816; b=gcittT4yZ30Nc/oQuNFeFRqlvAe4DI2feWsoI6pqwDQOVkyk1puj0AHVXtSBpID8k9 kDPt9XEiHfs5x6D9K3RKef+Zu7LjR4hZWj2T+yDUsRh0SQDeiQne6R3MGKlc5eZqZILN Axy7MoTdsCv908cRfHnMzLs6q4J7jZvCdmNwk3XeOTQZWn7lF8GcBIIfZlMswvv8QMKr YeZzqp5AuTbIReHiW9oY0089UXM5gX7BwMuFrlXYdvo0KbNqC4Cwbvh4trFeurTqNRCN ZhH/BH2W626IaVS5YANKE4X1r3cHoceJLoTOseCVl3ztfQTrydXOg63ODUJ79HKOTAwu tz3A== 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=NSXa3qu98Zyqw3M2FWx/Zu1ZLHDcJlgIpw7a7EZt0Io=; b=deQhCP7hJhEADzNB1LeFiqu2j8n6kp5nQCRw8Vi0U8yVKB3pJZEjrMwH7tTAp5QCjC 58f9Qbm2vNnbfJf6JqqpZdycfuczxzOKFfdksJUC2kg2JtQuEar6dVV287oEdV3oPpsx wfJbEnTG6FbBaFwIkSZToXDNDXmwVrSHxQAUVQhU+JQDBxGTe3u95sE7XwzYmXYFC5j0 ESFuaIl04Xnh3yzu8WDtK/YpZQkRl/P0F3TNWDHde2irMSC6B8BVOpsYT+SZ+vM1prtv /nHvbQlaK1cTakf2ifl4rEX01TlZCx9TmUcrftyhrGTpXFILa6+wQ/hyElT4SA899rUR tmUA== 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 f55si1475860qvd.25.2019.03.21.14.07.52 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 21 Mar 2019 14:07:52 -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-mx03.intmail.prod.int.phx2.redhat.com [10.5.11.13]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mx1.redhat.com (Postfix) with ESMTPS id 8BCCC3086211; Thu, 21 Mar 2019 21:07:51 +0000 (UTC) Received: from redhat.com (unknown [10.20.6.236]) by smtp.corp.redhat.com (Postfix) with ESMTPS id CD3AC60857; Thu, 21 Mar 2019 21:07:49 +0000 (UTC) Date: Thu, 21 Mar 2019 17:07:48 -0400 From: Jerome Glisse To: Thomas Hellstrom Cc: "linux-kernel@vger.kernel.org" , "peterz@infradead.org" , "willy@infradead.org" , "linux-mm@kvack.org" , "jrdr.linux@gmail.com" , "akpm@linux-foundation.org" , "minchan@kernel.org" , "dri-devel@lists.freedesktop.org" , "will.deacon@arm.com" , Linux-graphics-maintainer , "mhocko@suse.com" , "ying.huang@intel.com" , "riel@surriel.com" Subject: Re: [RFC PATCH RESEND 3/3] mm: Add write-protect and clean utilities for address space ranges Message-ID: <20190321210747.GC15074@redhat.com> References: <20190321132140.114878-1-thellstrom@vmware.com> <20190321132140.114878-4-thellstrom@vmware.com> <20190321141239.GD2904@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: User-Agent: Mutt/1.10.0 (2018-05-17) X-Scanned-By: MIMEDefang 2.79 on 10.5.11.13 X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.42]); Thu, 21 Mar 2019 21:07:51 +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 Thu, Mar 21, 2019 at 08:29:31PM +0000, Thomas Hellstrom wrote: > On Thu, 2019-03-21 at 10:12 -0400, Jerome Glisse wrote: > > On Thu, Mar 21, 2019 at 01:22:41PM +0000, Thomas Hellstrom wrote: > > > Add two utilities to a) write-protect and b) clean all ptes > > > pointing into > > > a range of an address space > > > The utilities are intended to aid in tracking dirty pages (either > > > driver-allocated system memory or pci device memory). > > > The write-protect utility should be used in conjunction with > > > page_mkwrite() and pfn_mkwrite() to trigger write page-faults on > > > page > > > accesses. Typically one would want to use this on sparse accesses > > > into > > > large memory regions. The clean utility should be used to utilize > > > hardware dirtying functionality and avoid the overhead of page- > > > faults, > > > typically on large accesses into small memory regions. > > > > Again this does not use mmu notifier and there is no scary comment to > > explain the very limited use case it should be use for ie mmap of a > > device file and only by the device driver. > > Scary comment and asserts will be added. > > > > > Using it ouside of this would break softdirty or trigger false COW or > > other scary thing. > > This is something that should clearly be avoided if at all possible. > False COWs could be avoided by asserting that VMAs are shared. I need > to look deaper into softdirty, but note that the __mkwrite / dirty / > clean pattern is already used in a very similar way in > drivers/video/fb_defio.c although it operates only on real pages one at > a time. It should just be allow only for mapping of device file for which none of the above apply (softdirty, COW, ...). > > > > > > 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 | 9 +- > > > mm/Makefile | 2 +- > > > mm/apply_as_range.c | 257 > > > ++++++++++++++++++++++++++++++++++++++++++++ > > > 3 files changed, 266 insertions(+), 2 deletions(-) > > > create mode 100644 mm/apply_as_range.c > > > > > > diff --git a/include/linux/mm.h b/include/linux/mm.h > > > index b7dd4ddd6efb..62f24dd0bfa0 100644 > > > --- a/include/linux/mm.h > > > +++ b/include/linux/mm.h > > > @@ -2642,7 +2642,14 @@ struct pfn_range_apply { > > > }; > > > extern int apply_to_pfn_range(struct pfn_range_apply *closure, > > > unsigned long address, unsigned long > > > size); > > > - > > > +unsigned long apply_as_wrprotect(struct address_space *mapping, > > > + pgoff_t first_index, pgoff_t nr); > > > +unsigned long apply_as_clean(struct address_space *mapping, > > > + pgoff_t first_index, pgoff_t nr, > > > + pgoff_t bitmap_pgoff, > > > + unsigned long *bitmap, > > > + pgoff_t *start, > > > + pgoff_t *end); > > > #ifdef CONFIG_PAGE_POISONING > > > extern bool page_poisoning_enabled(void); > > > extern void kernel_poison_pages(struct page *page, int numpages, > > > int enable); > > > diff --git a/mm/Makefile b/mm/Makefile > > > index d210cc9d6f80..a94b78f12692 100644 > > > --- a/mm/Makefile > > > +++ b/mm/Makefile > > > @@ -39,7 +39,7 @@ obj-y := filemap.o mempool.o > > > oom_kill.o fadvise.o \ > > > mm_init.o mmu_context.o percpu.o > > > slab_common.o \ > > > compaction.o vmacache.o \ > > > interval_tree.o list_lru.o workingset.o \ > > > - debug.o $(mmu-y) > > > + debug.o apply_as_range.o $(mmu-y) > > > > > > obj-y += init-mm.o > > > obj-y += memblock.o > > > diff --git a/mm/apply_as_range.c b/mm/apply_as_range.c > > > new file mode 100644 > > > index 000000000000..9f03e272ebd0 > > > --- /dev/null > > > +++ b/mm/apply_as_range.c > > > @@ -0,0 +1,257 @@ > > > +// SPDX-License-Identifier: GPL-2.0 > > > +#include > > > +#include > > > +#include > > > +#include > > > +#include > > > +#include > > > + > > > +/** > > > + * struct apply_as - Closure structure for apply_as_range > > > + * @base: struct pfn_range_apply we derive from > > > + * @start: Address of first modified pte > > > + * @end: Address of last modified pte + 1 > > > + * @total: Total number of modified ptes > > > + * @vma: Pointer to the struct vm_area_struct we're currently > > > operating on > > > + * @flush_cache: Whether to call a cache flush before modifying a > > > pte > > > + * @flush_tlb: Whether to flush the tlb after modifying a pte > > > + */ > > > +struct apply_as { > > > + struct pfn_range_apply base; > > > + unsigned long start, end; > > > + unsigned long total; > > > + const struct vm_area_struct *vma; > > > + u32 flush_cache : 1; > > > + u32 flush_tlb : 1; > > > +}; > > > + > > > +/** > > > + * apply_pt_wrprotect - Leaf pte callback to write-protect a pte > > > + * @pte: Pointer to the pte > > > + * @token: Page table token, see apply_to_pfn_range() > > > + * @addr: The virtual page address > > > + * @closure: Pointer to a struct pfn_range_apply embedded in a > > > + * struct apply_as > > > + * > > > + * The function write-protects a pte and records the range in > > > + * virtual address space of touched ptes for efficient TLB > > > flushes. > > > + * > > > + * Return: Always zero. > > > + */ > > > +static int apply_pt_wrprotect(pte_t *pte, pgtable_t token, > > > + unsigned long addr, > > > + struct pfn_range_apply *closure) > > > +{ > > > + struct apply_as *aas = container_of(closure, typeof(*aas), > > > base); > > > + > > > + if (pte_write(*pte)) { > > > + set_pte_at(closure->mm, addr, pte, > > > pte_wrprotect(*pte)); > > > > So there is no flushing here, even for x96 this is wrong. It > > should be something like: > > ptep_clear_flush() > > flush_cache_page() // if pte is pointing to a regular page > > set_pte_at() > > update_mmu_cache() > > > > Here cache flushing is done before any leaf function is called. > According to 1) that should be equivalent, although flushing cache in > the leaf function is probably more efficient for most use cases. Both > these functions are no-ops for both x86 and ARM64 where they most > likely will be used... > > For ptep_clear_flush() the TLB flushing is here instead deferred to > after all leaf functions have been called. It looks like if the PTE is > dirty, the TLB has no business touching it until then anyway, it should > be happy with its cached value. > > Since flushing a single tlb page involves a broadcast across all cores, > I believe flushing a range is a pretty important optimization. Reading the code i missed the range flush below, it should be ok but you should be using ptep_modify_prot_start()/ptep_modify_prot_commit() pattern. I think some arch like to be involve in pte changes and the 2 patterns so far in the kernel (AFAIK) is ptep_clear_flush() or the ptep_modify_prot_start//ptep_modify_prot_commit so i believe it is better to stick to one of those instead of introducing a third one. > > Also for update_mmu_cache() the impression I got from its docs is that > it should only be used when increasing pte permissions, like in fault > handlers, not the opposite? I think some arch rely on it for something else but if you use the range flushing properly you should not need it. > > > > > + aas->total++; > > > + if (addr < aas->start) > > > + aas->start = addr; > > > + if (addr + PAGE_SIZE > aas->end) > > > + aas->end = addr + PAGE_SIZE; > > > + } > > > + > > > + return 0; > > > +} > > > + > > > +/** > > > + * struct apply_as_clean - Closure structure for apply_as_clean > > > + * @base: struct apply_as we derive from > > > + * @bitmap_pgoff: Address_space Page offset of the first bit in > > > @bitmap > > > + * @bitmap: Bitmap with one bit for each page offset in the > > > address_space range > > > + * covered. > > > + * @start: Address_space page offset of first modified pte > > > + * @end: Address_space page offset of last modified pte > > > + */ > > > +struct apply_as_clean { > > > + struct apply_as base; > > > + pgoff_t bitmap_pgoff; > > > + unsigned long *bitmap; > > > + pgoff_t start, end; > > > +}; > > > + > > > +/** > > > + * apply_pt_clean - Leaf pte callback to clean a pte > > > + * @pte: Pointer to the pte > > > + * @token: Page table token, see apply_to_pfn_range() > > > + * @addr: The virtual page address > > > + * @closure: Pointer to a struct pfn_range_apply embedded in a > > > + * struct apply_as_clean > > > + * > > > + * The function cleans a pte and records the range in > > > + * virtual address space of touched ptes for efficient TLB > > > flushes. > > > + * It also records dirty ptes in a bitmap representing page > > > offsets > > > + * in the address_space, as well as the first and last of the bits > > > + * touched. > > > + * > > > + * Return: Always zero. > > > + */ > > > +static int apply_pt_clean(pte_t *pte, pgtable_t token, > > > + unsigned long addr, > > > + struct pfn_range_apply *closure) > > > +{ > > > + struct apply_as *aas = container_of(closure, typeof(*aas), > > > base); > > > + struct apply_as_clean *clean = container_of(aas, > > > typeof(*clean), base); > > > + > > > + if (pte_dirty(*pte)) { > > > + pgoff_t pgoff = ((addr - aas->vma->vm_start) >> > > > PAGE_SHIFT) + > > > + aas->vma->vm_pgoff - clean->bitmap_pgoff; > > > + > > > + set_pte_at(closure->mm, addr, pte, pte_mkclean(*pte)); > > > > Clearing the dirty bit is racy, it should be done with write protect > > instead as the dirty bit can be set again just after you clear it. > > So i am not sure what is the usage pattern where you want to clear > > that bit without write protect. > > If it's set again, then it will be picked up at the next GPU command > submission referencing this page i. e. the next run of this function. > What we're after here is to get to all pages that were dirtied *before* > this call. The raciness and remedy (if desired) is mentioned in the > comments to the exported function below. Typically users write-protect > before scanning dirty bits only if transitioning to mkwrite-dirtying. > The important thing is that we don't accidently clear dirty bits > without picking them up. Fair enough. > > > > You also need proper page flushing with flush_cache_page() > > > > > + aas->total++; > > > + if (addr < aas->start) > > > + aas->start = addr; > > > + if (addr + PAGE_SIZE > aas->end) > > > + aas->end = addr + PAGE_SIZE; > > > + > > > + __set_bit(pgoff, clean->bitmap); > > > + clean->start = min(clean->start, pgoff); > > > + clean->end = max(clean->end, pgoff + 1); > > > + } > > > + > > > + return 0; > > > +} > > > + > > > +/** > > > + * apply_as_range - Apply a pte callback to all PTEs pointing into > > > a range > > > + * of an address_space. > > > + * @mapping: Pointer to the struct address_space > > > + * @aas: Closure structure > > > + * @first_index: First page offset in the address_space > > > + * @nr: Number of incremental page offsets to cover > > > + * > > > + * Return: Number of ptes touched. Note that this number might be > > > larger > > > + * than @nr if there are overlapping vmas > > > + */ > > > > This comment need to be _scary_ it should only be use for device > > driver > > vma ie device driver mapping. > > > > > +static unsigned long apply_as_range(struct address_space *mapping, > > > + struct apply_as *aas, > > > + pgoff_t first_index, pgoff_t nr) > > > +{ > > > + struct vm_area_struct *vma; > > > + pgoff_t vba, vea, cba, cea; > > > + unsigned long start_addr, end_addr; > > > + > > > + /* FIXME: Is a read lock sufficient here? */ > > > + down_write(&mapping->i_mmap_rwsem); > > > > read would be sufficient and you should use i_mmap_lock_read() not > > the down_write/read API. > > > > > + vma_interval_tree_foreach(vma, &mapping->i_mmap, first_index, > > > + first_index + nr - 1) { > > > + aas->base.mm = vma->vm_mm; > > > + > > > + /* Clip to the vma */ > > > + vba = vma->vm_pgoff; > > > + vea = vba + vma_pages(vma); > > > + cba = first_index; > > > + cba = max(cba, vba); > > > + cea = first_index + nr; > > > + cea = min(cea, vea); > > > + > > > + /* Translate to virtual address */ > > > + start_addr = ((cba - vba) << PAGE_SHIFT) + vma- > > > >vm_start; > > > + end_addr = ((cea - vba) << PAGE_SHIFT) + vma->vm_start; > > > + > > > + /* > > > + * TODO: Should caches be flushed individually on > > > demand > > > + * in the leaf-pte callbacks instead? That is, how > > > + * costly are inter-core interrupts in an SMP system? > > > + */ > > > + if (aas->flush_cache) > > > + flush_cache_range(vma, start_addr, end_addr); > > > > flush_cache_range() is a noop on most architecture what you really > > need > > is proper per page flushing see above. > > From the docs 1) they are interchangeable. But I will change to > per-page cache flushing anyway. Yeah you can do flush_cache_range() it is fine. Cheers, Jérôme