From mboxrd@z Thu Jan 1 00:00:00 1970 From: Michal Hocko Subject: Re: [RFC PATCH] mm, oom: distinguish blockable mode for mmu notifiers Date: Wed, 27 Jun 2018 09:44:21 +0200 Message-ID: <20180627074421.GF32348@dhcp22.suse.cz> References: <20180622150242.16558-1-mhocko@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20180622150242.16558-1-mhocko-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: amd-gfx-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "amd-gfx" To: LKML Cc: kvm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Radim =?utf-8?B?S3LEjW3DocWZ?= , David Airlie , Joonas Lahtinen , Sudeep Dutt , dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-mm-Bw31MaZKKs3YtjvyW6yDsg@public.gmane.org, Felix Kuehling , Andrea Arcangeli , "David (ChunMing) Zhou" , Dimitri Sivanich , linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, amd-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Jason Gunthorpe , Doug Ledford , David Rientjes , xen-devel-GuqFBffKawtpuQazS67q72D2FQJk+8+b@public.gmane.org, intel-gfx-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Jani Nikula , =?iso-8859-1?B?Suly9G1l?= Glisse , Rodrigo Vivi , Boris Ostrovsky , Juergen Gross Mike Marciniszyn List-Id: linux-rdma@vger.kernel.org VGhpcyBpcyB0aGUgdjIgb2YgUkZDIGJhc2VkIG9uIHRoZSBmZWVkYmFjayBJJ3ZlIHJlY2VpdmVk IHNvIGZhci4gVGhlCmNvZGUgZXZlbiBjb21waWxlcyBhcyBhIGJvbnVzIDspIEkgaGF2ZW4ndCBy dW50aW1lIHRlc3RlZCBpdCB5ZXQsIG1vc3RseQpiZWNhdXNlIEkgaGF2ZSBubyBpZGVhIGhvdy4K CkFueSBmdXJ0aGVyIGZlZWRiYWNrIGlzIGhpZ2hseSBhcHByZWNpYXRlZCBvZiBjb3Vyc2UuCi0t LQpGcm9tIGVjOWE3MjQxYmY0MjJiOTA4NTMyYzRjMzM5NTNiMGRhMjY1NWFkMDUgTW9uIFNlcCAx NyAwMDowMDowMCAyMDAxCkZyb206IE1pY2hhbCBIb2NrbyA8bWhvY2tvQHN1c2UuY29tPgpEYXRl OiBXZWQsIDIwIEp1biAyMDE4IDE1OjAzOjIwICswMjAwClN1YmplY3Q6IFtQQVRDSF0gbW0sIG9v bTogZGlzdGluZ3Vpc2ggYmxvY2thYmxlIG1vZGUgZm9yIG1tdSBub3RpZmllcnMKTUlNRS1WZXJz aW9uOiAxLjAKQ29udGVudC1UeXBlOiB0ZXh0L3BsYWluOyBjaGFyc2V0PVVURi04CkNvbnRlbnQt VHJhbnNmZXItRW5jb2Rpbmc6IDhiaXQKClRoZXJlIGFyZSBzZXZlcmFsIGJsb2NrYWJsZSBtbXUg bm90aWZpZXJzIHdoaWNoIG1pZ2h0IHNsZWVwIGluCm1tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0IGFuZCB0aGF0IGlzIGEgcHJvYmxlbSBmb3IgdGhlCm9vbV9yZWFwZXIgYmVjYXVz ZSBpdCBuZWVkcyB0byBndWFyYW50ZWUgYSBmb3J3YXJkIHByb2dyZXNzIHNvIGl0IGNhbm5vdApk ZXBlbmQgb24gYW55IHNsZWVwYWJsZSBsb2Nrcy4KCkN1cnJlbnRseSB3ZSBzaW1wbHkgYmFjayBv ZmYgYW5kIG1hcmsgYW4gb29tIHZpY3RpbSB3aXRoIGJsb2NrYWJsZSBtbXUKbm90aWZpZXJzIGFz IGRvbmUgYWZ0ZXIgYSBzaG9ydCBzbGVlcC4gVGhhdCBjYW4gcmVzdWx0IGluIHNlbGVjdGluZyBh Cm5ldyBvb20gdmljdGltIHByZW1hdHVyZWx5IGJlY2F1c2UgdGhlIHByZXZpb3VzIG9uZSBzdGls bCBoYXNuJ3QgdG9ybgppdHMgbWVtb3J5IGRvd24geWV0LgoKV2UgY2FuIGRvIG11Y2ggYmV0dGVy IHRob3VnaC4gRXZlbiBpZiBtbXUgbm90aWZpZXJzIHVzZSBzbGVlcGFibGUgbG9ja3MKdGhlcmUg aXMgbm8gcmVhc29uIHRvIGF1dG9tYXRpY2FsbHkgYXNzdW1lIHRob3NlIGxvY2tzIGFyZSBoZWxk LgpNb3Jlb3ZlciBtYWpvcml0eSBvZiBub3RpZmllcnMgb25seSBjYXJlIGFib3V0IGEgcG9ydGlv biBvZiB0aGUgYWRkcmVzcwpzcGFjZSBhbmQgdGhlcmUgaXMgYWJzb2x1dGVseSB6ZXJvIHJlYXNv biB0byBmYWlsIHdoZW4gd2UgYXJlIHVubWFwcGluZyBhbgp1bnJlbGF0ZWQgcmFuZ2UuIE1hbnkg bm90aWZpZXJzIGRvIHJlYWxseSBibG9jayBhbmQgd2FpdCBmb3IgSFcgd2hpY2ggaXMKaGFyZGVy IHRvIGhhbmRsZSBhbmQgd2UgaGF2ZSB0byBiYWlsIG91dCB0aG91Z2guCgpUaGlzIHBhdGNoIGhh bmRsZXMgdGhlIGxvdyBoYW5naW5nIGZydWlkLiBfX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0CmdldHMgYSBibG9ja2FibGUgZmxhZyBhbmQgY2FsbGJhY2tzIGFyZSBub3QgYWxs b3dlZCB0byBzbGVlcCBpZiB0aGUKZmxhZyBpcyBzZXQgdG8gZmFsc2UuIFRoaXMgaXMgYWNoaWV2 ZWQgYnkgdXNpbmcgdHJ5bG9jayBpbnN0ZWFkIG9mIHRoZQpzbGVlcGFibGUgbG9jayBmb3IgbW9z dCBjYWxsYmFja3MgYW5kIGNvbnRpbnVlIGFzIGxvbmcgYXMgd2UgZG8gbm90CmJsb2NrIGRvd24g dGhlIGNhbGwgY2hhaW4uCgpJIHRoaW5rIHdlIGNhbiBpbXByb3ZlIHRoYXQgZXZlbiBmdXJ0aGVy IGJlY2F1c2UgdGhlcmUgaXMgYSBjb21tb24KcGF0dGVybiB0byBkbyBhIHJhbmdlIGxvb2t1cCBm aXJzdCBhbmQgdGhlbiBkbyBzb21ldGhpbmcgYWJvdXQgdGhhdC4KVGhlIGZpcnN0IHBhcnQgY2Fu IGJlIGRvbmUgd2l0aG91dCBhIHNsZWVwaW5nIGxvY2sgaW4gbW9zdCBjYXNlcyBBRkFJQ1MuCgpU aGUgb29tX3JlYXBlciBlbmQgdGhlbiBzaW1wbHkgcmV0cmllcyBpZiB0aGVyZSBpcyBhdCBsZWFz dCBvbmUgbm90aWZpZXIKd2hpY2ggY291bGRuJ3QgbWFrZSBhbnkgcHJvZ3Jlc3MgaW4gIWJsb2Nr YWJsZSBtb2RlLiBBIHJldHJ5IGxvb3AgaXMKYWxyZWFkeSBpbXBsZW1lbnRlZCB0byB3YWl0IGZv ciB0aGUgbW1hcF9zZW0gYW5kIHRoaXMgaXMgYmFzaWNhbGx5IHRoZQpzYW1lIHRoaW5nLgoKQ2hh bmdlcyBzaW5jZSByZmMgdjEKLSBncHUgbm90aWZpZXJzIGNhbiBzbGVlcCB3aGlsZSB3YWl0aW5n IGZvciBIVyAoZXZpY3RfcHJvY2Vzc19xdWV1ZXNfY3BzY2gKICBvbiBhIGxvY2sgYW5kIGFtZGdw dV9tbl9pbnZhbGlkYXRlX25vZGUgb24gdW5ib3VuZCB0aW1lb3V0KSBtYWtlIHN1cmUKICB3ZSBi YWlsIG91dCB3aGVuIHdlIGhhdmUgYW4gaW50ZXJzZWN0aW5nIHJhbmdlIGZvciBzdGFydGVyCi0g bm90ZSB0aGF0IGEgbm90aWZpZXIgZmFpbGVkIHRvIHRoZSBsb2cgZm9yIGVhc2llciBkZWJ1Z2dp bmcKLSBiYWNrIG9mZiBlYXJseSBpbiBpYl91bWVtX25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vf c3RhcnQgaWYgdGhlCiAgY2FsbGJhY2sgaXMgY2FsbGVkCi0gbW5faW52bF9yYW5nZV9zdGFydCB3 YWl0cyBmb3IgY29tcGxldGlvbiBkb3duIHRoZSB1bm1hcF9ncmFudF9wYWdlcwogIHBhdGggc28g d2UgaGF2ZSB0byBiYWNrIG9mZiBlYXJseSBvbiBvdmVybGFwcGluZyByYW5nZXMKCkNjOiAiRGF2 aWQgKENodW5NaW5nKSBaaG91IiA8RGF2aWQxLlpob3VAYW1kLmNvbT4KQ2M6IFBhb2xvIEJvbnpp bmkgPHBib256aW5pQHJlZGhhdC5jb20+CkNjOiAiUmFkaW0gS3LEjW3DocWZIiA8cmtyY21hckBy ZWRoYXQuY29tPgpDYzogQWxleCBEZXVjaGVyIDxhbGV4YW5kZXIuZGV1Y2hlckBhbWQuY29tPgpD YzogIkNocmlzdGlhbiBLw7ZuaWciIDxjaHJpc3RpYW4ua29lbmlnQGFtZC5jb20+CkNjOiBEYXZp ZCBBaXJsaWUgPGFpcmxpZWRAbGludXguaWU+CkNjOiBKYW5pIE5pa3VsYSA8amFuaS5uaWt1bGFA bGludXguaW50ZWwuY29tPgpDYzogSm9vbmFzIExhaHRpbmVuIDxqb29uYXMubGFodGluZW5AbGlu dXguaW50ZWwuY29tPgpDYzogUm9kcmlnbyBWaXZpIDxyb2RyaWdvLnZpdmlAaW50ZWwuY29tPgpD YzogRG91ZyBMZWRmb3JkIDxkbGVkZm9yZEByZWRoYXQuY29tPgpDYzogSmFzb24gR3VudGhvcnBl IDxqZ2dAemllcGUuY2E+CkNjOiBNaWtlIE1hcmNpbmlzenluIDxtaWtlLm1hcmNpbmlzenluQGlu dGVsLmNvbT4KQ2M6IERlbm5pcyBEYWxlc3NhbmRybyA8ZGVubmlzLmRhbGVzc2FuZHJvQGludGVs LmNvbT4KQ2M6IFN1ZGVlcCBEdXR0IDxzdWRlZXAuZHV0dEBpbnRlbC5jb20+CkNjOiBBc2h1dG9z aCBEaXhpdCA8YXNodXRvc2guZGl4aXRAaW50ZWwuY29tPgpDYzogRGltaXRyaSBTaXZhbmljaCA8 c2l2YW5pY2hAc2dpLmNvbT4KQ2M6IEJvcmlzIE9zdHJvdnNreSA8Ym9yaXMub3N0cm92c2t5QG9y YWNsZS5jb20+CkNjOiBKdWVyZ2VuIEdyb3NzIDxqZ3Jvc3NAc3VzZS5jb20+CkNjOiAiSsOpcsO0 bWUgR2xpc3NlIiA8amdsaXNzZUByZWRoYXQuY29tPgpDYzogQW5kcmVhIEFyY2FuZ2VsaSA8YWFy Y2FuZ2VAcmVkaGF0LmNvbT4KQ2M6IEZlbGl4IEt1ZWhsaW5nIDxmZWxpeC5rdWVobGluZ0BhbWQu Y29tPgpDYzoga3ZtQHZnZXIua2VybmVsLm9yZyAob3BlbiBsaXN0OktFUk5FTCBWSVJUVUFMIE1B Q0hJTkUgRk9SIFg4NiAoS1ZNL3g4NikpCkNjOiBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3Jn IChvcGVuIGxpc3Q6WDg2IEFSQ0hJVEVDVFVSRSAoMzItQklUIEFORCA2NC1CSVQpKQpDYzogYW1k LWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcgKG9wZW4gbGlzdDpSQURFT04gYW5kIEFNREdQVSBE Uk0gRFJJVkVSUykKQ2M6IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcgKG9wZW4gbGlz dDpEUk0gRFJJVkVSUykKQ2M6IGludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcgKG9wZW4g bGlzdDpJTlRFTCBEUk0gRFJJVkVSUyAoZXhjbHVkaW5nIFBvdWxzYm8sIE1vb3Jlc3Rvdy4uLikK Q2M6IGxpbnV4LXJkbWFAdmdlci5rZXJuZWwub3JnIChvcGVuIGxpc3Q6SU5GSU5JQkFORCBTVUJT WVNURU0pCkNjOiB4ZW4tZGV2ZWxAbGlzdHMueGVucHJvamVjdC5vcmcgKG1vZGVyYXRlZCBsaXN0 OlhFTiBIWVBFUlZJU09SIElOVEVSRkFDRSkKQ2M6IGxpbnV4LW1tQGt2YWNrLm9yZyAob3BlbiBs aXN0OkhNTSAtIEhldGVyb2dlbmVvdXMgTWVtb3J5IE1hbmFnZW1lbnQpClJlcG9ydGVkLWJ5OiBE YXZpZCBSaWVudGplcyA8cmllbnRqZXNAZ29vZ2xlLmNvbT4KU2lnbmVkLW9mZi1ieTogTWljaGFs IEhvY2tvIDxtaG9ja29Ac3VzZS5jb20+Ci0tLQogYXJjaC94ODYva3ZtL3g4Ni5jICAgICAgICAg ICAgICAgICAgICAgIHwgIDcgKystLQogZHJpdmVycy9ncHUvZHJtL2FtZC9hbWRncHUvYW1kZ3B1 X21uLmMgIHwgNDMgKysrKysrKysrKysrKysrKysrKy0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X2dlbV91c2VycHRyLmMgfCAxMyArKysrKystLQogZHJpdmVycy9ncHUvZHJtL3JhZGVv bi9yYWRlb25fbW4uYyAgICAgIHwgMjIgKysrKysrKysrKystLQogZHJpdmVycy9pbmZpbmliYW5k L2NvcmUvdW1lbV9vZHAuYyAgICAgIHwgMzMgKysrKysrKysrKysrKysrLS0tLQogZHJpdmVycy9p bmZpbmliYW5kL2h3L2hmaTEvbW11X3JiLmMgICAgIHwgMTEgKysrKy0tLQogZHJpdmVycy9pbmZp bmliYW5kL2h3L21seDUvb2RwLmMgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMvbWlzYy9taWMvc2Np Zi9zY2lmX2RtYS5jICAgICAgICB8ICA3ICsrLS0KIGRyaXZlcnMvbWlzYy9zZ2ktZ3J1L2dydXRs YnB1cmdlLmMgICAgICB8ICA3ICsrLS0KIGRyaXZlcnMveGVuL2dudGRldi5jICAgICAgICAgICAg ICAgICAgICB8IDQ0ICsrKysrKysrKysrKysrKysrKysrLS0tLS0KIGluY2x1ZGUvbGludXgva3Zt X2hvc3QuaCAgICAgICAgICAgICAgICB8ICA0ICstLQogaW5jbHVkZS9saW51eC9tbXVfbm90aWZp ZXIuaCAgICAgICAgICAgIHwgMzUgKysrKysrKysrKysrKysrLS0tLS0KIGluY2x1ZGUvbGludXgv b29tLmggICAgICAgICAgICAgICAgICAgICB8ICAyICstCiBpbmNsdWRlL3JkbWEvaWJfdW1lbV9v ZHAuaCAgICAgICAgICAgICAgfCAgMyArLQogbW0vaG1tLmMgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgIDcgKystLQogbW0vbW1hcC5jICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgIDIgKy0KIG1tL21tdV9ub3RpZmllci5jICAgICAgICAgICAgICAgICAgICAgICB8IDE5 ICsrKysrKysrLS0tCiBtbS9vb21fa2lsbC5jICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAy OSArKysrKysrKy0tLS0tLS0tCiB2aXJ0L2t2bS9rdm1fbWFpbi5jICAgICAgICAgICAgICAgICAg ICAgfCAxNSArKysrKystLS0KIDE5IGZpbGVzIGNoYW5nZWQsIDIyNSBpbnNlcnRpb25zKCspLCA4 MCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rdm0veDg2LmMgYi9hcmNoL3g4 Ni9rdm0veDg2LmMKaW5kZXggNmJjZWNjMzI1ZTdlLi5hYzA4ZjVkNzExYmUgMTAwNjQ0Ci0tLSBh L2FyY2gveDg2L2t2bS94ODYuYworKysgYi9hcmNoL3g4Ni9rdm0veDg2LmMKQEAgLTcyMDMsOCAr NzIwMyw5IEBAIHN0YXRpYyB2b2lkIHZjcHVfbG9hZF9lb2lfZXhpdG1hcChzdHJ1Y3Qga3ZtX3Zj cHUgKnZjcHUpCiAJa3ZtX3g4Nl9vcHMtPmxvYWRfZW9pX2V4aXRtYXAodmNwdSwgZW9pX2V4aXRf Yml0bWFwKTsKIH0KIAotdm9pZCBrdm1fYXJjaF9tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5n ZShzdHJ1Y3Qga3ZtICprdm0sCi0JCXVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcg ZW5kKQoraW50IGt2bV9hcmNoX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlKHN0cnVjdCBr dm0gKmt2bSwKKwkJdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQsCisJCWJv b2wgYmxvY2thYmxlKQogewogCXVuc2lnbmVkIGxvbmcgYXBpY19hZGRyZXNzOwogCkBAIC03MjE1 LDYgKzcyMTYsOCBAQCB2b2lkIGt2bV9hcmNoX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jhbmdl KHN0cnVjdCBrdm0gKmt2bSwKIAlhcGljX2FkZHJlc3MgPSBnZm5fdG9faHZhKGt2bSwgQVBJQ19E RUZBVUxUX1BIWVNfQkFTRSA+PiBQQUdFX1NISUZUKTsKIAlpZiAoc3RhcnQgPD0gYXBpY19hZGRy ZXNzICYmIGFwaWNfYWRkcmVzcyA8IGVuZCkKIAkJa3ZtX21ha2VfYWxsX2NwdXNfcmVxdWVzdChr dm0sIEtWTV9SRVFfQVBJQ19QQUdFX1JFTE9BRCk7CisKKwlyZXR1cm4gMDsKIH0KIAogdm9pZCBr dm1fdmNwdV9yZWxvYWRfYXBpY19hY2Nlc3NfcGFnZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYyBiL2RyaXZl cnMvZ3B1L2RybS9hbWQvYW1kZ3B1L2FtZGdwdV9tbi5jCmluZGV4IDgzZTM0NGZiYjUwYS4uMzM5 OWE0YTkyN2ZiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVf bW4uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYW1kL2FtZGdwdS9hbWRncHVfbW4uYwpAQCAtMTM2 LDEyICsxMzYsMTggQEAgdm9pZCBhbWRncHVfbW5fdW5sb2NrKHN0cnVjdCBhbWRncHVfbW4gKm1u KQogICoKICAqIFRha2UgdGhlIHJtbiByZWFkIHNpZGUgbG9jay4KICAqLwotc3RhdGljIHZvaWQg YW1kZ3B1X21uX3JlYWRfbG9jayhzdHJ1Y3QgYW1kZ3B1X21uICpybW4pCitzdGF0aWMgaW50IGFt ZGdwdV9tbl9yZWFkX2xvY2soc3RydWN0IGFtZGdwdV9tbiAqcm1uLCBib29sIGJsb2NrYWJsZSkK IHsKLQltdXRleF9sb2NrKCZybW4tPnJlYWRfbG9jayk7CisJaWYgKGJsb2NrYWJsZSkKKwkJbXV0 ZXhfbG9jaygmcm1uLT5yZWFkX2xvY2spOworCWVsc2UgaWYgKCFtdXRleF90cnlsb2NrKCZybW4t PnJlYWRfbG9jaykpCisJCXJldHVybiAtRUFHQUlOOworCiAJaWYgKGF0b21pY19pbmNfcmV0dXJu KCZybW4tPnJlY3Vyc2lvbikgPT0gMSkKIAkJZG93bl9yZWFkX25vbl9vd25lcigmcm1uLT5sb2Nr KTsKIAltdXRleF91bmxvY2soJnJtbi0+cmVhZF9sb2NrKTsKKworCXJldHVybiAwOwogfQogCiAv KioKQEAgLTE5NywxMCArMjAzLDExIEBAIHN0YXRpYyB2b2lkIGFtZGdwdV9tbl9pbnZhbGlkYXRl X25vZGUoc3RydWN0IGFtZGdwdV9tbl9ub2RlICpub2RlLAogICogV2UgYmxvY2sgZm9yIGFsbCBC T3MgYmV0d2VlbiBzdGFydCBhbmQgZW5kIHRvIGJlIGlkbGUgYW5kCiAgKiB1bm1hcCB0aGVtIGJ5 IG1vdmUgdGhlbSBpbnRvIHN5c3RlbSBkb21haW4gYWdhaW4uCiAgKi8KLXN0YXRpYyB2b2lkIGFt ZGdwdV9tbl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0X2dmeChzdHJ1Y3QgbW11X25vdGlmaWVyICpt biwKK3N0YXRpYyBpbnQgYW1kZ3B1X21uX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRfZ2Z4KHN0cnVj dCBtbXVfbm90aWZpZXIgKm1uLAogCQkJCQkJIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLAogCQkJCQkJ IHVuc2lnbmVkIGxvbmcgc3RhcnQsCi0JCQkJCQkgdW5zaWduZWQgbG9uZyBlbmQpCisJCQkJCQkg dW5zaWduZWQgbG9uZyBlbmQsCisJCQkJCQkgYm9vbCBibG9ja2FibGUpCiB7CiAJc3RydWN0IGFt ZGdwdV9tbiAqcm1uID0gY29udGFpbmVyX29mKG1uLCBzdHJ1Y3QgYW1kZ3B1X21uLCBtbik7CiAJ c3RydWN0IGludGVydmFsX3RyZWVfbm9kZSAqaXQ7CkBAIC0yMDgsMTcgKzIxNSwyOCBAQCBzdGF0 aWMgdm9pZCBhbWRncHVfbW5faW52YWxpZGF0ZV9yYW5nZV9zdGFydF9nZngoc3RydWN0IG1tdV9u b3RpZmllciAqbW4sCiAJLyogbm90aWZpY2F0aW9uIGlzIGV4Y2x1c2l2ZSwgYnV0IGludGVydmFs IGlzIGluY2x1c2l2ZSAqLwogCWVuZCAtPSAxOwogCi0JYW1kZ3B1X21uX3JlYWRfbG9jayhybW4p OworCS8qIFRPRE8gd2Ugc2hvdWxkIGJlIGFibGUgdG8gc3BsaXQgbG9ja2luZyBmb3IgaW50ZXJ2 YWwgdHJlZSBhbmQKKwkgKiBhbWRncHVfbW5faW52YWxpZGF0ZV9ub2RlCisJICovCisJaWYgKGFt ZGdwdV9tbl9yZWFkX2xvY2socm1uLCBibG9ja2FibGUpKQorCQlyZXR1cm4gLUVBR0FJTjsKIAog CWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KCZybW4tPm9iamVjdHMsIHN0YXJ0LCBlbmQp OwogCXdoaWxlIChpdCkgewogCQlzdHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGU7CiAKKwkJaWYg KCFibG9ja2FibGUpIHsKKwkJCWFtZGdwdV9tbl9yZWFkX3VubG9jayhybW4pOworCQkJcmV0dXJu IC1FQUdBSU47CisJCX0KKwogCQlub2RlID0gY29udGFpbmVyX29mKGl0LCBzdHJ1Y3QgYW1kZ3B1 X21uX25vZGUsIGl0KTsKIAkJaXQgPSBpbnRlcnZhbF90cmVlX2l0ZXJfbmV4dChpdCwgc3RhcnQs IGVuZCk7CiAKIAkJYW1kZ3B1X21uX2ludmFsaWRhdGVfbm9kZShub2RlLCBzdGFydCwgZW5kKTsK IAl9CisKKwlyZXR1cm4gMDsKIH0KIAogLyoqCkBAIC0yMzMsMTAgKzI1MSwxMSBAQCBzdGF0aWMg dm9pZCBhbWRncHVfbW5faW52YWxpZGF0ZV9yYW5nZV9zdGFydF9nZngoc3RydWN0IG1tdV9ub3Rp ZmllciAqbW4sCiAgKiBuZWNlc3NpdGF0ZXMgZXZpY3RpbmcgYWxsIHVzZXItbW9kZSBxdWV1ZXMg b2YgdGhlIHByb2Nlc3MuIFRoZSBCT3MKICAqIGFyZSByZXN0b3J0ZWQgaW4gYW1kZ3B1X21uX2lu dmFsaWRhdGVfcmFuZ2VfZW5kX2hzYS4KICAqLwotc3RhdGljIHZvaWQgYW1kZ3B1X21uX2ludmFs aWRhdGVfcmFuZ2Vfc3RhcnRfaHNhKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAorc3RhdGljIGlu dCBhbWRncHVfbW5faW52YWxpZGF0ZV9yYW5nZV9zdGFydF9oc2Eoc3RydWN0IG1tdV9ub3RpZmll ciAqbW4sCiAJCQkJCQkgc3RydWN0IG1tX3N0cnVjdCAqbW0sCiAJCQkJCQkgdW5zaWduZWQgbG9u ZyBzdGFydCwKLQkJCQkJCSB1bnNpZ25lZCBsb25nIGVuZCkKKwkJCQkJCSB1bnNpZ25lZCBsb25n IGVuZCwKKwkJCQkJCSBib29sIGJsb2NrYWJsZSkKIHsKIAlzdHJ1Y3QgYW1kZ3B1X21uICpybW4g PSBjb250YWluZXJfb2YobW4sIHN0cnVjdCBhbWRncHVfbW4sIG1uKTsKIAlzdHJ1Y3QgaW50ZXJ2 YWxfdHJlZV9ub2RlICppdDsKQEAgLTI0NCwxMyArMjYzLDE5IEBAIHN0YXRpYyB2b2lkIGFtZGdw dV9tbl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0X2hzYShzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwK IAkvKiBub3RpZmljYXRpb24gaXMgZXhjbHVzaXZlLCBidXQgaW50ZXJ2YWwgaXMgaW5jbHVzaXZl ICovCiAJZW5kIC09IDE7CiAKLQlhbWRncHVfbW5fcmVhZF9sb2NrKHJtbik7CisJaWYgKGFtZGdw dV9tbl9yZWFkX2xvY2socm1uLCBibG9ja2FibGUpKQorCQlyZXR1cm4gLUVBR0FJTjsKIAogCWl0 ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KCZybW4tPm9iamVjdHMsIHN0YXJ0LCBlbmQpOwog CXdoaWxlIChpdCkgewogCQlzdHJ1Y3QgYW1kZ3B1X21uX25vZGUgKm5vZGU7CiAJCXN0cnVjdCBh bWRncHVfYm8gKmJvOwogCisJCWlmICghYmxvY2thYmxlKSB7CisJCQlhbWRncHVfbW5fcmVhZF91 bmxvY2socm1uKTsKKwkJCXJldHVybiAtRUFHQUlOOworCQl9CisKIAkJbm9kZSA9IGNvbnRhaW5l cl9vZihpdCwgc3RydWN0IGFtZGdwdV9tbl9ub2RlLCBpdCk7CiAJCWl0ID0gaW50ZXJ2YWxfdHJl ZV9pdGVyX25leHQoaXQsIHN0YXJ0LCBlbmQpOwogCkBAIC0yNjIsNiArMjg3LDggQEAgc3RhdGlj IHZvaWQgYW1kZ3B1X21uX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRfaHNhKHN0cnVjdCBtbXVfbm90 aWZpZXIgKm1uLAogCQkJCWFtZGdwdV9hbWRrZmRfZXZpY3RfdXNlcnB0cihtZW0sIG1tKTsKIAkJ fQogCX0KKworCXJldHVybiAwOwogfQogCiAvKioKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfZ2VtX3VzZXJwdHIuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2Vt X3VzZXJwdHIuYwppbmRleCA4NTRiZDUxYjk0NzguLjljYmZmNjhmNmI0MSAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW1fdXNlcnB0ci5jCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfZ2VtX3VzZXJwdHIuYwpAQCAtMTEyLDEwICsxMTIsMTEgQEAgc3RhdGlj IHZvaWQgZGVsX29iamVjdChzdHJ1Y3QgaTkxNV9tbXVfb2JqZWN0ICptbykKIAltby0+YXR0YWNo ZWQgPSBmYWxzZTsKIH0KIAotc3RhdGljIHZvaWQgaTkxNV9nZW1fdXNlcnB0cl9tbl9pbnZhbGlk YXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXIgKl9tbiwKK3N0YXRpYyBpbnQgaTkx NV9nZW1fdXNlcnB0cl9tbl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZp ZXIgKl9tbiwKIAkJCQkJCSAgICAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSwKIAkJCQkJCSAgICAg ICB1bnNpZ25lZCBsb25nIHN0YXJ0LAotCQkJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgZW5kKQor CQkJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgZW5kLAorCQkJCQkJICAgICAgIGJvb2wgYmxvY2th YmxlKQogewogCXN0cnVjdCBpOTE1X21tdV9ub3RpZmllciAqbW4gPQogCQljb250YWluZXJfb2Yo X21uLCBzdHJ1Y3QgaTkxNV9tbXVfbm90aWZpZXIsIG1uKTsKQEAgLTEyNCw3ICsxMjUsNyBAQCBz dGF0aWMgdm9pZCBpOTE1X2dlbV91c2VycHRyX21uX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3Ry dWN0IG1tdV9ub3RpZmllciAqX21uLAogCUxJU1RfSEVBRChjYW5jZWxsZWQpOwogCiAJaWYgKFJC X0VNUFRZX1JPT1QoJm1uLT5vYmplY3RzLnJiX3Jvb3QpKQotCQlyZXR1cm47CisJCXJldHVybiAw OwogCiAJLyogaW50ZXJ2YWwgcmFuZ2VzIGFyZSBpbmNsdXNpdmUsIGJ1dCBpbnZhbGlkYXRlIHJh bmdlIGlzIGV4Y2x1c2l2ZSAqLwogCWVuZC0tOwpAQCAtMTMyLDYgKzEzMywxMCBAQCBzdGF0aWMg dm9pZCBpOTE1X2dlbV91c2VycHRyX21uX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1t dV9ub3RpZmllciAqX21uLAogCXNwaW5fbG9jaygmbW4tPmxvY2spOwogCWl0ID0gaW50ZXJ2YWxf dHJlZV9pdGVyX2ZpcnN0KCZtbi0+b2JqZWN0cywgc3RhcnQsIGVuZCk7CiAJd2hpbGUgKGl0KSB7 CisJCWlmICghYmxvY2thYmxlKSB7CisJCQlzcGluX3VubG9jaygmbW4tPmxvY2spOworCQkJcmV0 dXJuIC1FQUdBSU47CisJCX0KIAkJLyogVGhlIG1tdV9vYmplY3QgaXMgcmVsZWFzZWQgbGF0ZSB3 aGVuIGRlc3Ryb3lpbmcgdGhlCiAJCSAqIEdFTSBvYmplY3Qgc28gaXQgaXMgZW50aXJlbHkgcG9z c2libGUgdG8gZ2FpbiBhCiAJCSAqIHJlZmVyZW5jZSBvbiBhbiBvYmplY3QgaW4gdGhlIHByb2Nl c3Mgb2YgYmVpbmcgZnJlZWQKQEAgLTE1NCw2ICsxNTksOCBAQCBzdGF0aWMgdm9pZCBpOTE1X2dl bV91c2VycHRyX21uX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAq X21uLAogCiAJaWYgKCFsaXN0X2VtcHR5KCZjYW5jZWxsZWQpKQogCQlmbHVzaF93b3JrcXVldWUo bW4tPndxKTsKKworCXJldHVybiAwOwogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IG1tdV9ub3Rp Zmllcl9vcHMgaTkxNV9nZW1fdXNlcnB0cl9ub3RpZmllciA9IHsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9yYWRlb24vcmFkZW9uX21uLmMgYi9kcml2ZXJzL2dwdS9kcm0vcmFkZW9uL3Jh ZGVvbl9tbi5jCmluZGV4IGFiZDI0OTc1YzliMS4uZjhiMzVkZjQ0YzYwIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vcmFkZW9uL3JhZGVvbl9tbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9y YWRlb24vcmFkZW9uX21uLmMKQEAgLTExOCwxOSArMTE4LDI3IEBAIHN0YXRpYyB2b2lkIHJhZGVv bl9tbl9yZWxlYXNlKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAogICogV2UgYmxvY2sgZm9yIGFs bCBCT3MgYmV0d2VlbiBzdGFydCBhbmQgZW5kIHRvIGJlIGlkbGUgYW5kCiAgKiB1bm1hcCB0aGVt IGJ5IG1vdmUgdGhlbSBpbnRvIHN5c3RlbSBkb21haW4gYWdhaW4uCiAgKi8KLXN0YXRpYyB2b2lk IHJhZGVvbl9tbl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXIgKm1u LAorc3RhdGljIGludCByYWRlb25fbW5faW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW11 X25vdGlmaWVyICptbiwKIAkJCQkJICAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSwKIAkJCQkJICAg ICB1bnNpZ25lZCBsb25nIHN0YXJ0LAotCQkJCQkgICAgIHVuc2lnbmVkIGxvbmcgZW5kKQorCQkJ CQkgICAgIHVuc2lnbmVkIGxvbmcgZW5kLAorCQkJCQkgICAgIGJvb2wgYmxvY2thYmxlKQogewog CXN0cnVjdCByYWRlb25fbW4gKnJtbiA9IGNvbnRhaW5lcl9vZihtbiwgc3RydWN0IHJhZGVvbl9t biwgbW4pOwogCXN0cnVjdCB0dG1fb3BlcmF0aW9uX2N0eCBjdHggPSB7IGZhbHNlLCBmYWxzZSB9 OwogCXN0cnVjdCBpbnRlcnZhbF90cmVlX25vZGUgKml0OworCWludCByZXQgPSAwOwogCiAJLyog bm90aWZpY2F0aW9uIGlzIGV4Y2x1c2l2ZSwgYnV0IGludGVydmFsIGlzIGluY2x1c2l2ZSAqLwog CWVuZCAtPSAxOwogCi0JbXV0ZXhfbG9jaygmcm1uLT5sb2NrKTsKKwkvKiBUT0RPIHdlIHNob3Vs ZCBiZSBhYmxlIHRvIHNwbGl0IGxvY2tpbmcgZm9yIGludGVydmFsIHRyZWUgYW5kCisJICogdGhl IHRlYXIgZG93bi4KKwkgKi8KKwlpZiAoYmxvY2thYmxlKQorCQltdXRleF9sb2NrKCZybW4tPmxv Y2spOworCWVsc2UgaWYgKCFtdXRleF90cnlsb2NrKCZybW4tPmxvY2spKQorCQlyZXR1cm4gLUVB R0FJTjsKIAogCWl0ID0gaW50ZXJ2YWxfdHJlZV9pdGVyX2ZpcnN0KCZybW4tPm9iamVjdHMsIHN0 YXJ0LCBlbmQpOwogCXdoaWxlIChpdCkgewpAQCAtMTM4LDYgKzE0NiwxMSBAQCBzdGF0aWMgdm9p ZCByYWRlb25fbW5faW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW11X25vdGlmaWVyICpt biwKIAkJc3RydWN0IHJhZGVvbl9ibyAqYm87CiAJCWxvbmcgcjsKIAorCQlpZiAoIWJsb2NrYWJs ZSkgeworCQkJcmV0ID0gLUVBR0FJTjsKKwkJCWdvdG8gb3V0X3VubG9jazsKKwkJfQorCiAJCW5v ZGUgPSBjb250YWluZXJfb2YoaXQsIHN0cnVjdCByYWRlb25fbW5fbm9kZSwgaXQpOwogCQlpdCA9 IGludGVydmFsX3RyZWVfaXRlcl9uZXh0KGl0LCBzdGFydCwgZW5kKTsKIApAQCAtMTY2LDcgKzE3 OSwxMCBAQCBzdGF0aWMgdm9pZCByYWRlb25fbW5faW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1 Y3QgbW11X25vdGlmaWVyICptbiwKIAkJfQogCX0KIAkKK291dF91bmxvY2s6CiAJbXV0ZXhfdW5s b2NrKCZybW4tPmxvY2spOworCisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGNvbnN0IHN0cnVj dCBtbXVfbm90aWZpZXJfb3BzIHJhZGVvbl9tbl9vcHMgPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJz L2luZmluaWJhbmQvY29yZS91bWVtX29kcC5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdW1l bV9vZHAuYwppbmRleCAxODI0MzZiOTJiYTkuLjZlYzc0OGVjY2ZmNyAxMDA2NDQKLS0tIGEvZHJp dmVycy9pbmZpbmliYW5kL2NvcmUvdW1lbV9vZHAuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQv Y29yZS91bWVtX29kcC5jCkBAIC0xODYsNiArMTg2LDcgQEAgc3RhdGljIHZvaWQgaWJfdW1lbV9u b3RpZmllcl9yZWxlYXNlKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAogCXJidF9pYl91bWVtX2Zv cl9lYWNoX2luX3JhbmdlKCZjb250ZXh0LT51bWVtX3RyZWUsIDAsCiAJCQkJICAgICAgVUxMT05H X01BWCwKIAkJCQkgICAgICBpYl91bWVtX25vdGlmaWVyX3JlbGVhc2VfdHJhbXBvbGluZSwKKwkJ CQkgICAgICB0cnVlLAogCQkJCSAgICAgIE5VTEwpOwogCXVwX3JlYWQoJmNvbnRleHQtPnVtZW1f cndzZW0pOwogfQpAQCAtMjA3LDIyICsyMDgsMzEgQEAgc3RhdGljIGludCBpbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0X3RyYW1wb2xpbmUoc3RydWN0IGliX3VtZW0gKml0ZW0sIHU2NCBzdGFydCwKIAly ZXR1cm4gMDsKIH0KIAotc3RhdGljIHZvaWQgaWJfdW1lbV9ub3RpZmllcl9pbnZhbGlkYXRlX3Jh bmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAorc3RhdGljIGludCBpYl91bWVtX25v dGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCiAJ CQkJCQkgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0sCiAJCQkJCQkgICAgdW5zaWduZWQgbG9uZyBz dGFydCwKLQkJCQkJCSAgICB1bnNpZ25lZCBsb25nIGVuZCkKKwkJCQkJCSAgICB1bnNpZ25lZCBs b25nIGVuZCwKKwkJCQkJCSAgICBib29sIGJsb2NrYWJsZSkKIHsKIAlzdHJ1Y3QgaWJfdWNvbnRl eHQgKmNvbnRleHQgPSBjb250YWluZXJfb2YobW4sIHN0cnVjdCBpYl91Y29udGV4dCwgbW4pOwor CWludCByZXQ7CiAKIAlpZiAoIWNvbnRleHQtPmludmFsaWRhdGVfcmFuZ2UpCi0JCXJldHVybjsK KwkJcmV0dXJuIDA7CisKKwlpZiAoYmxvY2thYmxlKQorCQlkb3duX3JlYWQoJmNvbnRleHQtPnVt ZW1fcndzZW0pOworCWVsc2UgaWYgKCFkb3duX3JlYWRfdHJ5bG9jaygmY29udGV4dC0+dW1lbV9y d3NlbSkpCisJCXJldHVybiAtRUFHQUlOOwogCiAJaWJfdWNvbnRleHRfbm90aWZpZXJfc3RhcnRf YWNjb3VudChjb250ZXh0KTsKLQlkb3duX3JlYWQoJmNvbnRleHQtPnVtZW1fcndzZW0pOwotCXJi dF9pYl91bWVtX2Zvcl9lYWNoX2luX3JhbmdlKCZjb250ZXh0LT51bWVtX3RyZWUsIHN0YXJ0LAor CXJldCA9IHJidF9pYl91bWVtX2Zvcl9lYWNoX2luX3JhbmdlKCZjb250ZXh0LT51bWVtX3RyZWUs IHN0YXJ0LAogCQkJCSAgICAgIGVuZCwKLQkJCQkgICAgICBpbnZhbGlkYXRlX3JhbmdlX3N0YXJ0 X3RyYW1wb2xpbmUsIE5VTEwpOworCQkJCSAgICAgIGludmFsaWRhdGVfcmFuZ2Vfc3RhcnRfdHJh bXBvbGluZSwKKwkJCQkgICAgICBibG9ja2FibGUsIE5VTEwpOwogCXVwX3JlYWQoJmNvbnRleHQt PnVtZW1fcndzZW0pOworCisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGludCBpbnZhbGlkYXRl X3JhbmdlX2VuZF90cmFtcG9saW5lKHN0cnVjdCBpYl91bWVtICppdGVtLCB1NjQgc3RhcnQsCkBA IC0yNDIsMTAgKzI1MiwxNSBAQCBzdGF0aWMgdm9pZCBpYl91bWVtX25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2VfZW5kKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAogCWlmICghY29udGV4dC0+aW52 YWxpZGF0ZV9yYW5nZSkKIAkJcmV0dXJuOwogCisJLyoKKwkgKiBUT0RPOiB3ZSBjdXJyZW50bHkg YmFpbCBvdXQgaWYgdGhlcmUgaXMgYW55IHNsZWVwYWJsZSB3b3JrIHRvIGJlIGRvbmUKKwkgKiBp biBpYl91bWVtX25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQgc28gd2Ugc2hvdWxkbid0 IHJlYWxseSBibG9jaworCSAqIGhlcmUuIEJ1dCB0aGlzIGlzIHVnbHkgYW5kIGZyYWdpbGUuCisJ ICovCiAJZG93bl9yZWFkKCZjb250ZXh0LT51bWVtX3J3c2VtKTsKIAlyYnRfaWJfdW1lbV9mb3Jf ZWFjaF9pbl9yYW5nZSgmY29udGV4dC0+dW1lbV90cmVlLCBzdGFydCwKIAkJCQkgICAgICBlbmQs Ci0JCQkJICAgICAgaW52YWxpZGF0ZV9yYW5nZV9lbmRfdHJhbXBvbGluZSwgTlVMTCk7CisJCQkJ ICAgICAgaW52YWxpZGF0ZV9yYW5nZV9lbmRfdHJhbXBvbGluZSwgdHJ1ZSwgTlVMTCk7CiAJdXBf cmVhZCgmY29udGV4dC0+dW1lbV9yd3NlbSk7CiAJaWJfdWNvbnRleHRfbm90aWZpZXJfZW5kX2Fj Y291bnQoY29udGV4dCk7CiB9CkBAIC03OTgsNiArODEzLDcgQEAgRVhQT1JUX1NZTUJPTChpYl91 bWVtX29kcF91bm1hcF9kbWFfcGFnZXMpOwogaW50IHJidF9pYl91bWVtX2Zvcl9lYWNoX2luX3Jh bmdlKHN0cnVjdCByYl9yb290X2NhY2hlZCAqcm9vdCwKIAkJCQkgIHU2NCBzdGFydCwgdTY0IGxh c3QsCiAJCQkJICB1bWVtX2NhbGxfYmFjayBjYiwKKwkJCQkgIGJvb2wgYmxvY2thYmxlLAogCQkJ CSAgdm9pZCAqY29va2llKQogewogCWludCByZXRfdmFsID0gMDsKQEAgLTgwOSw2ICs4MjUsOSBA QCBpbnQgcmJ0X2liX3VtZW1fZm9yX2VhY2hfaW5fcmFuZ2Uoc3RydWN0IHJiX3Jvb3RfY2FjaGVk ICpyb290LAogCiAJZm9yIChub2RlID0gcmJ0X2liX3VtZW1faXRlcl9maXJzdChyb290LCBzdGFy dCwgbGFzdCAtIDEpOwogCQkJbm9kZTsgbm9kZSA9IG5leHQpIHsKKwkJLyogVE9ETyBtb3ZlIHRo ZSBibG9ja2FibGUgZGVjaXNpb24gdXAgdG8gdGhlIGNhbGxiYWNrICovCisJCWlmICghYmxvY2th YmxlKQorCQkJcmV0dXJuIC1FQUdBSU47CiAJCW5leHQgPSByYnRfaWJfdW1lbV9pdGVyX25leHQo bm9kZSwgc3RhcnQsIGxhc3QgLSAxKTsKIAkJdW1lbSA9IGNvbnRhaW5lcl9vZihub2RlLCBzdHJ1 Y3QgaWJfdW1lbV9vZHAsIGludGVydmFsX3RyZWUpOwogCQlyZXRfdmFsID0gY2IodW1lbS0+dW1l bSwgc3RhcnQsIGxhc3QsIGNvb2tpZSkgfHwgcmV0X3ZhbDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv aW5maW5pYmFuZC9ody9oZmkxL21tdV9yYi5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2hmaTEv bW11X3JiLmMKaW5kZXggNzBhY2VlZmUxNGQ1Li5lMWM3OTk2YzAxOGUgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvaW5maW5pYmFuZC9ody9oZmkxL21tdV9yYi5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFu ZC9ody9oZmkxL21tdV9yYi5jCkBAIC02Nyw5ICs2Nyw5IEBAIHN0cnVjdCBtbXVfcmJfaGFuZGxl ciB7CiAKIHN0YXRpYyB1bnNpZ25lZCBsb25nIG1tdV9ub2RlX3N0YXJ0KHN0cnVjdCBtbXVfcmJf bm9kZSAqKTsKIHN0YXRpYyB1bnNpZ25lZCBsb25nIG1tdV9ub2RlX2xhc3Qoc3RydWN0IG1tdV9y Yl9ub2RlICopOwotc3RhdGljIHZvaWQgbW11X25vdGlmaWVyX3JhbmdlX3N0YXJ0KHN0cnVjdCBt bXVfbm90aWZpZXIgKiwKK3N0YXRpYyBpbnQgbW11X25vdGlmaWVyX3JhbmdlX3N0YXJ0KHN0cnVj dCBtbXVfbm90aWZpZXIgKiwKIAkJCQkgICAgIHN0cnVjdCBtbV9zdHJ1Y3QgKiwKLQkJCQkgICAg IHVuc2lnbmVkIGxvbmcsIHVuc2lnbmVkIGxvbmcpOworCQkJCSAgICAgdW5zaWduZWQgbG9uZywg dW5zaWduZWQgbG9uZywgYm9vbCk7CiBzdGF0aWMgc3RydWN0IG1tdV9yYl9ub2RlICpfX21tdV9y Yl9zZWFyY2goc3RydWN0IG1tdV9yYl9oYW5kbGVyICosCiAJCQkJCSAgIHVuc2lnbmVkIGxvbmcs IHVuc2lnbmVkIGxvbmcpOwogc3RhdGljIHZvaWQgZG9fcmVtb3ZlKHN0cnVjdCBtbXVfcmJfaGFu ZGxlciAqaGFuZGxlciwKQEAgLTI4NCwxMCArMjg0LDExIEBAIHZvaWQgaGZpMV9tbXVfcmJfcmVt b3ZlKHN0cnVjdCBtbXVfcmJfaGFuZGxlciAqaGFuZGxlciwKIAloYW5kbGVyLT5vcHMtPnJlbW92 ZShoYW5kbGVyLT5vcHNfYXJnLCBub2RlKTsKIH0KIAotc3RhdGljIHZvaWQgbW11X25vdGlmaWVy X3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAorc3RhdGljIGludCBtbXVfbm90 aWZpZXJfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCiAJCQkJICAgICBzdHJ1 Y3QgbW1fc3RydWN0ICptbSwKIAkJCQkgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsCi0JCQkJICAg ICB1bnNpZ25lZCBsb25nIGVuZCkKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgZW5kLAorCQkJCSAg ICAgYm9vbCBibG9ja2FibGUpCiB7CiAJc3RydWN0IG1tdV9yYl9oYW5kbGVyICpoYW5kbGVyID0K IAkJY29udGFpbmVyX29mKG1uLCBzdHJ1Y3QgbW11X3JiX2hhbmRsZXIsIG1uKTsKQEAgLTMxMyw2 ICszMTQsOCBAQCBzdGF0aWMgdm9pZCBtbXVfbm90aWZpZXJfcmFuZ2Vfc3RhcnQoc3RydWN0IG1t dV9ub3RpZmllciAqbW4sCiAKIAlpZiAoYWRkZWQpCiAJCXF1ZXVlX3dvcmsoaGFuZGxlci0+d3Es ICZoYW5kbGVyLT5kZWxfd29yayk7CisKKwlyZXR1cm4gMDsKIH0KIAogLyoKZGlmZiAtLWdpdCBh L2RyaXZlcnMvaW5maW5pYmFuZC9ody9tbHg1L29kcC5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3 L21seDUvb2RwLmMKaW5kZXggZjFhODdhNjkwYTRjLi5kMjE2ZTBkMjkyMWQgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvaW5maW5pYmFuZC9ody9tbHg1L29kcC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFu ZC9ody9tbHg1L29kcC5jCkBAIC00ODgsNyArNDg4LDcgQEAgdm9pZCBtbHg1X2liX2ZyZWVfaW1w bGljaXRfbXIoc3RydWN0IG1seDVfaWJfbXIgKmltcikKIAogCWRvd25fcmVhZCgmY3R4LT51bWVt X3J3c2VtKTsKIAlyYnRfaWJfdW1lbV9mb3JfZWFjaF9pbl9yYW5nZSgmY3R4LT51bWVtX3RyZWUs IDAsIFVMTE9OR19NQVgsCi0JCQkJICAgICAgbXJfbGVhZl9mcmVlLCBpbXIpOworCQkJCSAgICAg IG1yX2xlYWZfZnJlZSwgdHJ1ZSwgaW1yKTsKIAl1cF9yZWFkKCZjdHgtPnVtZW1fcndzZW0pOwog CiAJd2FpdF9ldmVudChpbXItPnFfbGVhZl9mcmVlLCAhYXRvbWljX3JlYWQoJmltci0+bnVtX2xl YWZfZnJlZSkpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9taXNjL21pYy9zY2lmL3NjaWZfZG1hLmMg Yi9kcml2ZXJzL21pc2MvbWljL3NjaWYvc2NpZl9kbWEuYwppbmRleCA2M2Q2MjQ2ZDZkZmYuLjYz NjlhZWFhNzA1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9taXNjL21pYy9zY2lmL3NjaWZfZG1hLmMK KysrIGIvZHJpdmVycy9taXNjL21pYy9zY2lmL3NjaWZfZG1hLmMKQEAgLTIwMCwxNSArMjAwLDE4 IEBAIHN0YXRpYyB2b2lkIHNjaWZfbW11X25vdGlmaWVyX3JlbGVhc2Uoc3RydWN0IG1tdV9ub3Rp ZmllciAqbW4sCiAJc2NoZWR1bGVfd29yaygmc2NpZl9pbmZvLm1pc2Nfd29yayk7CiB9CiAKLXN0 YXRpYyB2b2lkIHNjaWZfbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3RydWN0 IG1tdV9ub3RpZmllciAqbW4sCitzdGF0aWMgaW50IHNjaWZfbW11X25vdGlmaWVyX2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCiAJCQkJCQkgICAgIHN0cnVj dCBtbV9zdHJ1Y3QgKm1tLAogCQkJCQkJICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LAotCQkJCQkJ ICAgICB1bnNpZ25lZCBsb25nIGVuZCkKKwkJCQkJCSAgICAgdW5zaWduZWQgbG9uZyBlbmQsCisJ CQkJCQkgICAgIGJvb2wgYmxvY2thYmxlKQogewogCXN0cnVjdCBzY2lmX21tdV9ub3RpZgkqbW1u OwogCiAJbW1uID0gY29udGFpbmVyX29mKG1uLCBzdHJ1Y3Qgc2NpZl9tbXVfbm90aWYsIGVwX21t dV9ub3RpZmllcik7CiAJc2NpZl9ybWFfZGVzdHJveV90Y3cobW1uLCBzdGFydCwgZW5kIC0gc3Rh cnQpOworCisJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyB2b2lkIHNjaWZfbW11X25vdGlmaWVyX2lu dmFsaWRhdGVfcmFuZ2VfZW5kKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLApkaWZmIC0tZ2l0IGEv ZHJpdmVycy9taXNjL3NnaS1ncnUvZ3J1dGxicHVyZ2UuYyBiL2RyaXZlcnMvbWlzYy9zZ2ktZ3J1 L2dydXRsYnB1cmdlLmMKaW5kZXggYTM0NTRlYjU2ZmJmLi5iZTI4ZjA1YmZhZmEgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvbWlzYy9zZ2ktZ3J1L2dydXRsYnB1cmdlLmMKKysrIGIvZHJpdmVycy9taXNj L3NnaS1ncnUvZ3J1dGxicHVyZ2UuYwpAQCAtMjE5LDkgKzIxOSwxMCBAQCB2b2lkIGdydV9mbHVz aF9hbGxfdGxiKHN0cnVjdCBncnVfc3RhdGUgKmdydSkKIC8qCiAgKiBNTVVPUFMgbm90aWZpZXIg Y2FsbG91dCBmdW5jdGlvbnMKICAqLwotc3RhdGljIHZvaWQgZ3J1X2ludmFsaWRhdGVfcmFuZ2Vf c3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCitzdGF0aWMgaW50IGdydV9pbnZhbGlkYXRl X3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAogCQkJCSAgICAgICBzdHJ1Y3Qg bW1fc3RydWN0ICptbSwKLQkJCQkgICAgICAgdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQg bG9uZyBlbmQpCisJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcg ZW5kLAorCQkJCSAgICAgICBib29sIGJsb2NrYWJsZSkKIHsKIAlzdHJ1Y3QgZ3J1X21tX3N0cnVj dCAqZ21zID0gY29udGFpbmVyX29mKG1uLCBzdHJ1Y3QgZ3J1X21tX3N0cnVjdCwKIAkJCQkJCSBt c19ub3RpZmllcik7CkBAIC0yMzEsNiArMjMyLDggQEAgc3RhdGljIHZvaWQgZ3J1X2ludmFsaWRh dGVfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCiAJZ3J1X2RiZyhncnVkZXYs ICJnbXMgJXAsIHN0YXJ0IDB4JWx4LCBlbmQgMHglbHgsIGFjdCAlZFxuIiwgZ21zLAogCQlzdGFy dCwgZW5kLCBhdG9taWNfcmVhZCgmZ21zLT5tc19yYW5nZV9hY3RpdmUpKTsKIAlncnVfZmx1c2hf dGxiX3JhbmdlKGdtcywgc3RhcnQsIGVuZCAtIHN0YXJ0KTsKKworCXJldHVybiAwOwogfQogCiBz dGF0aWMgdm9pZCBncnVfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tdV9ub3RpZmllciAq bW4sCmRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9nbnRkZXYuYyBiL2RyaXZlcnMveGVuL2dudGRl di5jCmluZGV4IGJkNTY2NTNiOWJiYy4uNTViNGYwZTNmNGQ2IDEwMDY0NAotLS0gYS9kcml2ZXJz L3hlbi9nbnRkZXYuYworKysgYi9kcml2ZXJzL3hlbi9nbnRkZXYuYwpAQCAtNDQxLDE4ICs0NDEs MjUgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCB2bV9vcGVyYXRpb25zX3N0cnVjdCBnbnRkZXZfdm1v cHMgPSB7CiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogCitzdGF0aWMgYm9vbCBpbl9yYW5nZShzdHJ1Y3Qg Z3JhbnRfbWFwICptYXAsCisJCQkgICAgICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBs b25nIGVuZCkKK3sKKwlpZiAoIW1hcC0+dm1hKQorCQlyZXR1cm4gZmFsc2U7CisJaWYgKG1hcC0+ dm1hLT52bV9zdGFydCA+PSBlbmQpCisJCXJldHVybiBmYWxzZTsKKwlpZiAobWFwLT52bWEtPnZt X2VuZCA8PSBzdGFydCkKKwkJcmV0dXJuIGZhbHNlOworCisJcmV0dXJuIHRydWU7Cit9CisKIHN0 YXRpYyB2b2lkIHVubWFwX2lmX2luX3JhbmdlKHN0cnVjdCBncmFudF9tYXAgKm1hcCwKIAkJCSAg ICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kKQogewogCXVuc2lnbmVk IGxvbmcgbXN0YXJ0LCBtZW5kOwogCWludCBlcnI7CiAKLQlpZiAoIW1hcC0+dm1hKQotCQlyZXR1 cm47Ci0JaWYgKG1hcC0+dm1hLT52bV9zdGFydCA+PSBlbmQpCi0JCXJldHVybjsKLQlpZiAobWFw LT52bWEtPnZtX2VuZCA8PSBzdGFydCkKLQkJcmV0dXJuOwogCW1zdGFydCA9IG1heChzdGFydCwg bWFwLT52bWEtPnZtX3N0YXJ0KTsKIAltZW5kICAgPSBtaW4oZW5kLCAgIG1hcC0+dm1hLT52bV9l bmQpOwogCXByX2RlYnVnKCJtYXAgJWQrJWQgKCVseCAlbHgpLCByYW5nZSAlbHggJWx4LCBtcmFu Z2UgJWx4ICVseFxuIiwKQEAgLTQ2NSwyMSArNDcyLDQwIEBAIHN0YXRpYyB2b2lkIHVubWFwX2lm X2luX3JhbmdlKHN0cnVjdCBncmFudF9tYXAgKm1hcCwKIAlXQVJOX09OKGVycik7CiB9CiAKLXN0 YXRpYyB2b2lkIG1uX2ludmxfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCitz dGF0aWMgaW50IG1uX2ludmxfcmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCiAJ CQkJc3RydWN0IG1tX3N0cnVjdCAqbW0sCi0JCQkJdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWdu ZWQgbG9uZyBlbmQpCisJCQkJdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQs CisJCQkJYm9vbCBibG9ja2FibGUpCiB7CiAJc3RydWN0IGdudGRldl9wcml2ICpwcml2ID0gY29u dGFpbmVyX29mKG1uLCBzdHJ1Y3QgZ250ZGV2X3ByaXYsIG1uKTsKIAlzdHJ1Y3QgZ3JhbnRfbWFw ICptYXA7CisJaW50IHJldCA9IDA7CisKKwkvKiBUT0RPIGRvIHdlIHJlYWxseSBuZWVkIGEgbXV0 ZXggaGVyZT8gKi8KKwlpZiAoYmxvY2thYmxlKQorCQltdXRleF9sb2NrKCZwcml2LT5sb2NrKTsK KwllbHNlIGlmICghbXV0ZXhfdHJ5bG9jaygmcHJpdi0+bG9jaykpCisJCXJldHVybiAtRUFHQUlO OwogCi0JbXV0ZXhfbG9jaygmcHJpdi0+bG9jayk7CiAJbGlzdF9mb3JfZWFjaF9lbnRyeShtYXAs ICZwcml2LT5tYXBzLCBuZXh0KSB7CisJCWlmIChpbl9yYW5nZShtYXAsIHN0YXJ0LCBlbmQpKSB7 CisJCQlyZXQgPSAtRUFHQUlOOworCQkJZ290byBvdXRfdW5sb2NrOworCQl9CiAJCXVubWFwX2lm X2luX3JhbmdlKG1hcCwgc3RhcnQsIGVuZCk7CiAJfQogCWxpc3RfZm9yX2VhY2hfZW50cnkobWFw LCAmcHJpdi0+ZnJlZWFibGVfbWFwcywgbmV4dCkgeworCQlpZiAoaW5fcmFuZ2UobWFwLCBzdGFy dCwgZW5kKSkgeworCQkJcmV0ID0gLUVBR0FJTjsKKwkJCWdvdG8gb3V0X3VubG9jazsKKwkJfQog CQl1bm1hcF9pZl9pbl9yYW5nZShtYXAsIHN0YXJ0LCBlbmQpOwogCX0KKworb3V0X3VubG9jazoK IAltdXRleF91bmxvY2soJnByaXYtPmxvY2spOworCisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGlj IHZvaWQgbW5fcmVsZWFzZShzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKZGlmZiAtLWdpdCBhL2lu Y2x1ZGUvbGludXgva3ZtX2hvc3QuaCBiL2luY2x1ZGUvbGludXgva3ZtX2hvc3QuaAppbmRleCA0 ZWU3YmM1NDhhODMuLjE0ODkzNTA4NTE5NCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9rdm1f aG9zdC5oCisrKyBiL2luY2x1ZGUvbGludXgva3ZtX2hvc3QuaApAQCAtMTI3NSw4ICsxMjc1LDgg QEAgc3RhdGljIGlubGluZSBsb25nIGt2bV9hcmNoX3ZjcHVfYXN5bmNfaW9jdGwoc3RydWN0IGZp bGUgKmZpbHAsCiB9CiAjZW5kaWYgLyogQ09ORklHX0hBVkVfS1ZNX1ZDUFVfQVNZTkNfSU9DVEwg Ki8KIAotdm9pZCBrdm1fYXJjaF9tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZShzdHJ1Y3Qg a3ZtICprdm0sCi0JCXVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kKTsKK2lu dCBrdm1fYXJjaF9tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZShzdHJ1Y3Qga3ZtICprdm0s CisJCXVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kLCBib29sIGJsb2NrYWJs ZSk7CiAKICNpZmRlZiBDT05GSUdfSEFWRV9LVk1fVkNQVV9SVU5fUElEX0NIQU5HRQogaW50IGt2 bV9hcmNoX3ZjcHVfcnVuX3BpZF9jaGFuZ2Uoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKZGlmZiAt LWdpdCBhL2luY2x1ZGUvbGludXgvbW11X25vdGlmaWVyLmggYi9pbmNsdWRlL2xpbnV4L21tdV9u b3RpZmllci5oCmluZGV4IDM5MmU2YWY4MjcwMS4uMmViMWEyZDAxNzU5IDEwMDY0NAotLS0gYS9p bmNsdWRlL2xpbnV4L21tdV9ub3RpZmllci5oCisrKyBiL2luY2x1ZGUvbGludXgvbW11X25vdGlm aWVyLmgKQEAgLTE1MSwxMyArMTUxLDE1IEBAIHN0cnVjdCBtbXVfbm90aWZpZXJfb3BzIHsKIAkg KiBhZGRyZXNzIHNwYWNlIGJ1dCBtYXkgc3RpbGwgYmUgcmVmZXJlbmNlZCBieSBzcHRlcyB1bnRp bAogCSAqIHRoZSBsYXN0IHJlZmNvdW50IGlzIGRyb3BwZWQuCiAJICoKLQkgKiBJZiBib3RoIG9m IHRoZXNlIGNhbGxiYWNrcyBjYW5ub3QgYmxvY2ssIGFuZCBpbnZhbGlkYXRlX3JhbmdlCi0JICog Y2Fubm90IGJsb2NrLCBtbXVfbm90aWZpZXJfb3BzLmZsYWdzIHNob3VsZCBoYXZlCi0JICogTU1V X0lOVkFMSURBVEVfRE9FU19OT1RfQkxPQ0sgc2V0LgorCSAqIElmIGJsb2NrYWJsZSBhcmd1bWVu dCBpcyBzZXQgdG8gZmFsc2UgdGhlbiB0aGUgY2FsbGJhY2sgY2Fubm90CisJICogc2xlZXAgYW5k IGhhcyB0byByZXR1cm4gd2l0aCAtRUFHQUlOLiAwIHNob3VsZCBiZSByZXR1cm5lZAorCSAqIG90 aGVyd2lzZS4KKwkgKgogCSAqLwotCXZvaWQgKCppbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KShzdHJ1 Y3QgbW11X25vdGlmaWVyICptbiwKKwlpbnQgKCppbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KShzdHJ1 Y3QgbW11X25vdGlmaWVyICptbiwKIAkJCQkgICAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0sCi0J CQkJICAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kKTsKKwkJCQkg ICAgICAgdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQsCisJCQkJICAgICAg IGJvb2wgYmxvY2thYmxlKTsKIAl2b2lkICgqaW52YWxpZGF0ZV9yYW5nZV9lbmQpKHN0cnVjdCBt bXVfbm90aWZpZXIgKm1uLAogCQkJCSAgICAgc3RydWN0IG1tX3N0cnVjdCAqbW0sCiAJCQkJICAg ICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGVuZCk7CkBAIC0yMjksOCArMjMx LDkgQEAgZXh0ZXJuIGludCBfX21tdV9ub3RpZmllcl90ZXN0X3lvdW5nKHN0cnVjdCBtbV9zdHJ1 Y3QgKm1tLAogCQkJCSAgICAgdW5zaWduZWQgbG9uZyBhZGRyZXNzKTsKIGV4dGVybiB2b2lkIF9f bW11X25vdGlmaWVyX2NoYW5nZV9wdGUoc3RydWN0IG1tX3N0cnVjdCAqbW0sCiAJCQkJICAgICAg dW5zaWduZWQgbG9uZyBhZGRyZXNzLCBwdGVfdCBwdGUpOwotZXh0ZXJuIHZvaWQgX19tbXVfbm90 aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW1fc3RydWN0ICptbSwKLQkJCQkg IHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kKTsKK2V4dGVybiBpbnQgX19t bXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW1fc3RydWN0ICptbSwK KwkJCQkgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kLAorCQkJCSAgYm9v bCBibG9ja2FibGUpOwogZXh0ZXJuIHZvaWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5n ZV9lbmQoc3RydWN0IG1tX3N0cnVjdCAqbW0sCiAJCQkJICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1 bnNpZ25lZCBsb25nIGVuZCwKIAkJCQkgIGJvb2wgb25seV9lbmQpOwpAQCAtMjgxLDcgKzI4NCwx NyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3Rh cnQoc3RydWN0IG1tX3N0cnVjdCAqbW0sCiAJCQkJICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNp Z25lZCBsb25nIGVuZCkKIHsKIAlpZiAobW1faGFzX25vdGlmaWVycyhtbSkpCi0JCV9fbW11X25v dGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQobW0sIHN0YXJ0LCBlbmQpOworCQlfX21tdV9u b3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KG1tLCBzdGFydCwgZW5kLCB0cnVlKTsKK30K Kworc3RhdGljIGlubGluZSBpbnQgbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRf bm9uYmxvY2soc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJICB1bnNpZ25lZCBsb25nIHN0YXJ0 LCB1bnNpZ25lZCBsb25nIGVuZCkKK3sKKwlpbnQgcmV0ID0gMDsKKwlpZiAobW1faGFzX25vdGlm aWVycyhtbSkpCisJCXJldCA9IF9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQo bW0sIHN0YXJ0LCBlbmQsIGZhbHNlKTsKKworCXJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyBpbmxp bmUgdm9pZCBtbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9lbmQoc3RydWN0IG1tX3N0cnVj dCAqbW0sCkBAIC00NjEsNiArNDc0LDEyIEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBtbXVfbm90aWZp ZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW1fc3RydWN0ICptbSwKIHsKIH0KIAor c3RhdGljIGlubGluZSBpbnQgbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnRfbm9u YmxvY2soc3RydWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1 bnNpZ25lZCBsb25nIGVuZCkKK3sKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIGlubGluZSB2b2lk IG1tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX2VuZChzdHJ1Y3QgbW1fc3RydWN0ICptbSwK IAkJCQkgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kKQogewpkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9vb20uaCBiL2luY2x1ZGUvbGludXgvb29tLmgKaW5kZXggNmFk YWMxMTNlOTZkLi45MmY3MGU0YzYyNTIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvb29tLmgK KysrIGIvaW5jbHVkZS9saW51eC9vb20uaApAQCAtOTUsNyArOTUsNyBAQCBzdGF0aWMgaW5saW5l IGludCBjaGVja19zdGFibGVfYWRkcmVzc19zcGFjZShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAly ZXR1cm4gMDsKIH0KIAotdm9pZCBfX29vbV9yZWFwX3Rhc2tfbW0oc3RydWN0IG1tX3N0cnVjdCAq bW0pOworYm9vbCBfX29vbV9yZWFwX3Rhc2tfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0pOwogCiBl eHRlcm4gdW5zaWduZWQgbG9uZyBvb21fYmFkbmVzcyhzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAsCiAJ CXN0cnVjdCBtZW1fY2dyb3VwICptZW1jZywgY29uc3Qgbm9kZW1hc2tfdCAqbm9kZW1hc2ssCmRp ZmYgLS1naXQgYS9pbmNsdWRlL3JkbWEvaWJfdW1lbV9vZHAuaCBiL2luY2x1ZGUvcmRtYS9pYl91 bWVtX29kcC5oCmluZGV4IDZhMTdmODU2Zjg0MS4uMzgxY2RmNWE5YmQxIDEwMDY0NAotLS0gYS9p bmNsdWRlL3JkbWEvaWJfdW1lbV9vZHAuaAorKysgYi9pbmNsdWRlL3JkbWEvaWJfdW1lbV9vZHAu aApAQCAtMTE5LDcgKzExOSw4IEBAIHR5cGVkZWYgaW50ICgqdW1lbV9jYWxsX2JhY2spKHN0cnVj dCBpYl91bWVtICppdGVtLCB1NjQgc3RhcnQsIHU2NCBlbmQsCiAgKi8KIGludCByYnRfaWJfdW1l bV9mb3JfZWFjaF9pbl9yYW5nZShzdHJ1Y3QgcmJfcm9vdF9jYWNoZWQgKnJvb3QsCiAJCQkJICB1 NjQgc3RhcnQsIHU2NCBlbmQsCi0JCQkJICB1bWVtX2NhbGxfYmFjayBjYiwgdm9pZCAqY29va2ll KTsKKwkJCQkgIHVtZW1fY2FsbF9iYWNrIGNiLAorCQkJCSAgYm9vbCBibG9ja2FibGUsIHZvaWQg KmNvb2tpZSk7CiAKIC8qCiAgKiBGaW5kIGZpcnN0IHJlZ2lvbiBpbnRlcnNlY3Rpbmcgd2l0aCBh ZGRyZXNzIHJhbmdlLgpkaWZmIC0tZ2l0IGEvbW0vaG1tLmMgYi9tbS9obW0uYwppbmRleCBkZTdi NmJmNzcyMDEuLjgxZmQ1N2JkMjYzNCAxMDA2NDQKLS0tIGEvbW0vaG1tLmMKKysrIGIvbW0vaG1t LmMKQEAgLTE3NywxNiArMTc3LDE5IEBAIHN0YXRpYyB2b2lkIGhtbV9yZWxlYXNlKHN0cnVjdCBt bXVfbm90aWZpZXIgKm1uLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAl1cF93cml0ZSgmaG1tLT5t aXJyb3JzX3NlbSk7CiB9CiAKLXN0YXRpYyB2b2lkIGhtbV9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0 KHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAorc3RhdGljIGludCBobW1faW52YWxpZGF0ZV9yYW5n ZV9zdGFydChzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwKIAkJCQkgICAgICAgc3RydWN0IG1tX3N0 cnVjdCAqbW0sCiAJCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgc3RhcnQsCi0JCQkJICAgICAgIHVu c2lnbmVkIGxvbmcgZW5kKQorCQkJCSAgICAgICB1bnNpZ25lZCBsb25nIGVuZCwKKwkJCQkgICAg ICAgYm9vbCBibG9ja2FibGUpCiB7CiAJc3RydWN0IGhtbSAqaG1tID0gbW0tPmhtbTsKIAogCVZN X0JVR19PTighaG1tKTsKIAogCWF0b21pY19pbmMoJmhtbS0+c2VxdWVuY2UpOworCisJcmV0dXJu IDA7CiB9CiAKIHN0YXRpYyB2b2lkIGhtbV9pbnZhbGlkYXRlX3JhbmdlX2VuZChzdHJ1Y3QgbW11 X25vdGlmaWVyICptbiwKZGlmZiAtLWdpdCBhL21tL21tYXAuYyBiL21tL21tYXAuYwppbmRleCBk MWViODdlZjRiMWEuLjMzNmJlZThjNGUyNSAxMDA2NDQKLS0tIGEvbW0vbW1hcC5jCisrKyBiL21t L21tYXAuYwpAQCAtMzA3NCw3ICszMDc0LDcgQEAgdm9pZCBleGl0X21tYXAoc3RydWN0IG1tX3N0 cnVjdCAqbW0pCiAJCSAqIHJlbGlhYmx5IHRlc3QgaXQuCiAJCSAqLwogCQltdXRleF9sb2NrKCZv b21fbG9jayk7Ci0JCV9fb29tX3JlYXBfdGFza19tbShtbSk7CisJCSh2b2lkKV9fb29tX3JlYXBf dGFza19tbShtbSk7CiAJCW11dGV4X3VubG9jaygmb29tX2xvY2spOwogCiAJCXNldF9iaXQoTU1G X09PTV9TS0lQLCAmbW0tPmZsYWdzKTsKZGlmZiAtLWdpdCBhL21tL21tdV9ub3RpZmllci5jIGIv bW0vbW11X25vdGlmaWVyLmMKaW5kZXggZWZmNmI4OGE5OTNmLi4xMDNiMmI0NTAwNDMgMTAwNjQ0 Ci0tLSBhL21tL21tdV9ub3RpZmllci5jCisrKyBiL21tL21tdV9ub3RpZmllci5jCkBAIC0xNzQs MTggKzE3NCwyOSBAQCB2b2lkIF9fbW11X25vdGlmaWVyX2NoYW5nZV9wdGUoc3RydWN0IG1tX3N0 cnVjdCAqbW0sIHVuc2lnbmVkIGxvbmcgYWRkcmVzcywKIAlzcmN1X3JlYWRfdW5sb2NrKCZzcmN1 LCBpZCk7CiB9CiAKLXZvaWQgX19tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydChz dHJ1Y3QgbW1fc3RydWN0ICptbSwKLQkJCQkgIHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVk IGxvbmcgZW5kKQoraW50IF9fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQoc3Ry dWN0IG1tX3N0cnVjdCAqbW0sCisJCQkJICB1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBs b25nIGVuZCwKKwkJCQkgIGJvb2wgYmxvY2thYmxlKQogewogCXN0cnVjdCBtbXVfbm90aWZpZXIg Km1uOworCWludCByZXQgPSAwOwogCWludCBpZDsKIAogCWlkID0gc3JjdV9yZWFkX2xvY2soJnNy Y3UpOwogCWhsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShtbiwgJm1tLT5tbXVfbm90aWZpZXJfbW0t Pmxpc3QsIGhsaXN0KSB7Ci0JCWlmIChtbi0+b3BzLT5pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KQot CQkJbW4tPm9wcy0+aW52YWxpZGF0ZV9yYW5nZV9zdGFydChtbiwgbW0sIHN0YXJ0LCBlbmQpOwor CQlpZiAobW4tPm9wcy0+aW52YWxpZGF0ZV9yYW5nZV9zdGFydCkgeworCQkJaW50IF9yZXQgPSBt bi0+b3BzLT5pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KG1uLCBtbSwgc3RhcnQsIGVuZCwgYmxvY2th YmxlKTsKKwkJCWlmIChfcmV0KSB7CisJCQkJcHJfaW5mbygiJXBTIGNhbGxiYWNrIGZhaWxlZCB3 aXRoICVkIGluICVzYmxvY2thYmxlIGNvbnRleHQuXG4iLAorCQkJCQkJbW4tPm9wcy0+aW52YWxp ZGF0ZV9yYW5nZV9zdGFydCwgX3JldCwKKwkJCQkJCSFibG9ja2FibGUgPyAibm9uLSI6ICIiKTsK KwkJCQlyZXQgPSBfcmV0OworCQkJfQorCQl9CiAJfQogCXNyY3VfcmVhZF91bmxvY2soJnNyY3Us IGlkKTsKKworCXJldHVybiByZXQ7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChfX21tdV9ub3RpZmll cl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KTsKIApkaWZmIC0tZ2l0IGEvbW0vb29tX2tpbGwuYyBi L21tL29vbV9raWxsLmMKaW5kZXggODQwODFlNzdiYzUxLi41YTkzNmNmMjRkNzkgMTAwNjQ0Ci0t LSBhL21tL29vbV9raWxsLmMKKysrIGIvbW0vb29tX2tpbGwuYwpAQCAtNDc5LDkgKzQ3OSwxMCBA QCBzdGF0aWMgREVDTEFSRV9XQUlUX1FVRVVFX0hFQUQob29tX3JlYXBlcl93YWl0KTsKIHN0YXRp YyBzdHJ1Y3QgdGFza19zdHJ1Y3QgKm9vbV9yZWFwZXJfbGlzdDsKIHN0YXRpYyBERUZJTkVfU1BJ TkxPQ0sob29tX3JlYXBlcl9sb2NrKTsKIAotdm9pZCBfX29vbV9yZWFwX3Rhc2tfbW0oc3RydWN0 IG1tX3N0cnVjdCAqbW0pCitib29sIF9fb29tX3JlYXBfdGFza19tbShzdHJ1Y3QgbW1fc3RydWN0 ICptbSkKIHsKIAlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKKwlib29sIHJldCA9IHRydWU7 CiAKIAkvKgogCSAqIFRlbGwgYWxsIHVzZXJzIG9mIGdldF91c2VyL2NvcHlfZnJvbV91c2VyIGV0 Yy4uLiB0aGF0IHRoZSBjb250ZW50CkBAIC01MTEsMTIgKzUxMiwxNyBAQCB2b2lkIF9fb29tX3Jl YXBfdGFza19tbShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKIAkJCXN0cnVjdCBtbXVfZ2F0aGVyIHRs YjsKIAogCQkJdGxiX2dhdGhlcl9tbXUoJnRsYiwgbW0sIHN0YXJ0LCBlbmQpOwotCQkJbW11X25v dGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vfc3RhcnQobW0sIHN0YXJ0LCBlbmQpOworCQkJaWYgKG1t dV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0X25vbmJsb2NrKG1tLCBzdGFydCwgZW5k KSkgeworCQkJCXJldCA9IGZhbHNlOworCQkJCWNvbnRpbnVlOworCQkJfQogCQkJdW5tYXBfcGFn ZV9yYW5nZSgmdGxiLCB2bWEsIHN0YXJ0LCBlbmQsIE5VTEwpOwogCQkJbW11X25vdGlmaWVyX2lu dmFsaWRhdGVfcmFuZ2VfZW5kKG1tLCBzdGFydCwgZW5kKTsKIAkJCXRsYl9maW5pc2hfbW11KCZ0 bGIsIHN0YXJ0LCBlbmQpOwogCQl9CiAJfQorCisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGJv b2wgb29tX3JlYXBfdGFza19tbShzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzaywgc3RydWN0IG1tX3N0 cnVjdCAqbW0pCkBAIC01NDUsMTggKzU1MSw2IEBAIHN0YXRpYyBib29sIG9vbV9yZWFwX3Rhc2tf bW0oc3RydWN0IHRhc2tfc3RydWN0ICp0c2ssIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQogCQlnb3Rv IHVubG9ja19vb207CiAJfQogCi0JLyoKLQkgKiBJZiB0aGUgbW0gaGFzIGludmFsaWRhdGVfe3N0 YXJ0LGVuZH0oKSBub3RpZmllcnMgdGhhdCBjb3VsZCBibG9jaywKLQkgKiBzbGVlcCB0byBnaXZl IHRoZSBvb20gdmljdGltIHNvbWUgbW9yZSB0aW1lLgotCSAqIFRPRE86IHdlIHJlYWxseSB3YW50 IHRvIGdldCByaWQgb2YgdGhpcyB1Z2x5IGhhY2sgYW5kIG1ha2Ugc3VyZSB0aGF0Ci0JICogbm90 aWZpZXJzIGNhbm5vdCBibG9jayBmb3IgdW5ib3VuZGVkIGFtb3VudCBvZiB0aW1lCi0JICovCi0J aWYgKG1tX2hhc19ibG9ja2FibGVfaW52YWxpZGF0ZV9ub3RpZmllcnMobW0pKSB7Ci0JCXVwX3Jl YWQoJm1tLT5tbWFwX3NlbSk7Ci0JCXNjaGVkdWxlX3RpbWVvdXRfaWRsZShIWik7Ci0JCWdvdG8g dW5sb2NrX29vbTsKLQl9Ci0KIAkvKgogCSAqIE1NRl9PT01fU0tJUCBpcyBzZXQgYnkgZXhpdF9t bWFwIHdoZW4gdGhlIE9PTSByZWFwZXIgY2FuJ3QKIAkgKiB3b3JrIG9uIHRoZSBtbSBhbnltb3Jl LiBUaGUgY2hlY2sgZm9yIE1NRl9PT01fU0tJUCBtdXN0IHJ1bgpAQCAtNTcxLDcgKzU2NSwxMiBA QCBzdGF0aWMgYm9vbCBvb21fcmVhcF90YXNrX21tKHN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrLCBz dHJ1Y3QgbW1fc3RydWN0ICptbSkKIAogCXRyYWNlX3N0YXJ0X3Rhc2tfcmVhcGluZyh0c2stPnBp ZCk7CiAKLQlfX29vbV9yZWFwX3Rhc2tfbW0obW0pOworCS8qIGZhaWxlZCB0byByZWFwIHBhcnQg b2YgdGhlIGFkZHJlc3Mgc3BhY2UuIFRyeSBhZ2FpbiBsYXRlciAqLworCWlmICghX19vb21fcmVh cF90YXNrX21tKG1tKSkgeworCQl1cF9yZWFkKCZtbS0+bW1hcF9zZW0pOworCQlyZXQgPSBmYWxz ZTsKKwkJZ290byB1bmxvY2tfb29tOworCX0KIAogCXByX2luZm8oIm9vbV9yZWFwZXI6IHJlYXBl ZCBwcm9jZXNzICVkICglcyksIG5vdyBhbm9uLXJzczolbHVrQiwgZmlsZS1yc3M6JWx1a0IsIHNo bWVtLXJzczolbHVrQlxuIiwKIAkJCXRhc2tfcGlkX25yKHRzayksIHRzay0+Y29tbSwKZGlmZiAt LWdpdCBhL3ZpcnQva3ZtL2t2bV9tYWluLmMgYi92aXJ0L2t2bS9rdm1fbWFpbi5jCmluZGV4IGFk YTIxZjQ3ZjIyYi4uMTZjZTM4ZjE3OGQxIDEwMDY0NAotLS0gYS92aXJ0L2t2bS9rdm1fbWFpbi5j CisrKyBiL3ZpcnQva3ZtL2t2bV9tYWluLmMKQEAgLTEzNSw5ICsxMzUsMTAgQEAgc3RhdGljIHZv aWQga3ZtX3VldmVudF9ub3RpZnlfY2hhbmdlKHVuc2lnbmVkIGludCB0eXBlLCBzdHJ1Y3Qga3Zt ICprdm0pOwogc3RhdGljIHVuc2lnbmVkIGxvbmcgbG9uZyBrdm1fY3JlYXRldm1fY291bnQ7CiBz dGF0aWMgdW5zaWduZWQgbG9uZyBsb25nIGt2bV9hY3RpdmVfdm1zOwogCi1fX3dlYWsgdm9pZCBr dm1fYXJjaF9tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZShzdHJ1Y3Qga3ZtICprdm0sCi0J CXVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kKQorX193ZWFrIGludCBrdm1f YXJjaF9tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZShzdHJ1Y3Qga3ZtICprdm0sCisJCXVu c2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgZW5kLCBib29sIGJsb2NrYWJsZSkKIHsK KwlyZXR1cm4gMDsKIH0KIAogYm9vbCBrdm1faXNfcmVzZXJ2ZWRfcGZuKGt2bV9wZm5fdCBwZm4p CkBAIC0zNTQsMTMgKzM1NSwxNSBAQCBzdGF0aWMgdm9pZCBrdm1fbW11X25vdGlmaWVyX2NoYW5n ZV9wdGUoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCiAJc3JjdV9yZWFkX3VubG9jaygma3ZtLT5z cmN1LCBpZHgpOwogfQogCi1zdGF0aWMgdm9pZCBrdm1fbW11X25vdGlmaWVyX2ludmFsaWRhdGVf cmFuZ2Vfc3RhcnQoc3RydWN0IG1tdV9ub3RpZmllciAqbW4sCitzdGF0aWMgaW50IGt2bV9tbXVf bm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZV9zdGFydChzdHJ1Y3QgbW11X25vdGlmaWVyICptbiwK IAkJCQkJCSAgICBzdHJ1Y3QgbW1fc3RydWN0ICptbSwKIAkJCQkJCSAgICB1bnNpZ25lZCBsb25n IHN0YXJ0LAotCQkJCQkJICAgIHVuc2lnbmVkIGxvbmcgZW5kKQorCQkJCQkJICAgIHVuc2lnbmVk IGxvbmcgZW5kLAorCQkJCQkJICAgIGJvb2wgYmxvY2thYmxlKQogewogCXN0cnVjdCBrdm0gKmt2 bSA9IG1tdV9ub3RpZmllcl90b19rdm0obW4pOwogCWludCBuZWVkX3RsYl9mbHVzaCA9IDAsIGlk eDsKKwlpbnQgcmV0OwogCiAJaWR4ID0gc3JjdV9yZWFkX2xvY2soJmt2bS0+c3JjdSk7CiAJc3Bp bl9sb2NrKCZrdm0tPm1tdV9sb2NrKTsKQEAgLTM3OCw5ICszODEsMTEgQEAgc3RhdGljIHZvaWQg a3ZtX21tdV9ub3RpZmllcl9pbnZhbGlkYXRlX3JhbmdlX3N0YXJ0KHN0cnVjdCBtbXVfbm90aWZp ZXIgKm1uLAogCiAJc3Bpbl91bmxvY2soJmt2bS0+bW11X2xvY2spOwogCi0Ja3ZtX2FyY2hfbW11 X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Uoa3ZtLCBzdGFydCwgZW5kKTsKKwlyZXQgPSBrdm1f YXJjaF9tbXVfbm90aWZpZXJfaW52YWxpZGF0ZV9yYW5nZShrdm0sIHN0YXJ0LCBlbmQsIGJsb2Nr YWJsZSk7CiAKIAlzcmN1X3JlYWRfdW5sb2NrKCZrdm0tPnNyY3UsIGlkeCk7CisKKwlyZXR1cm4g cmV0OwogfQogCiBzdGF0aWMgdm9pZCBrdm1fbW11X25vdGlmaWVyX2ludmFsaWRhdGVfcmFuZ2Vf ZW5kKHN0cnVjdCBtbXVfbm90aWZpZXIgKm1uLAotLSAKMi4xOC4wCgotLSAKTWljaGFsIEhvY2tv ClNVU0UgTGFicwpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwphbWQtZ2Z4IG1haWxpbmcgbGlzdAphbWQtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRw czovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2FtZC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.5 required=3.0 tests=MAILING_LIST_MULTI,SPF_PASS, URIBL_BLOCKED,USER_AGENT_MUTT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 07E0EC43142 for ; Wed, 27 Jun 2018 07:44:30 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 8D9B026857 for ; Wed, 27 Jun 2018 07:44:29 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8D9B026857 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753160AbeF0Ho2 (ORCPT ); Wed, 27 Jun 2018 03:44:28 -0400 Received: from mx2.suse.de ([195.135.220.15]:41512 "EHLO mx2.suse.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751945AbeF0HoZ (ORCPT ); Wed, 27 Jun 2018 03:44:25 -0400 X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (charybdis-ext-too.suse.de [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 5009EABDD; Wed, 27 Jun 2018 07:44:23 +0000 (UTC) Date: Wed, 27 Jun 2018 09:44:21 +0200 From: Michal Hocko To: LKML Cc: "David (ChunMing) Zhou" , Paolo Bonzini , Radim =?utf-8?B?S3LEjW3DocWZ?= , Alex Deucher , Christian =?iso-8859-1?Q?K=F6nig?= , David Airlie , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , Doug Ledford , Jason Gunthorpe , Mike Marciniszyn , Dennis Dalessandro , Sudeep Dutt , Ashutosh Dixit , Dimitri Sivanich , Boris Ostrovsky , Juergen Gross , =?iso-8859-1?B?Suly9G1l?= Glisse , Andrea Arcangeli , kvm@vger.kernel.org, amd-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, linux-rdma@vger.kernel.org, xen-devel@lists.xenproject.org, linux-mm@kvack.org, David Rientjes , Felix Kuehling Subject: Re: [RFC PATCH] mm, oom: distinguish blockable mode for mmu notifiers Message-ID: <20180627074421.GF32348@dhcp22.suse.cz> References: <20180622150242.16558-1-mhocko@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20180622150242.16558-1-mhocko@kernel.org> User-Agent: Mutt/1.10.0 (2018-05-17) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This is the v2 of RFC based on the feedback I've received so far. The code even compiles as a bonus ;) I haven't runtime tested it yet, mostly because I have no idea how. Any further feedback is highly appreciated of course. --- >From ec9a7241bf422b908532c4c33953b0da2655ad05 Mon Sep 17 00:00:00 2001 From: Michal Hocko Date: Wed, 20 Jun 2018 15:03:20 +0200 Subject: [PATCH] mm, oom: distinguish blockable mode for mmu notifiers MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit There are several blockable mmu notifiers which might sleep in mmu_notifier_invalidate_range_start and that is a problem for the oom_reaper because it needs to guarantee a forward progress so it cannot depend on any sleepable locks. Currently we simply back off and mark an oom victim with blockable mmu notifiers as done after a short sleep. That can result in selecting a new oom victim prematurely because the previous one still hasn't torn its memory down yet. We can do much better though. Even if mmu notifiers use sleepable locks there is no reason to automatically assume those locks are held. Moreover majority of notifiers only care about a portion of the address space and there is absolutely zero reason to fail when we are unmapping an unrelated range. Many notifiers do really block and wait for HW which is harder to handle and we have to bail out though. This patch handles the low hanging fruid. __mmu_notifier_invalidate_range_start gets a blockable flag and callbacks are not allowed to sleep if the flag is set to false. This is achieved by using trylock instead of the sleepable lock for most callbacks and continue as long as we do not block down the call chain. I think we can improve that even further because there is a common pattern to do a range lookup first and then do something about that. The first part can be done without a sleeping lock in most cases AFAICS. The oom_reaper end then simply retries if there is at least one notifier which couldn't make any progress in !blockable mode. A retry loop is already implemented to wait for the mmap_sem and this is basically the same thing. Changes since rfc v1 - gpu notifiers can sleep while waiting for HW (evict_process_queues_cpsch on a lock and amdgpu_mn_invalidate_node on unbound timeout) make sure we bail out when we have an intersecting range for starter - note that a notifier failed to the log for easier debugging - back off early in ib_umem_notifier_invalidate_range_start if the callback is called - mn_invl_range_start waits for completion down the unmap_grant_pages path so we have to back off early on overlapping ranges Cc: "David (ChunMing) Zhou" Cc: Paolo Bonzini Cc: "Radim Krčmář" Cc: Alex Deucher Cc: "Christian König" Cc: David Airlie Cc: Jani Nikula Cc: Joonas Lahtinen Cc: Rodrigo Vivi Cc: Doug Ledford Cc: Jason Gunthorpe Cc: Mike Marciniszyn Cc: Dennis Dalessandro Cc: Sudeep Dutt Cc: Ashutosh Dixit Cc: Dimitri Sivanich Cc: Boris Ostrovsky Cc: Juergen Gross Cc: "Jérôme Glisse" Cc: Andrea Arcangeli Cc: Felix Kuehling Cc: kvm@vger.kernel.org (open list:KERNEL VIRTUAL MACHINE FOR X86 (KVM/x86)) Cc: linux-kernel@vger.kernel.org (open list:X86 ARCHITECTURE (32-BIT AND 64-BIT)) Cc: amd-gfx@lists.freedesktop.org (open list:RADEON and AMDGPU DRM DRIVERS) Cc: dri-devel@lists.freedesktop.org (open list:DRM DRIVERS) Cc: intel-gfx@lists.freedesktop.org (open list:INTEL DRM DRIVERS (excluding Poulsbo, Moorestow...) Cc: linux-rdma@vger.kernel.org (open list:INFINIBAND SUBSYSTEM) Cc: xen-devel@lists.xenproject.org (moderated list:XEN HYPERVISOR INTERFACE) Cc: linux-mm@kvack.org (open list:HMM - Heterogeneous Memory Management) Reported-by: David Rientjes Signed-off-by: Michal Hocko --- arch/x86/kvm/x86.c | 7 ++-- drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c | 43 +++++++++++++++++++----- drivers/gpu/drm/i915/i915_gem_userptr.c | 13 ++++++-- drivers/gpu/drm/radeon/radeon_mn.c | 22 +++++++++++-- drivers/infiniband/core/umem_odp.c | 33 +++++++++++++++---- drivers/infiniband/hw/hfi1/mmu_rb.c | 11 ++++--- drivers/infiniband/hw/mlx5/odp.c | 2 +- drivers/misc/mic/scif/scif_dma.c | 7 ++-- drivers/misc/sgi-gru/grutlbpurge.c | 7 ++-- drivers/xen/gntdev.c | 44 ++++++++++++++++++++----- include/linux/kvm_host.h | 4 +-- include/linux/mmu_notifier.h | 35 +++++++++++++++----- include/linux/oom.h | 2 +- include/rdma/ib_umem_odp.h | 3 +- mm/hmm.c | 7 ++-- mm/mmap.c | 2 +- mm/mmu_notifier.c | 19 ++++++++--- mm/oom_kill.c | 29 ++++++++-------- virt/kvm/kvm_main.c | 15 ++++++--- 19 files changed, 225 insertions(+), 80 deletions(-) diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c index 6bcecc325e7e..ac08f5d711be 100644 --- a/arch/x86/kvm/x86.c +++ b/arch/x86/kvm/x86.c @@ -7203,8 +7203,9 @@ static void vcpu_load_eoi_exitmap(struct kvm_vcpu *vcpu) kvm_x86_ops->load_eoi_exitmap(vcpu, eoi_exit_bitmap); } -void kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm, - unsigned long start, unsigned long end) +int kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm, + unsigned long start, unsigned long end, + bool blockable) { unsigned long apic_address; @@ -7215,6 +7216,8 @@ void kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm, apic_address = gfn_to_hva(kvm, APIC_DEFAULT_PHYS_BASE >> PAGE_SHIFT); if (start <= apic_address && apic_address < end) kvm_make_all_cpus_request(kvm, KVM_REQ_APIC_PAGE_RELOAD); + + return 0; } void kvm_vcpu_reload_apic_access_page(struct kvm_vcpu *vcpu) diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c index 83e344fbb50a..3399a4a927fb 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mn.c @@ -136,12 +136,18 @@ void amdgpu_mn_unlock(struct amdgpu_mn *mn) * * Take the rmn read side lock. */ -static void amdgpu_mn_read_lock(struct amdgpu_mn *rmn) +static int amdgpu_mn_read_lock(struct amdgpu_mn *rmn, bool blockable) { - mutex_lock(&rmn->read_lock); + if (blockable) + mutex_lock(&rmn->read_lock); + else if (!mutex_trylock(&rmn->read_lock)) + return -EAGAIN; + if (atomic_inc_return(&rmn->recursion) == 1) down_read_non_owner(&rmn->lock); mutex_unlock(&rmn->read_lock); + + return 0; } /** @@ -197,10 +203,11 @@ static void amdgpu_mn_invalidate_node(struct amdgpu_mn_node *node, * We block for all BOs between start and end to be idle and * unmap them by move them into system domain again. */ -static void amdgpu_mn_invalidate_range_start_gfx(struct mmu_notifier *mn, +static int amdgpu_mn_invalidate_range_start_gfx(struct mmu_notifier *mn, struct mm_struct *mm, unsigned long start, - unsigned long end) + unsigned long end, + bool blockable) { struct amdgpu_mn *rmn = container_of(mn, struct amdgpu_mn, mn); struct interval_tree_node *it; @@ -208,17 +215,28 @@ static void amdgpu_mn_invalidate_range_start_gfx(struct mmu_notifier *mn, /* notification is exclusive, but interval is inclusive */ end -= 1; - amdgpu_mn_read_lock(rmn); + /* TODO we should be able to split locking for interval tree and + * amdgpu_mn_invalidate_node + */ + if (amdgpu_mn_read_lock(rmn, blockable)) + return -EAGAIN; it = interval_tree_iter_first(&rmn->objects, start, end); while (it) { struct amdgpu_mn_node *node; + if (!blockable) { + amdgpu_mn_read_unlock(rmn); + return -EAGAIN; + } + node = container_of(it, struct amdgpu_mn_node, it); it = interval_tree_iter_next(it, start, end); amdgpu_mn_invalidate_node(node, start, end); } + + return 0; } /** @@ -233,10 +251,11 @@ static void amdgpu_mn_invalidate_range_start_gfx(struct mmu_notifier *mn, * necessitates evicting all user-mode queues of the process. The BOs * are restorted in amdgpu_mn_invalidate_range_end_hsa. */ -static void amdgpu_mn_invalidate_range_start_hsa(struct mmu_notifier *mn, +static int amdgpu_mn_invalidate_range_start_hsa(struct mmu_notifier *mn, struct mm_struct *mm, unsigned long start, - unsigned long end) + unsigned long end, + bool blockable) { struct amdgpu_mn *rmn = container_of(mn, struct amdgpu_mn, mn); struct interval_tree_node *it; @@ -244,13 +263,19 @@ static void amdgpu_mn_invalidate_range_start_hsa(struct mmu_notifier *mn, /* notification is exclusive, but interval is inclusive */ end -= 1; - amdgpu_mn_read_lock(rmn); + if (amdgpu_mn_read_lock(rmn, blockable)) + return -EAGAIN; it = interval_tree_iter_first(&rmn->objects, start, end); while (it) { struct amdgpu_mn_node *node; struct amdgpu_bo *bo; + if (!blockable) { + amdgpu_mn_read_unlock(rmn); + return -EAGAIN; + } + node = container_of(it, struct amdgpu_mn_node, it); it = interval_tree_iter_next(it, start, end); @@ -262,6 +287,8 @@ static void amdgpu_mn_invalidate_range_start_hsa(struct mmu_notifier *mn, amdgpu_amdkfd_evict_userptr(mem, mm); } } + + return 0; } /** diff --git a/drivers/gpu/drm/i915/i915_gem_userptr.c b/drivers/gpu/drm/i915/i915_gem_userptr.c index 854bd51b9478..9cbff68f6b41 100644 --- a/drivers/gpu/drm/i915/i915_gem_userptr.c +++ b/drivers/gpu/drm/i915/i915_gem_userptr.c @@ -112,10 +112,11 @@ static void del_object(struct i915_mmu_object *mo) mo->attached = false; } -static void i915_gem_userptr_mn_invalidate_range_start(struct mmu_notifier *_mn, +static int i915_gem_userptr_mn_invalidate_range_start(struct mmu_notifier *_mn, struct mm_struct *mm, unsigned long start, - unsigned long end) + unsigned long end, + bool blockable) { struct i915_mmu_notifier *mn = container_of(_mn, struct i915_mmu_notifier, mn); @@ -124,7 +125,7 @@ static void i915_gem_userptr_mn_invalidate_range_start(struct mmu_notifier *_mn, LIST_HEAD(cancelled); if (RB_EMPTY_ROOT(&mn->objects.rb_root)) - return; + return 0; /* interval ranges are inclusive, but invalidate range is exclusive */ end--; @@ -132,6 +133,10 @@ static void i915_gem_userptr_mn_invalidate_range_start(struct mmu_notifier *_mn, spin_lock(&mn->lock); it = interval_tree_iter_first(&mn->objects, start, end); while (it) { + if (!blockable) { + spin_unlock(&mn->lock); + return -EAGAIN; + } /* The mmu_object is released late when destroying the * GEM object so it is entirely possible to gain a * reference on an object in the process of being freed @@ -154,6 +159,8 @@ static void i915_gem_userptr_mn_invalidate_range_start(struct mmu_notifier *_mn, if (!list_empty(&cancelled)) flush_workqueue(mn->wq); + + return 0; } static const struct mmu_notifier_ops i915_gem_userptr_notifier = { diff --git a/drivers/gpu/drm/radeon/radeon_mn.c b/drivers/gpu/drm/radeon/radeon_mn.c index abd24975c9b1..f8b35df44c60 100644 --- a/drivers/gpu/drm/radeon/radeon_mn.c +++ b/drivers/gpu/drm/radeon/radeon_mn.c @@ -118,19 +118,27 @@ static void radeon_mn_release(struct mmu_notifier *mn, * We block for all BOs between start and end to be idle and * unmap them by move them into system domain again. */ -static void radeon_mn_invalidate_range_start(struct mmu_notifier *mn, +static int radeon_mn_invalidate_range_start(struct mmu_notifier *mn, struct mm_struct *mm, unsigned long start, - unsigned long end) + unsigned long end, + bool blockable) { struct radeon_mn *rmn = container_of(mn, struct radeon_mn, mn); struct ttm_operation_ctx ctx = { false, false }; struct interval_tree_node *it; + int ret = 0; /* notification is exclusive, but interval is inclusive */ end -= 1; - mutex_lock(&rmn->lock); + /* TODO we should be able to split locking for interval tree and + * the tear down. + */ + if (blockable) + mutex_lock(&rmn->lock); + else if (!mutex_trylock(&rmn->lock)) + return -EAGAIN; it = interval_tree_iter_first(&rmn->objects, start, end); while (it) { @@ -138,6 +146,11 @@ static void radeon_mn_invalidate_range_start(struct mmu_notifier *mn, struct radeon_bo *bo; long r; + if (!blockable) { + ret = -EAGAIN; + goto out_unlock; + } + node = container_of(it, struct radeon_mn_node, it); it = interval_tree_iter_next(it, start, end); @@ -166,7 +179,10 @@ static void radeon_mn_invalidate_range_start(struct mmu_notifier *mn, } } +out_unlock: mutex_unlock(&rmn->lock); + + return ret; } static const struct mmu_notifier_ops radeon_mn_ops = { diff --git a/drivers/infiniband/core/umem_odp.c b/drivers/infiniband/core/umem_odp.c index 182436b92ba9..6ec748eccff7 100644 --- a/drivers/infiniband/core/umem_odp.c +++ b/drivers/infiniband/core/umem_odp.c @@ -186,6 +186,7 @@ static void ib_umem_notifier_release(struct mmu_notifier *mn, rbt_ib_umem_for_each_in_range(&context->umem_tree, 0, ULLONG_MAX, ib_umem_notifier_release_trampoline, + true, NULL); up_read(&context->umem_rwsem); } @@ -207,22 +208,31 @@ static int invalidate_range_start_trampoline(struct ib_umem *item, u64 start, return 0; } -static void ib_umem_notifier_invalidate_range_start(struct mmu_notifier *mn, +static int ib_umem_notifier_invalidate_range_start(struct mmu_notifier *mn, struct mm_struct *mm, unsigned long start, - unsigned long end) + unsigned long end, + bool blockable) { struct ib_ucontext *context = container_of(mn, struct ib_ucontext, mn); + int ret; if (!context->invalidate_range) - return; + return 0; + + if (blockable) + down_read(&context->umem_rwsem); + else if (!down_read_trylock(&context->umem_rwsem)) + return -EAGAIN; ib_ucontext_notifier_start_account(context); - down_read(&context->umem_rwsem); - rbt_ib_umem_for_each_in_range(&context->umem_tree, start, + ret = rbt_ib_umem_for_each_in_range(&context->umem_tree, start, end, - invalidate_range_start_trampoline, NULL); + invalidate_range_start_trampoline, + blockable, NULL); up_read(&context->umem_rwsem); + + return ret; } static int invalidate_range_end_trampoline(struct ib_umem *item, u64 start, @@ -242,10 +252,15 @@ static void ib_umem_notifier_invalidate_range_end(struct mmu_notifier *mn, if (!context->invalidate_range) return; + /* + * TODO: we currently bail out if there is any sleepable work to be done + * in ib_umem_notifier_invalidate_range_start so we shouldn't really block + * here. But this is ugly and fragile. + */ down_read(&context->umem_rwsem); rbt_ib_umem_for_each_in_range(&context->umem_tree, start, end, - invalidate_range_end_trampoline, NULL); + invalidate_range_end_trampoline, true, NULL); up_read(&context->umem_rwsem); ib_ucontext_notifier_end_account(context); } @@ -798,6 +813,7 @@ EXPORT_SYMBOL(ib_umem_odp_unmap_dma_pages); int rbt_ib_umem_for_each_in_range(struct rb_root_cached *root, u64 start, u64 last, umem_call_back cb, + bool blockable, void *cookie) { int ret_val = 0; @@ -809,6 +825,9 @@ int rbt_ib_umem_for_each_in_range(struct rb_root_cached *root, for (node = rbt_ib_umem_iter_first(root, start, last - 1); node; node = next) { + /* TODO move the blockable decision up to the callback */ + if (!blockable) + return -EAGAIN; next = rbt_ib_umem_iter_next(node, start, last - 1); umem = container_of(node, struct ib_umem_odp, interval_tree); ret_val = cb(umem->umem, start, last, cookie) || ret_val; diff --git a/drivers/infiniband/hw/hfi1/mmu_rb.c b/drivers/infiniband/hw/hfi1/mmu_rb.c index 70aceefe14d5..e1c7996c018e 100644 --- a/drivers/infiniband/hw/hfi1/mmu_rb.c +++ b/drivers/infiniband/hw/hfi1/mmu_rb.c @@ -67,9 +67,9 @@ struct mmu_rb_handler { static unsigned long mmu_node_start(struct mmu_rb_node *); static unsigned long mmu_node_last(struct mmu_rb_node *); -static void mmu_notifier_range_start(struct mmu_notifier *, +static int mmu_notifier_range_start(struct mmu_notifier *, struct mm_struct *, - unsigned long, unsigned long); + unsigned long, unsigned long, bool); static struct mmu_rb_node *__mmu_rb_search(struct mmu_rb_handler *, unsigned long, unsigned long); static void do_remove(struct mmu_rb_handler *handler, @@ -284,10 +284,11 @@ void hfi1_mmu_rb_remove(struct mmu_rb_handler *handler, handler->ops->remove(handler->ops_arg, node); } -static void mmu_notifier_range_start(struct mmu_notifier *mn, +static int mmu_notifier_range_start(struct mmu_notifier *mn, struct mm_struct *mm, unsigned long start, - unsigned long end) + unsigned long end, + bool blockable) { struct mmu_rb_handler *handler = container_of(mn, struct mmu_rb_handler, mn); @@ -313,6 +314,8 @@ static void mmu_notifier_range_start(struct mmu_notifier *mn, if (added) queue_work(handler->wq, &handler->del_work); + + return 0; } /* diff --git a/drivers/infiniband/hw/mlx5/odp.c b/drivers/infiniband/hw/mlx5/odp.c index f1a87a690a4c..d216e0d2921d 100644 --- a/drivers/infiniband/hw/mlx5/odp.c +++ b/drivers/infiniband/hw/mlx5/odp.c @@ -488,7 +488,7 @@ void mlx5_ib_free_implicit_mr(struct mlx5_ib_mr *imr) down_read(&ctx->umem_rwsem); rbt_ib_umem_for_each_in_range(&ctx->umem_tree, 0, ULLONG_MAX, - mr_leaf_free, imr); + mr_leaf_free, true, imr); up_read(&ctx->umem_rwsem); wait_event(imr->q_leaf_free, !atomic_read(&imr->num_leaf_free)); diff --git a/drivers/misc/mic/scif/scif_dma.c b/drivers/misc/mic/scif/scif_dma.c index 63d6246d6dff..6369aeaa7056 100644 --- a/drivers/misc/mic/scif/scif_dma.c +++ b/drivers/misc/mic/scif/scif_dma.c @@ -200,15 +200,18 @@ static void scif_mmu_notifier_release(struct mmu_notifier *mn, schedule_work(&scif_info.misc_work); } -static void scif_mmu_notifier_invalidate_range_start(struct mmu_notifier *mn, +static int scif_mmu_notifier_invalidate_range_start(struct mmu_notifier *mn, struct mm_struct *mm, unsigned long start, - unsigned long end) + unsigned long end, + bool blockable) { struct scif_mmu_notif *mmn; mmn = container_of(mn, struct scif_mmu_notif, ep_mmu_notifier); scif_rma_destroy_tcw(mmn, start, end - start); + + return 0; } static void scif_mmu_notifier_invalidate_range_end(struct mmu_notifier *mn, diff --git a/drivers/misc/sgi-gru/grutlbpurge.c b/drivers/misc/sgi-gru/grutlbpurge.c index a3454eb56fbf..be28f05bfafa 100644 --- a/drivers/misc/sgi-gru/grutlbpurge.c +++ b/drivers/misc/sgi-gru/grutlbpurge.c @@ -219,9 +219,10 @@ void gru_flush_all_tlb(struct gru_state *gru) /* * MMUOPS notifier callout functions */ -static void gru_invalidate_range_start(struct mmu_notifier *mn, +static int gru_invalidate_range_start(struct mmu_notifier *mn, struct mm_struct *mm, - unsigned long start, unsigned long end) + unsigned long start, unsigned long end, + bool blockable) { struct gru_mm_struct *gms = container_of(mn, struct gru_mm_struct, ms_notifier); @@ -231,6 +232,8 @@ static void gru_invalidate_range_start(struct mmu_notifier *mn, gru_dbg(grudev, "gms %p, start 0x%lx, end 0x%lx, act %d\n", gms, start, end, atomic_read(&gms->ms_range_active)); gru_flush_tlb_range(gms, start, end - start); + + return 0; } static void gru_invalidate_range_end(struct mmu_notifier *mn, diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c index bd56653b9bbc..55b4f0e3f4d6 100644 --- a/drivers/xen/gntdev.c +++ b/drivers/xen/gntdev.c @@ -441,18 +441,25 @@ static const struct vm_operations_struct gntdev_vmops = { /* ------------------------------------------------------------------ */ +static bool in_range(struct grant_map *map, + unsigned long start, unsigned long end) +{ + if (!map->vma) + return false; + if (map->vma->vm_start >= end) + return false; + if (map->vma->vm_end <= start) + return false; + + return true; +} + static void unmap_if_in_range(struct grant_map *map, unsigned long start, unsigned long end) { unsigned long mstart, mend; int err; - if (!map->vma) - return; - if (map->vma->vm_start >= end) - return; - if (map->vma->vm_end <= start) - return; mstart = max(start, map->vma->vm_start); mend = min(end, map->vma->vm_end); pr_debug("map %d+%d (%lx %lx), range %lx %lx, mrange %lx %lx\n", @@ -465,21 +472,40 @@ static void unmap_if_in_range(struct grant_map *map, WARN_ON(err); } -static void mn_invl_range_start(struct mmu_notifier *mn, +static int mn_invl_range_start(struct mmu_notifier *mn, struct mm_struct *mm, - unsigned long start, unsigned long end) + unsigned long start, unsigned long end, + bool blockable) { struct gntdev_priv *priv = container_of(mn, struct gntdev_priv, mn); struct grant_map *map; + int ret = 0; + + /* TODO do we really need a mutex here? */ + if (blockable) + mutex_lock(&priv->lock); + else if (!mutex_trylock(&priv->lock)) + return -EAGAIN; - mutex_lock(&priv->lock); list_for_each_entry(map, &priv->maps, next) { + if (in_range(map, start, end)) { + ret = -EAGAIN; + goto out_unlock; + } unmap_if_in_range(map, start, end); } list_for_each_entry(map, &priv->freeable_maps, next) { + if (in_range(map, start, end)) { + ret = -EAGAIN; + goto out_unlock; + } unmap_if_in_range(map, start, end); } + +out_unlock: mutex_unlock(&priv->lock); + + return ret; } static void mn_release(struct mmu_notifier *mn, diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h index 4ee7bc548a83..148935085194 100644 --- a/include/linux/kvm_host.h +++ b/include/linux/kvm_host.h @@ -1275,8 +1275,8 @@ static inline long kvm_arch_vcpu_async_ioctl(struct file *filp, } #endif /* CONFIG_HAVE_KVM_VCPU_ASYNC_IOCTL */ -void kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm, - unsigned long start, unsigned long end); +int kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm, + unsigned long start, unsigned long end, bool blockable); #ifdef CONFIG_HAVE_KVM_VCPU_RUN_PID_CHANGE int kvm_arch_vcpu_run_pid_change(struct kvm_vcpu *vcpu); diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h index 392e6af82701..2eb1a2d01759 100644 --- a/include/linux/mmu_notifier.h +++ b/include/linux/mmu_notifier.h @@ -151,13 +151,15 @@ struct mmu_notifier_ops { * address space but may still be referenced by sptes until * the last refcount is dropped. * - * If both of these callbacks cannot block, and invalidate_range - * cannot block, mmu_notifier_ops.flags should have - * MMU_INVALIDATE_DOES_NOT_BLOCK set. + * If blockable argument is set to false then the callback cannot + * sleep and has to return with -EAGAIN. 0 should be returned + * otherwise. + * */ - void (*invalidate_range_start)(struct mmu_notifier *mn, + int (*invalidate_range_start)(struct mmu_notifier *mn, struct mm_struct *mm, - unsigned long start, unsigned long end); + unsigned long start, unsigned long end, + bool blockable); void (*invalidate_range_end)(struct mmu_notifier *mn, struct mm_struct *mm, unsigned long start, unsigned long end); @@ -229,8 +231,9 @@ extern int __mmu_notifier_test_young(struct mm_struct *mm, unsigned long address); extern void __mmu_notifier_change_pte(struct mm_struct *mm, unsigned long address, pte_t pte); -extern void __mmu_notifier_invalidate_range_start(struct mm_struct *mm, - unsigned long start, unsigned long end); +extern int __mmu_notifier_invalidate_range_start(struct mm_struct *mm, + unsigned long start, unsigned long end, + bool blockable); extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm, unsigned long start, unsigned long end, bool only_end); @@ -281,7 +284,17 @@ static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm, unsigned long start, unsigned long end) { if (mm_has_notifiers(mm)) - __mmu_notifier_invalidate_range_start(mm, start, end); + __mmu_notifier_invalidate_range_start(mm, start, end, true); +} + +static inline int mmu_notifier_invalidate_range_start_nonblock(struct mm_struct *mm, + unsigned long start, unsigned long end) +{ + int ret = 0; + if (mm_has_notifiers(mm)) + ret = __mmu_notifier_invalidate_range_start(mm, start, end, false); + + return ret; } static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm, @@ -461,6 +474,12 @@ static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm, { } +static inline int mmu_notifier_invalidate_range_start_nonblock(struct mm_struct *mm, + unsigned long start, unsigned long end) +{ + return 0; +} + static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm, unsigned long start, unsigned long end) { diff --git a/include/linux/oom.h b/include/linux/oom.h index 6adac113e96d..92f70e4c6252 100644 --- a/include/linux/oom.h +++ b/include/linux/oom.h @@ -95,7 +95,7 @@ static inline int check_stable_address_space(struct mm_struct *mm) return 0; } -void __oom_reap_task_mm(struct mm_struct *mm); +bool __oom_reap_task_mm(struct mm_struct *mm); extern unsigned long oom_badness(struct task_struct *p, struct mem_cgroup *memcg, const nodemask_t *nodemask, diff --git a/include/rdma/ib_umem_odp.h b/include/rdma/ib_umem_odp.h index 6a17f856f841..381cdf5a9bd1 100644 --- a/include/rdma/ib_umem_odp.h +++ b/include/rdma/ib_umem_odp.h @@ -119,7 +119,8 @@ typedef int (*umem_call_back)(struct ib_umem *item, u64 start, u64 end, */ int rbt_ib_umem_for_each_in_range(struct rb_root_cached *root, u64 start, u64 end, - umem_call_back cb, void *cookie); + umem_call_back cb, + bool blockable, void *cookie); /* * Find first region intersecting with address range. diff --git a/mm/hmm.c b/mm/hmm.c index de7b6bf77201..81fd57bd2634 100644 --- a/mm/hmm.c +++ b/mm/hmm.c @@ -177,16 +177,19 @@ static void hmm_release(struct mmu_notifier *mn, struct mm_struct *mm) up_write(&hmm->mirrors_sem); } -static void hmm_invalidate_range_start(struct mmu_notifier *mn, +static int hmm_invalidate_range_start(struct mmu_notifier *mn, struct mm_struct *mm, unsigned long start, - unsigned long end) + unsigned long end, + bool blockable) { struct hmm *hmm = mm->hmm; VM_BUG_ON(!hmm); atomic_inc(&hmm->sequence); + + return 0; } static void hmm_invalidate_range_end(struct mmu_notifier *mn, diff --git a/mm/mmap.c b/mm/mmap.c index d1eb87ef4b1a..336bee8c4e25 100644 --- a/mm/mmap.c +++ b/mm/mmap.c @@ -3074,7 +3074,7 @@ void exit_mmap(struct mm_struct *mm) * reliably test it. */ mutex_lock(&oom_lock); - __oom_reap_task_mm(mm); + (void)__oom_reap_task_mm(mm); mutex_unlock(&oom_lock); set_bit(MMF_OOM_SKIP, &mm->flags); diff --git a/mm/mmu_notifier.c b/mm/mmu_notifier.c index eff6b88a993f..103b2b450043 100644 --- a/mm/mmu_notifier.c +++ b/mm/mmu_notifier.c @@ -174,18 +174,29 @@ void __mmu_notifier_change_pte(struct mm_struct *mm, unsigned long address, srcu_read_unlock(&srcu, id); } -void __mmu_notifier_invalidate_range_start(struct mm_struct *mm, - unsigned long start, unsigned long end) +int __mmu_notifier_invalidate_range_start(struct mm_struct *mm, + unsigned long start, unsigned long end, + bool blockable) { struct mmu_notifier *mn; + int ret = 0; int id; id = srcu_read_lock(&srcu); hlist_for_each_entry_rcu(mn, &mm->mmu_notifier_mm->list, hlist) { - if (mn->ops->invalidate_range_start) - mn->ops->invalidate_range_start(mn, mm, start, end); + if (mn->ops->invalidate_range_start) { + int _ret = mn->ops->invalidate_range_start(mn, mm, start, end, blockable); + if (_ret) { + pr_info("%pS callback failed with %d in %sblockable context.\n", + mn->ops->invalidate_range_start, _ret, + !blockable ? "non-": ""); + ret = _ret; + } + } } srcu_read_unlock(&srcu, id); + + return ret; } EXPORT_SYMBOL_GPL(__mmu_notifier_invalidate_range_start); diff --git a/mm/oom_kill.c b/mm/oom_kill.c index 84081e77bc51..5a936cf24d79 100644 --- a/mm/oom_kill.c +++ b/mm/oom_kill.c @@ -479,9 +479,10 @@ static DECLARE_WAIT_QUEUE_HEAD(oom_reaper_wait); static struct task_struct *oom_reaper_list; static DEFINE_SPINLOCK(oom_reaper_lock); -void __oom_reap_task_mm(struct mm_struct *mm) +bool __oom_reap_task_mm(struct mm_struct *mm) { struct vm_area_struct *vma; + bool ret = true; /* * Tell all users of get_user/copy_from_user etc... that the content @@ -511,12 +512,17 @@ void __oom_reap_task_mm(struct mm_struct *mm) struct mmu_gather tlb; tlb_gather_mmu(&tlb, mm, start, end); - mmu_notifier_invalidate_range_start(mm, start, end); + if (mmu_notifier_invalidate_range_start_nonblock(mm, start, end)) { + ret = false; + continue; + } unmap_page_range(&tlb, vma, start, end, NULL); mmu_notifier_invalidate_range_end(mm, start, end); tlb_finish_mmu(&tlb, start, end); } } + + return ret; } static bool oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm) @@ -545,18 +551,6 @@ static bool oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm) goto unlock_oom; } - /* - * If the mm has invalidate_{start,end}() notifiers that could block, - * sleep to give the oom victim some more time. - * TODO: we really want to get rid of this ugly hack and make sure that - * notifiers cannot block for unbounded amount of time - */ - if (mm_has_blockable_invalidate_notifiers(mm)) { - up_read(&mm->mmap_sem); - schedule_timeout_idle(HZ); - goto unlock_oom; - } - /* * MMF_OOM_SKIP is set by exit_mmap when the OOM reaper can't * work on the mm anymore. The check for MMF_OOM_SKIP must run @@ -571,7 +565,12 @@ static bool oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm) trace_start_task_reaping(tsk->pid); - __oom_reap_task_mm(mm); + /* failed to reap part of the address space. Try again later */ + if (!__oom_reap_task_mm(mm)) { + up_read(&mm->mmap_sem); + ret = false; + goto unlock_oom; + } pr_info("oom_reaper: reaped process %d (%s), now anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n", task_pid_nr(tsk), tsk->comm, diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c index ada21f47f22b..16ce38f178d1 100644 --- a/virt/kvm/kvm_main.c +++ b/virt/kvm/kvm_main.c @@ -135,9 +135,10 @@ static void kvm_uevent_notify_change(unsigned int type, struct kvm *kvm); static unsigned long long kvm_createvm_count; static unsigned long long kvm_active_vms; -__weak void kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm, - unsigned long start, unsigned long end) +__weak int kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm, + unsigned long start, unsigned long end, bool blockable) { + return 0; } bool kvm_is_reserved_pfn(kvm_pfn_t pfn) @@ -354,13 +355,15 @@ static void kvm_mmu_notifier_change_pte(struct mmu_notifier *mn, srcu_read_unlock(&kvm->srcu, idx); } -static void kvm_mmu_notifier_invalidate_range_start(struct mmu_notifier *mn, +static int kvm_mmu_notifier_invalidate_range_start(struct mmu_notifier *mn, struct mm_struct *mm, unsigned long start, - unsigned long end) + unsigned long end, + bool blockable) { struct kvm *kvm = mmu_notifier_to_kvm(mn); int need_tlb_flush = 0, idx; + int ret; idx = srcu_read_lock(&kvm->srcu); spin_lock(&kvm->mmu_lock); @@ -378,9 +381,11 @@ static void kvm_mmu_notifier_invalidate_range_start(struct mmu_notifier *mn, spin_unlock(&kvm->mmu_lock); - kvm_arch_mmu_notifier_invalidate_range(kvm, start, end); + ret = kvm_arch_mmu_notifier_invalidate_range(kvm, start, end, blockable); srcu_read_unlock(&kvm->srcu, idx); + + return ret; } static void kvm_mmu_notifier_invalidate_range_end(struct mmu_notifier *mn, -- 2.18.0 -- Michal Hocko SUSE Labs From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ed1-f72.google.com (mail-ed1-f72.google.com [209.85.208.72]) by kanga.kvack.org (Postfix) with ESMTP id 09FB96B0003 for ; Wed, 27 Jun 2018 03:44:26 -0400 (EDT) Received: by mail-ed1-f72.google.com with SMTP id c20-v6so1055238eds.21 for ; Wed, 27 Jun 2018 00:44:25 -0700 (PDT) Received: from mx2.suse.de (mx2.suse.de. [195.135.220.15]) by mx.google.com with ESMTPS id q8-v6si1802757edk.369.2018.06.27.00.44.23 for (version=TLS1 cipher=AES128-SHA bits=128/128); Wed, 27 Jun 2018 00:44:24 -0700 (PDT) Date: Wed, 27 Jun 2018 09:44:21 +0200 From: Michal Hocko Subject: Re: [RFC PATCH] mm, oom: distinguish blockable mode for mmu notifiers Message-ID: <20180627074421.GF32348@dhcp22.suse.cz> References: <20180622150242.16558-1-mhocko@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20180622150242.16558-1-mhocko@kernel.org> Sender: owner-linux-mm@kvack.org List-ID: To: LKML Cc: "David (ChunMing) Zhou" , Paolo Bonzini , Radim =?utf-8?B?S3LEjW3DocWZ?= , Alex Deucher , Christian =?iso-8859-1?Q?K=F6nig?= , David Airlie , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , Doug Ledford , Jason Gunthorpe , Mike Marciniszyn , Dennis Dalessandro , Sudeep Dutt , Ashutosh Dixit , Dimitri Sivanich , Boris Ostrovsky , Juergen Gross , =?iso-8859-1?B?Suly9G1l?= Glisse , Andrea Arcangeli , kvm@vger.kernel.org, amd-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, intel-gfx@lists.freedesktop.org, linux-rdma@vger.kernel.org, xen-devel@lists.xenproject.org, linux-mm@kvack.org, David Rientjes , Felix Kuehling This is the v2 of RFC based on the feedback I've received so far. The code even compiles as a bonus ;) I haven't runtime tested it yet, mostly because I have no idea how. Any further feedback is highly appreciated of course. ---