From mboxrd@z Thu Jan 1 00:00:00 1970 From: Minchan Kim Subject: Re: [PATCH v2 13/18] mm/compaction: support non-lru movable page migration Date: Tue, 22 Mar 2016 23:55:45 +0900 Message-ID: <20160322145545.GB3221@bbox> References: <1458541867-27380-1-git-send-email-minchan@kernel.org> <1458541867-27380-14-git-send-email-minchan@kernel.org> <20160322055037.GC31955@js1304-P5Q-DELUXE> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from lgeamrelo12.lge.com (LGEAMRELO12.lge.com [156.147.23.52]) by gabe.freedesktop.org (Postfix) with ESMTP id 5697E6E312 for ; Tue, 22 Mar 2016 14:54:31 +0000 (UTC) In-Reply-To: <20160322055037.GC31955@js1304-P5Q-DELUXE> Content-Disposition: inline List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Joonsoo Kim Cc: Rik van Riel , YiPing Xu , aquini@redhat.com, rknize@motorola.com, Sergey Senozhatsky , Chan Gyun Jeong , dri-devel@lists.freedesktop.org, Hugh Dickins , linux-kernel@vger.kernel.org, Al Viro , virtualization@lists.linux-foundation.org, bfields@fieldses.org, linux-mm@kvack.org, Gioh Kim , Gioh Kim , koct9i@gmail.com, Sangseok Lee , Andrew Morton , jlayton@poochiereds.net, Vlastimil Babka , Mel Gorman List-Id: dri-devel@lists.freedesktop.org T24gVHVlLCBNYXIgMjIsIDIwMTYgYXQgMDI6NTA6MzdQTSArMDkwMCwgSm9vbnNvbyBLaW0gd3Jv dGU6Cj4gT24gTW9uLCBNYXIgMjEsIDIwMTYgYXQgMDM6MzE6MDJQTSArMDkwMCwgTWluY2hhbiBL aW0gd3JvdGU6Cj4gPiBXZSBoYXZlIGFsbG93ZWQgbWlncmF0aW9uIGZvciBvbmx5IExSVSBwYWdl cyB1bnRpbCBub3cgYW5kIGl0IHdhcwo+ID4gZW5vdWdoIHRvIG1ha2UgaGlnaC1vcmRlciBwYWdl cy4gQnV0IHJlY2VudGx5LCBlbWJlZGRlZCBzeXN0ZW0oZS5nLiwKPiA+IHdlYk9TLCBhbmRyb2lk KSB1c2VzIGxvdHMgb2Ygbm9uLW1vdmFibGUgcGFnZXMoZS5nLiwgenJhbSwgR1BVIG1lbW9yeSkK PiA+IHNvIHdlIGhhdmUgc2VlbiBzZXZlcmFsIHJlcG9ydHMgYWJvdXQgdHJvdWJsZXMgb2Ygc21h bGwgaGlnaC1vcmRlcgo+ID4gYWxsb2NhdGlvbi4gRm9yIGZpeGluZyB0aGUgcHJvYmxlbSwgdGhl cmUgd2VyZSBzZXZlcmFsIGVmZm9ydHMKPiA+IChlLGcsLiBlbmhhbmNlIGNvbXBhY3Rpb24gYWxn b3JpdGhtLCBTTFVCIGZhbGxiYWNrIHRvIDAtb3JkZXIgcGFnZSwKPiA+IHJlc2VydmVkIG1lbW9y eSwgdm1hbGxvYyBhbmQgc28gb24pIGJ1dCBpZiB0aGVyZSBhcmUgbG90cyBvZgo+ID4gbm9uLW1v dmFibGUgcGFnZXMgaW4gc3lzdGVtLCB0aGVpciBzb2x1dGlvbnMgYXJlIHZvaWQgaW4gdGhlIGxv bmcgcnVuLgo+ID4gCj4gPiBTbywgdGhpcyBwYXRjaCBpcyB0byBzdXBwb3J0IGZhY2lsaXR5IHRv IGNoYW5nZSBub24tbW92YWJsZSBwYWdlcwo+ID4gd2l0aCBtb3ZhYmxlLiBGb3IgdGhlIGZlYXR1 cmUsIHRoaXMgcGF0Y2ggaW50cm9kdWNlcyBmdW5jdGlvbnMgcmVsYXRlZAo+ID4gdG8gbWlncmF0 aW9uIHRvIGFkZHJlc3Nfc3BhY2Vfb3BlcmF0aW9ucyBhcyB3ZWxsIGFzIHNvbWUgcGFnZSBmbGFn cy4KPiA+IAo+ID4gQmFzaWNhbGx5LCB0aGlzIHBhdGNoIHN1cHBvcnRzIHR3byBwYWdlLWZsYWdz IGFuZCB0d28gZnVuY3Rpb25zIHJlbGF0ZWQKPiA+IHRvIHBhZ2UgbWlncmF0aW9uLiBUaGUgZmxh ZyBhbmQgcGFnZS0+bWFwcGluZyBzdGFiaWxpdHkgYXJlIHByb3RlY3RlZAo+ID4gYnkgUEdfbG9j ay4KPiA+IAo+ID4gCVBHX21vdmFibGUKPiA+IAlQR19pc29sYXRlZAo+ID4gCj4gPiAJYm9vbCAo Kmlzb2xhdGVfcGFnZSkgKHN0cnVjdCBwYWdlICosIGlzb2xhdGVfbW9kZV90KTsKPiA+IAl2b2lk ICgqcHV0YmFja19wYWdlKSAoc3RydWN0IHBhZ2UgKik7Cj4gPiAKPiA+IER1dHkgb2Ygc3Vic3lz dGVtIHdhbnQgdG8gbWFrZSB0aGVpciBwYWdlcyBhcyBtaWdyYXRhYmxlIGFyZQo+ID4gYXMgZm9s bG93czoKPiA+IAo+ID4gMS4gSXQgc2hvdWxkIHJlZ2lzdGVyIGFkZHJlc3Nfc3BhY2UgdG8gcGFn ZS0+bWFwcGluZyB0aGVuIG1hcmsKPiA+IHRoZSBwYWdlIGFzIFBHX21vdmFibGUgdmlhIF9fU2V0 UGFnZU1vdmFibGUuCj4gPiAKPiA+IDIuIEl0IHNob3VsZCBtYXJrIHRoZSBwYWdlIGFzIFBHX2lz b2xhdGVkIHZpYSBTZXRQYWdlSXNvbGF0ZWQKPiA+IGlmIGlzb2xhdGlvbiBpcyBzdWNlc3NmdWwg YW5kIHJldHVybiB0cnVlLgo+ID4gCj4gPiAzLiBJZiBtaWdyYXRpb24gaXMgc3VjY2Vzc2Z1bCwg aXQgc2hvdWxkIGNsZWFyIFBHX2lzb2xhdGVkIGFuZAo+ID4gUEdfbW92YWJsZSBvZiB0aGUgcGFn ZSBmb3IgZnJlZSBwcmVwYXJhdGlvbiB0aGVuIHJlbGVhc2UgdGhlCj4gPiByZWZlcmVuY2Ugb2Yg dGhlIHBhZ2UgdG8gZnJlZS4KPiA+IAo+ID4gNC4gSWYgbWlncmF0aW9uIGZhaWxzLCBwdXRiYWNr IGZ1bmN0aW9uIG9mIHN1YnN5c3RlbSBzaG91bGQKPiA+IGNsZWFyIFBHX2lzb2xhdGVkIHZpYSBD bGVhclBhZ2VJc29sYXRlZC4KPiAKPiBJIHRoaW5rIHRoYXQgdGhpcyBmZWF0dXJlIG5lZWRzIGEg c2VwYXJhdGUgZG9jdW1lbnQgdG8gZGVzY3JpYmUKPiByZXF1aXJlbWVudCBvZiBlYWNoIHN0ZXAg aW4gbW9yZSBkZXRhaWwuIEZvciBleGFtcGxlLCAjMSBjYW4gYmUKPiBwb3NzaWJsZSB3aXRob3V0 IGhvbGRpbmcgYSBsb2NrPyBJJ20gbm90IHN1cmUgYmVjYXVzZSB5b3UgbG9jawo+IHRoZSBwYWdl IHdoZW4gaW1wbGVtZW50aW5nIHpzbWFsbG9jIHBhZ2UgbWlncmF0aW9uIGluIDE1dGggcGF0Y2gu CgpZZXMsIHdlIG5lZWRzIFBHX2xvY2sgYmVjYXVzZSBpbnN0YWxsIHBhZ2UtPm1hcHBpbmcgYW5k IFBHX21vdmFibGUKc2hvdWxkIGJlIGF0b21pYyBhbmQgUEdfbG9jayBwcm90ZWN0cyBpdC4KCkJl dHRlciBpbnRlcmZhY2UgbWlnaHQgYmUKCnZvaWQgX19TZXRQYWdlTW92YWJsZShzdHJ1Y3QgcGFn ZSAqcGFnZSwgc3J1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZyk7Cgo+IAo+ICMzIGFsc28gbmVl ZCBtb3JlIGV4cGxhbmF0aW9uLiBCZWZvcmUgcmVsZWFzZSwgd2UgbmVlZCB0bwo+IHVucmVnaXN0 ZXIgYWRkcmVzc19zcGFjZS4gSSBndWVzcyB0aGF0IGl0IG5lZWRzIHRvIGJlIGRvbmUKPiBpbiBt aWdyYXRlcGFnZSgpIGJ1dCB0aGVyZSBpcyBubyBleHBsYW5hdGlvbi4KCk9rYXksIHdlIGNhbiB1 bnJlZ2lzdGVyIGFkZHJlc3Nfc3BhY2UgaW4gX19DbGVhclBhZ2VNb3ZhYmxlLgpJIHdpbGwgY2hh bmdlIGl0LgoKPiAKPiA+IAo+ID4gQ2M6IFZsYXN0aW1pbCBCYWJrYSA8dmJhYmthQHN1c2UuY3o+ Cj4gPiBDYzogTWVsIEdvcm1hbiA8bWdvcm1hbkBzdXNlLmRlPgo+ID4gQ2M6IEh1Z2ggRGlja2lu cyA8aHVnaGRAZ29vZ2xlLmNvbT4KPiA+IENjOiBkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCj4gPiBDYzogdmlydHVhbGl6YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKPiA+ IFNpZ25lZC1vZmYtYnk6IEdpb2ggS2ltIDxndXJ1Z2lvQGhhbm1haWwubmV0Pgo+ID4gU2lnbmVk LW9mZi1ieTogTWluY2hhbiBLaW0gPG1pbmNoYW5Aa2VybmVsLm9yZz4KPiA+IC0tLQo+ID4gIERv Y3VtZW50YXRpb24vZmlsZXN5c3RlbXMvTG9ja2luZyAgICAgIHwgICA0ICsKPiA+ICBEb2N1bWVu dGF0aW9uL2ZpbGVzeXN0ZW1zL3Zmcy50eHQgICAgICB8ICAgNSArKwo+ID4gIGZzL3Byb2MvcGFn ZS5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAzICsKPiA+ICBpbmNsdWRlL2xpbnV4L2Zz LmggICAgICAgICAgICAgICAgICAgICB8ICAgMiArCj4gPiAgaW5jbHVkZS9saW51eC9taWdyYXRl LmggICAgICAgICAgICAgICAgfCAgIDIgKwo+ID4gIGluY2x1ZGUvbGludXgvcGFnZS1mbGFncy5o ICAgICAgICAgICAgIHwgIDI5ICsrKysrKysrCj4gPiAgaW5jbHVkZS91YXBpL2xpbnV4L2tlcm5l bC1wYWdlLWZsYWdzLmggfCAgIDEgKwo+ID4gIG1tL2NvbXBhY3Rpb24uYyAgICAgICAgICAgICAg ICAgICAgICAgIHwgIDE0ICsrKy0KPiA+ICBtbS9taWdyYXRlLmMgICAgICAgICAgICAgICAgICAg ICAgICAgICB8IDEzMiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0KPiA+ICA5IGZp bGVzIGNoYW5nZWQsIDE3NyBpbnNlcnRpb25zKCspLCAxNSBkZWxldGlvbnMoLSkKPiA+IAo+ID4g ZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvTG9ja2luZyBiL0RvY3VtZW50 YXRpb24vZmlsZXN5c3RlbXMvTG9ja2luZwo+ID4gaW5kZXggNjE5YWY5YmZkY2IzLi4wYmI3OTU2 MGFiYjMgMTAwNjQ0Cj4gPiAtLS0gYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL0xvY2tpbmcK PiA+ICsrKyBiL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvTG9ja2luZwo+ID4gQEAgLTE5NSw3 ICsxOTUsOSBAQCB1bmxvY2tzIGFuZCBkcm9wcyB0aGUgcmVmZXJlbmNlLgo+ID4gIAlpbnQgKCpy ZWxlYXNlcGFnZSkgKHN0cnVjdCBwYWdlICosIGludCk7Cj4gPiAgCXZvaWQgKCpmcmVlcGFnZSko c3RydWN0IHBhZ2UgKik7Cj4gPiAgCWludCAoKmRpcmVjdF9JTykoc3RydWN0IGtpb2NiICosIHN0 cnVjdCBpb3ZfaXRlciAqaXRlciwgbG9mZl90IG9mZnNldCk7Cj4gPiArCWJvb2wgKCppc29sYXRl X3BhZ2UpIChzdHJ1Y3QgcGFnZSAqLCBpc29sYXRlX21vZGVfdCk7Cj4gPiAgCWludCAoKm1pZ3Jh dGVwYWdlKShzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqLCBzdHJ1Y3QgcGFnZSAqLCBzdHJ1Y3QgcGFn ZSAqKTsKPiA+ICsJdm9pZCAoKnB1dGJhY2tfcGFnZSkgKHN0cnVjdCBwYWdlICopOwo+ID4gIAlp bnQgKCpsYXVuZGVyX3BhZ2UpKHN0cnVjdCBwYWdlICopOwo+ID4gIAlpbnQgKCppc19wYXJ0aWFs bHlfdXB0b2RhdGUpKHN0cnVjdCBwYWdlICosIHVuc2lnbmVkIGxvbmcsIHVuc2lnbmVkIGxvbmcp Owo+ID4gIAlpbnQgKCplcnJvcl9yZW1vdmVfcGFnZSkoc3RydWN0IGFkZHJlc3Nfc3BhY2UgKiwg c3RydWN0IHBhZ2UgKik7Cj4gPiBAQCAtMjE5LDcgKzIyMSw5IEBAIGludmFsaWRhdGVwYWdlOgkJ eWVzCj4gPiAgcmVsZWFzZXBhZ2U6CQl5ZXMKPiA+ICBmcmVlcGFnZToJCXllcwo+ID4gIGRpcmVj dF9JTzoKPiA+ICtpc29sYXRlX3BhZ2U6CQl5ZXMKPiA+ICBtaWdyYXRlcGFnZToJCXllcyAoYm90 aCkKPiA+ICtwdXRiYWNrX3BhZ2U6CQl5ZXMKPiA+ICBsYXVuZGVyX3BhZ2U6CQl5ZXMKPiA+ICBp c19wYXJ0aWFsbHlfdXB0b2RhdGU6CXllcwo+ID4gIGVycm9yX3JlbW92ZV9wYWdlOgl5ZXMKPiA+ IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Zmcy50eHQgYi9Eb2N1bWVu dGF0aW9uL2ZpbGVzeXN0ZW1zL3Zmcy50eHQKPiA+IGluZGV4IGIwMmE3ZDU5ODI1OC4uNGMxYjZj M2I0YmM4IDEwMDY0NAo+ID4gLS0tIGEvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy92ZnMudHh0 Cj4gPiArKysgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL3Zmcy50eHQKPiA+IEBAIC01OTIs OSArNTkyLDE0IEBAIHN0cnVjdCBhZGRyZXNzX3NwYWNlX29wZXJhdGlvbnMgewo+ID4gIAlpbnQg KCpyZWxlYXNlcGFnZSkgKHN0cnVjdCBwYWdlICosIGludCk7Cj4gPiAgCXZvaWQgKCpmcmVlcGFn ZSkoc3RydWN0IHBhZ2UgKik7Cj4gPiAgCXNzaXplX3QgKCpkaXJlY3RfSU8pKHN0cnVjdCBraW9j YiAqLCBzdHJ1Y3QgaW92X2l0ZXIgKml0ZXIsIGxvZmZfdCBvZmZzZXQpOwo+ID4gKwkvKiBpc29s YXRlIGEgcGFnZSBmb3IgbWlncmF0aW9uICovCj4gPiArCWJvb2wgKCppc29sYXRlX3BhZ2UpIChz dHJ1Y3QgcGFnZSAqLCBpc29sYXRlX21vZGVfdCk7Cj4gPiAgCS8qIG1pZ3JhdGUgdGhlIGNvbnRl bnRzIG9mIGEgcGFnZSB0byB0aGUgc3BlY2lmaWVkIHRhcmdldCAqLwo+ID4gIAlpbnQgKCptaWdy YXRlcGFnZSkgKHN0cnVjdCBwYWdlICosIHN0cnVjdCBwYWdlICopOwo+ID4gKwkvKiBwdXQgdGhl IHBhZ2UgYmFjayB0byByaWdodCBsaXN0ICovCj4gPiArCXZvaWQgKCpwdXRiYWNrX3BhZ2UpIChz dHJ1Y3QgcGFnZSAqKTsKPiA+ICAJaW50ICgqbGF1bmRlcl9wYWdlKSAoc3RydWN0IHBhZ2UgKik7 Cj4gPiArCj4gPiAgCWludCAoKmlzX3BhcnRpYWxseV91cHRvZGF0ZSkgKHN0cnVjdCBwYWdlICos IHVuc2lnbmVkIGxvbmcsCj4gPiAgCQkJCQl1bnNpZ25lZCBsb25nKTsKPiA+ICAJdm9pZCAoKmlz X2RpcnR5X3dyaXRlYmFjaykgKHN0cnVjdCBwYWdlICosIGJvb2wgKiwgYm9vbCAqKTsKPiA+IGRp ZmYgLS1naXQgYS9mcy9wcm9jL3BhZ2UuYyBiL2ZzL3Byb2MvcGFnZS5jCj4gPiBpbmRleCA3MTJm MWI5OTkyY2MuLmUyMDY2ZTczYTliOCAxMDA2NDQKPiA+IC0tLSBhL2ZzL3Byb2MvcGFnZS5jCj4g PiArKysgYi9mcy9wcm9jL3BhZ2UuYwo+ID4gQEAgLTE1Nyw2ICsxNTcsOSBAQCB1NjQgc3RhYmxl X3BhZ2VfZmxhZ3Moc3RydWN0IHBhZ2UgKnBhZ2UpCj4gPiAgCWlmIChwYWdlX2lzX2lkbGUocGFn ZSkpCj4gPiAgCQl1IHw9IDEgPDwgS1BGX0lETEU7Cj4gPiAgCj4gPiArCWlmIChQYWdlTW92YWJs ZShwYWdlKSkKPiA+ICsJCXUgfD0gMSA8PCBLUEZfTU9WQUJMRTsKPiA+ICsKPiA+ICAJdSB8PSBr cGZfY29weV9iaXQoaywgS1BGX0xPQ0tFRCwJUEdfbG9ja2VkKTsKPiA+ICAKPiA+ICAJdSB8PSBr cGZfY29weV9iaXQoaywgS1BGX1NMQUIsCQlQR19zbGFiKTsKPiA+IGRpZmYgLS1naXQgYS9pbmNs dWRlL2xpbnV4L2ZzLmggYi9pbmNsdWRlL2xpbnV4L2ZzLmgKPiA+IGluZGV4IDE0YTk3MTk0YjM0 Yi4uYjdlZjJlNDFmYTRhIDEwMDY0NAo+ID4gLS0tIGEvaW5jbHVkZS9saW51eC9mcy5oCj4gPiAr KysgYi9pbmNsdWRlL2xpbnV4L2ZzLmgKPiA+IEBAIC00MDEsNiArNDAxLDggQEAgc3RydWN0IGFk ZHJlc3Nfc3BhY2Vfb3BlcmF0aW9ucyB7Cj4gPiAgCSAqLwo+ID4gIAlpbnQgKCptaWdyYXRlcGFn ZSkgKHN0cnVjdCBhZGRyZXNzX3NwYWNlICosCj4gPiAgCQkJc3RydWN0IHBhZ2UgKiwgc3RydWN0 IHBhZ2UgKiwgZW51bSBtaWdyYXRlX21vZGUpOwo+ID4gKwlib29sICgqaXNvbGF0ZV9wYWdlKShz dHJ1Y3QgcGFnZSAqLCBpc29sYXRlX21vZGVfdCk7Cj4gPiArCXZvaWQgKCpwdXRiYWNrX3BhZ2Up KHN0cnVjdCBwYWdlICopOwo+ID4gIAlpbnQgKCpsYXVuZGVyX3BhZ2UpIChzdHJ1Y3QgcGFnZSAq KTsKPiA+ICAJaW50ICgqaXNfcGFydGlhbGx5X3VwdG9kYXRlKSAoc3RydWN0IHBhZ2UgKiwgdW5z aWduZWQgbG9uZywKPiA+ICAJCQkJCXVuc2lnbmVkIGxvbmcpOwo+ID4gZGlmZiAtLWdpdCBhL2lu Y2x1ZGUvbGludXgvbWlncmF0ZS5oIGIvaW5jbHVkZS9saW51eC9taWdyYXRlLmgKPiA+IGluZGV4 IDliNTAzMjVlNGRkZi4uNDA0ZmJmZWZlYjMzIDEwMDY0NAo+ID4gLS0tIGEvaW5jbHVkZS9saW51 eC9taWdyYXRlLmgKPiA+ICsrKyBiL2luY2x1ZGUvbGludXgvbWlncmF0ZS5oCj4gPiBAQCAtMzcs NiArMzcsOCBAQCBleHRlcm4gaW50IG1pZ3JhdGVfcGFnZShzdHJ1Y3QgYWRkcmVzc19zcGFjZSAq LAo+ID4gIAkJCXN0cnVjdCBwYWdlICosIHN0cnVjdCBwYWdlICosIGVudW0gbWlncmF0ZV9tb2Rl KTsKPiA+ICBleHRlcm4gaW50IG1pZ3JhdGVfcGFnZXMoc3RydWN0IGxpc3RfaGVhZCAqbCwgbmV3 X3BhZ2VfdCBuZXcsIGZyZWVfcGFnZV90IGZyZWUsCj4gPiAgCQl1bnNpZ25lZCBsb25nIHByaXZh dGUsIGVudW0gbWlncmF0ZV9tb2RlIG1vZGUsIGludCByZWFzb24pOwo+ID4gK2V4dGVybiBib29s IGlzb2xhdGVfbW92YWJsZV9wYWdlKHN0cnVjdCBwYWdlICpwYWdlLCBpc29sYXRlX21vZGVfdCBt b2RlKTsKPiA+ICtleHRlcm4gdm9pZCBwdXRiYWNrX21vdmFibGVfcGFnZShzdHJ1Y3QgcGFnZSAq cGFnZSk7Cj4gPiAgCj4gPiAgZXh0ZXJuIGludCBtaWdyYXRlX3ByZXAodm9pZCk7Cj4gPiAgZXh0 ZXJuIGludCBtaWdyYXRlX3ByZXBfbG9jYWwodm9pZCk7Cj4gPiBkaWZmIC0tZ2l0IGEvaW5jbHVk ZS9saW51eC9wYWdlLWZsYWdzLmggYi9pbmNsdWRlL2xpbnV4L3BhZ2UtZmxhZ3MuaAo+ID4gaW5k ZXggZjRlZDRmMWIwYzc3Li4zODg1MDY0NjQxYzQgMTAwNjQ0Cj4gPiAtLS0gYS9pbmNsdWRlL2xp bnV4L3BhZ2UtZmxhZ3MuaAo+ID4gKysrIGIvaW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLmgKPiA+ IEBAIC0xMjksNiArMTI5LDEwIEBAIGVudW0gcGFnZWZsYWdzIHsKPiA+ICAKPiA+ICAJLyogQ29t cG91bmQgcGFnZXMuIFN0b3JlZCBpbiBmaXJzdCB0YWlsIHBhZ2UncyBmbGFncyAqLwo+ID4gIAlQ R19kb3VibGVfbWFwID0gUEdfcHJpdmF0ZV8yLAo+ID4gKwo+ID4gKwkvKiBub24tbHJ1IG1vdmFi bGUgcGFnZXMgKi8KPiA+ICsJUEdfbW92YWJsZSA9IFBHX3JlY2xhaW0sCj4gPiArCVBHX2lzb2xh dGVkID0gUEdfb3duZXJfcHJpdl8xLAo+ID4gIH07Cj4gPiAgCj4gPiAgI2lmbmRlZiBfX0dFTkVS QVRJTkdfQk9VTkRTX0gKPiA+IEBAIC02MTQsNiArNjE4LDMxIEBAIHN0YXRpYyBpbmxpbmUgdm9p ZCBfX0NsZWFyUGFnZUJhbGxvb24oc3RydWN0IHBhZ2UgKnBhZ2UpCj4gPiAgCWF0b21pY19zZXQo JnBhZ2UtPl9tYXBjb3VudCwgLTEpOwo+ID4gIH0KPiA+ICAKPiA+ICsjZGVmaW5lIFBBR0VfTU9W QUJMRV9NQVBDT1VOVF9WQUxVRSAoLTI1NSkKPiA+ICsKPiA+ICtzdGF0aWMgaW5saW5lIGludCBQ YWdlTW92YWJsZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPiA+ICt7Cj4gPiArCXJldHVybiAoKHRlc3Rf Yml0KFBHX21vdmFibGUsICYocGFnZSktPmZsYWdzKSAmJgo+ID4gKwkJYXRvbWljX3JlYWQoJnBh Z2UtPl9tYXBjb3VudCkgPT0gUEFHRV9NT1ZBQkxFX01BUENPVU5UX1ZBTFVFKQo+ID4gKwkJfHwg UGFnZUJhbGxvb24ocGFnZSkpOwo+ID4gK30KPiA+ICsKPiA+ICsvKgo+ID4gKyAqIENhbGxlciBz aG91bGQgaG9sZCBhIFBHX2xvY2sgKi8KPiA+ICtzdGF0aWMgaW5saW5lIHZvaWQgX19TZXRQYWdl TW92YWJsZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPiA+ICt7Cj4gPiArCV9fc2V0X2JpdChQR19tb3Zh YmxlLCAmcGFnZS0+ZmxhZ3MpOwo+ID4gKwlhdG9taWNfc2V0KCZwYWdlLT5fbWFwY291bnQsIFBB R0VfTU9WQUJMRV9NQVBDT1VOVF9WQUxVRSk7Cj4gPiArfQo+IAo+IEkgdGhpbmsgdGhlcmUgaXMg bm8gYmlnIGJlbmVmaXQgdG8gdXNlIG5vbi1hdG9taWMgdmVyc2lvbiBoZXJlLgo+IFBhZ2VNb3Zh YmxlKCkgaXMgc3BlY3VsYXRpdmVseSBjaGVja2VkIHdpdGhvdXQgaG9sZGluZyBhIFBHX2xvY2sK PiBzbyBzb21lIGNwdSBjYW4gbWlzcyB0aGlzIGZsYWcgc2V0IGlmIHdlIHVzZSBub24tYXRvbWlj IHZlcnNpb24uCgpJIHdhbnRlZCB0byBzaG93IHRoYXQgZG91YmxlIHVuZGVyc2NvcmUgaXMgbm9u LWF0b21pYyBzbyBjYWxsZXIKc2hvdWxkIHRha2UgY2FyZSBvZiB0aGUgbG9jayhpLmUuLCBQR19s b2NrKS4KSWYgd2UgdXNlIGF0b21pYyB2ZXJzaW9uLCB3aGF0IGtpbmRzIG9mIGJlbmVmaXQgZG8g d2UgaGF2ZT8KV2l0aG91dCBob2xkaW5nIFBHX2xvY2ssIGF0b21pYyB2ZXJzaW9uIGNvdWxkIGJl IHJhY2VkLCB0b28uCgo+IAo+ID4gKwo+ID4gK3N0YXRpYyBpbmxpbmUgdm9pZCBfX0NsZWFyUGFn ZU1vdmFibGUoc3RydWN0IHBhZ2UgKnBhZ2UpCj4gPiArewo+ID4gKwlhdG9taWNfc2V0KCZwYWdl LT5fbWFwY291bnQsIC0xKTsKPiA+ICsJX19jbGVhcl9iaXQoUEdfbW92YWJsZSwgJihwYWdlKS0+ ZmxhZ3MpOwo+ID4gK30KPiA+ICsKPiA+ICtQQUdFRkxBRyhJc29sYXRlZCwgaXNvbGF0ZWQsIFBG X0FOWSk7Cj4gPiArCj4gPiAgLyoKPiA+ICAgKiBJZiBuZXR3b3JrLWJhc2VkIHN3YXAgaXMgZW5h YmxlZCwgc2wqYiBtdXN0IGtlZXAgdHJhY2sgb2Ygd2hldGhlciBwYWdlcwo+ID4gICAqIHdlcmUg YWxsb2NhdGVkIGZyb20gcGZtZW1hbGxvYyByZXNlcnZlcy4KPiA+IGRpZmYgLS1naXQgYS9pbmNs dWRlL3VhcGkvbGludXgva2VybmVsLXBhZ2UtZmxhZ3MuaCBiL2luY2x1ZGUvdWFwaS9saW51eC9r ZXJuZWwtcGFnZS1mbGFncy5oCj4gPiBpbmRleCA1ZGE1Zjg3NTFjZTcuLmExODRmZDI0MzRmYSAx MDA2NDQKPiA+IC0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9rZXJuZWwtcGFnZS1mbGFncy5oCj4g PiArKysgYi9pbmNsdWRlL3VhcGkvbGludXgva2VybmVsLXBhZ2UtZmxhZ3MuaAo+ID4gQEAgLTM0 LDYgKzM0LDcgQEAKPiA+ICAjZGVmaW5lIEtQRl9CQUxMT09OCQkyMwo+ID4gICNkZWZpbmUgS1BG X1pFUk9fUEFHRQkJMjQKPiA+ICAjZGVmaW5lIEtQRl9JRExFCQkyNQo+ID4gKyNkZWZpbmUgS1BG X01PVkFCTEUJCTI2Cj4gPiAgCj4gPiAgCj4gPiAgI2VuZGlmIC8qIF9VQVBJTElOVVhfS0VSTkVM X1BBR0VfRkxBR1NfSCAqLwo+ID4gZGlmZiAtLWdpdCBhL21tL2NvbXBhY3Rpb24uYyBiL21tL2Nv bXBhY3Rpb24uYwo+ID4gaW5kZXggY2NmOTdiMDJiODVmLi43NTU3YWVkZGRhZWUgMTAwNjQ0Cj4g PiAtLS0gYS9tbS9jb21wYWN0aW9uLmMKPiA+ICsrKyBiL21tL2NvbXBhY3Rpb24uYwo+ID4gQEAg LTcwMyw3ICs3MDMsNyBAQCBpc29sYXRlX21pZ3JhdGVwYWdlc19ibG9jayhzdHJ1Y3QgY29tcGFj dF9jb250cm9sICpjYywgdW5zaWduZWQgbG9uZyBsb3dfcGZuLAo+ID4gIAo+ID4gIAkJLyoKPiA+ ICAJCSAqIENoZWNrIG1heSBiZSBsb2NrbGVzcyBidXQgdGhhdCdzIG9rIGFzIHdlIHJlY2hlY2sg bGF0ZXIuCj4gPiAtCQkgKiBJdCdzIHBvc3NpYmxlIHRvIG1pZ3JhdGUgTFJVIHBhZ2VzIGFuZCBi YWxsb29uIHBhZ2VzCj4gPiArCQkgKiBJdCdzIHBvc3NpYmxlIHRvIG1pZ3JhdGUgTFJVIGFuZCBt b3ZhYmxlIGtlcm5lbCBwYWdlcy4KPiA+ICAJCSAqIFNraXAgYW55IG90aGVyIHR5cGUgb2YgcGFn ZQo+ID4gIAkJICovCj4gPiAgCQlpc19scnUgPSBQYWdlTFJVKHBhZ2UpOwo+ID4gQEAgLTcxNCw2 ICs3MTQsMTggQEAgaXNvbGF0ZV9taWdyYXRlcGFnZXNfYmxvY2soc3RydWN0IGNvbXBhY3RfY29u dHJvbCAqY2MsIHVuc2lnbmVkIGxvbmcgbG93X3BmbiwKPiA+ICAJCQkJCWdvdG8gaXNvbGF0ZV9z dWNjZXNzOwo+ID4gIAkJCQl9Cj4gPiAgCQkJfQo+ID4gKwo+ID4gKwkJCWlmICh1bmxpa2VseShQ YWdlTW92YWJsZShwYWdlKSkgJiYKPiA+ICsJCQkJCSFQYWdlSXNvbGF0ZWQocGFnZSkpIHsKPiA+ ICsJCQkJaWYgKGxvY2tlZCkgewo+ID4gKwkJCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmem9u ZS0+bHJ1X2xvY2ssCj4gPiArCQkJCQkJCQkJZmxhZ3MpOwo+ID4gKwkJCQkJbG9ja2VkID0gZmFs c2U7Cj4gPiArCQkJCX0KPiA+ICsKPiA+ICsJCQkJaWYgKGlzb2xhdGVfbW92YWJsZV9wYWdlKHBh Z2UsIGlzb2xhdGVfbW9kZSkpCj4gPiArCQkJCQlnb3RvIGlzb2xhdGVfc3VjY2VzczsKPiA+ICsJ CQl9Cj4gPiAgCQl9Cj4gPiAgCj4gPiAgCQkvKgo+ID4gZGlmZiAtLWdpdCBhL21tL21pZ3JhdGUu YyBiL21tL21pZ3JhdGUuYwo+ID4gaW5kZXggYjY1Yzg0MjY3Y2UwLi5mYzI4NDJhMTU4MDcgMTAw NjQ0Cj4gPiAtLS0gYS9tbS9taWdyYXRlLmMKPiA+ICsrKyBiL21tL21pZ3JhdGUuYwo+ID4gQEAg LTczLDYgKzczLDc1IEBAIGludCBtaWdyYXRlX3ByZXBfbG9jYWwodm9pZCkKPiA+ICAJcmV0dXJu IDA7Cj4gPiAgfQo+ID4gIAo+ID4gK2Jvb2wgaXNvbGF0ZV9tb3ZhYmxlX3BhZ2Uoc3RydWN0IHBh Z2UgKnBhZ2UsIGlzb2xhdGVfbW9kZV90IG1vZGUpCj4gPiArewo+ID4gKwlib29sIHJldCA9IGZh bHNlOwo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBBdm9pZCBidXJuaW5nIGN5Y2xlcyB3aXRoIHBh Z2VzIHRoYXQgYXJlIHlldCB1bmRlciBfX2ZyZWVfcGFnZXMoKSwKPiA+ICsJICogb3IganVzdCBn b3QgZnJlZWQgdW5kZXIgdXMuCj4gPiArCSAqCj4gPiArCSAqIEluIGNhc2Ugd2UgJ3dpbicgYSBy YWNlIGZvciBhIG1vdmFibGUgcGFnZSBiZWluZyBmcmVlZCB1bmRlciB1cyBhbmQKPiA+ICsJICog cmFpc2UgaXRzIHJlZmNvdW50IHByZXZlbnRpbmcgX19mcmVlX3BhZ2VzKCkgZnJvbSBkb2luZyBp dHMgam9iCj4gPiArCSAqIHRoZSBwdXRfcGFnZSgpIGF0IHRoZSBlbmQgb2YgdGhpcyBibG9jayB3 aWxsIHRha2UgY2FyZSBvZgo+ID4gKwkgKiByZWxlYXNlIHRoaXMgcGFnZSwgdGh1cyBhdm9pZGlu ZyBhIG5hc3R5IGxlYWthZ2UuCj4gPiArCSAqLwo+ID4gKwlpZiAodW5saWtlbHkoIWdldF9wYWdl X3VubGVzc196ZXJvKHBhZ2UpKSkKPiA+ICsJCWdvdG8gb3V0Owo+IAo+IEFmdGVyIGdldHRpbmcg dGhlIHJlZiBjb3VudGVyLCB3ZSBuZWVkIHRvIHJlLWNoZWNrIFBhZ2VNb3ZhYmxlKCkKPiB0byBl bnN1cmUgdGhhdCB3ZSBpbmRlZWQgaGFuZGxlIFBhZ2VNb3ZhYmxlKCkgdHlwZSBwYWdlLiBXaXRo b3V0IGl0LAo+IHRoZSBwYWdlIHdlIGhhbmRsZSBjYW4gYmUgZnJlZWQgYW5kIHJlLWFsbG9jYXRl ZCB0byBzb21lb25lIGVsc2UKPiB0aGF0IGlzbid0IHJlbGF0ZWQgdG8gUGFnZU1vdmFibGUoKSBi ZWZvcmUgZ3JhYmJpbmcgdGhlIHBhZ2UuIFRyeWluZwo+IHRyeWxvY2tfcGFnZSgpIGluIHRoaXMg Y2FzZSBjb3VsZCBjYXVzZSBhIHByb2JsZW0uCgpJIGRvbid0IGdldCBpdC4gV2h5IGRvIHlvdSB0 aGluayB0cnlsb2NrX3BhZ2UgY291bGQgY2F1c2UgYSBwcm9ibGVtPwpDb3VsZCB5b3UgZWxhYm9y YXRlIGl0IG1vcmU/Cgo+IAo+ID4gKwkvKgo+ID4gKwkgKiBBcyBtb3ZhYmxlIHBhZ2VzIGFyZSBu b3QgaXNvbGF0ZWQgZnJvbSBMUlUgbGlzdHMsIGNvbmN1cnJlbnQKPiA+ICsJICogY29tcGFjdGlv biB0aHJlYWRzIGNhbiByYWNlIGFnYWluc3QgcGFnZSBtaWdyYXRpb24gZnVuY3Rpb25zCj4gPiAr CSAqIGFzIHdlbGwgYXMgcmFjZSBhZ2FpbnN0IHRoZSByZWxlYXNpbmcgYSBwYWdlLgo+ID4gKwkg Kgo+ID4gKwkgKiBJbiBvcmRlciB0byBhdm9pZCBoYXZpbmcgYW4gYWxyZWFkeSBpc29sYXRlZCBt b3ZhYmxlIHBhZ2UKPiA+ICsJICogYmVpbmcgKHdyb25nbHkpIHJlLWlzb2xhdGVkIHdoaWxlIGl0 IGlzIHVuZGVyIG1pZ3JhdGlvbiwKPiA+ICsJICogb3IgdG8gYXZvaWQgYXR0ZW1wdGluZyB0byBp c29sYXRlIHBhZ2VzIGJlaW5nIHJlbGVhc2VkLAo+ID4gKwkgKiBsZXRzIGJlIHN1cmUgd2UgaGF2 ZSB0aGUgcGFnZSBsb2NrCj4gPiArCSAqIGJlZm9yZSBwcm9jZWVkaW5nIHdpdGggdGhlIG1vdmFi bGUgcGFnZSBpc29sYXRpb24gc3RlcHMuCj4gPiArCSAqLwo+ID4gKwlpZiAodW5saWtlbHkoIXRy eWxvY2tfcGFnZShwYWdlKSkpCj4gPiArCQlnb3RvIG91dF9wdXRwYWdlOwo+ID4gKwo+ID4gKwlp ZiAoIVBhZ2VNb3ZhYmxlKHBhZ2UpIHx8IFBhZ2VJc29sYXRlZChwYWdlKSkKPiA+ICsJCWdvdG8g b3V0X25vX2lzb2xhdGVkOwo+ID4gKwo+ID4gKwlyZXQgPSBwYWdlLT5tYXBwaW5nLT5hX29wcy0+ aXNvbGF0ZV9wYWdlKHBhZ2UsIG1vZGUpOwo+ID4gKwlpZiAoIXJldCkKPiA+ICsJCWdvdG8gb3V0 X25vX2lzb2xhdGVkOwo+ID4gKwo+ID4gKwlXQVJOX09OX09OQ0UoIVBhZ2VJc29sYXRlZChwYWdl KSk7Cj4gPiArCXVubG9ja19wYWdlKHBhZ2UpOwo+ID4gKwlyZXR1cm4gcmV0Owo+ID4gKwo+ID4g K291dF9ub19pc29sYXRlZDoKPiA+ICsJdW5sb2NrX3BhZ2UocGFnZSk7Cj4gPiArb3V0X3B1dHBh Z2U6Cj4gPiArCXB1dF9wYWdlKHBhZ2UpOwo+ID4gK291dDoKPiA+ICsJcmV0dXJuIHJldDsKPiA+ ICt9Cj4gPiArCj4gPiArdm9pZCBwdXRiYWNrX21vdmFibGVfcGFnZShzdHJ1Y3QgcGFnZSAqcGFn ZSkKPiA+ICt7Cj4gPiArCXN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nOwo+ID4gKwo+ID4g KwkvKgo+ID4gKwkgKiAnbG9ja19wYWdlKCknIHN0YWJpbGl6ZXMgdGhlIHBhZ2UgYW5kIHByZXZl bnRzIHJhY2VzIGFnYWluc3QKPiA+ICsJICogY29uY3VycmVudCBpc29sYXRpb24gdGhyZWFkcyBh dHRlbXB0aW5nIHRvIHJlLWlzb2xhdGUgaXQuCj4gPiArCSAqLwo+ID4gKwlsb2NrX3BhZ2UocGFn ZSk7Cj4gPiArCW1hcHBpbmcgPSBwYWdlX21hcHBpbmcocGFnZSk7Cj4gPiArCWlmIChtYXBwaW5n KSB7Cj4gPiArCQltYXBwaW5nLT5hX29wcy0+cHV0YmFja19wYWdlKHBhZ2UpOwo+ID4gKwkJV0FS Tl9PTl9PTkNFKFBhZ2VJc29sYXRlZChwYWdlKSk7Cj4gPiArCX0KPiA+ICsJdW5sb2NrX3BhZ2Uo cGFnZSk7Cj4gPiArCS8qIGRyb3AgdGhlIGV4dHJhIHJlZiBjb3VudCB0YWtlbiBmb3IgbW92YWJs ZSBwYWdlIGlzb2xhdGlvbiAqLwo+ID4gKwlwdXRfcGFnZShwYWdlKTsKPiA+ICt9Cj4gCj4gVGhp cyBpcyBjb21wbGljYXRlZCBwYXJ0IGZvciBtZS4gbWFwcGluZyBjYW4gZGlzYXBwZWFyPyBJbiB0 aGlzIGNhc2UsCj4gd2hvIGNsZWFyIFBhZ2VJc29sYXRlZCgpPwoKUGFnZSdzIG93bmVyLCBmb3Ig ZXhtYXBsZSwgenNtYWxsb2MsIHZpcnRpby1iYWxsb29uLgpUaGV5IGNhbiBmcmVlIHBhZ2Ugd2hl bmV2ZXIgdGhleSB3YW50IG9uY2UgaXQgaG9sZHMgYSBQR19sb2NrLgpUaGV5IHNob3VsZCBjbGVh ciBtYXBwaW5nIGFuZCBQR19tb3ZhYmxlIHdpdGggUEdfbG9jay4KCj4gCj4gPiArCj4gPiArCj4g PiAgLyoKPiA+ICAgKiBQdXQgcHJldmlvdXNseSBpc29sYXRlZCBwYWdlcyBiYWNrIG9udG8gdGhl IGFwcHJvcHJpYXRlIGxpc3RzCj4gPiAgICogZnJvbSB3aGVyZSB0aGV5IHdlcmUgb25jZSB0YWtl biBvZmYgZm9yIGNvbXBhY3Rpb24vbWlncmF0aW9uLgo+ID4gQEAgLTk2LDYgKzE2NSw4IEBAIHZv aWQgcHV0YmFja19tb3ZhYmxlX3BhZ2VzKHN0cnVjdCBsaXN0X2hlYWQgKmwpCj4gPiAgCQkJCXBh Z2VfaXNfZmlsZV9jYWNoZShwYWdlKSk7Cj4gPiAgCQlpZiAodW5saWtlbHkoaXNvbGF0ZWRfYmFs bG9vbl9wYWdlKHBhZ2UpKSkKPiA+ICAJCQliYWxsb29uX3BhZ2VfcHV0YmFjayhwYWdlKTsKPiA+ ICsJCWVsc2UgaWYgKHVubGlrZWx5KFBhZ2VJc29sYXRlZChwYWdlKSkpCj4gPiArCQkJcHV0YmFj a19tb3ZhYmxlX3BhZ2UocGFnZSk7Cj4gPiAgCQllbHNlCj4gPiAgCQkJcHV0YmFja19scnVfcGFn ZShwYWdlKTsKPiA+ICAJfQo+IAo+IEkgdGhpbmsgdGhhdCB0aGlzIHdpbGwgbm90IHdvcmsuIFlv dSB1c2VzIFBHX293bmVyX3ByaXZfMSBhcwo+IFBHX2lzb2xhdGVkIGFuZCBpdCBpcyBwb3NzaWJs ZSB0aGF0IHNvbWUgbHJ1IHBhZ2VzIGhhcyB0aGlzIGZsYWcuCj4gSSBndWVzcyB5b3UgbmVlZCB0 byBhZGQgUGFnZU1vdmFibGUoKSBjaGVjayBidXQgaXQgc2VlbXMgdGhhdCBtYXBwaW5nCj4gYW5k IHRoaXMgZmxhZyBjYW4gYmUgY2xlYXJlZCBieSBvdGhlcnMuCgpIbW0sIFBhZ2VNb3ZhYmxlIGNo ZWNrIG1heSB3b3JrIGJlY2F1c2UgSWYgUGFnZU1vdmFibGUgY2hlY2sgZmFpbHMsCml0IG1lYW5z IHBhZ2UncyBvd25lciBmcmVlIHRoZSBwYWdlIHNvIHdlIGNhbiBzaW1wbGUgcHV0IHRoZSBwYWdl IHRvCnJlbGVhc2UgcmVmY291bnQgaW4gaGVyZS4KSSB3aWxsIGNoZWNrIGl0LgoKPiAKPiA+IEBA IC01OTIsNyArNjYzLDcgQEAgdm9pZCBtaWdyYXRlX3BhZ2VfY29weShzdHJ1Y3QgcGFnZSAqbmV3 cGFnZSwgc3RydWN0IHBhZ2UgKnBhZ2UpCj4gPiAgICoqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwo+ID4gIAo+ID4gIC8qCj4gPiAtICog Q29tbW9uIGxvZ2ljIHRvIGRpcmVjdGx5IG1pZ3JhdGUgYSBzaW5nbGUgcGFnZSBzdWl0YWJsZSBm b3IKPiA+ICsgKiBDb21tb24gbG9naWMgdG8gZGlyZWN0bHkgbWlncmF0ZSBhIHNpbmdsZSBMUlUg cGFnZSBzdWl0YWJsZSBmb3IKPiA+ICAgKiBwYWdlcyB0aGF0IGRvIG5vdCB1c2UgUGFnZVByaXZh dGUvUGFnZVByaXZhdGUyLgo+ID4gICAqCj4gPiAgICogUGFnZXMgYXJlIGxvY2tlZCB1cG9uIGVu dHJ5IGFuZCBleGl0Lgo+ID4gQEAgLTc1NSwyNCArODI2LDUzIEBAIHN0YXRpYyBpbnQgbW92ZV90 b19uZXdfcGFnZShzdHJ1Y3QgcGFnZSAqbmV3cGFnZSwgc3RydWN0IHBhZ2UgKnBhZ2UsCj4gPiAg CQkJCWVudW0gbWlncmF0ZV9tb2RlIG1vZGUpCj4gPiAgewo+ID4gIAlzdHJ1Y3QgYWRkcmVzc19z cGFjZSAqbWFwcGluZzsKPiA+IC0JaW50IHJjOwo+ID4gKwlpbnQgcmMgPSAtRUFHQUlOOwo+ID4g Kwlib29sIGlzb2xhdGVkX2xydV9wYWdlOwo+ID4gIAo+ID4gIAlWTV9CVUdfT05fUEFHRSghUGFn ZUxvY2tlZChwYWdlKSwgcGFnZSk7Cj4gPiAgCVZNX0JVR19PTl9QQUdFKCFQYWdlTG9ja2VkKG5l d3BhZ2UpLCBuZXdwYWdlKTsKPiA+ICAKPiA+ICAJbWFwcGluZyA9IHBhZ2VfbWFwcGluZyhwYWdl KTsKPiA+IC0JaWYgKCFtYXBwaW5nKQo+ID4gLQkJcmMgPSBtaWdyYXRlX3BhZ2UobWFwcGluZywg bmV3cGFnZSwgcGFnZSwgbW9kZSk7Cj4gPiAtCWVsc2UgaWYgKG1hcHBpbmctPmFfb3BzLT5taWdy YXRlcGFnZSkKPiA+ICsJLyoKPiA+ICsJICogSW4gY2FzZSBvZiBub24tbHJ1IHBhZ2UsIGl0IGNv dWxkIGJlIHJlbGVhc2VkIGFmdGVyCj4gPiArCSAqIGlzb2xhdGlvbiBzdGVwLiBJbiB0aGF0IGNh c2UsIHdlIHNob3VsZG4ndCB0cnkKPiA+ICsJICogZmFsbGJhY2sgbWlncmF0aW9uIHdoaWNoIHdh cyBkZXNpZ25lZCBmb3IgTFJVIHBhZ2VzLgo+IAo+IFNvLCBwYWdlIHdlIHRyeSB0byBtaWdyYXRl IGNhbiBiZSByZWxlYXNlZCBkdXJpbmcgbWlncmF0aW9uLgo+IEluIHRoaXMgY2FzZSwgd2hvIGRv ZXMgY2xlYXIgbWFwcGluZyBhbmQgZmxhZz8gQW5kLCB3aXRob3V0IG1hcHBpbmcsCj4gaG93IHdl IGNhbiBjbGVhciBQYWdlSXNvbGF0ZWQoKT8KCkFzIEkgd3JvdGUgZG93biBpbiBkZXNjcmlwdGlv biwgaXQncyByb2xlIG9mIHVzZXIuCgo+IAo+ID4gKwkgKiBUbyBpZGVudGlmeSBzdWNoIHBhZ2Vz LCB3ZSBjYW5ub3QgdXNlIFBhZ2VNb3ZhYmxlCj4gPiArCSAqIGJlY2F1c2Ugb3duZXIgb2YgdGhl IHBhZ2UgY2FuIHJlc2V0IGl0LiBTbyBpbnRlYWQsCj4gPiArCSAqIHVzZSBQR19pc29sYXRlZCBi aXQuCj4gPiArCSAqLwo+ID4gKwlpc29sYXRlZF9scnVfcGFnZSA9ICFQYWdlSXNvbGF0ZWQocGFn ZSk7Cj4gCj4gRGl0dG8uIFBhZ2VJc29sYXRlZCgpIGlzbid0IHN1ZmZpY2llbnQgdG8gZGlzdGlu Z3Vpc2ggbm9uLWxydSBwYWdlLgoKT2theSwgSSB3aWxsIHNlZSBpdC4KCj4gCj4gTXkgY29tbWVu dCBtYWlubHkgcG9pbnRzIG91dCBydWxlcyBhYm91dCB3aGVuL3dobyBjbGVhciBtYXBwaW5nCj4g YW5kIGZsYWcuIE1heWJlLCB5b3UgbmVlZCB0byBhbnN3ZXIganVzdCBvbmUgb2YgdGhlbS4gOikK CkkgYWdyZWUgZG9jdW1lbnQgaXMgcmVhbGx5IGxhY2sgb2YgaW5mb3JtYXRpb24gYXQgdGhlIG1v bWVudC4KSSB3aWxsIHB1dCBtb3JlIHdvcmRzLgoKVGhhbmtzIGZvciB0aGUgcmV2aWV3LCBKb29u c29vIQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmkt ZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6 Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pf0-f180.google.com (mail-pf0-f180.google.com [209.85.192.180]) by kanga.kvack.org (Postfix) with ESMTP id DCAD86B007E for ; Tue, 22 Mar 2016 10:54:33 -0400 (EDT) Received: by mail-pf0-f180.google.com with SMTP id n5so314619724pfn.2 for ; Tue, 22 Mar 2016 07:54:33 -0700 (PDT) Received: from lgeamrelo12.lge.com (LGEAMRELO12.lge.com. [156.147.23.52]) by mx.google.com with ESMTP id v67si6842601pfa.181.2016.03.22.07.54.32 for ; Tue, 22 Mar 2016 07:54:32 -0700 (PDT) Date: Tue, 22 Mar 2016 23:55:45 +0900 From: Minchan Kim Subject: Re: [PATCH v2 13/18] mm/compaction: support non-lru movable page migration Message-ID: <20160322145545.GB3221@bbox> References: <1458541867-27380-1-git-send-email-minchan@kernel.org> <1458541867-27380-14-git-send-email-minchan@kernel.org> <20160322055037.GC31955@js1304-P5Q-DELUXE> MIME-Version: 1.0 In-Reply-To: <20160322055037.GC31955@js1304-P5Q-DELUXE> Content-Type: text/plain; charset="us-ascii" Content-Disposition: inline Sender: owner-linux-mm@kvack.org List-ID: To: Joonsoo Kim Cc: Andrew Morton , linux-kernel@vger.kernel.org, linux-mm@kvack.org, jlayton@poochiereds.net, bfields@fieldses.org, Vlastimil Babka , koct9i@gmail.com, aquini@redhat.com, virtualization@lists.linux-foundation.org, Mel Gorman , Hugh Dickins , Sergey Senozhatsky , Rik van Riel , rknize@motorola.com, Gioh Kim , Sangseok Lee , Chan Gyun Jeong , Al Viro , YiPing Xu , dri-devel@lists.freedesktop.org, Gioh Kim On Tue, Mar 22, 2016 at 02:50:37PM +0900, Joonsoo Kim wrote: > On Mon, Mar 21, 2016 at 03:31:02PM +0900, Minchan Kim wrote: > > We have allowed migration for only LRU pages until now and it was > > enough to make high-order pages. But recently, embedded system(e.g., > > webOS, android) uses lots of non-movable pages(e.g., zram, GPU memory) > > so we have seen several reports about troubles of small high-order > > allocation. For fixing the problem, there were several efforts > > (e,g,. enhance compaction algorithm, SLUB fallback to 0-order page, > > reserved memory, vmalloc and so on) but if there are lots of > > non-movable pages in system, their solutions are void in the long run. > > > > So, this patch is to support facility to change non-movable pages > > with movable. For the feature, this patch introduces functions related > > to migration to address_space_operations as well as some page flags. > > > > Basically, this patch supports two page-flags and two functions related > > to page migration. The flag and page->mapping stability are protected > > by PG_lock. > > > > PG_movable > > PG_isolated > > > > bool (*isolate_page) (struct page *, isolate_mode_t); > > void (*putback_page) (struct page *); > > > > Duty of subsystem want to make their pages as migratable are > > as follows: > > > > 1. It should register address_space to page->mapping then mark > > the page as PG_movable via __SetPageMovable. > > > > 2. It should mark the page as PG_isolated via SetPageIsolated > > if isolation is sucessful and return true. > > > > 3. If migration is successful, it should clear PG_isolated and > > PG_movable of the page for free preparation then release the > > reference of the page to free. > > > > 4. If migration fails, putback function of subsystem should > > clear PG_isolated via ClearPageIsolated. > > I think that this feature needs a separate document to describe > requirement of each step in more detail. For example, #1 can be > possible without holding a lock? I'm not sure because you lock > the page when implementing zsmalloc page migration in 15th patch. Yes, we needs PG_lock because install page->mapping and PG_movable should be atomic and PG_lock protects it. Better interface might be void __SetPageMovable(struct page *page, sruct address_space *mapping); > > #3 also need more explanation. Before release, we need to > unregister address_space. I guess that it needs to be done > in migratepage() but there is no explanation. Okay, we can unregister address_space in __ClearPageMovable. I will change it. > > > > > Cc: Vlastimil Babka > > Cc: Mel Gorman > > Cc: Hugh Dickins > > Cc: dri-devel@lists.freedesktop.org > > Cc: virtualization@lists.linux-foundation.org > > Signed-off-by: Gioh Kim > > Signed-off-by: Minchan Kim > > --- > > Documentation/filesystems/Locking | 4 + > > Documentation/filesystems/vfs.txt | 5 ++ > > fs/proc/page.c | 3 + > > include/linux/fs.h | 2 + > > include/linux/migrate.h | 2 + > > include/linux/page-flags.h | 29 ++++++++ > > include/uapi/linux/kernel-page-flags.h | 1 + > > mm/compaction.c | 14 +++- > > mm/migrate.c | 132 +++++++++++++++++++++++++++++---- > > 9 files changed, 177 insertions(+), 15 deletions(-) > > > > diff --git a/Documentation/filesystems/Locking b/Documentation/filesystems/Locking > > index 619af9bfdcb3..0bb79560abb3 100644 > > --- a/Documentation/filesystems/Locking > > +++ b/Documentation/filesystems/Locking > > @@ -195,7 +195,9 @@ unlocks and drops the reference. > > int (*releasepage) (struct page *, int); > > void (*freepage)(struct page *); > > int (*direct_IO)(struct kiocb *, struct iov_iter *iter, loff_t offset); > > + bool (*isolate_page) (struct page *, isolate_mode_t); > > int (*migratepage)(struct address_space *, struct page *, struct page *); > > + void (*putback_page) (struct page *); > > int (*launder_page)(struct page *); > > int (*is_partially_uptodate)(struct page *, unsigned long, unsigned long); > > int (*error_remove_page)(struct address_space *, struct page *); > > @@ -219,7 +221,9 @@ invalidatepage: yes > > releasepage: yes > > freepage: yes > > direct_IO: > > +isolate_page: yes > > migratepage: yes (both) > > +putback_page: yes > > launder_page: yes > > is_partially_uptodate: yes > > error_remove_page: yes > > diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt > > index b02a7d598258..4c1b6c3b4bc8 100644 > > --- a/Documentation/filesystems/vfs.txt > > +++ b/Documentation/filesystems/vfs.txt > > @@ -592,9 +592,14 @@ struct address_space_operations { > > int (*releasepage) (struct page *, int); > > void (*freepage)(struct page *); > > ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter, loff_t offset); > > + /* isolate a page for migration */ > > + bool (*isolate_page) (struct page *, isolate_mode_t); > > /* migrate the contents of a page to the specified target */ > > int (*migratepage) (struct page *, struct page *); > > + /* put the page back to right list */ > > + void (*putback_page) (struct page *); > > int (*launder_page) (struct page *); > > + > > int (*is_partially_uptodate) (struct page *, unsigned long, > > unsigned long); > > void (*is_dirty_writeback) (struct page *, bool *, bool *); > > diff --git a/fs/proc/page.c b/fs/proc/page.c > > index 712f1b9992cc..e2066e73a9b8 100644 > > --- a/fs/proc/page.c > > +++ b/fs/proc/page.c > > @@ -157,6 +157,9 @@ u64 stable_page_flags(struct page *page) > > if (page_is_idle(page)) > > u |= 1 << KPF_IDLE; > > > > + if (PageMovable(page)) > > + u |= 1 << KPF_MOVABLE; > > + > > u |= kpf_copy_bit(k, KPF_LOCKED, PG_locked); > > > > u |= kpf_copy_bit(k, KPF_SLAB, PG_slab); > > diff --git a/include/linux/fs.h b/include/linux/fs.h > > index 14a97194b34b..b7ef2e41fa4a 100644 > > --- a/include/linux/fs.h > > +++ b/include/linux/fs.h > > @@ -401,6 +401,8 @@ struct address_space_operations { > > */ > > int (*migratepage) (struct address_space *, > > struct page *, struct page *, enum migrate_mode); > > + bool (*isolate_page)(struct page *, isolate_mode_t); > > + void (*putback_page)(struct page *); > > int (*launder_page) (struct page *); > > int (*is_partially_uptodate) (struct page *, unsigned long, > > unsigned long); > > diff --git a/include/linux/migrate.h b/include/linux/migrate.h > > index 9b50325e4ddf..404fbfefeb33 100644 > > --- a/include/linux/migrate.h > > +++ b/include/linux/migrate.h > > @@ -37,6 +37,8 @@ extern int migrate_page(struct address_space *, > > struct page *, struct page *, enum migrate_mode); > > extern int migrate_pages(struct list_head *l, new_page_t new, free_page_t free, > > unsigned long private, enum migrate_mode mode, int reason); > > +extern bool isolate_movable_page(struct page *page, isolate_mode_t mode); > > +extern void putback_movable_page(struct page *page); > > > > extern int migrate_prep(void); > > extern int migrate_prep_local(void); > > diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h > > index f4ed4f1b0c77..3885064641c4 100644 > > --- a/include/linux/page-flags.h > > +++ b/include/linux/page-flags.h > > @@ -129,6 +129,10 @@ enum pageflags { > > > > /* Compound pages. Stored in first tail page's flags */ > > PG_double_map = PG_private_2, > > + > > + /* non-lru movable pages */ > > + PG_movable = PG_reclaim, > > + PG_isolated = PG_owner_priv_1, > > }; > > > > #ifndef __GENERATING_BOUNDS_H > > @@ -614,6 +618,31 @@ static inline void __ClearPageBalloon(struct page *page) > > atomic_set(&page->_mapcount, -1); > > } > > > > +#define PAGE_MOVABLE_MAPCOUNT_VALUE (-255) > > + > > +static inline int PageMovable(struct page *page) > > +{ > > + return ((test_bit(PG_movable, &(page)->flags) && > > + atomic_read(&page->_mapcount) == PAGE_MOVABLE_MAPCOUNT_VALUE) > > + || PageBalloon(page)); > > +} > > + > > +/* > > + * Caller should hold a PG_lock */ > > +static inline void __SetPageMovable(struct page *page) > > +{ > > + __set_bit(PG_movable, &page->flags); > > + atomic_set(&page->_mapcount, PAGE_MOVABLE_MAPCOUNT_VALUE); > > +} > > I think there is no big benefit to use non-atomic version here. > PageMovable() is speculatively checked without holding a PG_lock > so some cpu can miss this flag set if we use non-atomic version. I wanted to show that double underscore is non-atomic so caller should take care of the lock(i.e., PG_lock). If we use atomic version, what kinds of benefit do we have? Without holding PG_lock, atomic version could be raced, too. > > > + > > +static inline void __ClearPageMovable(struct page *page) > > +{ > > + atomic_set(&page->_mapcount, -1); > > + __clear_bit(PG_movable, &(page)->flags); > > +} > > + > > +PAGEFLAG(Isolated, isolated, PF_ANY); > > + > > /* > > * If network-based swap is enabled, sl*b must keep track of whether pages > > * were allocated from pfmemalloc reserves. > > diff --git a/include/uapi/linux/kernel-page-flags.h b/include/uapi/linux/kernel-page-flags.h > > index 5da5f8751ce7..a184fd2434fa 100644 > > --- a/include/uapi/linux/kernel-page-flags.h > > +++ b/include/uapi/linux/kernel-page-flags.h > > @@ -34,6 +34,7 @@ > > #define KPF_BALLOON 23 > > #define KPF_ZERO_PAGE 24 > > #define KPF_IDLE 25 > > +#define KPF_MOVABLE 26 > > > > > > #endif /* _UAPILINUX_KERNEL_PAGE_FLAGS_H */ > > diff --git a/mm/compaction.c b/mm/compaction.c > > index ccf97b02b85f..7557aedddaee 100644 > > --- a/mm/compaction.c > > +++ b/mm/compaction.c > > @@ -703,7 +703,7 @@ isolate_migratepages_block(struct compact_control *cc, unsigned long low_pfn, > > > > /* > > * Check may be lockless but that's ok as we recheck later. > > - * It's possible to migrate LRU pages and balloon pages > > + * It's possible to migrate LRU and movable kernel pages. > > * Skip any other type of page > > */ > > is_lru = PageLRU(page); > > @@ -714,6 +714,18 @@ isolate_migratepages_block(struct compact_control *cc, unsigned long low_pfn, > > goto isolate_success; > > } > > } > > + > > + if (unlikely(PageMovable(page)) && > > + !PageIsolated(page)) { > > + if (locked) { > > + spin_unlock_irqrestore(&zone->lru_lock, > > + flags); > > + locked = false; > > + } > > + > > + if (isolate_movable_page(page, isolate_mode)) > > + goto isolate_success; > > + } > > } > > > > /* > > diff --git a/mm/migrate.c b/mm/migrate.c > > index b65c84267ce0..fc2842a15807 100644 > > --- a/mm/migrate.c > > +++ b/mm/migrate.c > > @@ -73,6 +73,75 @@ int migrate_prep_local(void) > > return 0; > > } > > > > +bool isolate_movable_page(struct page *page, isolate_mode_t mode) > > +{ > > + bool ret = false; > > + > > + /* > > + * Avoid burning cycles with pages that are yet under __free_pages(), > > + * or just got freed under us. > > + * > > + * In case we 'win' a race for a movable page being freed under us and > > + * raise its refcount preventing __free_pages() from doing its job > > + * the put_page() at the end of this block will take care of > > + * release this page, thus avoiding a nasty leakage. > > + */ > > + if (unlikely(!get_page_unless_zero(page))) > > + goto out; > > After getting the ref counter, we need to re-check PageMovable() > to ensure that we indeed handle PageMovable() type page. Without it, > the page we handle can be freed and re-allocated to someone else > that isn't related to PageMovable() before grabbing the page. Trying > trylock_page() in this case could cause a problem. I don't get it. Why do you think trylock_page could cause a problem? Could you elaborate it more? > > > + /* > > + * As movable pages are not isolated from LRU lists, concurrent > > + * compaction threads can race against page migration functions > > + * as well as race against the releasing a page. > > + * > > + * In order to avoid having an already isolated movable page > > + * being (wrongly) re-isolated while it is under migration, > > + * or to avoid attempting to isolate pages being released, > > + * lets be sure we have the page lock > > + * before proceeding with the movable page isolation steps. > > + */ > > + if (unlikely(!trylock_page(page))) > > + goto out_putpage; > > + > > + if (!PageMovable(page) || PageIsolated(page)) > > + goto out_no_isolated; > > + > > + ret = page->mapping->a_ops->isolate_page(page, mode); > > + if (!ret) > > + goto out_no_isolated; > > + > > + WARN_ON_ONCE(!PageIsolated(page)); > > + unlock_page(page); > > + return ret; > > + > > +out_no_isolated: > > + unlock_page(page); > > +out_putpage: > > + put_page(page); > > +out: > > + return ret; > > +} > > + > > +void putback_movable_page(struct page *page) > > +{ > > + struct address_space *mapping; > > + > > + /* > > + * 'lock_page()' stabilizes the page and prevents races against > > + * concurrent isolation threads attempting to re-isolate it. > > + */ > > + lock_page(page); > > + mapping = page_mapping(page); > > + if (mapping) { > > + mapping->a_ops->putback_page(page); > > + WARN_ON_ONCE(PageIsolated(page)); > > + } > > + unlock_page(page); > > + /* drop the extra ref count taken for movable page isolation */ > > + put_page(page); > > +} > > This is complicated part for me. mapping can disappear? In this case, > who clear PageIsolated()? Page's owner, for exmaple, zsmalloc, virtio-balloon. They can free page whenever they want once it holds a PG_lock. They should clear mapping and PG_movable with PG_lock. > > > + > > + > > /* > > * Put previously isolated pages back onto the appropriate lists > > * from where they were once taken off for compaction/migration. > > @@ -96,6 +165,8 @@ void putback_movable_pages(struct list_head *l) > > page_is_file_cache(page)); > > if (unlikely(isolated_balloon_page(page))) > > balloon_page_putback(page); > > + else if (unlikely(PageIsolated(page))) > > + putback_movable_page(page); > > else > > putback_lru_page(page); > > } > > I think that this will not work. You uses PG_owner_priv_1 as > PG_isolated and it is possible that some lru pages has this flag. > I guess you need to add PageMovable() check but it seems that mapping > and this flag can be cleared by others. Hmm, PageMovable check may work because If PageMovable check fails, it means page's owner free the page so we can simple put the page to release refcount in here. I will check it. > > > @@ -592,7 +663,7 @@ void migrate_page_copy(struct page *newpage, struct page *page) > > ***********************************************************/ > > > > /* > > - * Common logic to directly migrate a single page suitable for > > + * Common logic to directly migrate a single LRU page suitable for > > * pages that do not use PagePrivate/PagePrivate2. > > * > > * Pages are locked upon entry and exit. > > @@ -755,24 +826,53 @@ static int move_to_new_page(struct page *newpage, struct page *page, > > enum migrate_mode mode) > > { > > struct address_space *mapping; > > - int rc; > > + int rc = -EAGAIN; > > + bool isolated_lru_page; > > > > VM_BUG_ON_PAGE(!PageLocked(page), page); > > VM_BUG_ON_PAGE(!PageLocked(newpage), newpage); > > > > mapping = page_mapping(page); > > - if (!mapping) > > - rc = migrate_page(mapping, newpage, page, mode); > > - else if (mapping->a_ops->migratepage) > > + /* > > + * In case of non-lru page, it could be released after > > + * isolation step. In that case, we shouldn't try > > + * fallback migration which was designed for LRU pages. > > So, page we try to migrate can be released during migration. > In this case, who does clear mapping and flag? And, without mapping, > how we can clear PageIsolated()? As I wrote down in description, it's role of user. > > > + * To identify such pages, we cannot use PageMovable > > + * because owner of the page can reset it. So intead, > > + * use PG_isolated bit. > > + */ > > + isolated_lru_page = !PageIsolated(page); > > Ditto. PageIsolated() isn't sufficient to distinguish non-lru page. Okay, I will see it. > > My comment mainly points out rules about when/who clear mapping > and flag. Maybe, you need to answer just one of them. :) I agree document is really lack of information at the moment. I will put more words. Thanks for the review, Joonsoo! -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to majordomo@kvack.org. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: email@kvack.org From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1759482AbcCVOyp (ORCPT ); Tue, 22 Mar 2016 10:54:45 -0400 Received: from LGEAMRELO12.lge.com ([156.147.23.52]:36707 "EHLO lgeamrelo12.lge.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1759462AbcCVOyd (ORCPT ); Tue, 22 Mar 2016 10:54:33 -0400 X-Original-SENDERIP: 156.147.1.126 X-Original-MAILFROM: minchan@kernel.org X-Original-SENDERIP: 165.244.98.203 X-Original-MAILFROM: minchan@kernel.org X-Original-SENDERIP: 10.177.223.161 X-Original-MAILFROM: minchan@kernel.org Date: Tue, 22 Mar 2016 23:55:45 +0900 From: Minchan Kim To: Joonsoo Kim CC: Andrew Morton , linux-kernel@vger.kernel.org, linux-mm@kvack.org, jlayton@poochiereds.net, bfields@fieldses.org, Vlastimil Babka , koct9i@gmail.com, aquini@redhat.com, virtualization@lists.linux-foundation.org, Mel Gorman , Hugh Dickins , Sergey Senozhatsky , Rik van Riel , rknize@motorola.com, Gioh Kim , Sangseok Lee , Chan Gyun Jeong , Al Viro , YiPing Xu , dri-devel@lists.freedesktop.org, Gioh Kim Subject: Re: [PATCH v2 13/18] mm/compaction: support non-lru movable page migration Message-ID: <20160322145545.GB3221@bbox> References: <1458541867-27380-1-git-send-email-minchan@kernel.org> <1458541867-27380-14-git-send-email-minchan@kernel.org> <20160322055037.GC31955@js1304-P5Q-DELUXE> MIME-Version: 1.0 In-Reply-To: <20160322055037.GC31955@js1304-P5Q-DELUXE> User-Agent: Mutt/1.5.21 (2010-09-15) X-MIMETrack: Itemize by SMTP Server on LGEKRMHUB01/LGE/LG Group(Release 8.5.3FP6|November 21, 2013) at 2016/03/22 23:54:29, Serialize by Router on LGEKRMHUB01/LGE/LG Group(Release 8.5.3FP6|November 21, 2013) at 2016/03/22 23:54:29, Serialize complete at 2016/03/22 23:54:29 Content-Type: text/plain; charset="us-ascii" Content-Disposition: inline Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, Mar 22, 2016 at 02:50:37PM +0900, Joonsoo Kim wrote: > On Mon, Mar 21, 2016 at 03:31:02PM +0900, Minchan Kim wrote: > > We have allowed migration for only LRU pages until now and it was > > enough to make high-order pages. But recently, embedded system(e.g., > > webOS, android) uses lots of non-movable pages(e.g., zram, GPU memory) > > so we have seen several reports about troubles of small high-order > > allocation. For fixing the problem, there were several efforts > > (e,g,. enhance compaction algorithm, SLUB fallback to 0-order page, > > reserved memory, vmalloc and so on) but if there are lots of > > non-movable pages in system, their solutions are void in the long run. > > > > So, this patch is to support facility to change non-movable pages > > with movable. For the feature, this patch introduces functions related > > to migration to address_space_operations as well as some page flags. > > > > Basically, this patch supports two page-flags and two functions related > > to page migration. The flag and page->mapping stability are protected > > by PG_lock. > > > > PG_movable > > PG_isolated > > > > bool (*isolate_page) (struct page *, isolate_mode_t); > > void (*putback_page) (struct page *); > > > > Duty of subsystem want to make their pages as migratable are > > as follows: > > > > 1. It should register address_space to page->mapping then mark > > the page as PG_movable via __SetPageMovable. > > > > 2. It should mark the page as PG_isolated via SetPageIsolated > > if isolation is sucessful and return true. > > > > 3. If migration is successful, it should clear PG_isolated and > > PG_movable of the page for free preparation then release the > > reference of the page to free. > > > > 4. If migration fails, putback function of subsystem should > > clear PG_isolated via ClearPageIsolated. > > I think that this feature needs a separate document to describe > requirement of each step in more detail. For example, #1 can be > possible without holding a lock? I'm not sure because you lock > the page when implementing zsmalloc page migration in 15th patch. Yes, we needs PG_lock because install page->mapping and PG_movable should be atomic and PG_lock protects it. Better interface might be void __SetPageMovable(struct page *page, sruct address_space *mapping); > > #3 also need more explanation. Before release, we need to > unregister address_space. I guess that it needs to be done > in migratepage() but there is no explanation. Okay, we can unregister address_space in __ClearPageMovable. I will change it. > > > > > Cc: Vlastimil Babka > > Cc: Mel Gorman > > Cc: Hugh Dickins > > Cc: dri-devel@lists.freedesktop.org > > Cc: virtualization@lists.linux-foundation.org > > Signed-off-by: Gioh Kim > > Signed-off-by: Minchan Kim > > --- > > Documentation/filesystems/Locking | 4 + > > Documentation/filesystems/vfs.txt | 5 ++ > > fs/proc/page.c | 3 + > > include/linux/fs.h | 2 + > > include/linux/migrate.h | 2 + > > include/linux/page-flags.h | 29 ++++++++ > > include/uapi/linux/kernel-page-flags.h | 1 + > > mm/compaction.c | 14 +++- > > mm/migrate.c | 132 +++++++++++++++++++++++++++++---- > > 9 files changed, 177 insertions(+), 15 deletions(-) > > > > diff --git a/Documentation/filesystems/Locking b/Documentation/filesystems/Locking > > index 619af9bfdcb3..0bb79560abb3 100644 > > --- a/Documentation/filesystems/Locking > > +++ b/Documentation/filesystems/Locking > > @@ -195,7 +195,9 @@ unlocks and drops the reference. > > int (*releasepage) (struct page *, int); > > void (*freepage)(struct page *); > > int (*direct_IO)(struct kiocb *, struct iov_iter *iter, loff_t offset); > > + bool (*isolate_page) (struct page *, isolate_mode_t); > > int (*migratepage)(struct address_space *, struct page *, struct page *); > > + void (*putback_page) (struct page *); > > int (*launder_page)(struct page *); > > int (*is_partially_uptodate)(struct page *, unsigned long, unsigned long); > > int (*error_remove_page)(struct address_space *, struct page *); > > @@ -219,7 +221,9 @@ invalidatepage: yes > > releasepage: yes > > freepage: yes > > direct_IO: > > +isolate_page: yes > > migratepage: yes (both) > > +putback_page: yes > > launder_page: yes > > is_partially_uptodate: yes > > error_remove_page: yes > > diff --git a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt > > index b02a7d598258..4c1b6c3b4bc8 100644 > > --- a/Documentation/filesystems/vfs.txt > > +++ b/Documentation/filesystems/vfs.txt > > @@ -592,9 +592,14 @@ struct address_space_operations { > > int (*releasepage) (struct page *, int); > > void (*freepage)(struct page *); > > ssize_t (*direct_IO)(struct kiocb *, struct iov_iter *iter, loff_t offset); > > + /* isolate a page for migration */ > > + bool (*isolate_page) (struct page *, isolate_mode_t); > > /* migrate the contents of a page to the specified target */ > > int (*migratepage) (struct page *, struct page *); > > + /* put the page back to right list */ > > + void (*putback_page) (struct page *); > > int (*launder_page) (struct page *); > > + > > int (*is_partially_uptodate) (struct page *, unsigned long, > > unsigned long); > > void (*is_dirty_writeback) (struct page *, bool *, bool *); > > diff --git a/fs/proc/page.c b/fs/proc/page.c > > index 712f1b9992cc..e2066e73a9b8 100644 > > --- a/fs/proc/page.c > > +++ b/fs/proc/page.c > > @@ -157,6 +157,9 @@ u64 stable_page_flags(struct page *page) > > if (page_is_idle(page)) > > u |= 1 << KPF_IDLE; > > > > + if (PageMovable(page)) > > + u |= 1 << KPF_MOVABLE; > > + > > u |= kpf_copy_bit(k, KPF_LOCKED, PG_locked); > > > > u |= kpf_copy_bit(k, KPF_SLAB, PG_slab); > > diff --git a/include/linux/fs.h b/include/linux/fs.h > > index 14a97194b34b..b7ef2e41fa4a 100644 > > --- a/include/linux/fs.h > > +++ b/include/linux/fs.h > > @@ -401,6 +401,8 @@ struct address_space_operations { > > */ > > int (*migratepage) (struct address_space *, > > struct page *, struct page *, enum migrate_mode); > > + bool (*isolate_page)(struct page *, isolate_mode_t); > > + void (*putback_page)(struct page *); > > int (*launder_page) (struct page *); > > int (*is_partially_uptodate) (struct page *, unsigned long, > > unsigned long); > > diff --git a/include/linux/migrate.h b/include/linux/migrate.h > > index 9b50325e4ddf..404fbfefeb33 100644 > > --- a/include/linux/migrate.h > > +++ b/include/linux/migrate.h > > @@ -37,6 +37,8 @@ extern int migrate_page(struct address_space *, > > struct page *, struct page *, enum migrate_mode); > > extern int migrate_pages(struct list_head *l, new_page_t new, free_page_t free, > > unsigned long private, enum migrate_mode mode, int reason); > > +extern bool isolate_movable_page(struct page *page, isolate_mode_t mode); > > +extern void putback_movable_page(struct page *page); > > > > extern int migrate_prep(void); > > extern int migrate_prep_local(void); > > diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h > > index f4ed4f1b0c77..3885064641c4 100644 > > --- a/include/linux/page-flags.h > > +++ b/include/linux/page-flags.h > > @@ -129,6 +129,10 @@ enum pageflags { > > > > /* Compound pages. Stored in first tail page's flags */ > > PG_double_map = PG_private_2, > > + > > + /* non-lru movable pages */ > > + PG_movable = PG_reclaim, > > + PG_isolated = PG_owner_priv_1, > > }; > > > > #ifndef __GENERATING_BOUNDS_H > > @@ -614,6 +618,31 @@ static inline void __ClearPageBalloon(struct page *page) > > atomic_set(&page->_mapcount, -1); > > } > > > > +#define PAGE_MOVABLE_MAPCOUNT_VALUE (-255) > > + > > +static inline int PageMovable(struct page *page) > > +{ > > + return ((test_bit(PG_movable, &(page)->flags) && > > + atomic_read(&page->_mapcount) == PAGE_MOVABLE_MAPCOUNT_VALUE) > > + || PageBalloon(page)); > > +} > > + > > +/* > > + * Caller should hold a PG_lock */ > > +static inline void __SetPageMovable(struct page *page) > > +{ > > + __set_bit(PG_movable, &page->flags); > > + atomic_set(&page->_mapcount, PAGE_MOVABLE_MAPCOUNT_VALUE); > > +} > > I think there is no big benefit to use non-atomic version here. > PageMovable() is speculatively checked without holding a PG_lock > so some cpu can miss this flag set if we use non-atomic version. I wanted to show that double underscore is non-atomic so caller should take care of the lock(i.e., PG_lock). If we use atomic version, what kinds of benefit do we have? Without holding PG_lock, atomic version could be raced, too. > > > + > > +static inline void __ClearPageMovable(struct page *page) > > +{ > > + atomic_set(&page->_mapcount, -1); > > + __clear_bit(PG_movable, &(page)->flags); > > +} > > + > > +PAGEFLAG(Isolated, isolated, PF_ANY); > > + > > /* > > * If network-based swap is enabled, sl*b must keep track of whether pages > > * were allocated from pfmemalloc reserves. > > diff --git a/include/uapi/linux/kernel-page-flags.h b/include/uapi/linux/kernel-page-flags.h > > index 5da5f8751ce7..a184fd2434fa 100644 > > --- a/include/uapi/linux/kernel-page-flags.h > > +++ b/include/uapi/linux/kernel-page-flags.h > > @@ -34,6 +34,7 @@ > > #define KPF_BALLOON 23 > > #define KPF_ZERO_PAGE 24 > > #define KPF_IDLE 25 > > +#define KPF_MOVABLE 26 > > > > > > #endif /* _UAPILINUX_KERNEL_PAGE_FLAGS_H */ > > diff --git a/mm/compaction.c b/mm/compaction.c > > index ccf97b02b85f..7557aedddaee 100644 > > --- a/mm/compaction.c > > +++ b/mm/compaction.c > > @@ -703,7 +703,7 @@ isolate_migratepages_block(struct compact_control *cc, unsigned long low_pfn, > > > > /* > > * Check may be lockless but that's ok as we recheck later. > > - * It's possible to migrate LRU pages and balloon pages > > + * It's possible to migrate LRU and movable kernel pages. > > * Skip any other type of page > > */ > > is_lru = PageLRU(page); > > @@ -714,6 +714,18 @@ isolate_migratepages_block(struct compact_control *cc, unsigned long low_pfn, > > goto isolate_success; > > } > > } > > + > > + if (unlikely(PageMovable(page)) && > > + !PageIsolated(page)) { > > + if (locked) { > > + spin_unlock_irqrestore(&zone->lru_lock, > > + flags); > > + locked = false; > > + } > > + > > + if (isolate_movable_page(page, isolate_mode)) > > + goto isolate_success; > > + } > > } > > > > /* > > diff --git a/mm/migrate.c b/mm/migrate.c > > index b65c84267ce0..fc2842a15807 100644 > > --- a/mm/migrate.c > > +++ b/mm/migrate.c > > @@ -73,6 +73,75 @@ int migrate_prep_local(void) > > return 0; > > } > > > > +bool isolate_movable_page(struct page *page, isolate_mode_t mode) > > +{ > > + bool ret = false; > > + > > + /* > > + * Avoid burning cycles with pages that are yet under __free_pages(), > > + * or just got freed under us. > > + * > > + * In case we 'win' a race for a movable page being freed under us and > > + * raise its refcount preventing __free_pages() from doing its job > > + * the put_page() at the end of this block will take care of > > + * release this page, thus avoiding a nasty leakage. > > + */ > > + if (unlikely(!get_page_unless_zero(page))) > > + goto out; > > After getting the ref counter, we need to re-check PageMovable() > to ensure that we indeed handle PageMovable() type page. Without it, > the page we handle can be freed and re-allocated to someone else > that isn't related to PageMovable() before grabbing the page. Trying > trylock_page() in this case could cause a problem. I don't get it. Why do you think trylock_page could cause a problem? Could you elaborate it more? > > > + /* > > + * As movable pages are not isolated from LRU lists, concurrent > > + * compaction threads can race against page migration functions > > + * as well as race against the releasing a page. > > + * > > + * In order to avoid having an already isolated movable page > > + * being (wrongly) re-isolated while it is under migration, > > + * or to avoid attempting to isolate pages being released, > > + * lets be sure we have the page lock > > + * before proceeding with the movable page isolation steps. > > + */ > > + if (unlikely(!trylock_page(page))) > > + goto out_putpage; > > + > > + if (!PageMovable(page) || PageIsolated(page)) > > + goto out_no_isolated; > > + > > + ret = page->mapping->a_ops->isolate_page(page, mode); > > + if (!ret) > > + goto out_no_isolated; > > + > > + WARN_ON_ONCE(!PageIsolated(page)); > > + unlock_page(page); > > + return ret; > > + > > +out_no_isolated: > > + unlock_page(page); > > +out_putpage: > > + put_page(page); > > +out: > > + return ret; > > +} > > + > > +void putback_movable_page(struct page *page) > > +{ > > + struct address_space *mapping; > > + > > + /* > > + * 'lock_page()' stabilizes the page and prevents races against > > + * concurrent isolation threads attempting to re-isolate it. > > + */ > > + lock_page(page); > > + mapping = page_mapping(page); > > + if (mapping) { > > + mapping->a_ops->putback_page(page); > > + WARN_ON_ONCE(PageIsolated(page)); > > + } > > + unlock_page(page); > > + /* drop the extra ref count taken for movable page isolation */ > > + put_page(page); > > +} > > This is complicated part for me. mapping can disappear? In this case, > who clear PageIsolated()? Page's owner, for exmaple, zsmalloc, virtio-balloon. They can free page whenever they want once it holds a PG_lock. They should clear mapping and PG_movable with PG_lock. > > > + > > + > > /* > > * Put previously isolated pages back onto the appropriate lists > > * from where they were once taken off for compaction/migration. > > @@ -96,6 +165,8 @@ void putback_movable_pages(struct list_head *l) > > page_is_file_cache(page)); > > if (unlikely(isolated_balloon_page(page))) > > balloon_page_putback(page); > > + else if (unlikely(PageIsolated(page))) > > + putback_movable_page(page); > > else > > putback_lru_page(page); > > } > > I think that this will not work. You uses PG_owner_priv_1 as > PG_isolated and it is possible that some lru pages has this flag. > I guess you need to add PageMovable() check but it seems that mapping > and this flag can be cleared by others. Hmm, PageMovable check may work because If PageMovable check fails, it means page's owner free the page so we can simple put the page to release refcount in here. I will check it. > > > @@ -592,7 +663,7 @@ void migrate_page_copy(struct page *newpage, struct page *page) > > ***********************************************************/ > > > > /* > > - * Common logic to directly migrate a single page suitable for > > + * Common logic to directly migrate a single LRU page suitable for > > * pages that do not use PagePrivate/PagePrivate2. > > * > > * Pages are locked upon entry and exit. > > @@ -755,24 +826,53 @@ static int move_to_new_page(struct page *newpage, struct page *page, > > enum migrate_mode mode) > > { > > struct address_space *mapping; > > - int rc; > > + int rc = -EAGAIN; > > + bool isolated_lru_page; > > > > VM_BUG_ON_PAGE(!PageLocked(page), page); > > VM_BUG_ON_PAGE(!PageLocked(newpage), newpage); > > > > mapping = page_mapping(page); > > - if (!mapping) > > - rc = migrate_page(mapping, newpage, page, mode); > > - else if (mapping->a_ops->migratepage) > > + /* > > + * In case of non-lru page, it could be released after > > + * isolation step. In that case, we shouldn't try > > + * fallback migration which was designed for LRU pages. > > So, page we try to migrate can be released during migration. > In this case, who does clear mapping and flag? And, without mapping, > how we can clear PageIsolated()? As I wrote down in description, it's role of user. > > > + * To identify such pages, we cannot use PageMovable > > + * because owner of the page can reset it. So intead, > > + * use PG_isolated bit. > > + */ > > + isolated_lru_page = !PageIsolated(page); > > Ditto. PageIsolated() isn't sufficient to distinguish non-lru page. Okay, I will see it. > > My comment mainly points out rules about when/who clear mapping > and flag. Maybe, you need to answer just one of them. :) I agree document is really lack of information at the moment. I will put more words. Thanks for the review, Joonsoo!