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=-9.8 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MIME_BASE64_TEXT,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, USER_AGENT_GIT 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 29CF8C2D0D0 for ; Mon, 23 Dec 2019 11:33:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id DEC112063A for ; Mon, 23 Dec 2019 11:33:42 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="hjqqHWuj" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726840AbfLWLdl (ORCPT ); Mon, 23 Dec 2019 06:33:41 -0500 Received: from mailgw01.mediatek.com ([210.61.82.183]:63952 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726666AbfLWLdl (ORCPT ); Mon, 23 Dec 2019 06:33:41 -0500 X-UUID: ff6927678b874ed6bc52e90e70d90812-20191223 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:Message-ID:Date:Subject:CC:To:From; bh=qX14vySNe6dWHS9CVDjOljRuxmLr34hwjucjAyQrc40=; b=hjqqHWujsKPp7M8G3XBepzWUuos1NXZO7NRHReI4zK9WxsB0H96Tdw1RN3Gdf3uxTi/KCiM4UTstKJ7K/MifEvdv74G7Scu7htGYhonscSWa33NWPVbWzLL7YmfSmKOpCBBFu9s55Ebebv1+Uxxc9I2Hg2msUn+kv+g99bAi+C0=; X-UUID: ff6927678b874ed6bc52e90e70d90812-20191223 Received: from mtkcas06.mediatek.inc [(172.21.101.30)] by mailgw01.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 13804429; Mon, 23 Dec 2019 19:33:30 +0800 Received: from mtkcas07.mediatek.inc (172.21.101.84) by mtkmbs06n2.mediatek.inc (172.21.101.130) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Mon, 23 Dec 2019 19:33:27 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkcas07.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Mon, 23 Dec 2019 19:32:33 +0800 From: Miles Chen To: Andrew Morton CC: Michal Hocko , , , , , Miles Chen Subject: [PATCH] mm/page_owner: print largest memory consumer when OOM panic occurs Date: Mon, 23 Dec 2019 19:33:26 +0800 Message-ID: <20191223113326.13828-1-miles.chen@mediatek.com> X-Mailer: git-send-email 2.18.0 MIME-Version: 1.0 Content-Type: text/plain X-TM-SNTS-SMTP: 9B750EF3048915A1305E13950C7313796853CA057EF394FBE0BAF085AE76E0202000:8 X-MTK: N Content-Transfer-Encoding: base64 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org TW90aXZhdGlvbjoNCi0tLS0tLS0tLS0tDQoNCldoZW4gZGVidWcgd2l0aCBhIE9PTSBrZXJuZWwg cGFuaWMsIGl0IGlzIGRpZmZpY3VsdCB0byBrbm93IHRoZQ0KbWVtb3J5IGFsbG9jYXRlZCBieSBr ZXJuZWwgZHJpdmVycyBvZiB2bWFsbG9jKCkgYnkgY2hlY2tpbmcgdGhlDQpNZW0tSW5mbyBvciBO b2RlL1pvbmUgaW5mby4gRm9yIGV4YW1wbGU6DQoNCiAgTWVtLUluZm86DQogIGFjdGl2ZV9hbm9u OjUxNDQgaW5hY3RpdmVfYW5vbjoxNjEyMCBpc29sYXRlZF9hbm9uOjANCiAgIGFjdGl2ZV9maWxl OjAgaW5hY3RpdmVfZmlsZTowIGlzb2xhdGVkX2ZpbGU6MA0KICAgdW5ldmljdGFibGU6MCBkaXJ0 eTowIHdyaXRlYmFjazowIHVuc3RhYmxlOjANCiAgIHNsYWJfcmVjbGFpbWFibGU6NzM5IHNsYWJf dW5yZWNsYWltYWJsZTo0NDI0NjkNCiAgIG1hcHBlZDo1MzQgc2htZW06MjEwNTAgcGFnZXRhYmxl czoyMSBib3VuY2U6MA0KICAgZnJlZToxNDgwOCBmcmVlX3BjcDozMzg5IGZyZWVfY21hOjgxMjgN Cg0KICBOb2RlIDAgYWN0aXZlX2Fub246MjA1NzZrQiBpbmFjdGl2ZV9hbm9uOjY0NDgwa0IgYWN0 aXZlX2ZpbGU6MGtCDQogIGluYWN0aXZlX2ZpbGU6MGtCIHVuZXZpY3RhYmxlOjBrQiBpc29sYXRl ZChhbm9uKTowa0IgaXNvbGF0ZWQoZmlsZSk6MGtCDQogIG1hcHBlZDoyMTM2a0IgZGlydHk6MGtC IHdyaXRlYmFjazowa0Igc2htZW06ODQyMDBrQiBzaG1lbV90aHA6IDBrQg0KICBzaG1lbV9wbWRt YXBwZWQ6IDBrQiBhbm9uX3RocDogMGtCIHdyaXRlYmFja190bXA6MGtCIHVuc3RhYmxlOjBrQg0K ICBhbGxfdW5yIGVjbGFpbWFibGU/IHllcw0KDQogIE5vZGUgMCBETUEgZnJlZToxNDQ3NmtCIG1p bjoyMTUxMmtCIGxvdzoyNjg4OGtCIGhpZ2g6MzIyNjRrQg0KICByZXNlcnZlZF9oaWdoYXRvbWlj OjBLQiBhY3RpdmVfYW5vbjowa0IgaW5hY3RpdmVfYW5vbjowa0INCiAgYWN0aXZlX2ZpbGU6IDBr QiBpbmFjdGl2ZV9maWxlOjBrQiB1bmV2aWN0YWJsZTowa0Igd3JpdGVwZW5kaW5nOjBrQg0KICBw cmVzZW50OjEwNDg1NzZrQiBtYW5hZ2VkOjk1MjczNmtCIG1sb2NrZWQ6MGtCIGtlcm5lbF9zdGFj azowa0INCiAgcGFnZXRhYmxlczowa0IgYm91bmNlOjBrQiBmcmVlX3BjcDoyNzE2a0IgbG9jYWxf cGNwOjBrQiBmcmVlX2NtYTowa0INCg0KVGhlIGluZm9ybWF0aW9uIGFib3ZlIHRlbGxzIHVzIHRo ZSBtZW1vcnkgdXNhZ2Ugb2YgdGhlIGtub3duIG1lbW9yeQ0KY2F0ZWdvcmllcyBhbmQgd2UgY2Fu IGNoZWNrIHRoZSBhYm5vcm1hbCBsYXJnZSBudW1iZXJzLiBIb3dldmVyLCBpZiBhDQptZW1vcnkg bGVha2FnZSBjYW5ub3QgYmUgb2JzZXJ2ZWQgaW4gdGhlIGNhdGVnb3JpZXMgYWJvdmUsIHdlIG5l ZWQgdG8NCnJlcHJvZHVjZSB0aGUgaXNzdWUgd2l0aCBDT05GSUdfUEFHRV9PV05FUi4NCg0KSXQg aXMgcG9zc2libGUgdG8gcmVhZCB0aGUgcGFnZSBvd25lciBpbmZvcm1hdGlvbiBmcm9tIGNvcmVk dW1wIGZpbGVzLg0KSG93ZXZlciwgY29yZWR1bXAgZmlsZXMgbWF5IG5vdCBhbHdheXMgYmUgYXZh aWxhYmxlLCBzbyBteSBhcHByb2FjaCBpcw0KdG8gcHJpbnQgb3V0IHRoZSBsYXJnZXN0IHBhZ2Ug Y29uc3VtZXIgd2hlbiBPT00ga2VybmVsIHBhbmljIG9jY3Vycy4NCg0KVGhlIGhldXJpc3RpYyBh cHByb2FjaCBhc3N1bWVzIHRoYXQgdGhlIE9PTSBrZXJuZWwgcGFuaWMgaXMgY2F1c2VkIGJ5DQph IHNpbmdsZSBiYWNrdHJhY2UuIFRoZSBhc3N1bXB0aW9uIGlzIG5vdCBhbHdheXMgdHJ1ZSBidXQg aXQgd29ya3MgaW4NCm1hbnkgY2FzZXMgZHVyaW5nIG91ciB0ZXN0Lg0KDQpXZSBoYXZlIHRlc3Rl ZCB0aGlzIGhldXJpc3RpYyBhcHByb2FjaCBzaW5jZSAyMDE5LzUgb24gYW5kcm9pZCBkZXZpY2Vz Lg0KSW4gMzggaW50ZXJuYWwgT09NIGtlcm5lbCBwYW5pYyByZXBvcnRzOg0KDQozMS8zODogY2Fu IGJlIGFuYWx5emVkIGJ5IHVzaW5nIGV4aXN0aW5nIGluZm9ybWF0aW9uDQo3LzM4OiBuZWVkIHBh Z2Ugb3duZXIgZm9ybWF0aW5vIGFuZCB0aGUgaGV1cmlzdGljIGFwcHJvYWNoIGluIHRoaXMgcGF0 Y2gNCnByaW50cyB0aGUgY29ycmVjdCBiYWNrdHJhY2VzIG9mIGFibm9ybWFsIG1lbW9yeSBhbGxv Y2F0aW9ucy4gTm8gbmVlZCB0bw0KcmVwcm9kdWNlIHRoZSBpc3N1ZXMuDQoNCk91dHB1dDoNCi0t LS0tLS0NCg0KVGhpcyBvdXRwdXQgYmVsb3cgaXMgZ2VuZXJhdGVkIGJ5IGEgZHVtbXkgaW5maW5p dGUNCmttYWxsb2MoMjU2LCBHRlBfS0VSTkVMKSBsb29wOg0KDQpbICAgNDkuNjkxMDI3XSBPT006 IGxhcmdlc3QgbWVtb3J5IGNvbnN1bWVyOiA0Mjg0NjggcGFnZXMgYXJlIGFsbG9jYXRlZCBmcm9t Og0KWyAgIDQ5LjY5MTI3OF0gIHByZXBfbmV3X3BhZ2UrMHgxOTgvMHgxOWMNClsgICA0OS42OTEz OTBdICBnZXRfcGFnZV9mcm9tX2ZyZWVsaXN0KzB4MWNiNC8weDFlNTQNClsgICA0OS42OTE1MDBd ICBfX2FsbG9jX3BhZ2VzX25vZGVtYXNrKzB4MTZjLzB4ZTEwDQpbICAgNDkuNjkxNTk5XSAgYWxs b2NfcGFnZXNfY3VycmVudCsweDEwNC8weDE5MA0KWyAgIDQ5LjY5MTY5N10gIGFsbG9jX3NsYWJf cGFnZSsweDE2MC8weDRlOA0KWyAgIDQ5LjY5MTc4Ml0gIG5ld19zbGFiKzB4YjgvMHg1MTANClsg ICA0OS42OTE4NjZdICBfX19zbGFiX2FsbG9jKzB4Mjk0LzB4M2RjDQpbICAgNDkuNjkxOTU3XSAg a21lbV9jYWNoZV9hbGxvYysweDFmMC8weDI1MA0KWyAgIDQ5LjY5MjA0N10gIG1lbWluZm9fcHJv Y19zaG93KzB4NjgvMHg4ZmMNClsgICA0OS42OTIxMzVdICBzZXFfcmVhZCsweDFkYy8weDQ3Yw0K WyAgIDQ5LjY5MjIxN10gIHByb2NfcmVnX3JlYWQrMHg1Yy8weGI0DQpbICAgNDkuNjkyMzAzXSAg ZG9faXRlcl9yZWFkKzB4ZGMvMHgxYzANClsgICA0OS42OTIzODldICB2ZnNfcmVhZHYrMHg2MC8w eGE4DQpbICAgNDkuNjkyNDcxXSAgZGVmYXVsdF9maWxlX3NwbGljZV9yZWFkKzB4MWYwLzB4MzA0 DQpbICAgNDkuNjkyNTgyXSAgc3BsaWNlX2RpcmVjdF90b19hY3RvcisweDEwMC8weDI5NA0KWyAg IDQ5LjY5MjY3OV0gIGRvX3NwbGljZV9kaXJlY3QrMHg3OC8weGM4DQpbICAgMzkuMzI4NjA3XSBL ZXJuZWwgcGFuaWMgLSBub3Qgc3luY2luZzogU3lzdGVtIGlzIGRlYWRsb2NrZWQgb24gbWVtb3J5 DQoNClNpZ25lZC1vZmYtYnk6IE1pbGVzIENoZW4gPG1pbGVzLmNoZW5AbWVkaWF0ZWsuY29tPg0K LS0tDQogaW5jbHVkZS9saW51eC9vb20uaCB8ICAgMSArDQogbW0vb29tX2tpbGwuYyAgICAgICB8 ICAgNCArKw0KIG1tL3BhZ2Vfb3duZXIuYyAgICAgfCAxMzUgKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysNCiAzIGZpbGVzIGNoYW5nZWQsIDE0MCBpbnNlcnRpb25z KCspDQoNCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L29vbS5oIGIvaW5jbHVkZS9saW51eC9v b20uaA0KaW5kZXggYzY5NmMyNjVmMDE5Li5mZTNjOTIzYWM4ZjMgMTAwNjQ0DQotLS0gYS9pbmNs dWRlL2xpbnV4L29vbS5oDQorKysgYi9pbmNsdWRlL2xpbnV4L29vbS5oDQpAQCAtMTIxLDYgKzEy MSw3IEBAIGV4dGVybiBib29sIG9vbV9raWxsZXJfZGlzYWJsZShzaWduZWQgbG9uZyB0aW1lb3V0 KTsNCiBleHRlcm4gdm9pZCBvb21fa2lsbGVyX2VuYWJsZSh2b2lkKTsNCiANCiBleHRlcm4gc3Ry dWN0IHRhc2tfc3RydWN0ICpmaW5kX2xvY2tfdGFza19tbShzdHJ1Y3QgdGFza19zdHJ1Y3QgKnAp Ow0KK2V4dGVybiB2b2lkIHJlcG9ydF9sYXJnZXN0X3BhZ2VfY29uc3VtZXIodm9pZCk7DQogDQog Lyogc3lzY3RscyAqLw0KIGV4dGVybiBpbnQgc3lzY3RsX29vbV9kdW1wX3Rhc2tzOw0KZGlmZiAt LWdpdCBhL21tL29vbV9raWxsLmMgYi9tbS9vb21fa2lsbC5jDQppbmRleCA3MWUzYWNlYTc4MTcu LjliMDY5YjVhNGFmZiAxMDA2NDQNCi0tLSBhL21tL29vbV9raWxsLmMNCisrKyBiL21tL29vbV9r aWxsLmMNCkBAIC00Miw2ICs0Miw3IEBADQogI2luY2x1ZGUgPGxpbnV4L2t0aHJlYWQuaD4NCiAj aW5jbHVkZSA8bGludXgvaW5pdC5oPg0KICNpbmNsdWRlIDxsaW51eC9tbXVfbm90aWZpZXIuaD4N CisjaW5jbHVkZSA8bGludXgvb25jZS5oPg0KIA0KICNpbmNsdWRlIDxhc20vdGxiLmg+DQogI2lu Y2x1ZGUgImludGVybmFsLmgiDQpAQCAtMTA5OSw2ICsxMTAwLDkgQEAgYm9vbCBvdXRfb2ZfbWVt b3J5KHN0cnVjdCBvb21fY29udHJvbCAqb2MpDQogCWlmICghb2MtPmNob3Nlbikgew0KIAkJZHVt cF9oZWFkZXIob2MsIE5VTEwpOw0KIAkJcHJfd2FybigiT3V0IG9mIG1lbW9yeSBhbmQgbm8ga2ls bGFibGUgcHJvY2Vzc2VzLi4uXG4iKTsNCisjaWZkZWYgQ09ORklHX1BBR0VfT1dORVINCisJCURP X09OQ0UocmVwb3J0X2xhcmdlc3RfcGFnZV9jb25zdW1lcik7DQorI2VuZGlmDQogCQkvKg0KIAkJ ICogSWYgd2UgZ290IGhlcmUgZHVlIHRvIGFuIGFjdHVhbCBhbGxvY2F0aW9uIGF0IHRoZQ0KIAkJ ICogc3lzdGVtIGxldmVsLCB3ZSBjYW5ub3Qgc3Vydml2ZSB0aGlzIGFuZCB3aWxsIGVudGVyDQpk aWZmIC0tZ2l0IGEvbW0vcGFnZV9vd25lci5jIGIvbW0vcGFnZV9vd25lci5jDQppbmRleCAxOGVj ZGU5ZjQ1YjIuLmIyM2U1ZmUzNWRhZCAxMDA2NDQNCi0tLSBhL21tL3BhZ2Vfb3duZXIuYw0KKysr IGIvbW0vcGFnZV9vd25lci5jDQpAQCAtMTAsNiArMTAsOCBAQA0KICNpbmNsdWRlIDxsaW51eC9t aWdyYXRlLmg+DQogI2luY2x1ZGUgPGxpbnV4L3N0YWNrZGVwb3QuaD4NCiAjaW5jbHVkZSA8bGlu dXgvc2VxX2ZpbGUuaD4NCisjaW5jbHVkZSA8bGludXgvc3RhY2t0cmFjZS5oPg0KKyNpbmNsdWRl IDxsaW51eC9oYXNodGFibGUuaD4NCiANCiAjaW5jbHVkZSAiaW50ZXJuYWwuaCINCiANCkBAIC0x OSwxMiArMjEsMTYgQEANCiAgKi8NCiAjZGVmaW5lIFBBR0VfT1dORVJfU1RBQ0tfREVQVEggKDE2 KQ0KIA0KKyNkZWZpbmUgT09NX0hBTkRMRV9IQVNIX0JJVFMJMTANCisNCiBzdHJ1Y3QgcGFnZV9v d25lciB7DQogCXVuc2lnbmVkIHNob3J0IG9yZGVyOw0KIAlzaG9ydCBsYXN0X21pZ3JhdGVfcmVh c29uOw0KIAlnZnBfdCBnZnBfbWFzazsNCiAJZGVwb3Rfc3RhY2tfaGFuZGxlX3QgaGFuZGxlOw0K IAlkZXBvdF9zdGFja19oYW5kbGVfdCBmcmVlX2hhbmRsZTsNCisJc3RydWN0IGhsaXN0X25vZGUg bm9kZTsNCisJdW5zaWduZWQgbG9uZyBwYWdlX2NvdW50OyAvKiBudW1iZXIgb2YgcGFnZXMgcG9p bnRzIHRvIHRoaXMgaGFuZGxlICovDQogfTsNCiANCiBzdGF0aWMgYm9vbCBwYWdlX293bmVyX2Vu YWJsZWQgPSBmYWxzZTsNCkBAIC0zMyw2ICszOSw4IEBAIERFRklORV9TVEFUSUNfS0VZX0ZBTFNF KHBhZ2Vfb3duZXJfaW5pdGVkKTsNCiBzdGF0aWMgZGVwb3Rfc3RhY2tfaGFuZGxlX3QgZHVtbXlf aGFuZGxlOw0KIHN0YXRpYyBkZXBvdF9zdGFja19oYW5kbGVfdCBmYWlsdXJlX2hhbmRsZTsNCiBz dGF0aWMgZGVwb3Rfc3RhY2tfaGFuZGxlX3QgZWFybHlfaGFuZGxlOw0KK3N0YXRpYyBERUZJTkVf SEFTSFRBQkxFKG9vbV9oYW5kbGVfaGFzaCwgT09NX0hBTkRMRV9IQVNIX0JJVFMpOw0KK3N0YXRp YyBzdHJ1Y3QgcGFnZV9vd25lciAqbW9zdF9yZWZlcmVuY2VkX3BhZ2Vfb3duZXI7DQogDQogc3Rh dGljIHZvaWQgaW5pdF9lYXJseV9hbGxvY2F0ZWRfcGFnZXModm9pZCk7DQogDQpAQCAtNDgsNiAr NTYsNTcgQEAgc3RhdGljIGludCBfX2luaXQgZWFybHlfcGFnZV9vd25lcl9wYXJhbShjaGFyICpi dWYpDQogfQ0KIGVhcmx5X3BhcmFtKCJwYWdlX293bmVyIiwgZWFybHlfcGFnZV9vd25lcl9wYXJh bSk7DQogDQorc3RhdGljIHN0cnVjdCBobGlzdF9oZWFkICpnZXRfYnVja2V0KGRlcG90X3N0YWNr X2hhbmRsZV90IGhhbmRsZSkNCit7DQorCXVuc2lnbmVkIGxvbmcgaGFzaDsNCisNCisJaGFzaCA9 IGhhc2hfbG9uZyhoYW5kbGUsIE9PTV9IQU5ETEVfSEFTSF9CSVRTKTsNCisJcmV0dXJuICZvb21f aGFuZGxlX2hhc2hbaGFzaF07DQorfQ0KKw0KKy8qDQorICogbG9va3VwIGEgcGFnZV9vd25lciBp biB0aGUgaGFzaCBidWNrZXQNCisgKi8NCitzdGF0aWMgc3RydWN0IHBhZ2Vfb3duZXIgKmxvb2t1 cF9wYWdlX293bmVyKGRlcG90X3N0YWNrX2hhbmRsZV90IGhhbmRsZSwNCisJCQkJCQlzdHJ1Y3Qg aGxpc3RfaGVhZCAqYikNCit7DQorCXN0cnVjdCBwYWdlX293bmVyICpwYWdlX293bmVyOw0KKw0K KwlobGlzdF9mb3JfZWFjaF9lbnRyeShwYWdlX293bmVyLCBiLCBub2RlKSB7DQorCQlpZiAocGFn ZV9vd25lci0+aGFuZGxlID09IGhhbmRsZSkNCisJCQlyZXR1cm4gcGFnZV9vd25lcjsNCisJfQ0K Kw0KKwlyZXR1cm4gTlVMTDsNCit9DQorDQorLyoNCisgKiBJbmNyZWFzZSB0aGUgcGFnZV9vd25l ci0+cGFnZV9jb3VudCBpbiB0aGUgaGFuZGxlX2hhc2ggYnkgKDEgPDwgb3JkZXIpDQorICovDQor c3RhdGljIHZvaWQgaW5jcmVhc2VfaGFuZGxlX2NvdW50KHN0cnVjdCBwYWdlX293bmVyICpwYWdl X293bmVyKQ0KK3sNCisJc3RydWN0IGhsaXN0X2hlYWQgKmJ1Y2tldDsNCisJc3RydWN0IHBhZ2Vf b3duZXIgKm93bmVyOw0KKw0KKwlidWNrZXQgPSBnZXRfYnVja2V0KHBhZ2Vfb3duZXItPmhhbmRs ZSk7DQorDQorCW93bmVyID0gbG9va3VwX3BhZ2Vfb3duZXIocGFnZV9vd25lci0+aGFuZGxlLCBi dWNrZXQpOw0KKw0KKwlpZiAoIW93bmVyKSB7DQorCQlvd25lciA9IHBhZ2Vfb3duZXI7DQorCQlo bGlzdF9hZGRfaGVhZCgmcGFnZV9vd25lci0+bm9kZSwgYnVja2V0KTsNCisJfQ0KKw0KKwkvKiBp bmNyZWFzZSBwYWdlIGNvdW50ZXIgKi8NCisJb3duZXItPnBhZ2VfY291bnQgKz0gKDEgPDwgb3du ZXItPm9yZGVyKTsNCisNCisJLyogdXBkYXRlIG1vc3RfcmVmZXJlbmNlZF9wYWdlX293bmVyICov DQorCWlmICghbW9zdF9yZWZlcmVuY2VkX3BhZ2Vfb3duZXIpDQorCQltb3N0X3JlZmVyZW5jZWRf cGFnZV9vd25lciA9IG93bmVyOw0KKwlpZiAobW9zdF9yZWZlcmVuY2VkX3BhZ2Vfb3duZXItPnBh Z2VfY291bnQgPCBvd25lci0+cGFnZV9jb3VudCkNCisJCW1vc3RfcmVmZXJlbmNlZF9wYWdlX293 bmVyID0gb3duZXI7DQorfQ0KKw0KIHN0YXRpYyBib29sIG5lZWRfcGFnZV9vd25lcih2b2lkKQ0K IHsNCiAJcmV0dXJuIHBhZ2Vfb3duZXJfZW5hYmxlZDsNCkBAIC0xNzIsNiArMjMxLDcgQEAgc3Rh dGljIGlubGluZSB2b2lkIF9fc2V0X3BhZ2Vfb3duZXJfaGFuZGxlKHN0cnVjdCBwYWdlICpwYWdl LA0KIAkJcGFnZV9vd25lci0+b3JkZXIgPSBvcmRlcjsNCiAJCXBhZ2Vfb3duZXItPmdmcF9tYXNr ID0gZ2ZwX21hc2s7DQogCQlwYWdlX293bmVyLT5sYXN0X21pZ3JhdGVfcmVhc29uID0gLTE7DQor CQlwYWdlX293bmVyLT5wYWdlX2NvdW50ID0gMDsNCiAJCV9fc2V0X2JpdChQQUdFX0VYVF9PV05F UiwgJnBhZ2VfZXh0LT5mbGFncyk7DQogCQlfX3NldF9iaXQoUEFHRV9FWFRfT1dORVJfQUxMT0NB VEVELCAmcGFnZV9leHQtPmZsYWdzKTsNCiANCkBAIC0yMTYsNiArMjc2LDcgQEAgdm9pZCBfX3Nw bGl0X3BhZ2Vfb3duZXIoc3RydWN0IHBhZ2UgKnBhZ2UsIHVuc2lnbmVkIGludCBvcmRlcikNCiAJ Zm9yIChpID0gMDsgaSA8ICgxIDw8IG9yZGVyKTsgaSsrKSB7DQogCQlwYWdlX293bmVyID0gZ2V0 X3BhZ2Vfb3duZXIocGFnZV9leHQpOw0KIAkJcGFnZV9vd25lci0+b3JkZXIgPSAwOw0KKwkJcGFn ZV9vd25lci0+cGFnZV9jb3VudCA9IDA7DQogCQlwYWdlX2V4dCA9IHBhZ2VfZXh0X25leHQocGFn ZV9leHQpOw0KIAl9DQogfQ0KQEAgLTIzNiw2ICsyOTcsNyBAQCB2b2lkIF9fY29weV9wYWdlX293 bmVyKHN0cnVjdCBwYWdlICpvbGRwYWdlLCBzdHJ1Y3QgcGFnZSAqbmV3cGFnZSkNCiAJbmV3X3Bh Z2Vfb3duZXItPmxhc3RfbWlncmF0ZV9yZWFzb24gPQ0KIAkJb2xkX3BhZ2Vfb3duZXItPmxhc3Rf bWlncmF0ZV9yZWFzb247DQogCW5ld19wYWdlX293bmVyLT5oYW5kbGUgPSBvbGRfcGFnZV9vd25l ci0+aGFuZGxlOw0KKwluZXdfcGFnZV9vd25lci0+cGFnZV9jb3VudCA9IG5ld19wYWdlX293bmVy LT5wYWdlX2NvdW50Ow0KIA0KIAkvKg0KIAkgKiBXZSBkb24ndCBjbGVhciB0aGUgYml0IG9uIHRo ZSBvbGRwYWdlIGFzIGl0J3MgZ29pbmcgdG8gYmUgZnJlZWQNCkBAIC02MTUsNiArNjc3LDc5IEBA IHN0YXRpYyB2b2lkIGluaXRfcGFnZXNfaW5fem9uZShwZ19kYXRhX3QgKnBnZGF0LCBzdHJ1Y3Qg em9uZSAqem9uZSkNCiAJCXBnZGF0LT5ub2RlX2lkLCB6b25lLT5uYW1lLCBjb3VudCk7DQogfQ0K IA0KK3N0YXRpYyB2b2lkIF9fcmVwb3J0X2xhcmdlc3RfcGFnZV9jb25zdW1lcihzdHJ1Y3QgcGFn ZV9vd25lciAqcGFnZV9vd25lcikNCit7DQorCXVuc2lnbmVkIGxvbmcgKmVudHJpZXMgPSBOVUxM Ow0KKwl1bnNpZ25lZCBpbnQgbnJfZW50cmllczsNCisNCisJbnJfZW50cmllcyA9IHN0YWNrX2Rl cG90X2ZldGNoKHBhZ2Vfb3duZXItPmhhbmRsZSwgJmVudHJpZXMpOw0KKwlwcl9pbmZvKCJPT006 IGxhcmdlc3QgbWVtb3J5IGNvbnN1bWVyOiAlbHUgcGFnZXMgYXJlIGFsbG9jYXRlZCBmcm9tOlxu IiwNCisJCQlwYWdlX293bmVyLT5wYWdlX2NvdW50KTsNCisJc3RhY2tfdHJhY2VfcHJpbnQoZW50 cmllcywgbnJfZW50cmllcywgMCk7DQorfQ0KKw0KK3ZvaWQgcmVwb3J0X2xhcmdlc3RfcGFnZV9j b25zdW1lcih2b2lkKQ0KK3sNCisJdW5zaWduZWQgbG9uZyBwZm47DQorCXN0cnVjdCBwYWdlICpw YWdlOw0KKwlzdHJ1Y3QgcGFnZV9leHQgKnBhZ2VfZXh0Ow0KKwlzdHJ1Y3QgcGFnZV9vd25lciAq cGFnZV9vd25lcjsNCisJZGVwb3Rfc3RhY2tfaGFuZGxlX3QgaGFuZGxlOw0KKw0KKwlwZm4gPSBt aW5fbG93X3BmbjsNCisNCisJaWYgKCFzdGF0aWNfYnJhbmNoX3VubGlrZWx5KCZwYWdlX293bmVy X2luaXRlZCkpDQorCQlyZXR1cm47DQorDQorCS8qIEZpbmQgYSB2YWxpZCBQRk4gb3IgdGhlIHN0 YXJ0IG9mIGEgTUFYX09SREVSX05SX1BBR0VTIGFyZWEgKi8NCisJd2hpbGUgKCFwZm5fdmFsaWQo cGZuKSAmJiAocGZuICYgKE1BWF9PUkRFUl9OUl9QQUdFUyAtIDEpKSAhPSAwKQ0KKwkJcGZuKys7 DQorDQorCS8qIEZpbmQgYW4gYWxsb2NhdGVkIHBhZ2UgKi8NCisJZm9yICg7IHBmbiA8IG1heF9w Zm47IHBmbisrKSB7DQorCQlpZiAoKHBmbiAmIChNQVhfT1JERVJfTlJfUEFHRVMgLSAxKSkgPT0g MCAmJiAhcGZuX3ZhbGlkKHBmbikpIHsNCisJCQlwZm4gKz0gTUFYX09SREVSX05SX1BBR0VTIC0g MTsNCisJCQljb250aW51ZTsNCisJCX0NCisNCisJCWlmICghcGZuX3ZhbGlkX3dpdGhpbihwZm4p KQ0KKwkJCWNvbnRpbnVlOw0KKw0KKwkJcGFnZSA9IHBmbl90b19wYWdlKHBmbik7DQorCQlpZiAo UGFnZUJ1ZGR5KHBhZ2UpKSB7DQorCQkJdW5zaWduZWQgbG9uZyBmcmVlcGFnZV9vcmRlciA9IHBh Z2Vfb3JkZXJfdW5zYWZlKHBhZ2UpOw0KKw0KKwkJCWlmIChmcmVlcGFnZV9vcmRlciA8IE1BWF9P UkRFUikNCisJCQkJcGZuICs9ICgxVUwgPDwgZnJlZXBhZ2Vfb3JkZXIpIC0gMTsNCisJCQljb250 aW51ZTsNCisJCX0NCisNCisJCWlmIChQYWdlUmVzZXJ2ZWQocGFnZSkpDQorCQkJY29udGludWU7 DQorDQorCQlwYWdlX2V4dCA9IGxvb2t1cF9wYWdlX2V4dChwYWdlKTsNCisJCWlmICh1bmxpa2Vs eSghcGFnZV9leHQpKQ0KKwkJCWNvbnRpbnVlOw0KKw0KKwkJaWYgKCF0ZXN0X2JpdChQQUdFX0VY VF9PV05FUl9BTExPQ0FURUQsICZwYWdlX2V4dC0+ZmxhZ3MpKQ0KKwkJCWNvbnRpbnVlOw0KKw0K KwkJcGFnZV9vd25lciA9IGdldF9wYWdlX293bmVyKHBhZ2VfZXh0KTsNCisNCisJCWlmICghSVNf QUxJR05FRChwZm4sIDEgPDwgcGFnZV9vd25lci0+b3JkZXIpKQ0KKwkJCWNvbnRpbnVlOw0KKw0K KwkJaGFuZGxlID0gUkVBRF9PTkNFKHBhZ2Vfb3duZXItPmhhbmRsZSk7DQorCQlpZiAoIWhhbmRs ZSkNCisJCQljb250aW51ZTsNCisNCisJCWluY3JlYXNlX2hhbmRsZV9jb3VudChwYWdlX293bmVy KTsNCisJfQ0KKw0KKwlfX3JlcG9ydF9sYXJnZXN0X3BhZ2VfY29uc3VtZXIobW9zdF9yZWZlcmVu Y2VkX3BhZ2Vfb3duZXIpOw0KK30NCisNCisNCiBzdGF0aWMgdm9pZCBpbml0X3pvbmVzX2luX25v ZGUocGdfZGF0YV90ICpwZ2RhdCkNCiB7DQogCXN0cnVjdCB6b25lICp6b25lOw0KLS0gDQoyLjE4 LjANCg== 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=-9.8 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY,USER_AGENT_GIT 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 C4155C2D0D6 for ; Mon, 23 Dec 2019 11:33:49 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 8B0A62063A for ; Mon, 23 Dec 2019 11:33:49 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Y7s+dLjl"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="hjqqHWuj" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8B0A62063A Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=mediatek.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:Message-ID:Date:Subject:To :From:Reply-To:Content-ID:Content-Description:Resent-Date:Resent-From: Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To:References: List-Owner; bh=0LkkjGBvLSh2rkH2fOUyqZmUb15XZ9KpOFwGoUWiE84=; b=Y7s+dLjlCdzUBf +eYZ0yR46wdj6vPu3xYKAEZuPjrXZcyCapVShV51sTSg2P1R5e95RQ73xNVpIq6MUu6x6KZPeW8Mq N+F450VFlKlCeV+7wSHPOz4Eor1JXi7sx1l5g8yghsQZ4vDgrTawBoPjL4dx0VF/cvvtOtzsH6dMH 0irn4ZeZ5dtjLmVdpqv5bfCY9r2jO6f58wUYm78QHL1UEOpsQcDo60W+fsfzyxCgq2SIepiz02CeB h6hbe2SExdLYor7tSG2lE0+P7VYzwatUmW+5fXlQmRrz1Vq7wloqgA6k9bgvKmMf97G7wt5lRJYx3 IIm1klIMCNAQVqI7T+QQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1ijLy1-0007H7-CF; Mon, 23 Dec 2019 11:33:41 +0000 Received: from mailgw01.mediatek.com ([216.200.240.184]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1ijLxy-0007GX-CK for linux-mediatek@lists.infradead.org; Mon, 23 Dec 2019 11:33:40 +0000 X-UUID: b97d5ce91e5d43f38b2268c197e5097b-20191223 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=mediatek.com; s=dk; h=Content-Transfer-Encoding:Content-Type:MIME-Version:Message-ID:Date:Subject:CC:To:From; bh=qX14vySNe6dWHS9CVDjOljRuxmLr34hwjucjAyQrc40=; b=hjqqHWujsKPp7M8G3XBepzWUuos1NXZO7NRHReI4zK9WxsB0H96Tdw1RN3Gdf3uxTi/KCiM4UTstKJ7K/MifEvdv74G7Scu7htGYhonscSWa33NWPVbWzLL7YmfSmKOpCBBFu9s55Ebebv1+Uxxc9I2Hg2msUn+kv+g99bAi+C0=; X-UUID: b97d5ce91e5d43f38b2268c197e5097b-20191223 Received: from mtkcas67.mediatek.inc [(172.29.193.45)] by mailgw01.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 534524938; Mon, 23 Dec 2019 03:33:32 -0800 Received: from MTKMBS06N2.mediatek.inc (172.21.101.130) by MTKMBS62N1.mediatek.inc (172.29.193.41) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Mon, 23 Dec 2019 03:34:02 -0800 Received: from mtkcas07.mediatek.inc (172.21.101.84) by mtkmbs06n2.mediatek.inc (172.21.101.130) with Microsoft SMTP Server (TLS) id 15.0.1395.4; Mon, 23 Dec 2019 19:33:27 +0800 Received: from mtksdccf07.mediatek.inc (172.21.84.99) by mtkcas07.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1395.4 via Frontend Transport; Mon, 23 Dec 2019 19:32:33 +0800 From: Miles Chen To: Andrew Morton Subject: [PATCH] mm/page_owner: print largest memory consumer when OOM panic occurs Date: Mon, 23 Dec 2019 19:33:26 +0800 Message-ID: <20191223113326.13828-1-miles.chen@mediatek.com> X-Mailer: git-send-email 2.18.0 MIME-Version: 1.0 X-TM-SNTS-SMTP: 9B750EF3048915A1305E13950C7313796853CA057EF394FBE0BAF085AE76E0202000:8 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20191223_033338_437180_1AAE0023 X-CRM114-Status: GOOD ( 20.59 ) X-BeenThere: linux-mediatek@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Michal Hocko , wsd_upstream@mediatek.com, linux-kernel@vger.kernel.org, linux-mm@kvack.org, Miles Chen , linux-mediatek@lists.infradead.org Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "Linux-mediatek" Errors-To: linux-mediatek-bounces+linux-mediatek=archiver.kernel.org@lists.infradead.org Motivation: ----------- When debug with a OOM kernel panic, it is difficult to know the memory allocated by kernel drivers of vmalloc() by checking the Mem-Info or Node/Zone info. For example: Mem-Info: active_anon:5144 inactive_anon:16120 isolated_anon:0 active_file:0 inactive_file:0 isolated_file:0 unevictable:0 dirty:0 writeback:0 unstable:0 slab_reclaimable:739 slab_unreclaimable:442469 mapped:534 shmem:21050 pagetables:21 bounce:0 free:14808 free_pcp:3389 free_cma:8128 Node 0 active_anon:20576kB inactive_anon:64480kB active_file:0kB inactive_file:0kB unevictable:0kB isolated(anon):0kB isolated(file):0kB mapped:2136kB dirty:0kB writeback:0kB shmem:84200kB shmem_thp: 0kB shmem_pmdmapped: 0kB anon_thp: 0kB writeback_tmp:0kB unstable:0kB all_unr eclaimable? yes Node 0 DMA free:14476kB min:21512kB low:26888kB high:32264kB reserved_highatomic:0KB active_anon:0kB inactive_anon:0kB active_file: 0kB inactive_file:0kB unevictable:0kB writepending:0kB present:1048576kB managed:952736kB mlocked:0kB kernel_stack:0kB pagetables:0kB bounce:0kB free_pcp:2716kB local_pcp:0kB free_cma:0kB The information above tells us the memory usage of the known memory categories and we can check the abnormal large numbers. However, if a memory leakage cannot be observed in the categories above, we need to reproduce the issue with CONFIG_PAGE_OWNER. It is possible to read the page owner information from coredump files. However, coredump files may not always be available, so my approach is to print out the largest page consumer when OOM kernel panic occurs. The heuristic approach assumes that the OOM kernel panic is caused by a single backtrace. The assumption is not always true but it works in many cases during our test. We have tested this heuristic approach since 2019/5 on android devices. In 38 internal OOM kernel panic reports: 31/38: can be analyzed by using existing information 7/38: need page owner formatino and the heuristic approach in this patch prints the correct backtraces of abnormal memory allocations. No need to reproduce the issues. Output: ------- This output below is generated by a dummy infinite kmalloc(256, GFP_KERNEL) loop: [ 49.691027] OOM: largest memory consumer: 428468 pages are allocated from: [ 49.691278] prep_new_page+0x198/0x19c [ 49.691390] get_page_from_freelist+0x1cb4/0x1e54 [ 49.691500] __alloc_pages_nodemask+0x16c/0xe10 [ 49.691599] alloc_pages_current+0x104/0x190 [ 49.691697] alloc_slab_page+0x160/0x4e8 [ 49.691782] new_slab+0xb8/0x510 [ 49.691866] ___slab_alloc+0x294/0x3dc [ 49.691957] kmem_cache_alloc+0x1f0/0x250 [ 49.692047] meminfo_proc_show+0x68/0x8fc [ 49.692135] seq_read+0x1dc/0x47c [ 49.692217] proc_reg_read+0x5c/0xb4 [ 49.692303] do_iter_read+0xdc/0x1c0 [ 49.692389] vfs_readv+0x60/0xa8 [ 49.692471] default_file_splice_read+0x1f0/0x304 [ 49.692582] splice_direct_to_actor+0x100/0x294 [ 49.692679] do_splice_direct+0x78/0xc8 [ 39.328607] Kernel panic - not syncing: System is deadlocked on memory Signed-off-by: Miles Chen --- include/linux/oom.h | 1 + mm/oom_kill.c | 4 ++ mm/page_owner.c | 135 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 140 insertions(+) diff --git a/include/linux/oom.h b/include/linux/oom.h index c696c265f019..fe3c923ac8f3 100644 --- a/include/linux/oom.h +++ b/include/linux/oom.h @@ -121,6 +121,7 @@ extern bool oom_killer_disable(signed long timeout); extern void oom_killer_enable(void); extern struct task_struct *find_lock_task_mm(struct task_struct *p); +extern void report_largest_page_consumer(void); /* sysctls */ extern int sysctl_oom_dump_tasks; diff --git a/mm/oom_kill.c b/mm/oom_kill.c index 71e3acea7817..9b069b5a4aff 100644 --- a/mm/oom_kill.c +++ b/mm/oom_kill.c @@ -42,6 +42,7 @@ #include #include #include +#include #include #include "internal.h" @@ -1099,6 +1100,9 @@ bool out_of_memory(struct oom_control *oc) if (!oc->chosen) { dump_header(oc, NULL); pr_warn("Out of memory and no killable processes...\n"); +#ifdef CONFIG_PAGE_OWNER + DO_ONCE(report_largest_page_consumer); +#endif /* * If we got here due to an actual allocation at the * system level, we cannot survive this and will enter diff --git a/mm/page_owner.c b/mm/page_owner.c index 18ecde9f45b2..b23e5fe35dad 100644 --- a/mm/page_owner.c +++ b/mm/page_owner.c @@ -10,6 +10,8 @@ #include #include #include +#include +#include #include "internal.h" @@ -19,12 +21,16 @@ */ #define PAGE_OWNER_STACK_DEPTH (16) +#define OOM_HANDLE_HASH_BITS 10 + struct page_owner { unsigned short order; short last_migrate_reason; gfp_t gfp_mask; depot_stack_handle_t handle; depot_stack_handle_t free_handle; + struct hlist_node node; + unsigned long page_count; /* number of pages points to this handle */ }; static bool page_owner_enabled = false; @@ -33,6 +39,8 @@ DEFINE_STATIC_KEY_FALSE(page_owner_inited); static depot_stack_handle_t dummy_handle; static depot_stack_handle_t failure_handle; static depot_stack_handle_t early_handle; +static DEFINE_HASHTABLE(oom_handle_hash, OOM_HANDLE_HASH_BITS); +static struct page_owner *most_referenced_page_owner; static void init_early_allocated_pages(void); @@ -48,6 +56,57 @@ static int __init early_page_owner_param(char *buf) } early_param("page_owner", early_page_owner_param); +static struct hlist_head *get_bucket(depot_stack_handle_t handle) +{ + unsigned long hash; + + hash = hash_long(handle, OOM_HANDLE_HASH_BITS); + return &oom_handle_hash[hash]; +} + +/* + * lookup a page_owner in the hash bucket + */ +static struct page_owner *lookup_page_owner(depot_stack_handle_t handle, + struct hlist_head *b) +{ + struct page_owner *page_owner; + + hlist_for_each_entry(page_owner, b, node) { + if (page_owner->handle == handle) + return page_owner; + } + + return NULL; +} + +/* + * Increase the page_owner->page_count in the handle_hash by (1 << order) + */ +static void increase_handle_count(struct page_owner *page_owner) +{ + struct hlist_head *bucket; + struct page_owner *owner; + + bucket = get_bucket(page_owner->handle); + + owner = lookup_page_owner(page_owner->handle, bucket); + + if (!owner) { + owner = page_owner; + hlist_add_head(&page_owner->node, bucket); + } + + /* increase page counter */ + owner->page_count += (1 << owner->order); + + /* update most_referenced_page_owner */ + if (!most_referenced_page_owner) + most_referenced_page_owner = owner; + if (most_referenced_page_owner->page_count < owner->page_count) + most_referenced_page_owner = owner; +} + static bool need_page_owner(void) { return page_owner_enabled; @@ -172,6 +231,7 @@ static inline void __set_page_owner_handle(struct page *page, page_owner->order = order; page_owner->gfp_mask = gfp_mask; page_owner->last_migrate_reason = -1; + page_owner->page_count = 0; __set_bit(PAGE_EXT_OWNER, &page_ext->flags); __set_bit(PAGE_EXT_OWNER_ALLOCATED, &page_ext->flags); @@ -216,6 +276,7 @@ void __split_page_owner(struct page *page, unsigned int order) for (i = 0; i < (1 << order); i++) { page_owner = get_page_owner(page_ext); page_owner->order = 0; + page_owner->page_count = 0; page_ext = page_ext_next(page_ext); } } @@ -236,6 +297,7 @@ void __copy_page_owner(struct page *oldpage, struct page *newpage) new_page_owner->last_migrate_reason = old_page_owner->last_migrate_reason; new_page_owner->handle = old_page_owner->handle; + new_page_owner->page_count = new_page_owner->page_count; /* * We don't clear the bit on the oldpage as it's going to be freed @@ -615,6 +677,79 @@ static void init_pages_in_zone(pg_data_t *pgdat, struct zone *zone) pgdat->node_id, zone->name, count); } +static void __report_largest_page_consumer(struct page_owner *page_owner) +{ + unsigned long *entries = NULL; + unsigned int nr_entries; + + nr_entries = stack_depot_fetch(page_owner->handle, &entries); + pr_info("OOM: largest memory consumer: %lu pages are allocated from:\n", + page_owner->page_count); + stack_trace_print(entries, nr_entries, 0); +} + +void report_largest_page_consumer(void) +{ + unsigned long pfn; + struct page *page; + struct page_ext *page_ext; + struct page_owner *page_owner; + depot_stack_handle_t handle; + + pfn = min_low_pfn; + + if (!static_branch_unlikely(&page_owner_inited)) + return; + + /* Find a valid PFN or the start of a MAX_ORDER_NR_PAGES area */ + while (!pfn_valid(pfn) && (pfn & (MAX_ORDER_NR_PAGES - 1)) != 0) + pfn++; + + /* Find an allocated page */ + for (; pfn < max_pfn; pfn++) { + if ((pfn & (MAX_ORDER_NR_PAGES - 1)) == 0 && !pfn_valid(pfn)) { + pfn += MAX_ORDER_NR_PAGES - 1; + continue; + } + + if (!pfn_valid_within(pfn)) + continue; + + page = pfn_to_page(pfn); + if (PageBuddy(page)) { + unsigned long freepage_order = page_order_unsafe(page); + + if (freepage_order < MAX_ORDER) + pfn += (1UL << freepage_order) - 1; + continue; + } + + if (PageReserved(page)) + continue; + + page_ext = lookup_page_ext(page); + if (unlikely(!page_ext)) + continue; + + if (!test_bit(PAGE_EXT_OWNER_ALLOCATED, &page_ext->flags)) + continue; + + page_owner = get_page_owner(page_ext); + + if (!IS_ALIGNED(pfn, 1 << page_owner->order)) + continue; + + handle = READ_ONCE(page_owner->handle); + if (!handle) + continue; + + increase_handle_count(page_owner); + } + + __report_largest_page_consumer(most_referenced_page_owner); +} + + static void init_zones_in_node(pg_data_t *pgdat) { struct zone *zone; -- 2.18.0 _______________________________________________ Linux-mediatek mailing list Linux-mediatek@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-mediatek