From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gioh Kim Subject: Re: [PATCH] add generic callbacks into compaction Date: Mon, 13 Apr 2015 10:39:40 +0900 Message-ID: <552B1E5C.3030501@lge.com> References: <1427843490-27084-1-git-send-email-gioh.kim@lge.com> <20150407005344.GA27788@blaptop> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20150407005344.GA27788@blaptop> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: virtualization-bounces@lists.linux-foundation.org Errors-To: virtualization-bounces@lists.linux-foundation.org To: Minchan Kim Cc: mst@redhat.com, linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, bfields@fieldses.org, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, iamjoonsoo.kim@lge.com, jlayton@poochiereds.net, akpm@linux-foundation.org, koct9i@gmail.com List-Id: virtualization@lists.linuxfoundation.org CgoyMDE1LTA0LTA3IOyYpOyghCA5OjU57JeQIE1pbmNoYW4gS2ltIOydtCjqsIApIOyTtCDquIA6 Cj4gSGVsbG8gR2lvaCwKPgo+IEkgd2FudGVkIHRvIGhhdmUgc3VjaCBmZWF0dXJlIGZvciB6c21h bGxvYy4KPiBUaGFua3MgZm9yIHRoZSB3b3JrLgo+Cj4gT24gV2VkLCBBcHIgMDEsIDIwMTUgYXQg MDg6MTE6MzBBTSArMDkwMCwgR2lvaCBLaW0gd3JvdGU6Cj4+IEkgc2VudCBhIHBhdGNoIGFib3V0 IHBhZ2UgYWxsb2NhdGlvbiBmb3IgbGVzcyBmcmFnbWVudGF0aW9uLgo+PiBodHRwOi8vcGVybWFs aW5rLmdtYW5lLm9yZy9nbWFuZS5saW51eC5rZXJuZWwubW0vMTMwNTk5Cj4+Cj4+IEl0IHByb3Bv c2VzIGEgcGFnZSBhbGxvY2F0b3IgYWxsb2NhdGVzIHBhZ2VzIGluIHRoZSBzYW1lIHBhZ2VibG9j awo+PiBmb3IgdGhlIGRyaXZlcnMgdG8gbW92ZSB0aGVpciB1bm1vdmFibGUgcGFnZXMuIFNvbWUg ZHJpdmVycyB3aGljaCBjb21zdW1lcyBtYW55IHBhZ2VzCj4+IGFuZCBpbmNyZWFzZXMgc3lzdGVt IGZyYWdtZW50YXRpb24gdXNlIHRoZSBhbGxvY2F0b3IgdG8gbW92ZSB0aGVpciBwYWdlcyB0bwo+ PiBkZWNyZWFzZSBmcmFnbWVudGF0aW9uLgo+Pgo+PiBJIHRoaW5rIEkgY2FuIHRyeSBhbm90aGVy IGFwcHJvYWNoLgo+PiBUaGVyZSBpcyBhIGNvbXBhY3Rpb24gY29kZSBmb3IgYmFsbG9vbiBwYWdl cy4KPj4gQnV0IHRoZSBjb21wYWN0aW9uIGNvZGUgY2Fubm90IG1pZ3JhdGUgcGFnZXMgb2Ygb3Ro ZXIgZHJpdmVycy4KPj4gSWYgdGhlcmUgaXMgYSBnZW5lcmljIG1pZ3JhdGlvbiBmcmFtZXdvcmsg YXBwbGljYWJsZSB0byBhbnkgZHJpdmVycywKPj4gZHJpdmVycyBjYW4gcmVnaXN0ZXIgdGhlaXIg bWlncmF0aW9uIGZ1bmN0aW9ucy4KPj4gQW5kIHRoZSBjb21wYWN0aW9uIGNhbiBtaWdyYXRlIG1v dmFibGUgcGFnZXMgYW5kIGFsc28gZHJpdmVyJ3MgcGFnZXMuCj4+Cj4+IEknbSBub3QgZmFtaWxp YXIgd2l0aCB2aXJ0dWFsaXphdGlvbiBzbyBJIGNvdWxkbid0IHRlc3QgdGhpcyBwYXRjaCB5ZXQu Cj4+IEJ1dCBpZiBtbSBkZXZlbG9wZXJzIGFncmVlIHdpdGggdGhpcyBhcHByb2FjaCwgSSB3aWxs IGNvbXBsZXRlIHRoaXMgcGF0Y2guCj4+Cj4+IEkgd291bGQgZG8gYXBwcmVjaWF0ZSBhbnkgZmVl ZGJhY2suCj4KPiBDb3VsZCB5b3Ugc2VwYXJhdGUgaW50cm9kdWNpbmcgbWlncmF0ZSBjb3JlIHBh dGNoc2V0IGFuZCBiYWxsb29uIHBhdGNoc2V0IGZvcgo+IHVzaW5nIHRoZSBmZWF0dXJlPwoKU3Vy ZS4KCj4KPj4KPj4gU2lnbmVkLW9mZi1ieTogR2lvaCBLaW0gPGdpb2gua2ltQGxnZS5jb20+Cj4+ IC0tLQo+PiAgIGRyaXZlcnMvdmlydGlvL3ZpcnRpb19iYWxsb29uLmMgICAgfCAgICAyICsrCj4+ ICAgaW5jbHVkZS9saW51eC9iYWxsb29uX2NvbXBhY3Rpb24uaCB8ICAgMjMgKysrKysrKysrLS0t Cj4+ICAgaW5jbHVkZS9saW51eC9mcy5oICAgICAgICAgICAgICAgICB8ICAgIDMgKysKPj4gICBp bmNsdWRlL2xpbnV4L3BhZ2VtYXAuaCAgICAgICAgICAgIHwgICAyNiArKysrKysrKysrKysrKwo+ PiAgIG1tL2JhbGxvb25fY29tcGFjdGlvbi5jICAgICAgICAgICAgfCAgIDY4ICsrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKystLQo+PiAgIG1tL2NvbXBhY3Rpb24uYyAgICAgICAgICAg ICAgICAgICAgfCAgICA3ICsrLS0KPj4gICBtbS9taWdyYXRlLmMgICAgICAgICAgICAgICAgICAg ICAgIHwgICAyNCArKysrKystLS0tLS0tCj4+ICAgNyBmaWxlcyBjaGFuZ2VkLCAxMjkgaW5zZXJ0 aW9ucygrKSwgMjQgZGVsZXRpb25zKC0pCj4+Cj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZpcnRp by92aXJ0aW9fYmFsbG9vbi5jIGIvZHJpdmVycy92aXJ0aW8vdmlydGlvX2JhbGxvb24uYwo+PiBp bmRleCAwNDEzMTU3Li5jZDliOGU0IDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL3ZpcnRpby92aXJ0 aW9fYmFsbG9vbi5jCj4+ICsrKyBiL2RyaXZlcnMvdmlydGlvL3ZpcnRpb19iYWxsb29uLmMKPj4g QEAgLTQ4Niw2ICs0ODYsOCBAQCBzdGF0aWMgaW50IHZpcnRiYWxsb29uX3Byb2JlKHN0cnVjdCB2 aXJ0aW9fZGV2aWNlICp2ZGV2KQo+Pgo+PiAgIAliYWxsb29uX2RldmluZm9faW5pdCgmdmItPnZi X2Rldl9pbmZvKTsKPj4gICAjaWZkZWYgQ09ORklHX0JBTExPT05fQ09NUEFDVElPTgo+PiArCXZi LT52Yl9kZXZfaW5mby5tYXBwaW5nID0gYmFsbG9vbl9tYXBwaW5nX2FsbG9jKCZ2Yi0+dmJfZGV2 X2luZm8sCj4+ICsJCQkJCQkJJmJhbGxvb25fYW9wcyk7Cj4+ICAgCXZiLT52Yl9kZXZfaW5mby5t aWdyYXRlcGFnZSA9IHZpcnRiYWxsb29uX21pZ3JhdGVwYWdlOwo+PiAgICNlbmRpZgo+Pgo+PiBk aWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9iYWxsb29uX2NvbXBhY3Rpb24uaCBiL2luY2x1ZGUv bGludXgvYmFsbG9vbl9jb21wYWN0aW9uLmgKPj4gaW5kZXggOWIwYTE1ZC4uMGFmMzJiMyAxMDA2 NDQKPj4gLS0tIGEvaW5jbHVkZS9saW51eC9iYWxsb29uX2NvbXBhY3Rpb24uaAo+PiArKysgYi9p bmNsdWRlL2xpbnV4L2JhbGxvb25fY29tcGFjdGlvbi5oCj4+IEBAIC02Miw2ICs2Miw3IEBAIHN0 cnVjdCBiYWxsb29uX2Rldl9pbmZvIHsKPj4gICAJc3RydWN0IGxpc3RfaGVhZCBwYWdlczsJCS8q IFBhZ2VzIGVucXVldWVkICYgaGFuZGxlZCB0byBIb3N0ICovCj4+ICAgCWludCAoKm1pZ3JhdGVw YWdlKShzdHJ1Y3QgYmFsbG9vbl9kZXZfaW5mbyAqLCBzdHJ1Y3QgcGFnZSAqbmV3cGFnZSwKPj4g ICAJCQlzdHJ1Y3QgcGFnZSAqcGFnZSwgZW51bSBtaWdyYXRlX21vZGUgbW9kZSk7Cj4+ICsJc3Ry dWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmc7Cj4+ICAgfTsKPj4KPj4gICBleHRlcm4gc3RydWN0 IHBhZ2UgKmJhbGxvb25fcGFnZV9lbnF1ZXVlKHN0cnVjdCBiYWxsb29uX2Rldl9pbmZvICpiX2Rl dl9pbmZvKTsKPj4gQEAgLTc2LDEwICs3NywyMiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgYmFsbG9v bl9kZXZpbmZvX2luaXQoc3RydWN0IGJhbGxvb25fZGV2X2luZm8gKmJhbGxvb24pCj4+ICAgfQo+ Pgo+PiAgICNpZmRlZiBDT05GSUdfQkFMTE9PTl9DT01QQUNUSU9OCj4+IC1leHRlcm4gYm9vbCBi YWxsb29uX3BhZ2VfaXNvbGF0ZShzdHJ1Y3QgcGFnZSAqcGFnZSk7Cj4+IC1leHRlcm4gdm9pZCBi YWxsb29uX3BhZ2VfcHV0YmFjayhzdHJ1Y3QgcGFnZSAqcGFnZSk7Cj4+IC1leHRlcm4gaW50IGJh bGxvb25fcGFnZV9taWdyYXRlKHN0cnVjdCBwYWdlICpuZXdwYWdlLAo+PiAtCQkJCXN0cnVjdCBw YWdlICpwYWdlLCBlbnVtIG1pZ3JhdGVfbW9kZSBtb2RlKTsKPj4gK2V4dGVybiBjb25zdCBzdHJ1 Y3QgYWRkcmVzc19zcGFjZV9vcGVyYXRpb25zIGJhbGxvb25fYW9wczsKPj4gK2V4dGVybiBpbnQg YmFsbG9vbl9wYWdlX2lzb2xhdGUoc3RydWN0IHBhZ2UgKnBhZ2UpOwo+PiArZXh0ZXJuIGludCBi YWxsb29uX3BhZ2VfcHV0YmFjayhzdHJ1Y3QgcGFnZSAqcGFnZSk7Cj4+ICtleHRlcm4gaW50IGJh bGxvb25fcGFnZV9taWdyYXRlKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nLAo+PiArCQkJ CXN0cnVjdCBwYWdlICpuZXdwYWdlLAo+PiArCQkJCXN0cnVjdCBwYWdlICpwYWdlLAo+PiArCQkJ CWVudW0gbWlncmF0ZV9tb2RlIG1vZGUpOwo+PiArCj4+ICtleHRlcm4gc3RydWN0IGFkZHJlc3Nf c3BhY2UKPj4gKypiYWxsb29uX21hcHBpbmdfYWxsb2Moc3RydWN0IGJhbGxvb25fZGV2X2luZm8g KmJfZGV2X2luZm8sCj4+ICsJCSAgICAgICBjb25zdCBzdHJ1Y3QgYWRkcmVzc19zcGFjZV9vcGVy YXRpb25zICphX29wcyk7Cj4+ICsKPj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBiYWxsb29uX21hcHBp bmdfZnJlZShzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqYmFsbG9vbl9tYXBwaW5nKQo+PiArewo+PiAr CWtmcmVlKGJhbGxvb25fbWFwcGluZyk7Cj4+ICt9Cj4+Cj4+ICAgLyoKPj4gICAgKiBfX2lzX21v dmFibGVfYmFsbG9vbl9wYWdlIC0gaGVscGVyIHRvIHBlcmZvcm0gQHBhZ2UgUGFnZUJhbGxvb24g dGVzdHMKPj4gQEAgLTEyMyw2ICsxMzYsNyBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaXNvbGF0ZWRf YmFsbG9vbl9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQo+PiAgIHN0YXRpYyBpbmxpbmUgdm9pZCBi YWxsb29uX3BhZ2VfaW5zZXJ0KHN0cnVjdCBiYWxsb29uX2Rldl9pbmZvICpiYWxsb29uLAo+PiAg IAkJCQkgICAgICAgc3RydWN0IHBhZ2UgKnBhZ2UpCj4+ICAgewo+PiArCXBhZ2UtPm1hcHBpbmcg PSBiYWxsb29uLT5tYXBwaW5nOwo+PiAgIAlfX1NldFBhZ2VCYWxsb29uKHBhZ2UpOwo+PiAgIAlT ZXRQYWdlUHJpdmF0ZShwYWdlKTsKPj4gICAJc2V0X3BhZ2VfcHJpdmF0ZShwYWdlLCAodW5zaWdu ZWQgbG9uZyliYWxsb29uKTsKPj4gQEAgLTEzOSw2ICsxNTMsNyBAQCBzdGF0aWMgaW5saW5lIHZv aWQgYmFsbG9vbl9wYWdlX2luc2VydChzdHJ1Y3QgYmFsbG9vbl9kZXZfaW5mbyAqYmFsbG9vbiwK Pj4gICAgKi8KPj4gICBzdGF0aWMgaW5saW5lIHZvaWQgYmFsbG9vbl9wYWdlX2RlbGV0ZShzdHJ1 Y3QgcGFnZSAqcGFnZSkKPj4gICB7Cj4+ICsJcGFnZS0+bWFwcGluZyA9IE5VTEw7Cj4+ICAgCV9f Q2xlYXJQYWdlQmFsbG9vbihwYWdlKTsKPj4gICAJc2V0X3BhZ2VfcHJpdmF0ZShwYWdlLCAwKTsK Pj4gICAJaWYgKFBhZ2VQcml2YXRlKHBhZ2UpKSB7Cj4+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xp bnV4L2ZzLmggYi9pbmNsdWRlL2xpbnV4L2ZzLmgKPj4gaW5kZXggYjRkNzFiNS4uZGU0NjNiOSAx MDA2NDQKPj4gLS0tIGEvaW5jbHVkZS9saW51eC9mcy5oCj4+ICsrKyBiL2luY2x1ZGUvbGludXgv ZnMuaAo+PiBAQCAtMzY4LDYgKzM2OCw5IEBAIHN0cnVjdCBhZGRyZXNzX3NwYWNlX29wZXJhdGlv bnMgewo+PiAgIAkgKi8KPj4gICAJaW50ICgqbWlncmF0ZXBhZ2UpIChzdHJ1Y3QgYWRkcmVzc19z cGFjZSAqLAo+PiAgIAkJCXN0cnVjdCBwYWdlICosIHN0cnVjdCBwYWdlICosIGVudW0gbWlncmF0 ZV9tb2RlKTsKPj4gKwlpbnQgKCppc29sYXRlcGFnZSkoc3RydWN0IHBhZ2UgKik7Cj4KPiBJdCB3 b3VsZCBiZSB1c2VmdWwgaWYgaXNvbGF0ZXBhZ2UgaXMgYXdhcmUgb2YgbWlncmF0ZV9tb2RlIGFu ZCBhZGRyZXNzX3NwYWNlCj4gRm9yIGV4bWFwbGUsIGlmIGl0IGlzIE1JR1JBVEVfU1lOQywgZHJp dmVyIGNvdWxkIHdhaXQgIHNvbWUgb2Ygd29yayB0byBmaW5pc2guCj4+RnJvbSBhZGRyZXNzX3Nw YWNlLCBkcml2ZXIgY2FuIGdldCBwcml2YXRlIGRhdGEgcmVnaXN0ZXJlZCB3aGVuIGlzb2xhdGUv cHV0YmFjawo+IGhhcHBlbnMuCj4KPgo+PiArCWludCAoKnB1dGJhY2twYWdlKShzdHJ1Y3QgcGFn ZSAqKTsKPgo+IERpdHRvLgoKT0suIHYyIHdpbGwgYmU6CmludCAoKmlzb2xhdGVwYWdlKShzdHJ1 Y3QgYWRkcmVzc19zcGFjZSAqLCBzdHJ1Y3QgcGFnZSAqLCBlbnVtIG1pZ3JhdGVfbW9kZSk7Cmlu dCAoKnB1dGJhY2twYWdlKShzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqLCBzdHJ1Y3QgcGFnZSAqLCBl bnVtIG1pZ3JhdGVfbW9kZSk7Cgo+Cj4+ICsKPj4gICAJaW50ICgqbGF1bmRlcl9wYWdlKSAoc3Ry dWN0IHBhZ2UgKik7Cj4+ICAgCWludCAoKmlzX3BhcnRpYWxseV91cHRvZGF0ZSkgKHN0cnVjdCBw YWdlICosIHVuc2lnbmVkIGxvbmcsCj4+ICAgCQkJCQl1bnNpZ25lZCBsb25nKTsKPj4gZGlmZiAt LWdpdCBhL2luY2x1ZGUvbGludXgvcGFnZW1hcC5oIGIvaW5jbHVkZS9saW51eC9wYWdlbWFwLmgK Pj4gaW5kZXggNGIzNzM2Zi4uNzE1YjViMiAxMDA2NDQKPj4gLS0tIGEvaW5jbHVkZS9saW51eC9w YWdlbWFwLmgKPj4gKysrIGIvaW5jbHVkZS9saW51eC9wYWdlbWFwLmgKPj4gQEAgLTI1LDYgKzI1 LDcgQEAgZW51bSBtYXBwaW5nX2ZsYWdzIHsKPj4gICAJQVNfTU1fQUxMX0xPQ0tTCT0gX19HRlBf QklUU19TSElGVCArIDIsCS8qIHVuZGVyIG1tX3Rha2VfYWxsX2xvY2tzKCkgKi8KPj4gICAJQVNf VU5FVklDVEFCTEUJPSBfX0dGUF9CSVRTX1NISUZUICsgMywJLyogZS5nLiwgcmFtZGlzaywgU0hN X0xPQ0sgKi8KPj4gICAJQVNfRVhJVElORwk9IF9fR0ZQX0JJVFNfU0hJRlQgKyA0LCAvKiBmaW5h bCB0cnVuY2F0ZSBpbiBwcm9ncmVzcyAqLwo+PiArCUFTX01JR1JBVEFCTEUgICA9IF9fR0ZQX0JJ VFNfU0hJRlQgKyA1LAo+PiAgIH07Cj4+Cj4+ICAgc3RhdGljIGlubGluZSB2b2lkIG1hcHBpbmdf c2V0X2Vycm9yKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nLCBpbnQgZXJyb3IpCj4+IEBA IC01NCw2ICs1NSwzMSBAQCBzdGF0aWMgaW5saW5lIGludCBtYXBwaW5nX3VuZXZpY3RhYmxlKHN0 cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nKQo+PiAgIAlyZXR1cm4gISFtYXBwaW5nOwo+PiAg IH0KPj4KPj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBtYXBwaW5nX3NldF9taWdyYXRhYmxlKHN0cnVj dCBhZGRyZXNzX3NwYWNlICptYXBwaW5nKQo+PiArewo+PiArCXNldF9iaXQoQVNfTUlHUkFUQUJM RSwgJm1hcHBpbmctPmZsYWdzKTsKPj4gK30KPgo+IEl0IG1lYW5zIGV2ZXJ5IGFkZHJlc3Nfc3Bh Y2Ugd2hpY2ggd2FudCB0byBtaWdyYXRlIHBhZ2VzIG1hcHBlZCB0aGUgYWRkcmVzcyBzcGFjZQo+ IHNob3VsZCBjYWxsIHRoaXMgZnVuY3Rpb24/CgpZZXMsIGl0IGRvZXMuIEl0IGlzIHRoZSBjb21t b24gZnVuY3Rpb24gdG8gY2hlY2sgdGhlIHBhZ2UgbWlncmF0YWJsZS4KCj4KPj4gKwo+PiArc3Rh dGljIGlubGluZSB2b2lkIG1hcHBpbmdfY2xlYXJfbWlncmF0YWJsZShzdHJ1Y3QgYWRkcmVzc19z cGFjZSAqbWFwcGluZykKPj4gK3sKPj4gKwljbGVhcl9iaXQoQVNfTUlHUkFUQUJMRSwgJm1hcHBp bmctPmZsYWdzKTsKPj4gK30KPj4gKwo+PiArc3RhdGljIGlubGluZSBpbnQgX19tYXBwaW5nX29w cyhzdHJ1Y3QgYWRkcmVzc19zcGFjZSAqbWFwcGluZykKPgo+IFRoZSBuYW1pbmcgb2YgX19tYXBw aW5nX29wcyBpcyBhd2t3YXJkLiBIb3cgYWJvdXQgImJvb2wgaXNfbWlncmF0YWJsZSguLi4pIj8K Ck9LLiBXaGF0IGFib3V0IF9fY2hlY2tfbWlncmF0ZV9vcHM/Cgo+IEFub3RoZXIgcXVlc3Rpb246 Cj4gV2h5IHNob3VsZCB0aGV5IHN1cHBvcnQgYWxsIGZ1Y250aW9ucyBvZiBtaWdyYXRlKGllLCBt aWdyYXRlcGFnZSwgaXNvbGF0ZXBhZ2UsIHB1dGJhY2twYWdlKS4KPiBJIG1lYW4gY3VycmVudGx5 IGlub2RlIG9mIHJlZ3VsYXIgZmlsZSBzdXBwb3J0cyBvbmx5IG1pZ3JhdGVwYWdlLgo+IEJ5IHlv dXIgcnVsZSwgdGhleSBhcmUgbm90IG1pZ3JhdGFibGU/CgpJIHdhbnQgdG8gbWFrZSBhIGNvbW1v biBmcmFtZXdvcmsgdG8gYmUgYWJsZSB0byBzdXBwb3J0IG1pZ3JhdGUvaXNvbGF0ZS9wdXRiYWNr LgpJZiB5b3UgZG9lc24ndCBuZWVkIGFueSBvZiBpdCwgeW91IGNhbiBtYWtlIGl0IGVtcHR5IGZ1 bmN0aW9uLgpJcyBpdCBpcnJhdGlvbmFsPwoKPgo+PiArewo+PiArCXJldHVybiBtYXBwaW5nLT5h X29wcyAmJgo+PiArCQltYXBwaW5nLT5hX29wcy0+bWlncmF0ZXBhZ2UgJiYKPj4gKwkJbWFwcGlu Zy0+YV9vcHMtPmlzb2xhdGVwYWdlICYmCj4+ICsJCW1hcHBpbmctPmFfb3BzLT5wdXRiYWNrcGFn ZTsKPj4gK30KPj4gKwo+PiArc3RhdGljIGlubGluZSBpbnQgbWFwcGluZ19taWdyYXRhYmxlKHN0 cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nKQo+PiArewo+PiArCWlmIChtYXBwaW5nICYmIF9f bWFwcGluZ19vcHMobWFwcGluZykpCj4KPiBXaHkgZG8gd2UgbmVlZCBtYXBwaW5nIE5VTEwgY2hl Y2sgaW4gaGVyZT8KPiBJdCdzIHJvbGUgb2YgY2FsbGVyPwoKVGhpcyBpcyBzb21lIGRlcGVuc2Ug Y29kZSB0byBjaGVjayBlcnJvci4KCj4KPj4gKwkJcmV0dXJuIHRlc3RfYml0KEFTX01JR1JBVEFC TEUsICZtYXBwaW5nLT5mbGFncyk7Cj4KPiBJdCBtZWFucyBzb21lIG9mIGFkZHJlc3Nfc3BhY2Ug aGFzIG1pZ3JhdGVwYWdlLCBpc29sYXRlcGFnZSwgcHV0YmFja3BhZ2UgYnV0Cj4gaXQgZG9lc24n dCBzZXQgQVNfTUlHUkFUQUJMRT8gV2h5IGRvIHdlIG5lZWQgaXQ/CgpUaGlzIGFsc28gZGVwZW5z ZSBjb2RlLgpJIHRoaW5rIGRlcGVuc2UgY29kZSBzaG91bGQgY2hlY2sgZXZlcnkgY2FzZSwgZG9l c24ndCBpdD8KCj4KPj4gKwlyZXR1cm4gISFtYXBwaW5nOwo+PiArfQo+PiArCj4+ICAgc3RhdGlj IGlubGluZSB2b2lkIG1hcHBpbmdfc2V0X2V4aXRpbmcoc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1h cHBpbmcpCj4+ICAgewo+PiAgIAlzZXRfYml0KEFTX0VYSVRJTkcsICZtYXBwaW5nLT5mbGFncyk7 Cj4+IGRpZmYgLS1naXQgYS9tbS9iYWxsb29uX2NvbXBhY3Rpb24uYyBiL21tL2JhbGxvb25fY29t cGFjdGlvbi5jCj4+IGluZGV4IGZjYWQ4MzIuLjJlOWQ2MzUgMTAwNjQ0Cj4+IC0tLSBhL21tL2Jh bGxvb25fY29tcGFjdGlvbi5jCj4+ICsrKyBiL21tL2JhbGxvb25fY29tcGFjdGlvbi5jCj4+IEBA IC0xMzEsOCArMTMxLDExIEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBfX3B1dGJhY2tfYmFsbG9vbl9w YWdlKHN0cnVjdCBwYWdlICpwYWdlKQo+PiAgIH0KPj4KPj4gICAvKiBfX2lzb2xhdGVfbHJ1X3Bh Z2UoKSBjb3VudGVycGFydCBmb3IgYSBiYWxsb29uZWQgcGFnZSAqLwo+PiAtYm9vbCBiYWxsb29u X3BhZ2VfaXNvbGF0ZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPj4gK2ludCBiYWxsb29uX3BhZ2VfaXNv bGF0ZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPj4gICB7Cj4+ICsJaWYgKCFiYWxsb29uX3BhZ2VfbW92 YWJsZShwYWdlKSkKPj4gKwkJcmV0dXJuIGZhbHNlOwo+PiArCj4+ICAgCS8qCj4+ICAgCSAqIEF2 b2lkIGJ1cm5pbmcgY3ljbGVzIHdpdGggcGFnZXMgdGhhdCBhcmUgeWV0IHVuZGVyIF9fZnJlZV9w YWdlcygpLAo+PiAgIAkgKiBvciBqdXN0IGdvdCBmcmVlZCB1bmRlciB1cy4KPj4gQEAgLTE3Myw4 ICsxNzYsMTEgQEAgYm9vbCBiYWxsb29uX3BhZ2VfaXNvbGF0ZShzdHJ1Y3QgcGFnZSAqcGFnZSkK Pj4gICB9Cj4+Cj4+ICAgLyogcHV0YmFja19scnVfcGFnZSgpIGNvdW50ZXJwYXJ0IGZvciBhIGJh bGxvb25lZCBwYWdlICovCj4+IC12b2lkIGJhbGxvb25fcGFnZV9wdXRiYWNrKHN0cnVjdCBwYWdl ICpwYWdlKQo+PiAraW50IGJhbGxvb25fcGFnZV9wdXRiYWNrKHN0cnVjdCBwYWdlICpwYWdlKQo+ PiAgIHsKPj4gKwlpZiAoIWlzb2xhdGVkX2JhbGxvb25fcGFnZShwYWdlKSkKPj4gKwkJcmV0dXJu IDA7Cj4+ICsKPj4gICAJLyoKPj4gICAJICogJ2xvY2tfcGFnZSgpJyBzdGFiaWxpemVzIHRoZSBw YWdlIGFuZCBwcmV2ZW50cyByYWNlcyBhZ2FpbnN0Cj4+ICAgCSAqIGNvbmN1cnJlbnQgaXNvbGF0 aW9uIHRocmVhZHMgYXR0ZW1wdGluZyB0byByZS1pc29sYXRlIGl0Lgo+PiBAQCAtMTkwLDE1ICsx OTYsMjAgQEAgdm9pZCBiYWxsb29uX3BhZ2VfcHV0YmFjayhzdHJ1Y3QgcGFnZSAqcGFnZSkKPj4g ICAJCWR1bXBfcGFnZShwYWdlLCAibm90IG1vdmFibGUgYmFsbG9vbiBwYWdlIik7Cj4+ICAgCX0K Pj4gICAJdW5sb2NrX3BhZ2UocGFnZSk7Cj4+ICsJcmV0dXJuIDA7Cj4+ICAgfQo+Pgo+PiAgIC8q IG1vdmVfdG9fbmV3X3BhZ2UoKSBjb3VudGVycGFydCBmb3IgYSBiYWxsb29uZWQgcGFnZSAqLwo+ PiAtaW50IGJhbGxvb25fcGFnZV9taWdyYXRlKHN0cnVjdCBwYWdlICpuZXdwYWdlLAo+PiAraW50 IGJhbGxvb25fcGFnZV9taWdyYXRlKHN0cnVjdCBhZGRyZXNzX3NwYWNlICptYXBwaW5nLAo+PiAr CQkJIHN0cnVjdCBwYWdlICpuZXdwYWdlLAo+PiAgIAkJCSBzdHJ1Y3QgcGFnZSAqcGFnZSwgZW51 bSBtaWdyYXRlX21vZGUgbW9kZSkKPj4gICB7Cj4+ICAgCXN0cnVjdCBiYWxsb29uX2Rldl9pbmZv ICpiYWxsb29uID0gYmFsbG9vbl9wYWdlX2RldmljZShwYWdlKTsKPj4gICAJaW50IHJjID0gLUVB R0FJTjsKPj4KPj4gKwlpZiAoIWlzb2xhdGVkX2JhbGxvb25fcGFnZShwYWdlKSkKPj4gKwkJcmV0 dXJuIDA7Cj4+ICsKPj4gICAJLyoKPj4gICAJICogQmxvY2sgb3RoZXJzIGZyb20gYWNjZXNzaW5n IHRoZSAnbmV3cGFnZScgd2hlbiB3ZSBnZXQgYXJvdW5kIHRvCj4+ICAgCSAqIGVzdGFibGlzaGlu ZyBhZGRpdGlvbmFsIHJlZmVyZW5jZXMuIFdlIHNob3VsZCBiZSB0aGUgb25seSBvbmUKPj4gQEAg LTIxOCw0ICsyMjksNTUgQEAgaW50IGJhbGxvb25fcGFnZV9taWdyYXRlKHN0cnVjdCBwYWdlICpu ZXdwYWdlLAo+PiAgIAl1bmxvY2tfcGFnZShuZXdwYWdlKTsKPj4gICAJcmV0dXJuIHJjOwo+PiAg IH0KPj4gKwo+PiArLyogZGVmaW5lIHRoZSBiYWxsb29uX21hcHBpbmctPmFfb3BzIGNhbGxiYWNr IHRvIGFsbG93IGJhbGxvb24gcGFnZSBtaWdyYXRpb24gKi8KPj4gK2NvbnN0IHN0cnVjdCBhZGRy ZXNzX3NwYWNlX29wZXJhdGlvbnMgYmFsbG9vbl9hb3BzID0gewo+PiArCS5taWdyYXRlcGFnZSA9 IGJhbGxvb25fcGFnZV9taWdyYXRlLAo+PiArCS5pc29sYXRlcGFnZSA9IGJhbGxvb25fcGFnZV9p c29sYXRlLAo+PiArCS5wdXRiYWNrcGFnZSA9IGJhbGxvb25fcGFnZV9wdXRiYWNrLAo+PiArfTsK Pj4gK0VYUE9SVF9TWU1CT0xfR1BMKGJhbGxvb25fYW9wcyk7Cj4+ICsKPj4gK3N0cnVjdCBhZGRy ZXNzX3NwYWNlICpiYWxsb29uX21hcHBpbmdfYWxsb2Moc3RydWN0IGJhbGxvb25fZGV2X2luZm8g KmJfZGV2X2luZm8sCj4+ICsJCQkJY29uc3Qgc3RydWN0IGFkZHJlc3Nfc3BhY2Vfb3BlcmF0aW9u cyAqYV9vcHMpCj4+ICt7Cj4+ICsJc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmc7Cj4+ICsK Pj4gKwltYXBwaW5nID0ga21hbGxvYyhzaXplb2YoKm1hcHBpbmcpLCBHRlBfS0VSTkVMKTsKPj4g KwlpZiAoIW1hcHBpbmcpCj4+ICsJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwo+PiArCj4+ICsJ LyoKPj4gKwkgKiBHaXZlIGEgY2xlYW4gJ3plcm9lZCcgc3RhdHVzIHRvIGFsbCBlbGVtZW50cyBv ZiB0aGlzIHNwZWNpYWwKPj4gKwkgKiBiYWxsb29uIHBhZ2UtPm1hcHBpbmcgc3RydWN0IGFkZHJl c3Nfc3BhY2UgaW5zdGFuY2UuCj4+ICsJICovCj4+ICsJYWRkcmVzc19zcGFjZV9pbml0X29uY2Uo bWFwcGluZyk7Cj4+ICsKPj4gKwkvKgo+PiArCSAqIFNldCBtYXBwaW5nLT5mbGFncyBhcHByb3By aWF0ZWx5LCB0byBhbGxvdyBiYWxsb29uIHBhZ2VzCj4+ICsJICogLT5tYXBwaW5nIGlkZW50aWZp Y2F0aW9uLgo+PiArCSAqLwo+PiArCW1hcHBpbmdfc2V0X21pZ3JhdGFibGUobWFwcGluZyk7Cj4+ ICsJbWFwcGluZ19zZXRfZ2ZwX21hc2sobWFwcGluZywgYmFsbG9vbl9tYXBwaW5nX2dmcF9tYXNr KCkpOwo+PiArCj4+ICsJLyogYmFsbG9vbidzIHBhZ2UtPm1hcHBpbmctPmFfb3BzIGNhbGxiYWNr IGRlc2NyaXB0b3IgKi8KPj4gKwltYXBwaW5nLT5hX29wcyA9IGFfb3BzOwo+PiArCj4+ICsJLyoK Pj4gKwkgKiBFc3RhYmxpc2ggYSBwb2ludGVyIHJlZmVyZW5jZSBiYWNrIHRvIHRoZSBiYWxsb29u IGRldmljZSBkZXNjcmlwdG9yCj4+ICsJICogdGhpcyBwYXJ0aWN1bGFyIHBhZ2UtPm1hcHBpbmcg d2lsbCBiZSBzZXJ2aWNpbmcuCj4+ICsJICogVGhpcyBpcyB1c2VkIGJ5IGNvbXBhY3Rpb24gLyBt aWdyYXRpb24gcHJvY2VkdXJlcyB0byBpZGVudGlmeSBhbmQKPj4gKwkgKiBhY2Nlc3MgdGhlIGJh bGxvb24gZGV2aWNlIHBhZ2VzZXQgd2hpbGUgaXNvbGF0aW5nIC8gbWlncmF0aW5nIHBhZ2VzLgo+ PiArCSAqCj4+ICsJICogQXMgc29tZSBiYWxsb29uIGRyaXZlcnMgY2FuIHJlZ2lzdGVyIG11bHRp cGxlIGJhbGxvb24gZGV2aWNlcwo+PiArCSAqIGZvciBhIHNpbmdsZSBndWVzdCwgdGhpcyBhbHNv IGhlbHBzIGNvbXBhY3Rpb24gLyBtaWdyYXRpb24gdG8KPj4gKwkgKiBwcm9wZXJseSBkZWFsIHdp dGggbXVsdGlwbGUgYmFsbG9vbiBwYWdlc2V0cywgd2hlbiByZXF1aXJlZC4KPj4gKwkgKi8KPj4g KwltYXBwaW5nLT5wcml2YXRlX2RhdGEgPSBiX2Rldl9pbmZvOwo+PiArCWJfZGV2X2luZm8tPm1h cHBpbmcgPSBtYXBwaW5nOwo+PiArCj4+ICsJcmV0dXJuIG1hcHBpbmc7Cj4+ICt9Cj4+ICtFWFBP UlRfU1lNQk9MX0dQTChiYWxsb29uX21hcHBpbmdfYWxsb2MpOwo+PiArCj4+ICAgI2VuZGlmIC8q IENPTkZJR19CQUxMT09OX0NPTVBBQ1RJT04gKi8KPj4gZGlmZiAtLWdpdCBhL21tL2NvbXBhY3Rp b24uYyBiL21tL2NvbXBhY3Rpb24uYwo+PiBpbmRleCA4YzBkOTQ1Li45ZmJjYjdiIDEwMDY0NAo+ PiAtLS0gYS9tbS9jb21wYWN0aW9uLmMKPj4gKysrIGIvbW0vY29tcGFjdGlvbi5jCj4+IEBAIC03 NDAsMTIgKzc0MCw5IEBAIGlzb2xhdGVfbWlncmF0ZXBhZ2VzX2Jsb2NrKHN0cnVjdCBjb21wYWN0 X2NvbnRyb2wgKmNjLCB1bnNpZ25lZCBsb25nIGxvd19wZm4sCj4+ICAgCQkgKiBTa2lwIGFueSBv dGhlciB0eXBlIG9mIHBhZ2UKPj4gICAJCSAqLwo+PiAgIAkJaWYgKCFQYWdlTFJVKHBhZ2UpKSB7 Cj4+IC0JCQlpZiAodW5saWtlbHkoYmFsbG9vbl9wYWdlX21vdmFibGUocGFnZSkpKSB7Cj4+IC0J CQkJaWYgKGJhbGxvb25fcGFnZV9pc29sYXRlKHBhZ2UpKSB7Cj4+IC0JCQkJCS8qIFN1Y2Nlc3Nm dWxseSBpc29sYXRlZCAqLwo+PiArCQkJaWYgKG1hcHBpbmdfbWlncmF0YWJsZShwYWdlLT5tYXBw aW5nKSkKPgo+IEkgc2VlLiBEbyB5b3Ugd2FudCB0byBzdXBwb3J0IHRoaXMgZmVhdHVyZSBmb3Ig b25seSAibm9uLUxSVSBwYWdlcyI/Cj4gSG1tLCB5b3VyIHRlcm0gZm9yIGZ1bmN0aW9ucyB3YXMg dG9vIGdlbmVyaWMgc28gSSBnb3QgY29uZnVzZWQuCj4gQXQgbGVhc3QsIGl0IG5lZWRzIHByZWZp eCBsaWtlICJzcGVjaWFsX3h4eCIgc28gdGhhdCB3ZSBjb3VsZCBjbGFzc2lmeQo+IHJlZ3VsYXIg aW5vZGUgbWlncmF0ZSBhbmQgc3BlY2lhbCBkcml2ZXIgbWlncmF0ZS4KCk9LLiBXaGF0IGFib3V0 ICJtYXBwaW5nX2RyaXZlcl9taWdyYXRhYmxlIj8KSSB3aWxsIGNoYW5nZSBvdGhlciBuYW1lcyBs aWtlIG1hcHBpbmdfc2V0X2RyaXZlcl9taWdyYXRhYmxlL21hcHBpbmdfY2xlYXJfZHJpdmVyX21p Z3JhdGFibGUuCgo+Cj4gT3RoZXJ3aXNlLCB3ZSBjb3VsZCBtYWtlIGxvZ2ljIG1vcmUgZ2VuZXJh bCBzbyBldmVyeSBhZGRyZXNzX3NwYWNlCj4gd2FudCB0byBtaWdyYXRlIHRoZWlyIHBhZ2UgaGFz IGFsbCBvZiBtaWdyYXRlIGZ1bmN0aW9ucyhpZSwgbWlncmF0ZSxpc29sYXRlLHB1dGJhY2spCj4g YW5kIHdlIHN1cHBvcnQgZGVmYXVsdCBmdW5jdGlvbnMgc28gYWRkcmVzc3Nfc3BhY2Ugb2YgcmVn dWxhciBpbm9kZSB3aWxsCj4gaGF2ZSBkZWZhdWx0IGZ1bmN0aW9ucyB3aGlsZSBzcGVjaWFsIGRy aXZlciBvdmVycmlkZXMgaXQgYnkgb3duIGZ1bmN0aW9ucy4KPiBXaXRoIGl0LCBjb21wYWN0L21p Z3JhdGUganVzdCBjYWxscyByZWdpc3RlcmVkIGZ1bmN0aW9uIG9mIGVhY2ggc3Vic3lzdGVtIGFu ZAo+IHBhc3MgbWFueSByb2xlIHRvIHRoZW0uCj4KPgoKSSBjb25zaWRlciBpdCBhcyB0aGUgc2Vj b25kIHN0ZXAuCgo+PiArCQkJCWlmIChwYWdlLT5tYXBwaW5nLT5hX29wcy0+aXNvbGF0ZXBhZ2Uo cGFnZSkpCj4+ICAgCQkJCQlnb3RvIGlzb2xhdGVfc3VjY2VzczsKPj4gLQkJCQl9Cj4+IC0JCQl9 Cj4+ICAgCQkJY29udGludWU7Cj4+ICAgCQl9Cj4+Cj4+IGRpZmYgLS1naXQgYS9tbS9taWdyYXRl LmMgYi9tbS9taWdyYXRlLmMKPj4gaW5kZXggODVlMDQyNi4uMzdjYjM2NiAxMDA2NDQKPj4gLS0t IGEvbW0vbWlncmF0ZS5jCj4+ICsrKyBiL21tL21pZ3JhdGUuYwo+PiBAQCAtNzEsNiArNzEsMTIg QEAgaW50IG1pZ3JhdGVfcHJlcF9sb2NhbCh2b2lkKQo+PiAgIAlyZXR1cm4gMDsKPj4gICB9Cj4+ Cj4+ICtzdGF0aWMgYm9vbCBpc29sYXRlZF9taWdyYXRhYmxlX3BhZ2Uoc3RydWN0IHBhZ2UgKnBh Z2UpCj4+ICt7Cj4+ICsJcmV0dXJuIHBhZ2VfbWFwcGVkKHBhZ2UpID09IDAgJiYKPj4gKwkJbWFw cGluZ19taWdyYXRhYmxlKHBhZ2UtPm1hcHBpbmcpOwo+PiArfQo+Cj4gV2h5IGRvZXMgd2UgbmVl ZCB0byBjaGVjayBsaWtlIHRoaXM/Cj4gV2hldGhlciBpc29sYXRlIHdhcyBzdWNjZXNzZnVsIG9y IG5vdCBkZXBlbmRzIG9uIHRoZSBkcml2ZXIuCj4gV2UgY2Fubm90IGV4cGVjdCBpdCB3aXRoIG9u bHkgcGFnZV9tYXBwZWQuCgpJIGFzc3VtZSB0aGF0IHBhZ2VzIG9mIGRyaXZlciB3aXRob3V0IENQ VSBtYXBwaW5nIGNhbiBiZSBtaWdyYXRhYmxlLgpTbyBJIGFkZCBjaGVja2luZyBwYWdlX21hcHBl ZCB6ZXJvLgoKPgo+PiArCj4+ICAgLyoKPj4gICAgKiBQdXQgcHJldmlvdXNseSBpc29sYXRlZCBw YWdlcyBiYWNrIG9udG8gdGhlIGFwcHJvcHJpYXRlIGxpc3RzCj4+ICAgICogZnJvbSB3aGVyZSB0 aGV5IHdlcmUgb25jZSB0YWtlbiBvZmYgZm9yIGNvbXBhY3Rpb24vbWlncmF0aW9uLgo+PiBAQCAt OTEsOSArOTcsOSBAQCB2b2lkIHB1dGJhY2tfbW92YWJsZV9wYWdlcyhzdHJ1Y3QgbGlzdF9oZWFk ICpsKQo+PiAgIAkJfQo+PiAgIAkJbGlzdF9kZWwoJnBhZ2UtPmxydSk7Cj4+ICAgCQlkZWNfem9u ZV9wYWdlX3N0YXRlKHBhZ2UsIE5SX0lTT0xBVEVEX0FOT04gKwo+PiAtCQkJCXBhZ2VfaXNfZmls ZV9jYWNoZShwYWdlKSk7Cj4+IC0JCWlmICh1bmxpa2VseShpc29sYXRlZF9iYWxsb29uX3BhZ2Uo cGFnZSkpKQo+PiAtCQkJYmFsbG9vbl9wYWdlX3B1dGJhY2socGFnZSk7Cj4+ICsJCQkJICAgIHBh Z2VfaXNfZmlsZV9jYWNoZShwYWdlKSk7Cj4+ICsJCWlmICh1bmxpa2VseShpc29sYXRlZF9taWdy YXRhYmxlX3BhZ2UocGFnZSkpKQo+PiArCQkJcGFnZS0+bWFwcGluZy0+YV9vcHMtPnB1dGJhY2tw YWdlKHBhZ2UpOwo+PiAgIAkJZWxzZQo+PiAgIAkJCXB1dGJhY2tfbHJ1X3BhZ2UocGFnZSk7Cj4K PiBBcyBJIHNhaWQsIGhvdyBhYm91dCBoYXZpbmcgcHV0YmFja19scnVfcGFnZSBmb3IgcGFnZS0+ bWFwcGluZy0+YV9vcHMtPnB1dGJhY2twYWdlCj4gZm9yIHJlZ3VsYXIgaW5vZGU/IFdpdGggaXQs IHdlIG1heSByZW1vdmUgc29tZSBvZiBicmFuY2ggaW4gbWlncmF0ZS9jb21wYWN0LmMgdG8KPiBz ZXBhcmF0ZSBzcGVjaWFsIGRyaXZlciBhbmQgcmVndWxhciBhZGRyZXNzX3NwYWNlLgo+IEhvcGUg dG8gZW5oYW5jZSByZWFkYWJpbGl0eSBhbmQgbWFrZSBtb3JlIGZsZXhpYmxlLgoKSSBhZ3JlZS4K SSdsbCB0ZXN0IHRoaXMgcGF0Y2ggZW5vdWdoIGFuZCB0aGVuIHByb2NlZWQgdG8gaXQuCgpJIGRv IGFwcHJlY2lhdGUgeW91ciBmZWVkYmFjay4KCj4KPj4gICAJfQo+PiBAQCAtODQzLDE1ICs4NDks OSBAQCBzdGF0aWMgaW50IF9fdW5tYXBfYW5kX21vdmUoc3RydWN0IHBhZ2UgKnBhZ2UsIHN0cnVj dCBwYWdlICpuZXdwYWdlLAo+PiAgIAkJfQo+PiAgIAl9Cj4+Cj4+IC0JaWYgKHVubGlrZWx5KGlz b2xhdGVkX2JhbGxvb25fcGFnZShwYWdlKSkpIHsKPj4gLQkJLyoKPj4gLQkJICogQSBiYWxsb29u ZWQgcGFnZSBkb2VzIG5vdCBuZWVkIGFueSBzcGVjaWFsIGF0dGVudGlvbiBmcm9tCj4+IC0JCSAq IHBoeXNpY2FsIHRvIHZpcnR1YWwgcmV2ZXJzZSBtYXBwaW5nIHByb2NlZHVyZXMuCj4+IC0JCSAq IFNraXAgYW55IGF0dGVtcHQgdG8gdW5tYXAgUFRFcyBvciB0byByZW1hcCBzd2FwIGNhY2hlLAo+ PiAtCQkgKiBpbiBvcmRlciB0byBhdm9pZCBidXJuaW5nIGN5Y2xlcyBhdCBybWFwIGxldmVsLCBh bmQgcGVyZm9ybQo+PiAtCQkgKiB0aGUgcGFnZSBtaWdyYXRpb24gcmlnaHQgYXdheSAocHJvdGVj ZWQgYnkgcGFnZSBsb2NrKS4KPj4gLQkJICovCj4+IC0JCXJjID0gYmFsbG9vbl9wYWdlX21pZ3Jh dGUobmV3cGFnZSwgcGFnZSwgbW9kZSk7Cj4+ICsJaWYgKHVubGlrZWx5KGlzb2xhdGVkX21pZ3Jh dGFibGVfcGFnZShwYWdlKSkpIHsKPj4gKwkJcmMgPSBwYWdlLT5tYXBwaW5nLT5hX29wcy0+bWln cmF0ZXBhZ2UocGFnZS0+bWFwcGluZywKPj4gKwkJCQkJCSAgICAgICBuZXdwYWdlLCBwYWdlLCBt b2RlKTsKPj4gICAJCWdvdG8gb3V0X3VubG9jazsKPj4gICAJfQo+Pgo+PiAtLQo+PiAxLjcuOS41 Cj4+Cj4KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KVmly dHVhbGl6YXRpb24gbWFpbGluZyBsaXN0ClZpcnR1YWxpemF0aW9uQGxpc3RzLmxpbnV4LWZvdW5k YXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL3ZpcnR1YWxpemF0aW9u From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-pd0-f172.google.com (mail-pd0-f172.google.com [209.85.192.172]) by kanga.kvack.org (Postfix) with ESMTP id B00FC6B0032 for ; Sun, 12 Apr 2015 21:39:44 -0400 (EDT) Received: by pdea3 with SMTP id a3so89957217pde.3 for ; Sun, 12 Apr 2015 18:39:44 -0700 (PDT) Received: from lgeamrelo04.lge.com (lgeamrelo04.lge.com. [156.147.1.127]) by mx.google.com with ESMTP id e4si13421846pdp.245.2015.04.12.18.39.41 for ; Sun, 12 Apr 2015 18:39:42 -0700 (PDT) Message-ID: <552B1E5C.3030501@lge.com> Date: Mon, 13 Apr 2015 10:39:40 +0900 From: Gioh Kim MIME-Version: 1.0 Subject: Re: [PATCH] add generic callbacks into compaction References: <1427843490-27084-1-git-send-email-gioh.kim@lge.com> <20150407005344.GA27788@blaptop> In-Reply-To: <20150407005344.GA27788@blaptop> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Sender: owner-linux-mm@kvack.org List-ID: To: Minchan Kim Cc: rusty@rustcorp.com.au, mst@redhat.com, mgorman@suse.de, jlayton@poochiereds.net, bfields@fieldses.org, akpm@linux-foundation.org, koct9i@gmail.com, iamjoonsoo.kim@lge.com, virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org 2015-04-07 i??i ? 9:59i?? Minchan Kim i?'(e??) i?' e,?: > Hello Gioh, > > I wanted to have such feature for zsmalloc. > Thanks for the work. > > On Wed, Apr 01, 2015 at 08:11:30AM +0900, Gioh Kim wrote: >> I sent a patch about page allocation for less fragmentation. >> http://permalink.gmane.org/gmane.linux.kernel.mm/130599 >> >> It proposes a page allocator allocates pages in the same pageblock >> for the drivers to move their unmovable pages. Some drivers which comsumes many pages >> and increases system fragmentation use the allocator to move their pages to >> decrease fragmentation. >> >> I think I can try another approach. >> There is a compaction code for balloon pages. >> But the compaction code cannot migrate pages of other drivers. >> If there is a generic migration framework applicable to any drivers, >> drivers can register their migration functions. >> And the compaction can migrate movable pages and also driver's pages. >> >> I'm not familiar with virtualization so I couldn't test this patch yet. >> But if mm developers agree with this approach, I will complete this patch. >> >> I would do appreciate any feedback. > > Could you separate introducing migrate core patchset and balloon patchset for > using the feature? Sure. > >> >> Signed-off-by: Gioh Kim >> --- >> drivers/virtio/virtio_balloon.c | 2 ++ >> include/linux/balloon_compaction.h | 23 +++++++++--- >> include/linux/fs.h | 3 ++ >> include/linux/pagemap.h | 26 ++++++++++++++ >> mm/balloon_compaction.c | 68 ++++++++++++++++++++++++++++++++++-- >> mm/compaction.c | 7 ++-- >> mm/migrate.c | 24 ++++++------- >> 7 files changed, 129 insertions(+), 24 deletions(-) >> >> diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c >> index 0413157..cd9b8e4 100644 >> --- a/drivers/virtio/virtio_balloon.c >> +++ b/drivers/virtio/virtio_balloon.c >> @@ -486,6 +486,8 @@ static int virtballoon_probe(struct virtio_device *vdev) >> >> balloon_devinfo_init(&vb->vb_dev_info); >> #ifdef CONFIG_BALLOON_COMPACTION >> + vb->vb_dev_info.mapping = balloon_mapping_alloc(&vb->vb_dev_info, >> + &balloon_aops); >> vb->vb_dev_info.migratepage = virtballoon_migratepage; >> #endif >> >> diff --git a/include/linux/balloon_compaction.h b/include/linux/balloon_compaction.h >> index 9b0a15d..0af32b3 100644 >> --- a/include/linux/balloon_compaction.h >> +++ b/include/linux/balloon_compaction.h >> @@ -62,6 +62,7 @@ struct balloon_dev_info { >> struct list_head pages; /* Pages enqueued & handled to Host */ >> int (*migratepage)(struct balloon_dev_info *, struct page *newpage, >> struct page *page, enum migrate_mode mode); >> + struct address_space *mapping; >> }; >> >> extern struct page *balloon_page_enqueue(struct balloon_dev_info *b_dev_info); >> @@ -76,10 +77,22 @@ static inline void balloon_devinfo_init(struct balloon_dev_info *balloon) >> } >> >> #ifdef CONFIG_BALLOON_COMPACTION >> -extern bool balloon_page_isolate(struct page *page); >> -extern void balloon_page_putback(struct page *page); >> -extern int balloon_page_migrate(struct page *newpage, >> - struct page *page, enum migrate_mode mode); >> +extern const struct address_space_operations balloon_aops; >> +extern int balloon_page_isolate(struct page *page); >> +extern int balloon_page_putback(struct page *page); >> +extern int balloon_page_migrate(struct address_space *mapping, >> + struct page *newpage, >> + struct page *page, >> + enum migrate_mode mode); >> + >> +extern struct address_space >> +*balloon_mapping_alloc(struct balloon_dev_info *b_dev_info, >> + const struct address_space_operations *a_ops); >> + >> +static inline void balloon_mapping_free(struct address_space *balloon_mapping) >> +{ >> + kfree(balloon_mapping); >> +} >> >> /* >> * __is_movable_balloon_page - helper to perform @page PageBalloon tests >> @@ -123,6 +136,7 @@ static inline bool isolated_balloon_page(struct page *page) >> static inline void balloon_page_insert(struct balloon_dev_info *balloon, >> struct page *page) >> { >> + page->mapping = balloon->mapping; >> __SetPageBalloon(page); >> SetPagePrivate(page); >> set_page_private(page, (unsigned long)balloon); >> @@ -139,6 +153,7 @@ static inline void balloon_page_insert(struct balloon_dev_info *balloon, >> */ >> static inline void balloon_page_delete(struct page *page) >> { >> + page->mapping = NULL; >> __ClearPageBalloon(page); >> set_page_private(page, 0); >> if (PagePrivate(page)) { >> diff --git a/include/linux/fs.h b/include/linux/fs.h >> index b4d71b5..de463b9 100644 >> --- a/include/linux/fs.h >> +++ b/include/linux/fs.h >> @@ -368,6 +368,9 @@ struct address_space_operations { >> */ >> int (*migratepage) (struct address_space *, >> struct page *, struct page *, enum migrate_mode); >> + int (*isolatepage)(struct page *); > > It would be useful if isolatepage is aware of migrate_mode and address_space > For exmaple, if it is MIGRATE_SYNC, driver could wait some of work to finish. >>>From address_space, driver can get private data registered when isolate/putback > happens. > > >> + int (*putbackpage)(struct page *); > > Ditto. OK. v2 will be: int (*isolatepage)(struct address_space *, struct page *, enum migrate_mode); int (*putbackpage)(struct address_space *, struct page *, enum migrate_mode); > >> + >> int (*launder_page) (struct page *); >> int (*is_partially_uptodate) (struct page *, unsigned long, >> unsigned long); >> diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h >> index 4b3736f..715b5b2 100644 >> --- a/include/linux/pagemap.h >> +++ b/include/linux/pagemap.h >> @@ -25,6 +25,7 @@ enum mapping_flags { >> AS_MM_ALL_LOCKS = __GFP_BITS_SHIFT + 2, /* under mm_take_all_locks() */ >> AS_UNEVICTABLE = __GFP_BITS_SHIFT + 3, /* e.g., ramdisk, SHM_LOCK */ >> AS_EXITING = __GFP_BITS_SHIFT + 4, /* final truncate in progress */ >> + AS_MIGRATABLE = __GFP_BITS_SHIFT + 5, >> }; >> >> static inline void mapping_set_error(struct address_space *mapping, int error) >> @@ -54,6 +55,31 @@ static inline int mapping_unevictable(struct address_space *mapping) >> return !!mapping; >> } >> >> +static inline void mapping_set_migratable(struct address_space *mapping) >> +{ >> + set_bit(AS_MIGRATABLE, &mapping->flags); >> +} > > It means every address_space which want to migrate pages mapped the address space > should call this function? Yes, it does. It is the common function to check the page migratable. > >> + >> +static inline void mapping_clear_migratable(struct address_space *mapping) >> +{ >> + clear_bit(AS_MIGRATABLE, &mapping->flags); >> +} >> + >> +static inline int __mapping_ops(struct address_space *mapping) > > The naming of __mapping_ops is awkward. How about "bool is_migratable(...)"? OK. What about __check_migrate_ops? > Another question: > Why should they support all fucntions of migrate(ie, migratepage, isolatepage, putbackpage). > I mean currently inode of regular file supports only migratepage. > By your rule, they are not migratable? I want to make a common framework to be able to support migrate/isolate/putback. If you doesn't need any of it, you can make it empty function. Is it irrational? > >> +{ >> + return mapping->a_ops && >> + mapping->a_ops->migratepage && >> + mapping->a_ops->isolatepage && >> + mapping->a_ops->putbackpage; >> +} >> + >> +static inline int mapping_migratable(struct address_space *mapping) >> +{ >> + if (mapping && __mapping_ops(mapping)) > > Why do we need mapping NULL check in here? > It's role of caller? This is some depense code to check error. > >> + return test_bit(AS_MIGRATABLE, &mapping->flags); > > It means some of address_space has migratepage, isolatepage, putbackpage but > it doesn't set AS_MIGRATABLE? Why do we need it? This also depense code. I think depense code should check every case, doesn't it? > >> + return !!mapping; >> +} >> + >> static inline void mapping_set_exiting(struct address_space *mapping) >> { >> set_bit(AS_EXITING, &mapping->flags); >> diff --git a/mm/balloon_compaction.c b/mm/balloon_compaction.c >> index fcad832..2e9d635 100644 >> --- a/mm/balloon_compaction.c >> +++ b/mm/balloon_compaction.c >> @@ -131,8 +131,11 @@ static inline void __putback_balloon_page(struct page *page) >> } >> >> /* __isolate_lru_page() counterpart for a ballooned page */ >> -bool balloon_page_isolate(struct page *page) >> +int balloon_page_isolate(struct page *page) >> { >> + if (!balloon_page_movable(page)) >> + return false; >> + >> /* >> * Avoid burning cycles with pages that are yet under __free_pages(), >> * or just got freed under us. >> @@ -173,8 +176,11 @@ bool balloon_page_isolate(struct page *page) >> } >> >> /* putback_lru_page() counterpart for a ballooned page */ >> -void balloon_page_putback(struct page *page) >> +int balloon_page_putback(struct page *page) >> { >> + if (!isolated_balloon_page(page)) >> + return 0; >> + >> /* >> * 'lock_page()' stabilizes the page and prevents races against >> * concurrent isolation threads attempting to re-isolate it. >> @@ -190,15 +196,20 @@ void balloon_page_putback(struct page *page) >> dump_page(page, "not movable balloon page"); >> } >> unlock_page(page); >> + return 0; >> } >> >> /* move_to_new_page() counterpart for a ballooned page */ >> -int balloon_page_migrate(struct page *newpage, >> +int balloon_page_migrate(struct address_space *mapping, >> + struct page *newpage, >> struct page *page, enum migrate_mode mode) >> { >> struct balloon_dev_info *balloon = balloon_page_device(page); >> int rc = -EAGAIN; >> >> + if (!isolated_balloon_page(page)) >> + return 0; >> + >> /* >> * Block others from accessing the 'newpage' when we get around to >> * establishing additional references. We should be the only one >> @@ -218,4 +229,55 @@ int balloon_page_migrate(struct page *newpage, >> unlock_page(newpage); >> return rc; >> } >> + >> +/* define the balloon_mapping->a_ops callback to allow balloon page migration */ >> +const struct address_space_operations balloon_aops = { >> + .migratepage = balloon_page_migrate, >> + .isolatepage = balloon_page_isolate, >> + .putbackpage = balloon_page_putback, >> +}; >> +EXPORT_SYMBOL_GPL(balloon_aops); >> + >> +struct address_space *balloon_mapping_alloc(struct balloon_dev_info *b_dev_info, >> + const struct address_space_operations *a_ops) >> +{ >> + struct address_space *mapping; >> + >> + mapping = kmalloc(sizeof(*mapping), GFP_KERNEL); >> + if (!mapping) >> + return ERR_PTR(-ENOMEM); >> + >> + /* >> + * Give a clean 'zeroed' status to all elements of this special >> + * balloon page->mapping struct address_space instance. >> + */ >> + address_space_init_once(mapping); >> + >> + /* >> + * Set mapping->flags appropriately, to allow balloon pages >> + * ->mapping identification. >> + */ >> + mapping_set_migratable(mapping); >> + mapping_set_gfp_mask(mapping, balloon_mapping_gfp_mask()); >> + >> + /* balloon's page->mapping->a_ops callback descriptor */ >> + mapping->a_ops = a_ops; >> + >> + /* >> + * Establish a pointer reference back to the balloon device descriptor >> + * this particular page->mapping will be servicing. >> + * This is used by compaction / migration procedures to identify and >> + * access the balloon device pageset while isolating / migrating pages. >> + * >> + * As some balloon drivers can register multiple balloon devices >> + * for a single guest, this also helps compaction / migration to >> + * properly deal with multiple balloon pagesets, when required. >> + */ >> + mapping->private_data = b_dev_info; >> + b_dev_info->mapping = mapping; >> + >> + return mapping; >> +} >> +EXPORT_SYMBOL_GPL(balloon_mapping_alloc); >> + >> #endif /* CONFIG_BALLOON_COMPACTION */ >> diff --git a/mm/compaction.c b/mm/compaction.c >> index 8c0d945..9fbcb7b 100644 >> --- a/mm/compaction.c >> +++ b/mm/compaction.c >> @@ -740,12 +740,9 @@ isolate_migratepages_block(struct compact_control *cc, unsigned long low_pfn, >> * Skip any other type of page >> */ >> if (!PageLRU(page)) { >> - if (unlikely(balloon_page_movable(page))) { >> - if (balloon_page_isolate(page)) { >> - /* Successfully isolated */ >> + if (mapping_migratable(page->mapping)) > > I see. Do you want to support this feature for only "non-LRU pages"? > Hmm, your term for functions was too generic so I got confused. > At least, it needs prefix like "special_xxx" so that we could classify > regular inode migrate and special driver migrate. OK. What about "mapping_driver_migratable"? I will change other names like mapping_set_driver_migratable/mapping_clear_driver_migratable. > > Otherwise, we could make logic more general so every address_space > want to migrate their page has all of migrate functions(ie, migrate,isolate,putback) > and we support default functions so addresss_space of regular inode will > have default functions while special driver overrides it by own functions. > With it, compact/migrate just calls registered function of each subsystem and > pass many role to them. > > I consider it as the second step. >> + if (page->mapping->a_ops->isolatepage(page)) >> goto isolate_success; >> - } >> - } >> continue; >> } >> >> diff --git a/mm/migrate.c b/mm/migrate.c >> index 85e0426..37cb366 100644 >> --- a/mm/migrate.c >> +++ b/mm/migrate.c >> @@ -71,6 +71,12 @@ int migrate_prep_local(void) >> return 0; >> } >> >> +static bool isolated_migratable_page(struct page *page) >> +{ >> + return page_mapped(page) == 0 && >> + mapping_migratable(page->mapping); >> +} > > Why does we need to check like this? > Whether isolate was successful or not depends on the driver. > We cannot expect it with only page_mapped. I assume that pages of driver without CPU mapping can be migratable. So I add checking page_mapped zero. > >> + >> /* >> * Put previously isolated pages back onto the appropriate lists >> * from where they were once taken off for compaction/migration. >> @@ -91,9 +97,9 @@ void putback_movable_pages(struct list_head *l) >> } >> list_del(&page->lru); >> dec_zone_page_state(page, NR_ISOLATED_ANON + >> - page_is_file_cache(page)); >> - if (unlikely(isolated_balloon_page(page))) >> - balloon_page_putback(page); >> + page_is_file_cache(page)); >> + if (unlikely(isolated_migratable_page(page))) >> + page->mapping->a_ops->putbackpage(page); >> else >> putback_lru_page(page); > > As I said, how about having putback_lru_page for page->mapping->a_ops->putbackpage > for regular inode? With it, we may remove some of branch in migrate/compact.c to > separate special driver and regular address_space. > Hope to enhance readability and make more flexible. I agree. I'll test this patch enough and then proceed to it. I do appreciate your feedback. > >> } >> @@ -843,15 +849,9 @@ static int __unmap_and_move(struct page *page, struct page *newpage, >> } >> } >> >> - if (unlikely(isolated_balloon_page(page))) { >> - /* >> - * A ballooned page does not need any special attention from >> - * physical to virtual reverse mapping procedures. >> - * Skip any attempt to unmap PTEs or to remap swap cache, >> - * in order to avoid burning cycles at rmap level, and perform >> - * the page migration right away (proteced by page lock). >> - */ >> - rc = balloon_page_migrate(newpage, page, mode); >> + if (unlikely(isolated_migratable_page(page))) { >> + rc = page->mapping->a_ops->migratepage(page->mapping, >> + newpage, page, mode); >> goto out_unlock; >> } >> >> -- >> 1.7.9.5 >> > -- 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 S1752987AbbDMBjs (ORCPT ); Sun, 12 Apr 2015 21:39:48 -0400 Received: from lgeamrelo04.lge.com ([156.147.1.127]:51573 "EHLO lgeamrelo04.lge.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752805AbbDMBjn (ORCPT ); Sun, 12 Apr 2015 21:39:43 -0400 X-Original-SENDERIP: 10.178.37.108 X-Original-MAILFROM: gioh.kim@lge.com Message-ID: <552B1E5C.3030501@lge.com> Date: Mon, 13 Apr 2015 10:39:40 +0900 From: Gioh Kim User-Agent: Mozilla/5.0 (Windows NT 6.1; rv:31.0) Gecko/20100101 Thunderbird/31.6.0 MIME-Version: 1.0 To: Minchan Kim CC: rusty@rustcorp.com.au, mst@redhat.com, mgorman@suse.de, jlayton@poochiereds.net, bfields@fieldses.org, akpm@linux-foundation.org, koct9i@gmail.com, iamjoonsoo.kim@lge.com, virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-mm@kvack.org Subject: Re: [PATCH] add generic callbacks into compaction References: <1427843490-27084-1-git-send-email-gioh.kim@lge.com> <20150407005344.GA27788@blaptop> In-Reply-To: <20150407005344.GA27788@blaptop> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 2015-04-07 오전 9:59에 Minchan Kim 이(가) 쓴 글: > Hello Gioh, > > I wanted to have such feature for zsmalloc. > Thanks for the work. > > On Wed, Apr 01, 2015 at 08:11:30AM +0900, Gioh Kim wrote: >> I sent a patch about page allocation for less fragmentation. >> http://permalink.gmane.org/gmane.linux.kernel.mm/130599 >> >> It proposes a page allocator allocates pages in the same pageblock >> for the drivers to move their unmovable pages. Some drivers which comsumes many pages >> and increases system fragmentation use the allocator to move their pages to >> decrease fragmentation. >> >> I think I can try another approach. >> There is a compaction code for balloon pages. >> But the compaction code cannot migrate pages of other drivers. >> If there is a generic migration framework applicable to any drivers, >> drivers can register their migration functions. >> And the compaction can migrate movable pages and also driver's pages. >> >> I'm not familiar with virtualization so I couldn't test this patch yet. >> But if mm developers agree with this approach, I will complete this patch. >> >> I would do appreciate any feedback. > > Could you separate introducing migrate core patchset and balloon patchset for > using the feature? Sure. > >> >> Signed-off-by: Gioh Kim >> --- >> drivers/virtio/virtio_balloon.c | 2 ++ >> include/linux/balloon_compaction.h | 23 +++++++++--- >> include/linux/fs.h | 3 ++ >> include/linux/pagemap.h | 26 ++++++++++++++ >> mm/balloon_compaction.c | 68 ++++++++++++++++++++++++++++++++++-- >> mm/compaction.c | 7 ++-- >> mm/migrate.c | 24 ++++++------- >> 7 files changed, 129 insertions(+), 24 deletions(-) >> >> diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c >> index 0413157..cd9b8e4 100644 >> --- a/drivers/virtio/virtio_balloon.c >> +++ b/drivers/virtio/virtio_balloon.c >> @@ -486,6 +486,8 @@ static int virtballoon_probe(struct virtio_device *vdev) >> >> balloon_devinfo_init(&vb->vb_dev_info); >> #ifdef CONFIG_BALLOON_COMPACTION >> + vb->vb_dev_info.mapping = balloon_mapping_alloc(&vb->vb_dev_info, >> + &balloon_aops); >> vb->vb_dev_info.migratepage = virtballoon_migratepage; >> #endif >> >> diff --git a/include/linux/balloon_compaction.h b/include/linux/balloon_compaction.h >> index 9b0a15d..0af32b3 100644 >> --- a/include/linux/balloon_compaction.h >> +++ b/include/linux/balloon_compaction.h >> @@ -62,6 +62,7 @@ struct balloon_dev_info { >> struct list_head pages; /* Pages enqueued & handled to Host */ >> int (*migratepage)(struct balloon_dev_info *, struct page *newpage, >> struct page *page, enum migrate_mode mode); >> + struct address_space *mapping; >> }; >> >> extern struct page *balloon_page_enqueue(struct balloon_dev_info *b_dev_info); >> @@ -76,10 +77,22 @@ static inline void balloon_devinfo_init(struct balloon_dev_info *balloon) >> } >> >> #ifdef CONFIG_BALLOON_COMPACTION >> -extern bool balloon_page_isolate(struct page *page); >> -extern void balloon_page_putback(struct page *page); >> -extern int balloon_page_migrate(struct page *newpage, >> - struct page *page, enum migrate_mode mode); >> +extern const struct address_space_operations balloon_aops; >> +extern int balloon_page_isolate(struct page *page); >> +extern int balloon_page_putback(struct page *page); >> +extern int balloon_page_migrate(struct address_space *mapping, >> + struct page *newpage, >> + struct page *page, >> + enum migrate_mode mode); >> + >> +extern struct address_space >> +*balloon_mapping_alloc(struct balloon_dev_info *b_dev_info, >> + const struct address_space_operations *a_ops); >> + >> +static inline void balloon_mapping_free(struct address_space *balloon_mapping) >> +{ >> + kfree(balloon_mapping); >> +} >> >> /* >> * __is_movable_balloon_page - helper to perform @page PageBalloon tests >> @@ -123,6 +136,7 @@ static inline bool isolated_balloon_page(struct page *page) >> static inline void balloon_page_insert(struct balloon_dev_info *balloon, >> struct page *page) >> { >> + page->mapping = balloon->mapping; >> __SetPageBalloon(page); >> SetPagePrivate(page); >> set_page_private(page, (unsigned long)balloon); >> @@ -139,6 +153,7 @@ static inline void balloon_page_insert(struct balloon_dev_info *balloon, >> */ >> static inline void balloon_page_delete(struct page *page) >> { >> + page->mapping = NULL; >> __ClearPageBalloon(page); >> set_page_private(page, 0); >> if (PagePrivate(page)) { >> diff --git a/include/linux/fs.h b/include/linux/fs.h >> index b4d71b5..de463b9 100644 >> --- a/include/linux/fs.h >> +++ b/include/linux/fs.h >> @@ -368,6 +368,9 @@ struct address_space_operations { >> */ >> int (*migratepage) (struct address_space *, >> struct page *, struct page *, enum migrate_mode); >> + int (*isolatepage)(struct page *); > > It would be useful if isolatepage is aware of migrate_mode and address_space > For exmaple, if it is MIGRATE_SYNC, driver could wait some of work to finish. >>>From address_space, driver can get private data registered when isolate/putback > happens. > > >> + int (*putbackpage)(struct page *); > > Ditto. OK. v2 will be: int (*isolatepage)(struct address_space *, struct page *, enum migrate_mode); int (*putbackpage)(struct address_space *, struct page *, enum migrate_mode); > >> + >> int (*launder_page) (struct page *); >> int (*is_partially_uptodate) (struct page *, unsigned long, >> unsigned long); >> diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h >> index 4b3736f..715b5b2 100644 >> --- a/include/linux/pagemap.h >> +++ b/include/linux/pagemap.h >> @@ -25,6 +25,7 @@ enum mapping_flags { >> AS_MM_ALL_LOCKS = __GFP_BITS_SHIFT + 2, /* under mm_take_all_locks() */ >> AS_UNEVICTABLE = __GFP_BITS_SHIFT + 3, /* e.g., ramdisk, SHM_LOCK */ >> AS_EXITING = __GFP_BITS_SHIFT + 4, /* final truncate in progress */ >> + AS_MIGRATABLE = __GFP_BITS_SHIFT + 5, >> }; >> >> static inline void mapping_set_error(struct address_space *mapping, int error) >> @@ -54,6 +55,31 @@ static inline int mapping_unevictable(struct address_space *mapping) >> return !!mapping; >> } >> >> +static inline void mapping_set_migratable(struct address_space *mapping) >> +{ >> + set_bit(AS_MIGRATABLE, &mapping->flags); >> +} > > It means every address_space which want to migrate pages mapped the address space > should call this function? Yes, it does. It is the common function to check the page migratable. > >> + >> +static inline void mapping_clear_migratable(struct address_space *mapping) >> +{ >> + clear_bit(AS_MIGRATABLE, &mapping->flags); >> +} >> + >> +static inline int __mapping_ops(struct address_space *mapping) > > The naming of __mapping_ops is awkward. How about "bool is_migratable(...)"? OK. What about __check_migrate_ops? > Another question: > Why should they support all fucntions of migrate(ie, migratepage, isolatepage, putbackpage). > I mean currently inode of regular file supports only migratepage. > By your rule, they are not migratable? I want to make a common framework to be able to support migrate/isolate/putback. If you doesn't need any of it, you can make it empty function. Is it irrational? > >> +{ >> + return mapping->a_ops && >> + mapping->a_ops->migratepage && >> + mapping->a_ops->isolatepage && >> + mapping->a_ops->putbackpage; >> +} >> + >> +static inline int mapping_migratable(struct address_space *mapping) >> +{ >> + if (mapping && __mapping_ops(mapping)) > > Why do we need mapping NULL check in here? > It's role of caller? This is some depense code to check error. > >> + return test_bit(AS_MIGRATABLE, &mapping->flags); > > It means some of address_space has migratepage, isolatepage, putbackpage but > it doesn't set AS_MIGRATABLE? Why do we need it? This also depense code. I think depense code should check every case, doesn't it? > >> + return !!mapping; >> +} >> + >> static inline void mapping_set_exiting(struct address_space *mapping) >> { >> set_bit(AS_EXITING, &mapping->flags); >> diff --git a/mm/balloon_compaction.c b/mm/balloon_compaction.c >> index fcad832..2e9d635 100644 >> --- a/mm/balloon_compaction.c >> +++ b/mm/balloon_compaction.c >> @@ -131,8 +131,11 @@ static inline void __putback_balloon_page(struct page *page) >> } >> >> /* __isolate_lru_page() counterpart for a ballooned page */ >> -bool balloon_page_isolate(struct page *page) >> +int balloon_page_isolate(struct page *page) >> { >> + if (!balloon_page_movable(page)) >> + return false; >> + >> /* >> * Avoid burning cycles with pages that are yet under __free_pages(), >> * or just got freed under us. >> @@ -173,8 +176,11 @@ bool balloon_page_isolate(struct page *page) >> } >> >> /* putback_lru_page() counterpart for a ballooned page */ >> -void balloon_page_putback(struct page *page) >> +int balloon_page_putback(struct page *page) >> { >> + if (!isolated_balloon_page(page)) >> + return 0; >> + >> /* >> * 'lock_page()' stabilizes the page and prevents races against >> * concurrent isolation threads attempting to re-isolate it. >> @@ -190,15 +196,20 @@ void balloon_page_putback(struct page *page) >> dump_page(page, "not movable balloon page"); >> } >> unlock_page(page); >> + return 0; >> } >> >> /* move_to_new_page() counterpart for a ballooned page */ >> -int balloon_page_migrate(struct page *newpage, >> +int balloon_page_migrate(struct address_space *mapping, >> + struct page *newpage, >> struct page *page, enum migrate_mode mode) >> { >> struct balloon_dev_info *balloon = balloon_page_device(page); >> int rc = -EAGAIN; >> >> + if (!isolated_balloon_page(page)) >> + return 0; >> + >> /* >> * Block others from accessing the 'newpage' when we get around to >> * establishing additional references. We should be the only one >> @@ -218,4 +229,55 @@ int balloon_page_migrate(struct page *newpage, >> unlock_page(newpage); >> return rc; >> } >> + >> +/* define the balloon_mapping->a_ops callback to allow balloon page migration */ >> +const struct address_space_operations balloon_aops = { >> + .migratepage = balloon_page_migrate, >> + .isolatepage = balloon_page_isolate, >> + .putbackpage = balloon_page_putback, >> +}; >> +EXPORT_SYMBOL_GPL(balloon_aops); >> + >> +struct address_space *balloon_mapping_alloc(struct balloon_dev_info *b_dev_info, >> + const struct address_space_operations *a_ops) >> +{ >> + struct address_space *mapping; >> + >> + mapping = kmalloc(sizeof(*mapping), GFP_KERNEL); >> + if (!mapping) >> + return ERR_PTR(-ENOMEM); >> + >> + /* >> + * Give a clean 'zeroed' status to all elements of this special >> + * balloon page->mapping struct address_space instance. >> + */ >> + address_space_init_once(mapping); >> + >> + /* >> + * Set mapping->flags appropriately, to allow balloon pages >> + * ->mapping identification. >> + */ >> + mapping_set_migratable(mapping); >> + mapping_set_gfp_mask(mapping, balloon_mapping_gfp_mask()); >> + >> + /* balloon's page->mapping->a_ops callback descriptor */ >> + mapping->a_ops = a_ops; >> + >> + /* >> + * Establish a pointer reference back to the balloon device descriptor >> + * this particular page->mapping will be servicing. >> + * This is used by compaction / migration procedures to identify and >> + * access the balloon device pageset while isolating / migrating pages. >> + * >> + * As some balloon drivers can register multiple balloon devices >> + * for a single guest, this also helps compaction / migration to >> + * properly deal with multiple balloon pagesets, when required. >> + */ >> + mapping->private_data = b_dev_info; >> + b_dev_info->mapping = mapping; >> + >> + return mapping; >> +} >> +EXPORT_SYMBOL_GPL(balloon_mapping_alloc); >> + >> #endif /* CONFIG_BALLOON_COMPACTION */ >> diff --git a/mm/compaction.c b/mm/compaction.c >> index 8c0d945..9fbcb7b 100644 >> --- a/mm/compaction.c >> +++ b/mm/compaction.c >> @@ -740,12 +740,9 @@ isolate_migratepages_block(struct compact_control *cc, unsigned long low_pfn, >> * Skip any other type of page >> */ >> if (!PageLRU(page)) { >> - if (unlikely(balloon_page_movable(page))) { >> - if (balloon_page_isolate(page)) { >> - /* Successfully isolated */ >> + if (mapping_migratable(page->mapping)) > > I see. Do you want to support this feature for only "non-LRU pages"? > Hmm, your term for functions was too generic so I got confused. > At least, it needs prefix like "special_xxx" so that we could classify > regular inode migrate and special driver migrate. OK. What about "mapping_driver_migratable"? I will change other names like mapping_set_driver_migratable/mapping_clear_driver_migratable. > > Otherwise, we could make logic more general so every address_space > want to migrate their page has all of migrate functions(ie, migrate,isolate,putback) > and we support default functions so addresss_space of regular inode will > have default functions while special driver overrides it by own functions. > With it, compact/migrate just calls registered function of each subsystem and > pass many role to them. > > I consider it as the second step. >> + if (page->mapping->a_ops->isolatepage(page)) >> goto isolate_success; >> - } >> - } >> continue; >> } >> >> diff --git a/mm/migrate.c b/mm/migrate.c >> index 85e0426..37cb366 100644 >> --- a/mm/migrate.c >> +++ b/mm/migrate.c >> @@ -71,6 +71,12 @@ int migrate_prep_local(void) >> return 0; >> } >> >> +static bool isolated_migratable_page(struct page *page) >> +{ >> + return page_mapped(page) == 0 && >> + mapping_migratable(page->mapping); >> +} > > Why does we need to check like this? > Whether isolate was successful or not depends on the driver. > We cannot expect it with only page_mapped. I assume that pages of driver without CPU mapping can be migratable. So I add checking page_mapped zero. > >> + >> /* >> * Put previously isolated pages back onto the appropriate lists >> * from where they were once taken off for compaction/migration. >> @@ -91,9 +97,9 @@ void putback_movable_pages(struct list_head *l) >> } >> list_del(&page->lru); >> dec_zone_page_state(page, NR_ISOLATED_ANON + >> - page_is_file_cache(page)); >> - if (unlikely(isolated_balloon_page(page))) >> - balloon_page_putback(page); >> + page_is_file_cache(page)); >> + if (unlikely(isolated_migratable_page(page))) >> + page->mapping->a_ops->putbackpage(page); >> else >> putback_lru_page(page); > > As I said, how about having putback_lru_page for page->mapping->a_ops->putbackpage > for regular inode? With it, we may remove some of branch in migrate/compact.c to > separate special driver and regular address_space. > Hope to enhance readability and make more flexible. I agree. I'll test this patch enough and then proceed to it. I do appreciate your feedback. > >> } >> @@ -843,15 +849,9 @@ static int __unmap_and_move(struct page *page, struct page *newpage, >> } >> } >> >> - if (unlikely(isolated_balloon_page(page))) { >> - /* >> - * A ballooned page does not need any special attention from >> - * physical to virtual reverse mapping procedures. >> - * Skip any attempt to unmap PTEs or to remap swap cache, >> - * in order to avoid burning cycles at rmap level, and perform >> - * the page migration right away (proteced by page lock). >> - */ >> - rc = balloon_page_migrate(newpage, page, mode); >> + if (unlikely(isolated_migratable_page(page))) { >> + rc = page->mapping->a_ops->migratepage(page->mapping, >> + newpage, page, mode); >> goto out_unlock; >> } >> >> -- >> 1.7.9.5 >> >