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 BE4C7C2BA2B for ; Wed, 15 Apr 2020 05:38:24 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 8109F206D9 for ; Wed, 15 Apr 2020 05:38:24 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="BVAQkPwa" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2393359AbgDOFiW (ORCPT ); Wed, 15 Apr 2020 01:38:22 -0400 Received: from mailgw01.mediatek.com ([210.61.82.183]:56475 "EHLO mailgw01.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S2393341AbgDOFiH (ORCPT ); Wed, 15 Apr 2020 01:38:07 -0400 X-UUID: 9dd3477c64f144f08a1f399c72c29e2b-20200415 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:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=KjQbJJUyEyrEGfSk6POU3EoJwAM5QvHYKRXXe00b6e8=; b=BVAQkPwa1AS91Bqj0WdEgLX9OLtpZQZy8jLf355HU38gR9RZr1F4rcJ9EDpx3C6WAp5B8OhgHUukoQgpW0dKJZN/kZhnxWTXCOsIpnEspCsMrXYBPC18QERId9wo70YiwqcUAIlZhM9N0lP5l4DGD4wmO4D8+jDTlSxOIVX4sSY=; X-UUID: 9dd3477c64f144f08a1f399c72c29e2b-20200415 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 644576048; Wed, 15 Apr 2020 13:38:02 +0800 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs06n2.mediatek.inc (172.21.101.130) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 15 Apr 2020 13:38:00 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Wed, 15 Apr 2020 13:37:58 +0800 From: Frankie Chang To: Joel Fernandes , Greg Kroah-Hartman CC: Todd Kjos , Martijn Coenen , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Christian Brauner , , , wsd_upstream , Jian-Min Liu , Frankie Chang Subject: [PATCH v2 1/1] binder: transaction latency tracking for user build Date: Wed, 15 Apr 2020 13:37:24 +0800 Message-ID: <1586929044-12708-2-git-send-email-Frankie.Chang@mediatek.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1586929044-12708-1-git-send-email-Frankie.Chang@mediatek.com> References: <1586759071.9539.15.camel@mtkswgap22> <1586929044-12708-1-git-send-email-Frankie.Chang@mediatek.com> MIME-Version: 1.0 Content-Type: text/plain X-TM-SNTS-SMTP: 90A2E6BEE053E9251A0E607B11B9A26F304E4D5EBE45716A7778AA8969227A4B2000: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 UmVjb3JkIHN0YXJ0L2VuZCB0aW1lc3RhbXAgdG8gYmluZGVyIHRyYW5zYWN0aW9uLg0KV2hlbiB0 cmFuc2FjdGlvbiBpcyBjb21wbGV0ZWQgb3IgdHJhbnNhY3Rpb24gaXMgZnJlZSwNCml0IHdvdWxk IGJlIGNoZWNrZWQgaWYgdHJhbnNhY3Rpb24gbGF0ZW5jeSBvdmVyIHRocmVzaG9sZCAoMiBzZWMp LA0KaWYgeWVzLCBwcmludGluZyByZWxhdGVkIGluZm9ybWF0aW9uIGZvciB0cmFjaW5nLg0KDQov KiBJbXBsZW1lbnQgZGV0YWlscyAqLw0KLSBBZGQgdHJhY2Vwb2ludC90cmFjZSBhdCBmcmVlIHRy YW5zYWN0aW9uLg0KICBTaW5jZSB0aGUgb3JpZ2luYWwgdHJhY2VfYmluZGVyX3RyYW5zYWN0aW9u X3JldmVpdmVkIGNhbm5vdA0KICBwcmVjaXNlbHkgcHJlc2VudCB0aGUgcmVhbCBmaW5pc2hlZCB0 aW1lIG9mIHRyYW5zYWN0aW9uLCBhZGRpbmcgYQ0KICB0cmFjZV9iaW5kZXJfZnJlZV90cmFuc2Fj dGlvbiBhdCB0aGUgcG9pbnQgb2YgZnJlZSB0cmFuc2FjdGlvbg0KICBtYXkgYmUgbW9yZSBjbG9z ZSB0byBpdC4NCg0KLSBBZGQgbGF0ZW5jeSB0cmFjZXIgbW9kdWxlIHRvIG1vbml0b3Igc2xvdyB0 cmFuc2FjdGlvbi4NCiAgVGhlIHRyYWNlX2JpbmRlcl9mcmVlX3RyYW5zYWN0aW9uIHdvdWxkIG5v dCBiZSBlbmFibGVkDQogIGJ5IGRlZmF1bHQuIE1vbml0b3Jpbmcgd2hpY2ggdHJhbnNhY3Rpb24g aXMgdG9vIHNsb3cgdG8NCiAgY2F1c2Ugc29tZSBvZiBleGNlcHRpb25zIGlzIGltcG9ydGFudC4g U28gd2UgaG9vayB0aGUNCiAgdHJhY2Vwb2ludCB0byBjYWxsIHRoZSBtb25pdG9yIGZ1bmN0aW9u Lg0KDQotIE1vdmUgc29tZSBzdHJ1Y3QgZnJvbSBjb3JlIGZpbGUgdG8gaGVhZGVyIGZpbGUuDQog IE5lZWQgc29tZSBzdHJ1Y3QgZGVmaW5lZCBpbiBjb3JlIGZpbGUgaW4gbGF0ZW5jeSB0cmFjZSBt b2R1bGUNCiAgSW4gYWRkaXRpb24sIG1vdmluZyBzdHJ1Y3RzIHRvIGhlYWRlciBmaWxlIG1ha2Vz IG1vZHVsZSBtb3JlDQogIGV4dGVuZGFibGUuDQoNClNpZ25lZC1vZmYtYnk6IEZyYW5raWUgQ2hh bmcgPEZyYW5raWUuQ2hhbmdAbWVkaWF0ZWsuY29tPg0KLS0tDQogZHJpdmVycy9hbmRyb2lkL0tj b25maWcgICAgICAgICAgICAgICAgIHwgICAgOCArKw0KIGRyaXZlcnMvYW5kcm9pZC9NYWtlZmls ZSAgICAgICAgICAgICAgICB8ICAgIDEgKw0KIGRyaXZlcnMvYW5kcm9pZC9iaW5kZXIuYyAgICAg ICAgICAgICAgICB8ICAyMzcgKysrKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQ0KIGRyaXZl cnMvYW5kcm9pZC9iaW5kZXJfaW50ZXJuYWwuaCAgICAgICB8ICAyMjcgKysrKysrKysrKysrKysr KysrKysrKysrKysrKysNCiBkcml2ZXJzL2FuZHJvaWQvYmluZGVyX2xhdGVuY3lfdHJhY2VyLmMg fCAgMTAwICsrKysrKysrKysrKysNCiBkcml2ZXJzL2FuZHJvaWQvYmluZGVyX3RyYWNlLmggICAg ICAgICAgfCAgIDM2ICsrKysrDQogNiBmaWxlcyBjaGFuZ2VkLCA0MDAgaW5zZXJ0aW9ucygrKSwg MjA5IGRlbGV0aW9ucygtKQ0KIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2FuZHJvaWQvYmlu ZGVyX2xhdGVuY3lfdHJhY2VyLmMNCg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYW5kcm9pZC9LY29u ZmlnIGIvZHJpdmVycy9hbmRyb2lkL0tjb25maWcNCmluZGV4IDZmZGYyYWIuLjdiYTgwZWIgMTAw NjQ0DQotLS0gYS9kcml2ZXJzL2FuZHJvaWQvS2NvbmZpZw0KKysrIGIvZHJpdmVycy9hbmRyb2lk L0tjb25maWcNCkBAIC01NCw2ICs1NCwxNCBAQCBjb25maWcgQU5EUk9JRF9CSU5ERVJfSVBDX1NF TEZURVNUDQogCSAgZXhoYXVzdGl2ZWx5IHdpdGggY29tYmluYXRpb25zIG9mIHZhcmlvdXMgYnVm ZmVyIHNpemVzIGFuZA0KIAkgIGFsaWdubWVudHMuDQogDQorY29uZmlnIEJJTkRFUl9VU0VSX1RS QUNLSU5HDQorCWJvb2wgIkFuZHJvaWQgQmluZGVyIHRyYW5zYWN0aW9uIHRyYWNraW5nIg0KKwlo ZWxwDQorCSAgVXNlZCBmb3IgdHJhY2sgYWJub3JtYWwgYmluZGVyIHRyYW5zYWN0aW9uIHdoaWNo IGlzIG92ZXIgMiBzZWNvbmRzLA0KKwkgIHdoZW4gdGhlIHRyYW5zYWN0aW9uIGlzIGRvbmUgb3Ig YmUgZnJlZSwgdGhpcyB0cmFuc2FjdGlvbiB3b3VsZCBiZQ0KKwkgIGNoZWNrZWQgd2hldGhlciBp dCBleGVjdXRlZCBvdmVydGltZS4NCisJICBJZiB5ZXMsIHByaW50aW5nIG91dCB0aGUgZGV0YWls IGluZm8gYWJvdXQgaXQuDQorDQogZW5kaWYgIyBpZiBBTkRST0lEDQogDQogZW5kbWVudQ0KZGlm ZiAtLWdpdCBhL2RyaXZlcnMvYW5kcm9pZC9NYWtlZmlsZSBiL2RyaXZlcnMvYW5kcm9pZC9NYWtl ZmlsZQ0KaW5kZXggYzlkM2QwYzkuLjU1MmU4YWMgMTAwNjQ0DQotLS0gYS9kcml2ZXJzL2FuZHJv aWQvTWFrZWZpbGUNCisrKyBiL2RyaXZlcnMvYW5kcm9pZC9NYWtlZmlsZQ0KQEAgLTQsMyArNCw0 IEBAIGNjZmxhZ3MteSArPSAtSSQoc3JjKQkJCSMgbmVlZGVkIGZvciB0cmFjZSBldmVudHMNCiBv YmotJChDT05GSUdfQU5EUk9JRF9CSU5ERVJGUykJCSs9IGJpbmRlcmZzLm8NCiBvYmotJChDT05G SUdfQU5EUk9JRF9CSU5ERVJfSVBDKQkrPSBiaW5kZXIubyBiaW5kZXJfYWxsb2Mubw0KIG9iai0k KENPTkZJR19BTkRST0lEX0JJTkRFUl9JUENfU0VMRlRFU1QpICs9IGJpbmRlcl9hbGxvY19zZWxm dGVzdC5vDQorb2JqLSQoQ09ORklHX0JJTkRFUl9VU0VSX1RSQUNLSU5HKQkrPSBiaW5kZXJfbGF0 ZW5jeV90cmFjZXIubw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYW5kcm9pZC9iaW5kZXIuYyBiL2Ry aXZlcnMvYW5kcm9pZC9iaW5kZXIuYw0KaW5kZXggYTZiMjA4Mi4uMzgwYTY4YiAxMDA2NDQNCi0t LSBhL2RyaXZlcnMvYW5kcm9pZC9iaW5kZXIuYw0KKysrIGIvZHJpdmVycy9hbmRyb2lkL2JpbmRl ci5jDQpAQCAtMTYwLDI0ICsxNjAsNiBAQCBzdGF0aWMgaW50IGJpbmRlcl9zZXRfc3RvcF9vbl91 c2VyX2Vycm9yKGNvbnN0IGNoYXIgKnZhbCwNCiAjZGVmaW5lIHRvX2JpbmRlcl9mZF9hcnJheV9v YmplY3QoaGRyKSBcDQogCWNvbnRhaW5lcl9vZihoZHIsIHN0cnVjdCBiaW5kZXJfZmRfYXJyYXlf b2JqZWN0LCBoZHIpDQogDQotZW51bSBiaW5kZXJfc3RhdF90eXBlcyB7DQotCUJJTkRFUl9TVEFU X1BST0MsDQotCUJJTkRFUl9TVEFUX1RIUkVBRCwNCi0JQklOREVSX1NUQVRfTk9ERSwNCi0JQklO REVSX1NUQVRfUkVGLA0KLQlCSU5ERVJfU1RBVF9ERUFUSCwNCi0JQklOREVSX1NUQVRfVFJBTlNB Q1RJT04sDQotCUJJTkRFUl9TVEFUX1RSQU5TQUNUSU9OX0NPTVBMRVRFLA0KLQlCSU5ERVJfU1RB VF9DT1VOVA0KLX07DQotDQotc3RydWN0IGJpbmRlcl9zdGF0cyB7DQotCWF0b21pY190IGJyW19J T0NfTlIoQlJfRkFJTEVEX1JFUExZKSArIDFdOw0KLQlhdG9taWNfdCBiY1tfSU9DX05SKEJDX1JF UExZX1NHKSArIDFdOw0KLQlhdG9taWNfdCBvYmpfY3JlYXRlZFtCSU5ERVJfU1RBVF9DT1VOVF07 DQotCWF0b21pY190IG9ial9kZWxldGVkW0JJTkRFUl9TVEFUX0NPVU5UXTsNCi19Ow0KLQ0KIHN0 YXRpYyBzdHJ1Y3QgYmluZGVyX3N0YXRzIGJpbmRlcl9zdGF0czsNCiANCiBzdGF0aWMgaW5saW5l IHZvaWQgYmluZGVyX3N0YXRzX2RlbGV0ZWQoZW51bSBiaW5kZXJfc3RhdF90eXBlcyB0eXBlKQ0K QEAgLTIxNCwzMiArMTk2LDYgQEAgc3RhdGljIHN0cnVjdCBiaW5kZXJfdHJhbnNhY3Rpb25fbG9n X2VudHJ5ICpiaW5kZXJfdHJhbnNhY3Rpb25fbG9nX2FkZCgNCiB9DQogDQogLyoqDQotICogc3Ry dWN0IGJpbmRlcl93b3JrIC0gd29yayBlbnF1ZXVlZCBvbiBhIHdvcmtsaXN0DQotICogQGVudHJ5 OiAgICAgICAgICAgICBub2RlIGVucXVldWVkIG9uIGxpc3QNCi0gKiBAdHlwZTogICAgICAgICAg ICAgIHR5cGUgb2Ygd29yayB0byBiZSBwZXJmb3JtZWQNCi0gKg0KLSAqIFRoZXJlIGFyZSBzZXBh cmF0ZSB3b3JrIGxpc3RzIGZvciBwcm9jLCB0aHJlYWQsIGFuZCBub2RlIChhc3luYykuDQotICov DQotc3RydWN0IGJpbmRlcl93b3JrIHsNCi0Jc3RydWN0IGxpc3RfaGVhZCBlbnRyeTsNCi0NCi0J ZW51bSB7DQotCQlCSU5ERVJfV09SS19UUkFOU0FDVElPTiA9IDEsDQotCQlCSU5ERVJfV09SS19U UkFOU0FDVElPTl9DT01QTEVURSwNCi0JCUJJTkRFUl9XT1JLX1JFVFVSTl9FUlJPUiwNCi0JCUJJ TkRFUl9XT1JLX05PREUsDQotCQlCSU5ERVJfV09SS19ERUFEX0JJTkRFUiwNCi0JCUJJTkRFUl9X T1JLX0RFQURfQklOREVSX0FORF9DTEVBUiwNCi0JCUJJTkRFUl9XT1JLX0NMRUFSX0RFQVRIX05P VElGSUNBVElPTiwNCi0JfSB0eXBlOw0KLX07DQotDQotc3RydWN0IGJpbmRlcl9lcnJvciB7DQot CXN0cnVjdCBiaW5kZXJfd29yayB3b3JrOw0KLQl1aW50MzJfdCBjbWQ7DQotfTsNCi0NCi0vKioN CiAgKiBzdHJ1Y3QgYmluZGVyX25vZGUgLSBiaW5kZXIgbm9kZSBib29ra2VlcGluZw0KICAqIEBk ZWJ1Z19pZDogICAgICAgICAgICAgdW5pcXVlIElEIGZvciBkZWJ1Z2dpbmcNCiAgKiAgICAgICAg ICAgICAgICAgICAgICAgIChpbnZhcmlhbnQgYWZ0ZXIgaW5pdGlhbGl6ZWQpDQpAQCAtNDAyLDg5 ICszNTgsNiBAQCBlbnVtIGJpbmRlcl9kZWZlcnJlZF9zdGF0ZSB7DQogCUJJTkRFUl9ERUZFUlJF RF9SRUxFQVNFICAgICAgPSAweDAyLA0KIH07DQogDQotLyoqDQotICogc3RydWN0IGJpbmRlcl9w cm9jIC0gYmluZGVyIHByb2Nlc3MgYm9va2tlZXBpbmcNCi0gKiBAcHJvY19ub2RlOiAgICAgICAg ICAgIGVsZW1lbnQgZm9yIGJpbmRlcl9wcm9jcyBsaXN0DQotICogQHRocmVhZHM6ICAgICAgICAg ICAgICByYnRyZWUgb2YgYmluZGVyX3RocmVhZHMgaW4gdGhpcyBwcm9jDQotICogICAgICAgICAg ICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5IEBpbm5lcl9sb2NrKQ0KLSAqIEBub2RlczogICAg ICAgICAgICAgICAgcmJ0cmVlIG9mIGJpbmRlciBub2RlcyBhc3NvY2lhdGVkIHdpdGgNCi0gKiAg ICAgICAgICAgICAgICAgICAgICAgIHRoaXMgcHJvYyBvcmRlcmVkIGJ5IG5vZGUtPnB0cg0KLSAq ICAgICAgICAgICAgICAgICAgICAgICAgKHByb3RlY3RlZCBieSBAaW5uZXJfbG9jaykNCi0gKiBA cmVmc19ieV9kZXNjOiAgICAgICAgIHJidHJlZSBvZiByZWZzIG9yZGVyZWQgYnkgcmVmLT5kZXNj DQotICogICAgICAgICAgICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5IEBvdXRlcl9sb2NrKQ0K LSAqIEByZWZzX2J5X25vZGU6ICAgICAgICAgcmJ0cmVlIG9mIHJlZnMgb3JkZXJlZCBieSByZWYt Pm5vZGUNCi0gKiAgICAgICAgICAgICAgICAgICAgICAgIChwcm90ZWN0ZWQgYnkgQG91dGVyX2xv Y2spDQotICogQHdhaXRpbmdfdGhyZWFkczogICAgICB0aHJlYWRzIGN1cnJlbnRseSB3YWl0aW5n IGZvciBwcm9jIHdvcmsNCi0gKiAgICAgICAgICAgICAgICAgICAgICAgIChwcm90ZWN0ZWQgYnkg QGlubmVyX2xvY2spDQotICogQHBpZCAgICAgICAgICAgICAgICAgICBQSUQgb2YgZ3JvdXBfbGVh ZGVyIG9mIHByb2Nlc3MNCi0gKiAgICAgICAgICAgICAgICAgICAgICAgIChpbnZhcmlhbnQgYWZ0 ZXIgaW5pdGlhbGl6ZWQpDQotICogQHRzayAgICAgICAgICAgICAgICAgICB0YXNrX3N0cnVjdCBm b3IgZ3JvdXBfbGVhZGVyIG9mIHByb2Nlc3MNCi0gKiAgICAgICAgICAgICAgICAgICAgICAgIChp bnZhcmlhbnQgYWZ0ZXIgaW5pdGlhbGl6ZWQpDQotICogQGRlZmVycmVkX3dvcmtfbm9kZTogICBl bGVtZW50IGZvciBiaW5kZXJfZGVmZXJyZWRfbGlzdA0KLSAqICAgICAgICAgICAgICAgICAgICAg ICAgKHByb3RlY3RlZCBieSBiaW5kZXJfZGVmZXJyZWRfbG9jaykNCi0gKiBAZGVmZXJyZWRfd29y azogICAgICAgIGJpdG1hcCBvZiBkZWZlcnJlZCB3b3JrIHRvIHBlcmZvcm0NCi0gKiAgICAgICAg ICAgICAgICAgICAgICAgIChwcm90ZWN0ZWQgYnkgYmluZGVyX2RlZmVycmVkX2xvY2spDQotICog QGlzX2RlYWQ6ICAgICAgICAgICAgICBwcm9jZXNzIGlzIGRlYWQgYW5kIGF3YWl0aW5nIGZyZWUN Ci0gKiAgICAgICAgICAgICAgICAgICAgICAgIHdoZW4gb3V0c3RhbmRpbmcgdHJhbnNhY3Rpb25z IGFyZSBjbGVhbmVkIHVwDQotICogICAgICAgICAgICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5 IEBpbm5lcl9sb2NrKQ0KLSAqIEB0b2RvOiAgICAgICAgICAgICAgICAgbGlzdCBvZiB3b3JrIGZv ciB0aGlzIHByb2Nlc3MNCi0gKiAgICAgICAgICAgICAgICAgICAgICAgIChwcm90ZWN0ZWQgYnkg QGlubmVyX2xvY2spDQotICogQHN0YXRzOiAgICAgICAgICAgICAgICBwZXItcHJvY2VzcyBiaW5k ZXIgc3RhdGlzdGljcw0KLSAqICAgICAgICAgICAgICAgICAgICAgICAgKGF0b21pY3MsIG5vIGxv Y2sgbmVlZGVkKQ0KLSAqIEBkZWxpdmVyZWRfZGVhdGg6ICAgICAgbGlzdCBvZiBkZWxpdmVyZWQg ZGVhdGggbm90aWZpY2F0aW9uDQotICogICAgICAgICAgICAgICAgICAgICAgICAocHJvdGVjdGVk IGJ5IEBpbm5lcl9sb2NrKQ0KLSAqIEBtYXhfdGhyZWFkczogICAgICAgICAgY2FwIG9uIG51bWJl ciBvZiBiaW5kZXIgdGhyZWFkcw0KLSAqICAgICAgICAgICAgICAgICAgICAgICAgKHByb3RlY3Rl ZCBieSBAaW5uZXJfbG9jaykNCi0gKiBAcmVxdWVzdGVkX3RocmVhZHM6ICAgIG51bWJlciBvZiBi aW5kZXIgdGhyZWFkcyByZXF1ZXN0ZWQgYnV0IG5vdA0KLSAqICAgICAgICAgICAgICAgICAgICAg ICAgeWV0IHN0YXJ0ZWQuIEluIGN1cnJlbnQgaW1wbGVtZW50YXRpb24sIGNhbg0KLSAqICAgICAg ICAgICAgICAgICAgICAgICAgb25seSBiZSAwIG9yIDEuDQotICogICAgICAgICAgICAgICAgICAg ICAgICAocHJvdGVjdGVkIGJ5IEBpbm5lcl9sb2NrKQ0KLSAqIEByZXF1ZXN0ZWRfdGhyZWFkc19z dGFydGVkOiBudW1iZXIgYmluZGVyIHRocmVhZHMgc3RhcnRlZA0KLSAqICAgICAgICAgICAgICAg ICAgICAgICAgKHByb3RlY3RlZCBieSBAaW5uZXJfbG9jaykNCi0gKiBAdG1wX3JlZjogICAgICAg ICAgICAgIHRlbXBvcmFyeSByZWZlcmVuY2UgdG8gaW5kaWNhdGUgcHJvYyBpcyBpbiB1c2UNCi0g KiAgICAgICAgICAgICAgICAgICAgICAgIChwcm90ZWN0ZWQgYnkgQGlubmVyX2xvY2spDQotICog QGRlZmF1bHRfcHJpb3JpdHk6ICAgICBkZWZhdWx0IHNjaGVkdWxlciBwcmlvcml0eQ0KLSAqICAg ICAgICAgICAgICAgICAgICAgICAgKGludmFyaWFudCBhZnRlciBpbml0aWFsaXplZCkNCi0gKiBA ZGVidWdmc19lbnRyeTogICAgICAgIGRlYnVnZnMgbm9kZQ0KLSAqIEBhbGxvYzogICAgICAgICAg ICAgICAgYmluZGVyIGFsbG9jYXRvciBib29ra2VlcGluZw0KLSAqIEBjb250ZXh0OiAgICAgICAg ICAgICAgYmluZGVyX2NvbnRleHQgZm9yIHRoaXMgcHJvYw0KLSAqICAgICAgICAgICAgICAgICAg ICAgICAgKGludmFyaWFudCBhZnRlciBpbml0aWFsaXplZCkNCi0gKiBAaW5uZXJfbG9jazogICAg ICAgICAgIGNhbiBuZXN0IHVuZGVyIG91dGVyX2xvY2sgYW5kL29yIG5vZGUgbG9jaw0KLSAqIEBv dXRlcl9sb2NrOiAgICAgICAgICAgbm8gbmVzdGluZyB1bmRlciBpbm5vciBvciBub2RlIGxvY2sN Ci0gKiAgICAgICAgICAgICAgICAgICAgICAgIExvY2sgb3JkZXI6IDEpIG91dGVyLCAyKSBub2Rl LCAzKSBpbm5lcg0KLSAqIEBiaW5kZXJmc19lbnRyeTogICAgICAgcHJvY2Vzcy1zcGVjaWZpYyBi aW5kZXJmcyBsb2cgZmlsZQ0KLSAqDQotICogQm9va2tlZXBpbmcgc3RydWN0dXJlIGZvciBiaW5k ZXIgcHJvY2Vzc2VzDQotICovDQotc3RydWN0IGJpbmRlcl9wcm9jIHsNCi0Jc3RydWN0IGhsaXN0 X25vZGUgcHJvY19ub2RlOw0KLQlzdHJ1Y3QgcmJfcm9vdCB0aHJlYWRzOw0KLQlzdHJ1Y3QgcmJf cm9vdCBub2RlczsNCi0Jc3RydWN0IHJiX3Jvb3QgcmVmc19ieV9kZXNjOw0KLQlzdHJ1Y3QgcmJf cm9vdCByZWZzX2J5X25vZGU7DQotCXN0cnVjdCBsaXN0X2hlYWQgd2FpdGluZ190aHJlYWRzOw0K LQlpbnQgcGlkOw0KLQlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzazsNCi0Jc3RydWN0IGhsaXN0X25v ZGUgZGVmZXJyZWRfd29ya19ub2RlOw0KLQlpbnQgZGVmZXJyZWRfd29yazsNCi0JYm9vbCBpc19k ZWFkOw0KLQ0KLQlzdHJ1Y3QgbGlzdF9oZWFkIHRvZG87DQotCXN0cnVjdCBiaW5kZXJfc3RhdHMg c3RhdHM7DQotCXN0cnVjdCBsaXN0X2hlYWQgZGVsaXZlcmVkX2RlYXRoOw0KLQlpbnQgbWF4X3Ro cmVhZHM7DQotCWludCByZXF1ZXN0ZWRfdGhyZWFkczsNCi0JaW50IHJlcXVlc3RlZF90aHJlYWRz X3N0YXJ0ZWQ7DQotCWludCB0bXBfcmVmOw0KLQlsb25nIGRlZmF1bHRfcHJpb3JpdHk7DQotCXN0 cnVjdCBkZW50cnkgKmRlYnVnZnNfZW50cnk7DQotCXN0cnVjdCBiaW5kZXJfYWxsb2MgYWxsb2M7 DQotCXN0cnVjdCBiaW5kZXJfY29udGV4dCAqY29udGV4dDsNCi0Jc3BpbmxvY2tfdCBpbm5lcl9s b2NrOw0KLQlzcGlubG9ja190IG91dGVyX2xvY2s7DQotCXN0cnVjdCBkZW50cnkgKmJpbmRlcmZz X2VudHJ5Ow0KLX07DQotDQogZW51bSB7DQogCUJJTkRFUl9MT09QRVJfU1RBVEVfUkVHSVNURVJF RCAgPSAweDAxLA0KIAlCSU5ERVJfTE9PUEVSX1NUQVRFX0VOVEVSRUQgICAgID0gMHgwMiwNCkBA IC00OTUsNjAgKzM2OCw2IEBAIGVudW0gew0KIH07DQogDQogLyoqDQotICogc3RydWN0IGJpbmRl cl90aHJlYWQgLSBiaW5kZXIgdGhyZWFkIGJvb2trZWVwaW5nDQotICogQHByb2M6ICAgICAgICAg ICAgICAgICBiaW5kZXIgcHJvY2VzcyBmb3IgdGhpcyB0aHJlYWQNCi0gKiAgICAgICAgICAgICAg ICAgICAgICAgIChpbnZhcmlhbnQgYWZ0ZXIgaW5pdGlhbGl6YXRpb24pDQotICogQHJiX25vZGU6 ICAgICAgICAgICAgICBlbGVtZW50IGZvciBwcm9jLT50aHJlYWRzIHJidHJlZQ0KLSAqICAgICAg ICAgICAgICAgICAgICAgICAgKHByb3RlY3RlZCBieSBAcHJvYy0+aW5uZXJfbG9jaykNCi0gKiBA d2FpdGluZ190aHJlYWRfbm9kZTogIGVsZW1lbnQgZm9yIEBwcm9jLT53YWl0aW5nX3RocmVhZHMg bGlzdA0KLSAqICAgICAgICAgICAgICAgICAgICAgICAgKHByb3RlY3RlZCBieSBAcHJvYy0+aW5u ZXJfbG9jaykNCi0gKiBAcGlkOiAgICAgICAgICAgICAgICAgIFBJRCBmb3IgdGhpcyB0aHJlYWQN Ci0gKiAgICAgICAgICAgICAgICAgICAgICAgIChpbnZhcmlhbnQgYWZ0ZXIgaW5pdGlhbGl6YXRp b24pDQotICogQGxvb3BlcjogICAgICAgICAgICAgICBiaXRtYXAgb2YgbG9vcGluZyBzdGF0ZQ0K LSAqICAgICAgICAgICAgICAgICAgICAgICAgKG9ubHkgYWNjZXNzZWQgYnkgdGhpcyB0aHJlYWQp DQotICogQGxvb3Blcl9uZWVkc19yZXR1cm46ICBsb29waW5nIHRocmVhZCBuZWVkcyB0byBleGl0 IGRyaXZlcg0KLSAqICAgICAgICAgICAgICAgICAgICAgICAgKG5vIGxvY2sgbmVlZGVkKQ0KLSAq IEB0cmFuc2FjdGlvbl9zdGFjazogICAgc3RhY2sgb2YgaW4tcHJvZ3Jlc3MgdHJhbnNhY3Rpb25z IGZvciB0aGlzIHRocmVhZA0KLSAqICAgICAgICAgICAgICAgICAgICAgICAgKHByb3RlY3RlZCBi eSBAcHJvYy0+aW5uZXJfbG9jaykNCi0gKiBAdG9kbzogICAgICAgICAgICAgICAgIGxpc3Qgb2Yg d29yayB0byBkbyBmb3IgdGhpcyB0aHJlYWQNCi0gKiAgICAgICAgICAgICAgICAgICAgICAgIChw cm90ZWN0ZWQgYnkgQHByb2MtPmlubmVyX2xvY2spDQotICogQHByb2Nlc3NfdG9kbzogICAgICAg ICB3aGV0aGVyIHdvcmsgaW4gQHRvZG8gc2hvdWxkIGJlIHByb2Nlc3NlZA0KLSAqICAgICAgICAg ICAgICAgICAgICAgICAgKHByb3RlY3RlZCBieSBAcHJvYy0+aW5uZXJfbG9jaykNCi0gKiBAcmV0 dXJuX2Vycm9yOiAgICAgICAgIHRyYW5zYWN0aW9uIGVycm9ycyByZXBvcnRlZCBieSB0aGlzIHRo cmVhZA0KLSAqICAgICAgICAgICAgICAgICAgICAgICAgKG9ubHkgYWNjZXNzZWQgYnkgdGhpcyB0 aHJlYWQpDQotICogQHJlcGx5X2Vycm9yOiAgICAgICAgICB0cmFuc2FjdGlvbiBlcnJvcnMgcmVw b3J0ZWQgYnkgdGFyZ2V0IHRocmVhZA0KLSAqICAgICAgICAgICAgICAgICAgICAgICAgKHByb3Rl Y3RlZCBieSBAcHJvYy0+aW5uZXJfbG9jaykNCi0gKiBAd2FpdDogICAgICAgICAgICAgICAgIHdh aXQgcXVldWUgZm9yIHRocmVhZCB3b3JrDQotICogQHN0YXRzOiAgICAgICAgICAgICAgICBwZXIt dGhyZWFkIHN0YXRpc3RpY3MNCi0gKiAgICAgICAgICAgICAgICAgICAgICAgIChhdG9taWNzLCBu byBsb2NrIG5lZWRlZCkNCi0gKiBAdG1wX3JlZjogICAgICAgICAgICAgIHRlbXBvcmFyeSByZWZl cmVuY2UgdG8gaW5kaWNhdGUgdGhyZWFkIGlzIGluIHVzZQ0KLSAqICAgICAgICAgICAgICAgICAg ICAgICAgKGF0b21pYyBzaW5jZSBAcHJvYy0+aW5uZXJfbG9jayBjYW5ub3QNCi0gKiAgICAgICAg ICAgICAgICAgICAgICAgIGFsd2F5cyBiZSBhY3F1aXJlZCkNCi0gKiBAaXNfZGVhZDogICAgICAg ICAgICAgIHRocmVhZCBpcyBkZWFkIGFuZCBhd2FpdGluZyBmcmVlDQotICogICAgICAgICAgICAg ICAgICAgICAgICB3aGVuIG91dHN0YW5kaW5nIHRyYW5zYWN0aW9ucyBhcmUgY2xlYW5lZCB1cA0K LSAqICAgICAgICAgICAgICAgICAgICAgICAgKHByb3RlY3RlZCBieSBAcHJvYy0+aW5uZXJfbG9j aykNCi0gKg0KLSAqIEJvb2trZWVwaW5nIHN0cnVjdHVyZSBmb3IgYmluZGVyIHRocmVhZHMuDQot ICovDQotc3RydWN0IGJpbmRlcl90aHJlYWQgew0KLQlzdHJ1Y3QgYmluZGVyX3Byb2MgKnByb2M7 DQotCXN0cnVjdCByYl9ub2RlIHJiX25vZGU7DQotCXN0cnVjdCBsaXN0X2hlYWQgd2FpdGluZ190 aHJlYWRfbm9kZTsNCi0JaW50IHBpZDsNCi0JaW50IGxvb3BlcjsgICAgICAgICAgICAgIC8qIG9u bHkgbW9kaWZpZWQgYnkgdGhpcyB0aHJlYWQgKi8NCi0JYm9vbCBsb29wZXJfbmVlZF9yZXR1cm47 IC8qIGNhbiBiZSB3cml0dGVuIGJ5IG90aGVyIHRocmVhZCAqLw0KLQlzdHJ1Y3QgYmluZGVyX3Ry YW5zYWN0aW9uICp0cmFuc2FjdGlvbl9zdGFjazsNCi0Jc3RydWN0IGxpc3RfaGVhZCB0b2RvOw0K LQlib29sIHByb2Nlc3NfdG9kbzsNCi0Jc3RydWN0IGJpbmRlcl9lcnJvciByZXR1cm5fZXJyb3I7 DQotCXN0cnVjdCBiaW5kZXJfZXJyb3IgcmVwbHlfZXJyb3I7DQotCXdhaXRfcXVldWVfaGVhZF90 IHdhaXQ7DQotCXN0cnVjdCBiaW5kZXJfc3RhdHMgc3RhdHM7DQotCWF0b21pY190IHRtcF9yZWY7 DQotCWJvb2wgaXNfZGVhZDsNCi19Ow0KLQ0KLS8qKg0KICAqIHN0cnVjdCBiaW5kZXJfdHhuX2Zk X2ZpeHVwIC0gdHJhbnNhY3Rpb24gZmQgZml4dXAgbGlzdCBlbGVtZW50DQogICogQGZpeHVwX2Vu dHJ5OiAgICAgICAgICBsaXN0IGVudHJ5DQogICogQGZpbGU6ICAgICAgICAgICAgICAgICBzdHJ1 Y3QgZmlsZSB0byBiZSBhc3NvY2lhdGVkIHdpdGggbmV3IGZkDQpAQCAtNTY1LDM0ICszODQsNiBA QCBzdHJ1Y3QgYmluZGVyX3R4bl9mZF9maXh1cCB7DQogCXNpemVfdCBvZmZzZXQ7DQogfTsNCiAN Ci1zdHJ1Y3QgYmluZGVyX3RyYW5zYWN0aW9uIHsNCi0JaW50IGRlYnVnX2lkOw0KLQlzdHJ1Y3Qg YmluZGVyX3dvcmsgd29yazsNCi0Jc3RydWN0IGJpbmRlcl90aHJlYWQgKmZyb207DQotCXN0cnVj dCBiaW5kZXJfdHJhbnNhY3Rpb24gKmZyb21fcGFyZW50Ow0KLQlzdHJ1Y3QgYmluZGVyX3Byb2Mg KnRvX3Byb2M7DQotCXN0cnVjdCBiaW5kZXJfdGhyZWFkICp0b190aHJlYWQ7DQotCXN0cnVjdCBi aW5kZXJfdHJhbnNhY3Rpb24gKnRvX3BhcmVudDsNCi0JdW5zaWduZWQgbmVlZF9yZXBseToxOw0K LQkvKiB1bnNpZ25lZCBpc19kZWFkOjE7ICovCS8qIG5vdCB1c2VkIGF0IHRoZSBtb21lbnQgKi8N Ci0NCi0Jc3RydWN0IGJpbmRlcl9idWZmZXIgKmJ1ZmZlcjsNCi0JdW5zaWduZWQgaW50CWNvZGU7 DQotCXVuc2lnbmVkIGludAlmbGFnczsNCi0JbG9uZwlwcmlvcml0eTsNCi0JbG9uZwlzYXZlZF9w cmlvcml0eTsNCi0Ja3VpZF90CXNlbmRlcl9ldWlkOw0KLQlzdHJ1Y3QgbGlzdF9oZWFkIGZkX2Zp eHVwczsNCi0JYmluZGVyX3VpbnRwdHJfdCBzZWN1cml0eV9jdHg7DQotCS8qKg0KLQkgKiBAbG9j azogIHByb3RlY3RzIEBmcm9tLCBAdG9fcHJvYywgYW5kIEB0b190aHJlYWQNCi0JICoNCi0JICog QGZyb20sIEB0b19wcm9jLCBhbmQgQHRvX3RocmVhZCBjYW4gYmUgc2V0IHRvIE5VTEwNCi0JICog ZHVyaW5nIHRocmVhZCB0ZWFyZG93bg0KLQkgKi8NCi0Jc3BpbmxvY2tfdCBsb2NrOw0KLX07DQot DQogLyoqDQogICogc3RydWN0IGJpbmRlcl9vYmplY3QgLSB1bmlvbiBvZiBmbGF0IGJpbmRlciBv YmplY3QgdHlwZXMNCiAgKiBAaGRyOiAgIGdlbmVyaWMgb2JqZWN0IGhlYWRlcg0KQEAgLTYxMyw2 ICs0MDQsMjYgQEAgc3RydWN0IGJpbmRlcl9vYmplY3Qgew0KIAl9Ow0KIH07DQogDQorc3RhdGlj IHZvaWQgKCpfX2JpbmRlcl91cGRhdGVfaW5mb19jYikoc3RydWN0IGJpbmRlcl90cmFuc2FjdGlv biAqdCwNCisJCQkJCXN0cnVjdCBiaW5kZXJfdHJhbnNhY3Rpb25fbG9nX2VudHJ5ICplKTsNCisN Cit2b2lkIHNldF9iaW5kZXJfdXBkYXRlX2luZm9fY2Iodm9pZCAoKmZuKShzdHJ1Y3QgYmluZGVy X3RyYW5zYWN0aW9uICp0LA0KKwkJCQkJc3RydWN0IGJpbmRlcl90cmFuc2FjdGlvbl9sb2dfZW50 cnkgKmUpKQ0KK3sNCisJX19iaW5kZXJfdXBkYXRlX2luZm9fY2IgPSBmbjsNCit9DQorRVhQT1JU X1NZTUJPTF9HUEwoc2V0X2JpbmRlcl91cGRhdGVfaW5mb19jYik7DQorDQorc3RhdGljIHZvaWQg KCpfX3ByaW50X3RyYW5zYWN0aW9uX2V4dF9jYikoc3RydWN0IHNlcV9maWxlICptLA0KKwkJCQkJ c3RydWN0IGJpbmRlcl90cmFuc2FjdGlvbiAqdCk7DQorDQordm9pZCBzZXRfcHJpbnRfdHJhbnNh Y3Rpb25fZXh0X2NiKHZvaWQgKCpmbikoc3RydWN0IHNlcV9maWxlICptLA0KKwkJCQkJc3RydWN0 IGJpbmRlcl90cmFuc2FjdGlvbiAqdCkpDQorew0KKwlfX3ByaW50X3RyYW5zYWN0aW9uX2V4dF9j YiA9IGZuOw0KK30NCitFWFBPUlRfU1lNQk9MX0dQTChzZXRfcHJpbnRfdHJhbnNhY3Rpb25fZXh0 X2NiKTsNCisNCiAvKioNCiAgKiBiaW5kZXJfcHJvY19sb2NrKCkgLSBBY3F1aXJlIG91dGVyIGxv Y2sgZm9yIGdpdmVuIGJpbmRlcl9wcm9jDQogICogQHByb2M6ICAgICAgICAgc3RydWN0IGJpbmRl cl9wcm9jIHRvIGFjcXVpcmUNCkBAIC0xOTI3LDYgKzE3MzgsNyBAQCBzdGF0aWMgdm9pZCBiaW5k ZXJfZnJlZV90cmFuc2FjdGlvbihzdHJ1Y3QgYmluZGVyX3RyYW5zYWN0aW9uICp0KQ0KIAkgKiBJ ZiB0aGUgdHJhbnNhY3Rpb24gaGFzIG5vIHRhcmdldF9wcm9jLCB0aGVuDQogCSAqIHQtPmJ1ZmZl ci0+dHJhbnNhY3Rpb24gaGFzIGFscmVhZHkgYmVlbiBjbGVhcmVkLg0KIAkgKi8NCisJdHJhY2Vf YmluZGVyX2ZyZWVfdHJhbnNhY3Rpb24odCk7DQogCWJpbmRlcl9mcmVlX3R4bl9maXh1cHModCk7 DQogCWtmcmVlKHQpOw0KIAliaW5kZXJfc3RhdHNfZGVsZXRlZChCSU5ERVJfU1RBVF9UUkFOU0FD VElPTik7DQpAQCAtMjg3NCw2ICsyNjg2LDcgQEAgc3RhdGljIHZvaWQgYmluZGVyX3RyYW5zYWN0 aW9uKHN0cnVjdCBiaW5kZXJfcHJvYyAqcHJvYywNCiAJZS0+b2Zmc2V0c19zaXplID0gdHItPm9m ZnNldHNfc2l6ZTsNCiAJc3Ryc2NweShlLT5jb250ZXh0X25hbWUsIHByb2MtPmNvbnRleHQtPm5h bWUsIEJJTkRFUkZTX01BWF9OQU1FKTsNCiANCisNCiAJaWYgKHJlcGx5KSB7DQogCQliaW5kZXJf aW5uZXJfcHJvY19sb2NrKHByb2MpOw0KIAkJaW5fcmVwbHlfdG8gPSB0aHJlYWQtPnRyYW5zYWN0 aW9uX3N0YWNrOw0KQEAgLTMwNjAsNiArMjg3Myw5IEBAIHN0YXRpYyB2b2lkIGJpbmRlcl90cmFu c2FjdGlvbihzdHJ1Y3QgYmluZGVyX3Byb2MgKnByb2MsDQogCQlyZXR1cm5fZXJyb3JfbGluZSA9 IF9fTElORV9fOw0KIAkJZ290byBlcnJfYWxsb2NfdF9mYWlsZWQ7DQogCX0NCisNCisJaWYgKF9f YmluZGVyX3VwZGF0ZV9pbmZvX2NiKQ0KKwkJX19iaW5kZXJfdXBkYXRlX2luZm9fY2IodCwgZSk7 DQogCUlOSVRfTElTVF9IRUFEKCZ0LT5mZF9maXh1cHMpOw0KIAliaW5kZXJfc3RhdHNfY3JlYXRl ZChCSU5ERVJfU1RBVF9UUkFOU0FDVElPTik7DQogCXNwaW5fbG9ja19pbml0KCZ0LT5sb2NrKTsN CkBAIC0zNDk4LDYgKzMzMTQsNyBAQCBzdGF0aWMgdm9pZCBiaW5kZXJfdHJhbnNhY3Rpb24oc3Ry dWN0IGJpbmRlcl9wcm9jICpwcm9jLA0KIAlrZnJlZSh0Y29tcGxldGUpOw0KIAliaW5kZXJfc3Rh dHNfZGVsZXRlZChCSU5ERVJfU1RBVF9UUkFOU0FDVElPTl9DT01QTEVURSk7DQogZXJyX2FsbG9j X3Rjb21wbGV0ZV9mYWlsZWQ6DQorCXRyYWNlX2JpbmRlcl9mcmVlX3RyYW5zYWN0aW9uKHQpOw0K IAlrZnJlZSh0KTsNCiAJYmluZGVyX3N0YXRzX2RlbGV0ZWQoQklOREVSX1NUQVRfVFJBTlNBQ1RJ T04pOw0KIGVycl9hbGxvY190X2ZhaWxlZDoNCkBAIC01NTQ3LDYgKzUzNjQsOCBAQCBzdGF0aWMg dm9pZCBwcmludF9iaW5kZXJfdHJhbnNhY3Rpb25faWxvY2tlZChzdHJ1Y3Qgc2VxX2ZpbGUgKm0s DQogCQkgICB0LT50b190aHJlYWQgPyB0LT50b190aHJlYWQtPnBpZCA6IDAsDQogCQkgICB0LT5j b2RlLCB0LT5mbGFncywgdC0+cHJpb3JpdHksIHQtPm5lZWRfcmVwbHkpOw0KIAlzcGluX3VubG9j aygmdC0+bG9jayk7DQorCWlmIChfX3ByaW50X3RyYW5zYWN0aW9uX2V4dF9jYikNCisJCV9fcHJp bnRfdHJhbnNhY3Rpb25fZXh0X2NiKG0sIHQpOw0KIA0KIAlpZiAocHJvYyAhPSB0b19wcm9jKSB7 DQogCQkvKg0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYW5kcm9pZC9iaW5kZXJfaW50ZXJuYWwuaCBi L2RyaXZlcnMvYW5kcm9pZC9iaW5kZXJfaW50ZXJuYWwuaA0KaW5kZXggYWU5OTEwOS4uODZiNDk2 MCAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvYW5kcm9pZC9iaW5kZXJfaW50ZXJuYWwuaA0KKysrIGIv ZHJpdmVycy9hbmRyb2lkL2JpbmRlcl9pbnRlcm5hbC5oDQpAQCAtMTIsNiArMTIsMTEgQEANCiAj aW5jbHVkZSA8bGludXgvdHlwZXMuaD4NCiAjaW5jbHVkZSA8bGludXgvdWlkZ2lkLmg+DQogDQor I2lmZGVmIENPTkZJR19CSU5ERVJfVVNFUl9UUkFDS0lORw0KKyNpbmNsdWRlIDxsaW51eC9ydGMu aD4NCisjaW5jbHVkZSA8bGludXgvdGltZS5oPg0KKyNlbmRpZg0KKw0KIHN0cnVjdCBiaW5kZXJf Y29udGV4dCB7DQogCXN0cnVjdCBiaW5kZXJfbm9kZSAqYmluZGVyX2NvbnRleHRfbWdyX25vZGU7 DQogCXN0cnVjdCBtdXRleCBjb250ZXh0X21ncl9ub2RlX2xvY2s7DQpAQCAtMTMxLDYgKzEzNiwx MCBAQCBzdHJ1Y3QgYmluZGVyX3RyYW5zYWN0aW9uX2xvZ19lbnRyeSB7DQogCXVpbnQzMl90IHJl dHVybl9lcnJvcjsNCiAJdWludDMyX3QgcmV0dXJuX2Vycm9yX3BhcmFtOw0KIAljaGFyIGNvbnRl eHRfbmFtZVtCSU5ERVJGU19NQVhfTkFNRSArIDFdOw0KKyNpZmRlZiBDT05GSUdfQklOREVSX1VT RVJfVFJBQ0tJTkcNCisJc3RydWN0IHRpbWVzcGVjIHRpbWVzdGFtcDsNCisJc3RydWN0IHRpbWV2 YWwgdHY7DQorI2VuZGlmDQogfTsNCiANCiBzdHJ1Y3QgYmluZGVyX3RyYW5zYWN0aW9uX2xvZyB7 DQpAQCAtMTM5LDYgKzE0OCwyMjQgQEAgc3RydWN0IGJpbmRlcl90cmFuc2FjdGlvbl9sb2cgew0K IAlzdHJ1Y3QgYmluZGVyX3RyYW5zYWN0aW9uX2xvZ19lbnRyeSBlbnRyeVszMl07DQogfTsNCiAN CitlbnVtIGJpbmRlcl9zdGF0X3R5cGVzIHsNCisJQklOREVSX1NUQVRfUFJPQywNCisJQklOREVS X1NUQVRfVEhSRUFELA0KKwlCSU5ERVJfU1RBVF9OT0RFLA0KKwlCSU5ERVJfU1RBVF9SRUYsDQor CUJJTkRFUl9TVEFUX0RFQVRILA0KKwlCSU5ERVJfU1RBVF9UUkFOU0FDVElPTiwNCisJQklOREVS X1NUQVRfVFJBTlNBQ1RJT05fQ09NUExFVEUsDQorCUJJTkRFUl9TVEFUX0NPVU5UDQorfTsNCisN CitzdHJ1Y3QgYmluZGVyX3N0YXRzIHsNCisJYXRvbWljX3QgYnJbX0lPQ19OUihCUl9GQUlMRURf UkVQTFkpICsgMV07DQorCWF0b21pY190IGJjW19JT0NfTlIoQkNfUkVQTFlfU0cpICsgMV07DQor CWF0b21pY190IG9ial9jcmVhdGVkW0JJTkRFUl9TVEFUX0NPVU5UXTsNCisJYXRvbWljX3Qgb2Jq X2RlbGV0ZWRbQklOREVSX1NUQVRfQ09VTlRdOw0KK307DQorDQorLyoqDQorICogc3RydWN0IGJp bmRlcl93b3JrIC0gd29yayBlbnF1ZXVlZCBvbiBhIHdvcmtsaXN0DQorICogQGVudHJ5OiAgICAg ICAgICAgICBub2RlIGVucXVldWVkIG9uIGxpc3QNCisgKiBAdHlwZTogICAgICAgICAgICAgIHR5 cGUgb2Ygd29yayB0byBiZSBwZXJmb3JtZWQNCisgKg0KKyAqIFRoZXJlIGFyZSBzZXBhcmF0ZSB3 b3JrIGxpc3RzIGZvciBwcm9jLCB0aHJlYWQsIGFuZCBub2RlIChhc3luYykuDQorICovDQorc3Ry dWN0IGJpbmRlcl93b3JrIHsNCisJc3RydWN0IGxpc3RfaGVhZCBlbnRyeTsNCisNCisJZW51bSB7 DQorCQlCSU5ERVJfV09SS19UUkFOU0FDVElPTiA9IDEsDQorCQlCSU5ERVJfV09SS19UUkFOU0FD VElPTl9DT01QTEVURSwNCisJCUJJTkRFUl9XT1JLX1JFVFVSTl9FUlJPUiwNCisJCUJJTkRFUl9X T1JLX05PREUsDQorCQlCSU5ERVJfV09SS19ERUFEX0JJTkRFUiwNCisJCUJJTkRFUl9XT1JLX0RF QURfQklOREVSX0FORF9DTEVBUiwNCisJCUJJTkRFUl9XT1JLX0NMRUFSX0RFQVRIX05PVElGSUNB VElPTiwNCisJfSB0eXBlOw0KK307DQorDQorc3RydWN0IGJpbmRlcl9lcnJvciB7DQorCXN0cnVj dCBiaW5kZXJfd29yayB3b3JrOw0KKwl1aW50MzJfdCBjbWQ7DQorfTsNCisNCisvKioNCisgKiBz dHJ1Y3QgYmluZGVyX3Byb2MgLSBiaW5kZXIgcHJvY2VzcyBib29ra2VlcGluZw0KKyAqIEBwcm9j X25vZGU6ICAgICAgICAgICAgZWxlbWVudCBmb3IgYmluZGVyX3Byb2NzIGxpc3QNCisgKiBAdGhy ZWFkczogICAgICAgICAgICAgIHJidHJlZSBvZiBiaW5kZXJfdGhyZWFkcyBpbiB0aGlzIHByb2MN CisgKiAgICAgICAgICAgICAgICAgICAgICAgIChwcm90ZWN0ZWQgYnkgQGlubmVyX2xvY2spDQor ICogQG5vZGVzOiAgICAgICAgICAgICAgICByYnRyZWUgb2YgYmluZGVyIG5vZGVzIGFzc29jaWF0 ZWQgd2l0aA0KKyAqICAgICAgICAgICAgICAgICAgICAgICAgdGhpcyBwcm9jIG9yZGVyZWQgYnkg bm9kZS0+cHRyDQorICogICAgICAgICAgICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5IEBpbm5l cl9sb2NrKQ0KKyAqIEByZWZzX2J5X2Rlc2M6ICAgICAgICAgcmJ0cmVlIG9mIHJlZnMgb3JkZXJl ZCBieSByZWYtPmRlc2MNCisgKiAgICAgICAgICAgICAgICAgICAgICAgIChwcm90ZWN0ZWQgYnkg QG91dGVyX2xvY2spDQorICogQHJlZnNfYnlfbm9kZTogICAgICAgICByYnRyZWUgb2YgcmVmcyBv cmRlcmVkIGJ5IHJlZi0+bm9kZQ0KKyAqICAgICAgICAgICAgICAgICAgICAgICAgKHByb3RlY3Rl ZCBieSBAb3V0ZXJfbG9jaykNCisgKiBAd2FpdGluZ190aHJlYWRzOiAgICAgIHRocmVhZHMgY3Vy cmVudGx5IHdhaXRpbmcgZm9yIHByb2Mgd29yaw0KKyAqICAgICAgICAgICAgICAgICAgICAgICAg KHByb3RlY3RlZCBieSBAaW5uZXJfbG9jaykNCisgKiBAcGlkICAgICAgICAgICAgICAgICAgIFBJ RCBvZiBncm91cF9sZWFkZXIgb2YgcHJvY2Vzcw0KKyAqICAgICAgICAgICAgICAgICAgICAgICAg KGludmFyaWFudCBhZnRlciBpbml0aWFsaXplZCkNCisgKiBAdHNrICAgICAgICAgICAgICAgICAg IHRhc2tfc3RydWN0IGZvciBncm91cF9sZWFkZXIgb2YgcHJvY2Vzcw0KKyAqICAgICAgICAgICAg ICAgICAgICAgICAgKGludmFyaWFudCBhZnRlciBpbml0aWFsaXplZCkNCisgKiBAZGVmZXJyZWRf d29ya19ub2RlOiAgIGVsZW1lbnQgZm9yIGJpbmRlcl9kZWZlcnJlZF9saXN0DQorICogICAgICAg ICAgICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5IGJpbmRlcl9kZWZlcnJlZF9sb2NrKQ0KKyAq IEBkZWZlcnJlZF93b3JrOiAgICAgICAgYml0bWFwIG9mIGRlZmVycmVkIHdvcmsgdG8gcGVyZm9y bQ0KKyAqICAgICAgICAgICAgICAgICAgICAgICAgKHByb3RlY3RlZCBieSBiaW5kZXJfZGVmZXJy ZWRfbG9jaykNCisgKiBAaXNfZGVhZDogICAgICAgICAgICAgIHByb2Nlc3MgaXMgZGVhZCBhbmQg YXdhaXRpbmcgZnJlZQ0KKyAqICAgICAgICAgICAgICAgICAgICAgICAgd2hlbiBvdXRzdGFuZGlu ZyB0cmFuc2FjdGlvbnMgYXJlIGNsZWFuZWQgdXANCisgKiAgICAgICAgICAgICAgICAgICAgICAg IChwcm90ZWN0ZWQgYnkgQGlubmVyX2xvY2spDQorICogQHRvZG86ICAgICAgICAgICAgICAgICBs aXN0IG9mIHdvcmsgZm9yIHRoaXMgcHJvY2Vzcw0KKyAqICAgICAgICAgICAgICAgICAgICAgICAg KHByb3RlY3RlZCBieSBAaW5uZXJfbG9jaykNCisgKiBAc3RhdHM6ICAgICAgICAgICAgICAgIHBl ci1wcm9jZXNzIGJpbmRlciBzdGF0aXN0aWNzDQorICogICAgICAgICAgICAgICAgICAgICAgICAo YXRvbWljcywgbm8gbG9jayBuZWVkZWQpDQorICogQGRlbGl2ZXJlZF9kZWF0aDogICAgICBsaXN0 IG9mIGRlbGl2ZXJlZCBkZWF0aCBub3RpZmljYXRpb24NCisgKiAgICAgICAgICAgICAgICAgICAg ICAgIChwcm90ZWN0ZWQgYnkgQGlubmVyX2xvY2spDQorICogQG1heF90aHJlYWRzOiAgICAgICAg ICBjYXAgb24gbnVtYmVyIG9mIGJpbmRlciB0aHJlYWRzDQorICogICAgICAgICAgICAgICAgICAg ICAgICAocHJvdGVjdGVkIGJ5IEBpbm5lcl9sb2NrKQ0KKyAqIEByZXF1ZXN0ZWRfdGhyZWFkczog ICAgbnVtYmVyIG9mIGJpbmRlciB0aHJlYWRzIHJlcXVlc3RlZCBidXQgbm90DQorICogICAgICAg ICAgICAgICAgICAgICAgICB5ZXQgc3RhcnRlZC4gSW4gY3VycmVudCBpbXBsZW1lbnRhdGlvbiwg Y2FuDQorICogICAgICAgICAgICAgICAgICAgICAgICBvbmx5IGJlIDAgb3IgMS4NCisgKiAgICAg ICAgICAgICAgICAgICAgICAgIChwcm90ZWN0ZWQgYnkgQGlubmVyX2xvY2spDQorICogQHJlcXVl c3RlZF90aHJlYWRzX3N0YXJ0ZWQ6IG51bWJlciBiaW5kZXIgdGhyZWFkcyBzdGFydGVkDQorICog ICAgICAgICAgICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5IEBpbm5lcl9sb2NrKQ0KKyAqIEB0 bXBfcmVmOiAgICAgICAgICAgICAgdGVtcG9yYXJ5IHJlZmVyZW5jZSB0byBpbmRpY2F0ZSBwcm9j IGlzIGluIHVzZQ0KKyAqICAgICAgICAgICAgICAgICAgICAgICAgKHByb3RlY3RlZCBieSBAaW5u ZXJfbG9jaykNCisgKiBAZGVmYXVsdF9wcmlvcml0eTogICAgIGRlZmF1bHQgc2NoZWR1bGVyIHBy aW9yaXR5DQorICogICAgICAgICAgICAgICAgICAgICAgICAoaW52YXJpYW50IGFmdGVyIGluaXRp YWxpemVkKQ0KKyAqIEBkZWJ1Z2ZzX2VudHJ5OiAgICAgICAgZGVidWdmcyBub2RlDQorICogQGFs bG9jOiAgICAgICAgICAgICAgICBiaW5kZXIgYWxsb2NhdG9yIGJvb2trZWVwaW5nDQorICogQGNv bnRleHQ6ICAgICAgICAgICAgICBiaW5kZXJfY29udGV4dCBmb3IgdGhpcyBwcm9jDQorICogICAg ICAgICAgICAgICAgICAgICAgICAoaW52YXJpYW50IGFmdGVyIGluaXRpYWxpemVkKQ0KKyAqIEBp bm5lcl9sb2NrOiAgICAgICAgICAgY2FuIG5lc3QgdW5kZXIgb3V0ZXJfbG9jayBhbmQvb3Igbm9k ZSBsb2NrDQorICogQG91dGVyX2xvY2s6ICAgICAgICAgICBubyBuZXN0aW5nIHVuZGVyIGlubm9y IG9yIG5vZGUgbG9jaw0KKyAqICAgICAgICAgICAgICAgICAgICAgICAgTG9jayBvcmRlcjogMSkg b3V0ZXIsIDIpIG5vZGUsIDMpIGlubmVyDQorICogQGJpbmRlcmZzX2VudHJ5OiAgICAgICBwcm9j ZXNzLXNwZWNpZmljIGJpbmRlcmZzIGxvZyBmaWxlDQorICoNCisgKiBCb29ra2VlcGluZyBzdHJ1 Y3R1cmUgZm9yIGJpbmRlciBwcm9jZXNzZXMNCisgKi8NCitzdHJ1Y3QgYmluZGVyX3Byb2Mgew0K KwlzdHJ1Y3QgaGxpc3Rfbm9kZSBwcm9jX25vZGU7DQorCXN0cnVjdCByYl9yb290IHRocmVhZHM7 DQorCXN0cnVjdCByYl9yb290IG5vZGVzOw0KKwlzdHJ1Y3QgcmJfcm9vdCByZWZzX2J5X2Rlc2M7 DQorCXN0cnVjdCByYl9yb290IHJlZnNfYnlfbm9kZTsNCisJc3RydWN0IGxpc3RfaGVhZCB3YWl0 aW5nX3RocmVhZHM7DQorCWludCBwaWQ7DQorCXN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrOw0KKwlz dHJ1Y3QgaGxpc3Rfbm9kZSBkZWZlcnJlZF93b3JrX25vZGU7DQorCWludCBkZWZlcnJlZF93b3Jr Ow0KKwlib29sIGlzX2RlYWQ7DQorDQorCXN0cnVjdCBsaXN0X2hlYWQgdG9kbzsNCisJc3RydWN0 IGJpbmRlcl9zdGF0cyBzdGF0czsNCisJc3RydWN0IGxpc3RfaGVhZCBkZWxpdmVyZWRfZGVhdGg7 DQorCWludCBtYXhfdGhyZWFkczsNCisJaW50IHJlcXVlc3RlZF90aHJlYWRzOw0KKwlpbnQgcmVx dWVzdGVkX3RocmVhZHNfc3RhcnRlZDsNCisJaW50IHRtcF9yZWY7DQorCWxvbmcgZGVmYXVsdF9w cmlvcml0eTsNCisJc3RydWN0IGRlbnRyeSAqZGVidWdmc19lbnRyeTsNCisJc3RydWN0IGJpbmRl cl9hbGxvYyBhbGxvYzsNCisJc3RydWN0IGJpbmRlcl9jb250ZXh0ICpjb250ZXh0Ow0KKwlzcGlu bG9ja190IGlubmVyX2xvY2s7DQorCXNwaW5sb2NrX3Qgb3V0ZXJfbG9jazsNCisJc3RydWN0IGRl bnRyeSAqYmluZGVyZnNfZW50cnk7DQorfTsNCisNCisvKioNCisgKiBzdHJ1Y3QgYmluZGVyX3Ro cmVhZCAtIGJpbmRlciB0aHJlYWQgYm9va2tlZXBpbmcNCisgKiBAcHJvYzogICAgICAgICAgICAg ICAgIGJpbmRlciBwcm9jZXNzIGZvciB0aGlzIHRocmVhZA0KKyAqICAgICAgICAgICAgICAgICAg ICAgICAgKGludmFyaWFudCBhZnRlciBpbml0aWFsaXphdGlvbikNCisgKiBAcmJfbm9kZTogICAg ICAgICAgICAgIGVsZW1lbnQgZm9yIHByb2MtPnRocmVhZHMgcmJ0cmVlDQorICogICAgICAgICAg ICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5IEBwcm9jLT5pbm5lcl9sb2NrKQ0KKyAqIEB3YWl0 aW5nX3RocmVhZF9ub2RlOiAgZWxlbWVudCBmb3IgQHByb2MtPndhaXRpbmdfdGhyZWFkcyBsaXN0 DQorICogICAgICAgICAgICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5IEBwcm9jLT5pbm5lcl9s b2NrKQ0KKyAqIEBwaWQ6ICAgICAgICAgICAgICAgICAgUElEIGZvciB0aGlzIHRocmVhZA0KKyAq ICAgICAgICAgICAgICAgICAgICAgICAgKGludmFyaWFudCBhZnRlciBpbml0aWFsaXphdGlvbikN CisgKiBAbG9vcGVyOiAgICAgICAgICAgICAgIGJpdG1hcCBvZiBsb29waW5nIHN0YXRlDQorICog ICAgICAgICAgICAgICAgICAgICAgICAob25seSBhY2Nlc3NlZCBieSB0aGlzIHRocmVhZCkNCisg KiBAbG9vcGVyX25lZWRzX3JldHVybjogIGxvb3BpbmcgdGhyZWFkIG5lZWRzIHRvIGV4aXQgZHJp dmVyDQorICogICAgICAgICAgICAgICAgICAgICAgICAobm8gbG9jayBuZWVkZWQpDQorICogQHRy YW5zYWN0aW9uX3N0YWNrOiAgICBzdGFjayBvZiBpbi1wcm9ncmVzcyB0cmFuc2FjdGlvbnMgZm9y IHRoaXMgdGhyZWFkDQorICogICAgICAgICAgICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5IEBw cm9jLT5pbm5lcl9sb2NrKQ0KKyAqIEB0b2RvOiAgICAgICAgICAgICAgICAgbGlzdCBvZiB3b3Jr IHRvIGRvIGZvciB0aGlzIHRocmVhZA0KKyAqICAgICAgICAgICAgICAgICAgICAgICAgKHByb3Rl Y3RlZCBieSBAcHJvYy0+aW5uZXJfbG9jaykNCisgKiBAcHJvY2Vzc190b2RvOiAgICAgICAgIHdo ZXRoZXIgd29yayBpbiBAdG9kbyBzaG91bGQgYmUgcHJvY2Vzc2VkDQorICogICAgICAgICAgICAg ICAgICAgICAgICAocHJvdGVjdGVkIGJ5IEBwcm9jLT5pbm5lcl9sb2NrKQ0KKyAqIEByZXR1cm5f ZXJyb3I6ICAgICAgICAgdHJhbnNhY3Rpb24gZXJyb3JzIHJlcG9ydGVkIGJ5IHRoaXMgdGhyZWFk DQorICogICAgICAgICAgICAgICAgICAgICAgICAob25seSBhY2Nlc3NlZCBieSB0aGlzIHRocmVh ZCkNCisgKiBAcmVwbHlfZXJyb3I6ICAgICAgICAgIHRyYW5zYWN0aW9uIGVycm9ycyByZXBvcnRl ZCBieSB0YXJnZXQgdGhyZWFkDQorICogICAgICAgICAgICAgICAgICAgICAgICAocHJvdGVjdGVk IGJ5IEBwcm9jLT5pbm5lcl9sb2NrKQ0KKyAqIEB3YWl0OiAgICAgICAgICAgICAgICAgd2FpdCBx dWV1ZSBmb3IgdGhyZWFkIHdvcmsNCisgKiBAc3RhdHM6ICAgICAgICAgICAgICAgIHBlci10aHJl YWQgc3RhdGlzdGljcw0KKyAqICAgICAgICAgICAgICAgICAgICAgICAgKGF0b21pY3MsIG5vIGxv Y2sgbmVlZGVkKQ0KKyAqIEB0bXBfcmVmOiAgICAgICAgICAgICAgdGVtcG9yYXJ5IHJlZmVyZW5j ZSB0byBpbmRpY2F0ZSB0aHJlYWQgaXMgaW4gdXNlDQorICogICAgICAgICAgICAgICAgICAgICAg ICAoYXRvbWljIHNpbmNlIEBwcm9jLT5pbm5lcl9sb2NrIGNhbm5vdA0KKyAqICAgICAgICAgICAg ICAgICAgICAgICAgYWx3YXlzIGJlIGFjcXVpcmVkKQ0KKyAqIEBpc19kZWFkOiAgICAgICAgICAg ICAgdGhyZWFkIGlzIGRlYWQgYW5kIGF3YWl0aW5nIGZyZWUNCisgKiAgICAgICAgICAgICAgICAg ICAgICAgIHdoZW4gb3V0c3RhbmRpbmcgdHJhbnNhY3Rpb25zIGFyZSBjbGVhbmVkIHVwDQorICog ICAgICAgICAgICAgICAgICAgICAgICAocHJvdGVjdGVkIGJ5IEBwcm9jLT5pbm5lcl9sb2NrKQ0K KyAqDQorICogQm9va2tlZXBpbmcgc3RydWN0dXJlIGZvciBiaW5kZXIgdGhyZWFkcy4NCisgKi8N CitzdHJ1Y3QgYmluZGVyX3RocmVhZCB7DQorCXN0cnVjdCBiaW5kZXJfcHJvYyAqcHJvYzsNCisJ c3RydWN0IHJiX25vZGUgcmJfbm9kZTsNCisJc3RydWN0IGxpc3RfaGVhZCB3YWl0aW5nX3RocmVh ZF9ub2RlOw0KKwlpbnQgcGlkOw0KKwlpbnQgbG9vcGVyOyAgICAgICAgICAgICAgLyogb25seSBt b2RpZmllZCBieSB0aGlzIHRocmVhZCAqLw0KKwlib29sIGxvb3Blcl9uZWVkX3JldHVybjsgLyog Y2FuIGJlIHdyaXR0ZW4gYnkgb3RoZXIgdGhyZWFkICovDQorCXN0cnVjdCBiaW5kZXJfdHJhbnNh Y3Rpb24gKnRyYW5zYWN0aW9uX3N0YWNrOw0KKwlzdHJ1Y3QgbGlzdF9oZWFkIHRvZG87DQorCWJv b2wgcHJvY2Vzc190b2RvOw0KKwlzdHJ1Y3QgYmluZGVyX2Vycm9yIHJldHVybl9lcnJvcjsNCisJ c3RydWN0IGJpbmRlcl9lcnJvciByZXBseV9lcnJvcjsNCisJd2FpdF9xdWV1ZV9oZWFkX3Qgd2Fp dDsNCisJc3RydWN0IGJpbmRlcl9zdGF0cyBzdGF0czsNCisJYXRvbWljX3QgdG1wX3JlZjsNCisJ Ym9vbCBpc19kZWFkOw0KK307DQorDQorc3RydWN0IGJpbmRlcl90cmFuc2FjdGlvbiB7DQorCWlu dCBkZWJ1Z19pZDsNCisJc3RydWN0IGJpbmRlcl93b3JrIHdvcms7DQorCXN0cnVjdCBiaW5kZXJf dGhyZWFkICpmcm9tOw0KKwlzdHJ1Y3QgYmluZGVyX3RyYW5zYWN0aW9uICpmcm9tX3BhcmVudDsN CisJc3RydWN0IGJpbmRlcl9wcm9jICp0b19wcm9jOw0KKwlzdHJ1Y3QgYmluZGVyX3RocmVhZCAq dG9fdGhyZWFkOw0KKwlzdHJ1Y3QgYmluZGVyX3RyYW5zYWN0aW9uICp0b19wYXJlbnQ7DQorCXVu c2lnbmVkIG5lZWRfcmVwbHk6MTsNCisJLyogdW5zaWduZWQgaXNfZGVhZDoxOyAqLyAgICAgICAv KiBub3QgdXNlZCBhdCB0aGUgbW9tZW50ICovDQorDQorCXN0cnVjdCBiaW5kZXJfYnVmZmVyICpi dWZmZXI7DQorCXVuc2lnbmVkIGludCAgICBjb2RlOw0KKwl1bnNpZ25lZCBpbnQgICAgZmxhZ3M7 DQorCWxvbmcgICAgcHJpb3JpdHk7DQorCWxvbmcgICAgc2F2ZWRfcHJpb3JpdHk7DQorCWt1aWRf dCAgc2VuZGVyX2V1aWQ7DQorCXN0cnVjdCBsaXN0X2hlYWQgZmRfZml4dXBzOw0KKwliaW5kZXJf dWludHB0cl90IHNlY3VyaXR5X2N0eDsNCisJLyoqDQorCSAqIEBsb2NrOiAgcHJvdGVjdHMgQGZy b20sIEB0b19wcm9jLCBhbmQgQHRvX3RocmVhZA0KKwkgKg0KKwkgKiBAZnJvbSwgQHRvX3Byb2Ms IGFuZCBAdG9fdGhyZWFkIGNhbiBiZSBzZXQgdG8gTlVMTA0KKwkgKiBkdXJpbmcgdGhyZWFkIHRl YXJkb3duDQorCSAqLw0KKwlzcGlubG9ja190IGxvY2s7DQorI2lmZGVmIENPTkZJR19CSU5ERVJf VVNFUl9UUkFDS0lORw0KKwlzdHJ1Y3QgdGltZXNwZWMgdGltZXN0YW1wOw0KKwlzdHJ1Y3QgdGlt ZXZhbCB0djsNCisjZW5kaWYNCit9Ow0KKw0KIGV4dGVybiBzdHJ1Y3QgYmluZGVyX3RyYW5zYWN0 aW9uX2xvZyBiaW5kZXJfdHJhbnNhY3Rpb25fbG9nOw0KIGV4dGVybiBzdHJ1Y3QgYmluZGVyX3Ry YW5zYWN0aW9uX2xvZyBiaW5kZXJfdHJhbnNhY3Rpb25fbG9nX2ZhaWxlZDsNCisNCitleHRlcm4g dm9pZCBzZXRfYmluZGVyX3VwZGF0ZV9pbmZvX2NiKHZvaWQgKCpmbikoc3RydWN0IGJpbmRlcl90 cmFuc2FjdGlvbiAqdCwNCisJCQkJc3RydWN0IGJpbmRlcl90cmFuc2FjdGlvbl9sb2dfZW50cnkg KmUpKTsNCitleHRlcm4gdm9pZCBzZXRfcHJpbnRfdHJhbnNhY3Rpb25fZXh0X2NiKHZvaWQgKCpm bikoc3RydWN0IHNlcV9maWxlICptLA0KKwkJCQkJc3RydWN0IGJpbmRlcl90cmFuc2FjdGlvbiAq dCkpOw0KICNlbmRpZiAvKiBfTElOVVhfQklOREVSX0lOVEVSTkFMX0ggKi8NCmRpZmYgLS1naXQg YS9kcml2ZXJzL2FuZHJvaWQvYmluZGVyX2xhdGVuY3lfdHJhY2VyLmMgYi9kcml2ZXJzL2FuZHJv aWQvYmluZGVyX2xhdGVuY3lfdHJhY2VyLmMNCm5ldyBmaWxlIG1vZGUgMTAwNjQ0DQppbmRleCAw MDAwMDAwLi5jOTYyNmY1DQotLS0gL2Rldi9udWxsDQorKysgYi9kcml2ZXJzL2FuZHJvaWQvYmlu ZGVyX2xhdGVuY3lfdHJhY2VyLmMNCkBAIC0wLDAgKzEsMTAwIEBADQorLy8gU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IEdQTC0yLjANCisvKg0KKyAqIENvcHlyaWdodCAoQykgMjAxOSBNZWRpYVRl ayBJbmMuDQorICovDQorDQorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPg0KKyNpbmNsdWRlIDx1 YXBpL2xpbnV4L2FuZHJvaWQvYmluZGVyLmg+DQorI2luY2x1ZGUgImJpbmRlcl9hbGxvYy5oIg0K KyNpbmNsdWRlICJiaW5kZXJfaW50ZXJuYWwuaCINCisjaW5jbHVkZSAiYmluZGVyX3RyYWNlLmgi DQorDQorLyoNCisgKiBwcm9iZV9iaW5kZXJfZnJlZV90cmFuc2FjdGlvbiAtIE91dHB1dCBpbmZv IG9mIGEgZGVsYXkgdHJhbnNhY3Rpb24NCisgKiBAdDogICAgICAgICAgcG9pbnRlciB0byB0aGUg b3Zlci10aW1lIHRyYW5zYWN0aW9uDQorICovDQordm9pZCBwcm9iZV9iaW5kZXJfZnJlZV90cmFu c2FjdGlvbih2b2lkICppZ25vcmUsIHN0cnVjdCBiaW5kZXJfdHJhbnNhY3Rpb24gKnQpDQorew0K KwlzdHJ1Y3QgcnRjX3RpbWUgdG07DQorCXN0cnVjdCB0aW1lc3BlYyAqc3RhcnRpbWU7DQorCXN0 cnVjdCB0aW1lc3BlYyBjdXIsIHN1Yl90Ow0KKw0KKwlrdGltZV9nZXRfdHMoJmN1cik7DQorCXN0 YXJ0aW1lID0gJnQtPnRpbWVzdGFtcDsNCisJc3ViX3QgPSB0aW1lc3BlY19zdWIoY3VyLCAqc3Rh cnRpbWUpOw0KKw0KKwkvKiBpZiB0cmFuc2FjdGlvbiB0aW1lIGlzIG92ZXIgdGhhbiAyIHNlYywN CisJICogc2hvdyB0aW1lb3V0IHdhcm5pbmcgbG9nLg0KKwkgKi8NCisJaWYgKHN1Yl90LnR2X3Nl YyA8IDIpDQorCQlyZXR1cm47DQorDQorCXJ0Y190aW1lX3RvX3RtKHQtPnR2LnR2X3NlYywgJnRt KTsNCisNCisJc3Bpbl9sb2NrKCZ0LT5sb2NrKTsNCisJcHJfaW5mb19yYXRlbGltaXRlZCgiJWQ6 IGZyb20gJWQ6JWQgdG8gJWQ6JWQiLA0KKwkJCXQtPmRlYnVnX2lkLA0KKwkJCXQtPmZyb20gPyB0 LT5mcm9tLT5wcm9jLT5waWQgOiAwLA0KKwkJCXQtPmZyb20gPyB0LT5mcm9tLT5waWQgOiAwLA0K KwkJCXQtPnRvX3Byb2MgPyB0LT50b19wcm9jLT5waWQgOiAwLA0KKwkJCXQtPnRvX3RocmVhZCA/ IHQtPnRvX3RocmVhZC0+cGlkIDogMCk7DQorCXNwaW5fdW5sb2NrKCZ0LT5sb2NrKTsNCisNCisJ cHJfaW5mb19yYXRlbGltaXRlZCgiIHRvdGFsICV1LiUwM2xkIHMgY29kZSAldSBzdGFydCAlbHUu JTAzbGQgYW5kcm9pZCAlZC0lMDJkLSUwMmQgJTAyZDolMDJkOiUwMmQuJTAzbHVcbiIsDQorCQkJ KHVuc2lnbmVkIGludClzdWJfdC50dl9zZWMsDQorCQkJKHN1Yl90LnR2X25zZWMgLyBOU0VDX1BF Ul9NU0VDKSwNCisJCQl0LT5jb2RlLA0KKwkJCSh1bnNpZ25lZCBsb25nKXN0YXJ0aW1lLT50dl9z ZWMsDQorCQkJKHN0YXJ0aW1lLT50dl9uc2VjIC8gTlNFQ19QRVJfTVNFQyksDQorCQkJKHRtLnRt X3llYXIgKyAxOTAwKSwgKHRtLnRtX21vbiArIDEpLCB0bS50bV9tZGF5LA0KKwkJCXRtLnRtX2hv dXIsIHRtLnRtX21pbiwgdG0udG1fc2VjLA0KKwkJCSh1bnNpZ25lZCBsb25nKSh0LT50di50dl91 c2VjIC8gVVNFQ19QRVJfTVNFQykpOw0KK30NCisNCitzdGF0aWMgdm9pZCBiaW5kZXJfdXBkYXRl X2luZm9fY2Ioc3RydWN0IGJpbmRlcl90cmFuc2FjdGlvbiAqdCwNCisJCQkgICBzdHJ1Y3QgYmlu ZGVyX3RyYW5zYWN0aW9uX2xvZ19lbnRyeSAqZSkNCit7DQorCWt0aW1lX2dldF90cygmZS0+dGlt ZXN0YW1wKTsNCisJZG9fZ2V0dGltZW9mZGF5KCZlLT50dik7DQorCWUtPnR2LnR2X3NlYyAtPSAo c3lzX3R6LnR6X21pbnV0ZXN3ZXN0ICogNjApOw0KKwltZW1jcHkoJnQtPnRpbWVzdGFtcCwgJmUt PnRpbWVzdGFtcCwgc2l6ZW9mKHN0cnVjdCB0aW1lc3BlYykpOw0KKwltZW1jcHkoJnQtPnR2LCAm ZS0+dHYsIHNpemVvZihzdHJ1Y3QgdGltZXZhbCkpOw0KK30NCisNCitzdGF0aWMgdm9pZCBwcmlu dF9iaW5kZXJfdHJhbnNhY3Rpb25fZXh0KHN0cnVjdCBzZXFfZmlsZSAqbSwNCisJCQkJCSBzdHJ1 Y3QgYmluZGVyX3RyYW5zYWN0aW9uICp0KQ0KK3sNCisJc3RydWN0IHJ0Y190aW1lIHRtOw0KKw0K KwlydGNfdGltZV90b190bSh0LT50di50dl9zZWMsICZ0bSk7DQorCXNlcV9wcmludGYobSwNCisJ CSAgICIgc3RhcnQgJWx1LiUwNmx1IGFuZHJvaWQgJWQtJTAyZC0lMDJkICUwMmQ6JTAyZDolMDJk LiUwM2x1IiwNCisJCSAgICh1bnNpZ25lZCBsb25nKXQtPnRpbWVzdGFtcC50dl9zZWMsDQorCQkg ICAodC0+dGltZXN0YW1wLnR2X25zZWMgLyBOU0VDX1BFUl9VU0VDKSwNCisJCSAgICh0bS50bV95 ZWFyICsgMTkwMCksICh0bS50bV9tb24gKyAxKSwgdG0udG1fbWRheSwNCisJCSAgIHRtLnRtX2hv dXIsIHRtLnRtX21pbiwgdG0udG1fc2VjLA0KKwkJICAgKHVuc2lnbmVkIGxvbmcpKHQtPnR2LnR2 X3VzZWMgLyBVU0VDX1BFUl9NU0VDKSk7DQorDQorfQ0KKw0KK3N0YXRpYyBpbnQgX19pbml0IGlu aXRfYmluZGVyX2xhdGVuY3lfdHJhY2VyKHZvaWQpDQorew0KKwlyZWdpc3Rlcl90cmFjZV9iaW5k ZXJfZnJlZV90cmFuc2FjdGlvbigNCisJCQlwcm9iZV9iaW5kZXJfZnJlZV90cmFuc2FjdGlvbiwg TlVMTCk7DQorDQorCXNldF9iaW5kZXJfdXBkYXRlX2luZm9fY2IoYmluZGVyX3VwZGF0ZV9pbmZv X2NiKTsNCisJc2V0X3ByaW50X3RyYW5zYWN0aW9uX2V4dF9jYihwcmludF9iaW5kZXJfdHJhbnNh Y3Rpb25fZXh0KTsNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIGV4aXRfYmluZGVy X2xhdGVuY3lfdHJhY2VyKHZvaWQpDQorew0KKwl1bnJlZ2lzdGVyX3RyYWNlX2JpbmRlcl9mcmVl X3RyYW5zYWN0aW9uKA0KKwkJCXByb2JlX2JpbmRlcl9mcmVlX3RyYW5zYWN0aW9uLCBOVUxMKTsN Cit9DQorDQorbW9kdWxlX2luaXQoaW5pdF9iaW5kZXJfbGF0ZW5jeV90cmFjZXIpOw0KK21vZHVs ZV9leGl0KGV4aXRfYmluZGVyX2xhdGVuY3lfdHJhY2VyKTsNCisNCitNT0RVTEVfTElDRU5TRSgi R1BMIHYyIik7DQorDQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hbmRyb2lkL2JpbmRlcl90cmFjZS5o IGIvZHJpdmVycy9hbmRyb2lkL2JpbmRlcl90cmFjZS5oDQppbmRleCA2NzMxYzNjLi5jN2M3NmMx IDEwMDY0NA0KLS0tIGEvZHJpdmVycy9hbmRyb2lkL2JpbmRlcl90cmFjZS5oDQorKysgYi9kcml2 ZXJzL2FuZHJvaWQvYmluZGVyX3RyYWNlLmgNCkBAIC05NSw2ICs5NSw0MiBAQA0KIAkJICBfX2Vu dHJ5LT50aHJlYWRfdG9kbykNCiApOw0KIA0KK1RSQUNFX0VWRU5UKGJpbmRlcl9mcmVlX3RyYW5z YWN0aW9uLA0KKwlUUF9QUk9UTyhzdHJ1Y3QgYmluZGVyX3RyYW5zYWN0aW9uICp0KSwNCisJVFBf QVJHUyh0KSwNCisJVFBfU1RSVUNUX19lbnRyeSgNCisJCV9fZmllbGQoaW50LCBkZWJ1Z19pZCkN CisJCV9fZmllbGQoaW50LCBmcm9tX3Byb2MpDQorCQlfX2ZpZWxkKGludCwgZnJvbV90aHJlYWQp DQorCQlfX2ZpZWxkKGludCwgdG9fcHJvYykNCisJCV9fZmllbGQoaW50LCB0b190aHJlYWQpDQor CQlfX2ZpZWxkKHVuc2lnbmVkIGludCwgY29kZSkNCisJCV9fZmllbGQodW5zaWduZWQgaW50LCBm bGFncykNCisJCV9fZmllbGQodW5zaWduZWQgbG9uZywgc3RhcnRfc2VjKQ0KKwkJX19maWVsZCh1 bnNpZ25lZCBsb25nLCBzdGFydF9uc2VjKQ0KKwkpLA0KKwlUUF9mYXN0X2Fzc2lnbigNCisJCV9f ZW50cnktPmRlYnVnX2lkID0gdC0+ZGVidWdfaWQ7DQorCQlfX2VudHJ5LT5mcm9tX3Byb2MgPSB0 LT5mcm9tID8gdC0+ZnJvbS0+cHJvYy0+cGlkIDogMDsNCisJCV9fZW50cnktPmZyb21fdGhyZWFk ID0gdC0+ZnJvbSA/IHQtPmZyb20tPnBpZCA6IDA7DQorCQlfX2VudHJ5LT50b19wcm9jID0gdC0+ dG9fcHJvYyA/IHQtPnRvX3Byb2MtPnBpZCA6IDA7DQorCQlfX2VudHJ5LT50b190aHJlYWQgPSB0 LT50b190aHJlYWQgPyB0LT50b190aHJlYWQtPnBpZCA6IDA7DQorCQlfX2VudHJ5LT5jb2RlID0g dC0+Y29kZTsNCisJCV9fZW50cnktPmZsYWdzID0gdC0+ZmxhZ3M7DQorI2lmZGVmIENPTkZJR19C SU5ERVJfVVNFUl9UUkFDS0lORw0KKwkJX19lbnRyeS0+c3RhcnRfc2VjID0gdC0+dGltZXN0YW1w LnR2X3NlYzsNCisJCV9fZW50cnktPnN0YXJ0X25zZWMgPSB0LT50aW1lc3RhbXAudHZfbnNlYyAv IE5TRUNfUEVSX01TRUM7DQorI2Vsc2UNCisJCV9fZW50cnktPnN0YXJ0X3NlYyA9IDA7DQorCQlf X2VudHJ5LT5zdGFydF9uc2VjID0gMDsNCisjZW5kaWYNCisJKSwNCisJVFBfcHJpbnRrKCJ0cmFu c2FjdGlvbj0lZCBmcm9tICVkOiVkIHRvICVkOiVkIGZsYWdzPTB4JXggY29kZT0weCV4IHN0YXJ0 ICVsdS4lMDNsZCIsDQorCQkgIF9fZW50cnktPmRlYnVnX2lkLCBfX2VudHJ5LT5mcm9tX3Byb2Ms IF9fZW50cnktPmZyb21fdGhyZWFkLA0KKwkJICBfX2VudHJ5LT50b19wcm9jLCBfX2VudHJ5LT50 b190aHJlYWQsIF9fZW50cnktPmNvZGUsDQorCQkgIF9fZW50cnktPmZsYWdzLCBfX2VudHJ5LT5z dGFydF9zZWMsIF9fZW50cnktPnN0YXJ0X25zZWMpDQorKTsNCisNCiBUUkFDRV9FVkVOVChiaW5k ZXJfdHJhbnNhY3Rpb24sDQogCVRQX1BST1RPKGJvb2wgcmVwbHksIHN0cnVjdCBiaW5kZXJfdHJh bnNhY3Rpb24gKnQsDQogCQkgc3RydWN0IGJpbmRlcl9ub2RlICp0YXJnZXRfbm9kZSksDQotLSAN CjEuNy45LjUNCg== 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 7F6F3C2BB85 for ; Wed, 15 Apr 2020 05:38:26 +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 51B00206D9 for ; Wed, 15 Apr 2020 05:38:26 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="EN7+dndu"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="BVAQkPwa" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 51B00206D9 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:References:In-Reply-To: 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: List-Owner; bh=vc/+SmdWkBxajWYsM8LpuGf+3SjgqDabmaFx9XKBlPE=; b=EN7+dndu+yvw+H 8LZnUFBv5bEQUbrsLzvSCfdD6B6qaW4rmiJStcWnd2q5by5kPRyPhCAdHc7QspY4ntebK4fhjWzpo a5+v724jnN/E6TAYLk6eB8l0jBf+wvbc7OxCMUaEvBfcC+mmR4I333f1FA9axsLmYR7fjG794BhhI LT9nWrv4Fq3wEYUo1Ci3CSXK2SpvAHFKM0KEHg5RxrInGqq6RPjoZ+fNfxCV0WOoX9q4iqL8SBRa5 hJJklzBgO9qfcFS49zlGrNxTrHb7pTE0Od+KXzvbgwWCL/kf5qGuQsIyMCS2Gb33Atalz4mPDGd39 Btkyn4TYuX9UdJ/2tKbA==; 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 1jOakb-00078T-G4; Wed, 15 Apr 2020 05:38:17 +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 1jOakX-00077o-53 for linux-mediatek@lists.infradead.org; Wed, 15 Apr 2020 05:38:15 +0000 X-UUID: 3210b744576243278a030c3b223fe154-20200414 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:References:In-Reply-To:Message-ID:Date:Subject:CC:To:From; bh=KjQbJJUyEyrEGfSk6POU3EoJwAM5QvHYKRXXe00b6e8=; b=BVAQkPwa1AS91Bqj0WdEgLX9OLtpZQZy8jLf355HU38gR9RZr1F4rcJ9EDpx3C6WAp5B8OhgHUukoQgpW0dKJZN/kZhnxWTXCOsIpnEspCsMrXYBPC18QERId9wo70YiwqcUAIlZhM9N0lP5l4DGD4wmO4D8+jDTlSxOIVX4sSY=; X-UUID: 3210b744576243278a030c3b223fe154-20200414 Received: from mtkcas67.mediatek.inc [(172.29.193.45)] by mailgw01.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 1535413344; Tue, 14 Apr 2020 21:38:00 -0800 Received: from MTKMBS06N2.mediatek.inc (172.21.101.130) by MTKMBS62DR.mediatek.inc (172.29.94.18) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Tue, 14 Apr 2020 22:38:00 -0700 Received: from mtkcas08.mediatek.inc (172.21.101.126) by mtkmbs06n2.mediatek.inc (172.21.101.130) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Wed, 15 Apr 2020 13:38:00 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by mtkcas08.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Wed, 15 Apr 2020 13:37:58 +0800 From: Frankie Chang To: Joel Fernandes , Greg Kroah-Hartman Subject: [PATCH v2 1/1] binder: transaction latency tracking for user build Date: Wed, 15 Apr 2020 13:37:24 +0800 Message-ID: <1586929044-12708-2-git-send-email-Frankie.Chang@mediatek.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1586929044-12708-1-git-send-email-Frankie.Chang@mediatek.com> References: <1586759071.9539.15.camel@mtkswgap22> <1586929044-12708-1-git-send-email-Frankie.Chang@mediatek.com> MIME-Version: 1.0 X-TM-SNTS-SMTP: 90A2E6BEE053E9251A0E607B11B9A26F304E4D5EBE45716A7778AA8969227A4B2000:8 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200414_223813_218719_38368A23 X-CRM114-Status: GOOD ( 14.55 ) 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: Todd Kjos , wsd_upstream , linux-kernel@vger.kernel.org, =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Jian-Min Liu , linux-mediatek@lists.infradead.org, Frankie Chang , Martijn Coenen , Christian Brauner 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 Record start/end timestamp to binder transaction. When transaction is completed or transaction is free, it would be checked if transaction latency over threshold (2 sec), if yes, printing related information for tracing. /* Implement details */ - Add tracepoint/trace at free transaction. Since the original trace_binder_transaction_reveived cannot precisely present the real finished time of transaction, adding a trace_binder_free_transaction at the point of free transaction may be more close to it. - Add latency tracer module to monitor slow transaction. The trace_binder_free_transaction would not be enabled by default. Monitoring which transaction is too slow to cause some of exceptions is important. So we hook the tracepoint to call the monitor function. - Move some struct from core file to header file. Need some struct defined in core file in latency trace module In addition, moving structs to header file makes module more extendable. Signed-off-by: Frankie Chang --- drivers/android/Kconfig | 8 ++ drivers/android/Makefile | 1 + drivers/android/binder.c | 237 ++++--------------------------- drivers/android/binder_internal.h | 227 +++++++++++++++++++++++++++++ drivers/android/binder_latency_tracer.c | 100 +++++++++++++ drivers/android/binder_trace.h | 36 +++++ 6 files changed, 400 insertions(+), 209 deletions(-) create mode 100644 drivers/android/binder_latency_tracer.c diff --git a/drivers/android/Kconfig b/drivers/android/Kconfig index 6fdf2ab..7ba80eb 100644 --- a/drivers/android/Kconfig +++ b/drivers/android/Kconfig @@ -54,6 +54,14 @@ config ANDROID_BINDER_IPC_SELFTEST exhaustively with combinations of various buffer sizes and alignments. +config BINDER_USER_TRACKING + bool "Android Binder transaction tracking" + help + Used for track abnormal binder transaction which is over 2 seconds, + when the transaction is done or be free, this transaction would be + checked whether it executed overtime. + If yes, printing out the detail info about it. + endif # if ANDROID endmenu diff --git a/drivers/android/Makefile b/drivers/android/Makefile index c9d3d0c9..552e8ac 100644 --- a/drivers/android/Makefile +++ b/drivers/android/Makefile @@ -4,3 +4,4 @@ ccflags-y += -I$(src) # needed for trace events obj-$(CONFIG_ANDROID_BINDERFS) += binderfs.o obj-$(CONFIG_ANDROID_BINDER_IPC) += binder.o binder_alloc.o obj-$(CONFIG_ANDROID_BINDER_IPC_SELFTEST) += binder_alloc_selftest.o +obj-$(CONFIG_BINDER_USER_TRACKING) += binder_latency_tracer.o diff --git a/drivers/android/binder.c b/drivers/android/binder.c index a6b2082..380a68b 100644 --- a/drivers/android/binder.c +++ b/drivers/android/binder.c @@ -160,24 +160,6 @@ static int binder_set_stop_on_user_error(const char *val, #define to_binder_fd_array_object(hdr) \ container_of(hdr, struct binder_fd_array_object, hdr) -enum binder_stat_types { - BINDER_STAT_PROC, - BINDER_STAT_THREAD, - BINDER_STAT_NODE, - BINDER_STAT_REF, - BINDER_STAT_DEATH, - BINDER_STAT_TRANSACTION, - BINDER_STAT_TRANSACTION_COMPLETE, - BINDER_STAT_COUNT -}; - -struct binder_stats { - atomic_t br[_IOC_NR(BR_FAILED_REPLY) + 1]; - atomic_t bc[_IOC_NR(BC_REPLY_SG) + 1]; - atomic_t obj_created[BINDER_STAT_COUNT]; - atomic_t obj_deleted[BINDER_STAT_COUNT]; -}; - static struct binder_stats binder_stats; static inline void binder_stats_deleted(enum binder_stat_types type) @@ -214,32 +196,6 @@ static struct binder_transaction_log_entry *binder_transaction_log_add( } /** - * struct binder_work - work enqueued on a worklist - * @entry: node enqueued on list - * @type: type of work to be performed - * - * There are separate work lists for proc, thread, and node (async). - */ -struct binder_work { - struct list_head entry; - - enum { - BINDER_WORK_TRANSACTION = 1, - BINDER_WORK_TRANSACTION_COMPLETE, - BINDER_WORK_RETURN_ERROR, - BINDER_WORK_NODE, - BINDER_WORK_DEAD_BINDER, - BINDER_WORK_DEAD_BINDER_AND_CLEAR, - BINDER_WORK_CLEAR_DEATH_NOTIFICATION, - } type; -}; - -struct binder_error { - struct binder_work work; - uint32_t cmd; -}; - -/** * struct binder_node - binder node bookkeeping * @debug_id: unique ID for debugging * (invariant after initialized) @@ -402,89 +358,6 @@ enum binder_deferred_state { BINDER_DEFERRED_RELEASE = 0x02, }; -/** - * struct binder_proc - binder process bookkeeping - * @proc_node: element for binder_procs list - * @threads: rbtree of binder_threads in this proc - * (protected by @inner_lock) - * @nodes: rbtree of binder nodes associated with - * this proc ordered by node->ptr - * (protected by @inner_lock) - * @refs_by_desc: rbtree of refs ordered by ref->desc - * (protected by @outer_lock) - * @refs_by_node: rbtree of refs ordered by ref->node - * (protected by @outer_lock) - * @waiting_threads: threads currently waiting for proc work - * (protected by @inner_lock) - * @pid PID of group_leader of process - * (invariant after initialized) - * @tsk task_struct for group_leader of process - * (invariant after initialized) - * @deferred_work_node: element for binder_deferred_list - * (protected by binder_deferred_lock) - * @deferred_work: bitmap of deferred work to perform - * (protected by binder_deferred_lock) - * @is_dead: process is dead and awaiting free - * when outstanding transactions are cleaned up - * (protected by @inner_lock) - * @todo: list of work for this process - * (protected by @inner_lock) - * @stats: per-process binder statistics - * (atomics, no lock needed) - * @delivered_death: list of delivered death notification - * (protected by @inner_lock) - * @max_threads: cap on number of binder threads - * (protected by @inner_lock) - * @requested_threads: number of binder threads requested but not - * yet started. In current implementation, can - * only be 0 or 1. - * (protected by @inner_lock) - * @requested_threads_started: number binder threads started - * (protected by @inner_lock) - * @tmp_ref: temporary reference to indicate proc is in use - * (protected by @inner_lock) - * @default_priority: default scheduler priority - * (invariant after initialized) - * @debugfs_entry: debugfs node - * @alloc: binder allocator bookkeeping - * @context: binder_context for this proc - * (invariant after initialized) - * @inner_lock: can nest under outer_lock and/or node lock - * @outer_lock: no nesting under innor or node lock - * Lock order: 1) outer, 2) node, 3) inner - * @binderfs_entry: process-specific binderfs log file - * - * Bookkeeping structure for binder processes - */ -struct binder_proc { - struct hlist_node proc_node; - struct rb_root threads; - struct rb_root nodes; - struct rb_root refs_by_desc; - struct rb_root refs_by_node; - struct list_head waiting_threads; - int pid; - struct task_struct *tsk; - struct hlist_node deferred_work_node; - int deferred_work; - bool is_dead; - - struct list_head todo; - struct binder_stats stats; - struct list_head delivered_death; - int max_threads; - int requested_threads; - int requested_threads_started; - int tmp_ref; - long default_priority; - struct dentry *debugfs_entry; - struct binder_alloc alloc; - struct binder_context *context; - spinlock_t inner_lock; - spinlock_t outer_lock; - struct dentry *binderfs_entry; -}; - enum { BINDER_LOOPER_STATE_REGISTERED = 0x01, BINDER_LOOPER_STATE_ENTERED = 0x02, @@ -495,60 +368,6 @@ enum { }; /** - * struct binder_thread - binder thread bookkeeping - * @proc: binder process for this thread - * (invariant after initialization) - * @rb_node: element for proc->threads rbtree - * (protected by @proc->inner_lock) - * @waiting_thread_node: element for @proc->waiting_threads list - * (protected by @proc->inner_lock) - * @pid: PID for this thread - * (invariant after initialization) - * @looper: bitmap of looping state - * (only accessed by this thread) - * @looper_needs_return: looping thread needs to exit driver - * (no lock needed) - * @transaction_stack: stack of in-progress transactions for this thread - * (protected by @proc->inner_lock) - * @todo: list of work to do for this thread - * (protected by @proc->inner_lock) - * @process_todo: whether work in @todo should be processed - * (protected by @proc->inner_lock) - * @return_error: transaction errors reported by this thread - * (only accessed by this thread) - * @reply_error: transaction errors reported by target thread - * (protected by @proc->inner_lock) - * @wait: wait queue for thread work - * @stats: per-thread statistics - * (atomics, no lock needed) - * @tmp_ref: temporary reference to indicate thread is in use - * (atomic since @proc->inner_lock cannot - * always be acquired) - * @is_dead: thread is dead and awaiting free - * when outstanding transactions are cleaned up - * (protected by @proc->inner_lock) - * - * Bookkeeping structure for binder threads. - */ -struct binder_thread { - struct binder_proc *proc; - struct rb_node rb_node; - struct list_head waiting_thread_node; - int pid; - int looper; /* only modified by this thread */ - bool looper_need_return; /* can be written by other thread */ - struct binder_transaction *transaction_stack; - struct list_head todo; - bool process_todo; - struct binder_error return_error; - struct binder_error reply_error; - wait_queue_head_t wait; - struct binder_stats stats; - atomic_t tmp_ref; - bool is_dead; -}; - -/** * struct binder_txn_fd_fixup - transaction fd fixup list element * @fixup_entry: list entry * @file: struct file to be associated with new fd @@ -565,34 +384,6 @@ struct binder_txn_fd_fixup { size_t offset; }; -struct binder_transaction { - int debug_id; - struct binder_work work; - struct binder_thread *from; - struct binder_transaction *from_parent; - struct binder_proc *to_proc; - struct binder_thread *to_thread; - struct binder_transaction *to_parent; - unsigned need_reply:1; - /* unsigned is_dead:1; */ /* not used at the moment */ - - struct binder_buffer *buffer; - unsigned int code; - unsigned int flags; - long priority; - long saved_priority; - kuid_t sender_euid; - struct list_head fd_fixups; - binder_uintptr_t security_ctx; - /** - * @lock: protects @from, @to_proc, and @to_thread - * - * @from, @to_proc, and @to_thread can be set to NULL - * during thread teardown - */ - spinlock_t lock; -}; - /** * struct binder_object - union of flat binder object types * @hdr: generic object header @@ -613,6 +404,26 @@ struct binder_object { }; }; +static void (*__binder_update_info_cb)(struct binder_transaction *t, + struct binder_transaction_log_entry *e); + +void set_binder_update_info_cb(void (*fn)(struct binder_transaction *t, + struct binder_transaction_log_entry *e)) +{ + __binder_update_info_cb = fn; +} +EXPORT_SYMBOL_GPL(set_binder_update_info_cb); + +static void (*__print_transaction_ext_cb)(struct seq_file *m, + struct binder_transaction *t); + +void set_print_transaction_ext_cb(void (*fn)(struct seq_file *m, + struct binder_transaction *t)) +{ + __print_transaction_ext_cb = fn; +} +EXPORT_SYMBOL_GPL(set_print_transaction_ext_cb); + /** * binder_proc_lock() - Acquire outer lock for given binder_proc * @proc: struct binder_proc to acquire @@ -1927,6 +1738,7 @@ static void binder_free_transaction(struct binder_transaction *t) * If the transaction has no target_proc, then * t->buffer->transaction has already been cleared. */ + trace_binder_free_transaction(t); binder_free_txn_fixups(t); kfree(t); binder_stats_deleted(BINDER_STAT_TRANSACTION); @@ -2874,6 +2686,7 @@ static void binder_transaction(struct binder_proc *proc, e->offsets_size = tr->offsets_size; strscpy(e->context_name, proc->context->name, BINDERFS_MAX_NAME); + if (reply) { binder_inner_proc_lock(proc); in_reply_to = thread->transaction_stack; @@ -3060,6 +2873,9 @@ static void binder_transaction(struct binder_proc *proc, return_error_line = __LINE__; goto err_alloc_t_failed; } + + if (__binder_update_info_cb) + __binder_update_info_cb(t, e); INIT_LIST_HEAD(&t->fd_fixups); binder_stats_created(BINDER_STAT_TRANSACTION); spin_lock_init(&t->lock); @@ -3498,6 +3314,7 @@ static void binder_transaction(struct binder_proc *proc, kfree(tcomplete); binder_stats_deleted(BINDER_STAT_TRANSACTION_COMPLETE); err_alloc_tcomplete_failed: + trace_binder_free_transaction(t); kfree(t); binder_stats_deleted(BINDER_STAT_TRANSACTION); err_alloc_t_failed: @@ -5547,6 +5364,8 @@ static void print_binder_transaction_ilocked(struct seq_file *m, t->to_thread ? t->to_thread->pid : 0, t->code, t->flags, t->priority, t->need_reply); spin_unlock(&t->lock); + if (__print_transaction_ext_cb) + __print_transaction_ext_cb(m, t); if (proc != to_proc) { /* diff --git a/drivers/android/binder_internal.h b/drivers/android/binder_internal.h index ae99109..86b4960 100644 --- a/drivers/android/binder_internal.h +++ b/drivers/android/binder_internal.h @@ -12,6 +12,11 @@ #include #include +#ifdef CONFIG_BINDER_USER_TRACKING +#include +#include +#endif + struct binder_context { struct binder_node *binder_context_mgr_node; struct mutex context_mgr_node_lock; @@ -131,6 +136,10 @@ struct binder_transaction_log_entry { uint32_t return_error; uint32_t return_error_param; char context_name[BINDERFS_MAX_NAME + 1]; +#ifdef CONFIG_BINDER_USER_TRACKING + struct timespec timestamp; + struct timeval tv; +#endif }; struct binder_transaction_log { @@ -139,6 +148,224 @@ struct binder_transaction_log { struct binder_transaction_log_entry entry[32]; }; +enum binder_stat_types { + BINDER_STAT_PROC, + BINDER_STAT_THREAD, + BINDER_STAT_NODE, + BINDER_STAT_REF, + BINDER_STAT_DEATH, + BINDER_STAT_TRANSACTION, + BINDER_STAT_TRANSACTION_COMPLETE, + BINDER_STAT_COUNT +}; + +struct binder_stats { + atomic_t br[_IOC_NR(BR_FAILED_REPLY) + 1]; + atomic_t bc[_IOC_NR(BC_REPLY_SG) + 1]; + atomic_t obj_created[BINDER_STAT_COUNT]; + atomic_t obj_deleted[BINDER_STAT_COUNT]; +}; + +/** + * struct binder_work - work enqueued on a worklist + * @entry: node enqueued on list + * @type: type of work to be performed + * + * There are separate work lists for proc, thread, and node (async). + */ +struct binder_work { + struct list_head entry; + + enum { + BINDER_WORK_TRANSACTION = 1, + BINDER_WORK_TRANSACTION_COMPLETE, + BINDER_WORK_RETURN_ERROR, + BINDER_WORK_NODE, + BINDER_WORK_DEAD_BINDER, + BINDER_WORK_DEAD_BINDER_AND_CLEAR, + BINDER_WORK_CLEAR_DEATH_NOTIFICATION, + } type; +}; + +struct binder_error { + struct binder_work work; + uint32_t cmd; +}; + +/** + * struct binder_proc - binder process bookkeeping + * @proc_node: element for binder_procs list + * @threads: rbtree of binder_threads in this proc + * (protected by @inner_lock) + * @nodes: rbtree of binder nodes associated with + * this proc ordered by node->ptr + * (protected by @inner_lock) + * @refs_by_desc: rbtree of refs ordered by ref->desc + * (protected by @outer_lock) + * @refs_by_node: rbtree of refs ordered by ref->node + * (protected by @outer_lock) + * @waiting_threads: threads currently waiting for proc work + * (protected by @inner_lock) + * @pid PID of group_leader of process + * (invariant after initialized) + * @tsk task_struct for group_leader of process + * (invariant after initialized) + * @deferred_work_node: element for binder_deferred_list + * (protected by binder_deferred_lock) + * @deferred_work: bitmap of deferred work to perform + * (protected by binder_deferred_lock) + * @is_dead: process is dead and awaiting free + * when outstanding transactions are cleaned up + * (protected by @inner_lock) + * @todo: list of work for this process + * (protected by @inner_lock) + * @stats: per-process binder statistics + * (atomics, no lock needed) + * @delivered_death: list of delivered death notification + * (protected by @inner_lock) + * @max_threads: cap on number of binder threads + * (protected by @inner_lock) + * @requested_threads: number of binder threads requested but not + * yet started. In current implementation, can + * only be 0 or 1. + * (protected by @inner_lock) + * @requested_threads_started: number binder threads started + * (protected by @inner_lock) + * @tmp_ref: temporary reference to indicate proc is in use + * (protected by @inner_lock) + * @default_priority: default scheduler priority + * (invariant after initialized) + * @debugfs_entry: debugfs node + * @alloc: binder allocator bookkeeping + * @context: binder_context for this proc + * (invariant after initialized) + * @inner_lock: can nest under outer_lock and/or node lock + * @outer_lock: no nesting under innor or node lock + * Lock order: 1) outer, 2) node, 3) inner + * @binderfs_entry: process-specific binderfs log file + * + * Bookkeeping structure for binder processes + */ +struct binder_proc { + struct hlist_node proc_node; + struct rb_root threads; + struct rb_root nodes; + struct rb_root refs_by_desc; + struct rb_root refs_by_node; + struct list_head waiting_threads; + int pid; + struct task_struct *tsk; + struct hlist_node deferred_work_node; + int deferred_work; + bool is_dead; + + struct list_head todo; + struct binder_stats stats; + struct list_head delivered_death; + int max_threads; + int requested_threads; + int requested_threads_started; + int tmp_ref; + long default_priority; + struct dentry *debugfs_entry; + struct binder_alloc alloc; + struct binder_context *context; + spinlock_t inner_lock; + spinlock_t outer_lock; + struct dentry *binderfs_entry; +}; + +/** + * struct binder_thread - binder thread bookkeeping + * @proc: binder process for this thread + * (invariant after initialization) + * @rb_node: element for proc->threads rbtree + * (protected by @proc->inner_lock) + * @waiting_thread_node: element for @proc->waiting_threads list + * (protected by @proc->inner_lock) + * @pid: PID for this thread + * (invariant after initialization) + * @looper: bitmap of looping state + * (only accessed by this thread) + * @looper_needs_return: looping thread needs to exit driver + * (no lock needed) + * @transaction_stack: stack of in-progress transactions for this thread + * (protected by @proc->inner_lock) + * @todo: list of work to do for this thread + * (protected by @proc->inner_lock) + * @process_todo: whether work in @todo should be processed + * (protected by @proc->inner_lock) + * @return_error: transaction errors reported by this thread + * (only accessed by this thread) + * @reply_error: transaction errors reported by target thread + * (protected by @proc->inner_lock) + * @wait: wait queue for thread work + * @stats: per-thread statistics + * (atomics, no lock needed) + * @tmp_ref: temporary reference to indicate thread is in use + * (atomic since @proc->inner_lock cannot + * always be acquired) + * @is_dead: thread is dead and awaiting free + * when outstanding transactions are cleaned up + * (protected by @proc->inner_lock) + * + * Bookkeeping structure for binder threads. + */ +struct binder_thread { + struct binder_proc *proc; + struct rb_node rb_node; + struct list_head waiting_thread_node; + int pid; + int looper; /* only modified by this thread */ + bool looper_need_return; /* can be written by other thread */ + struct binder_transaction *transaction_stack; + struct list_head todo; + bool process_todo; + struct binder_error return_error; + struct binder_error reply_error; + wait_queue_head_t wait; + struct binder_stats stats; + atomic_t tmp_ref; + bool is_dead; +}; + +struct binder_transaction { + int debug_id; + struct binder_work work; + struct binder_thread *from; + struct binder_transaction *from_parent; + struct binder_proc *to_proc; + struct binder_thread *to_thread; + struct binder_transaction *to_parent; + unsigned need_reply:1; + /* unsigned is_dead:1; */ /* not used at the moment */ + + struct binder_buffer *buffer; + unsigned int code; + unsigned int flags; + long priority; + long saved_priority; + kuid_t sender_euid; + struct list_head fd_fixups; + binder_uintptr_t security_ctx; + /** + * @lock: protects @from, @to_proc, and @to_thread + * + * @from, @to_proc, and @to_thread can be set to NULL + * during thread teardown + */ + spinlock_t lock; +#ifdef CONFIG_BINDER_USER_TRACKING + struct timespec timestamp; + struct timeval tv; +#endif +}; + extern struct binder_transaction_log binder_transaction_log; extern struct binder_transaction_log binder_transaction_log_failed; + +extern void set_binder_update_info_cb(void (*fn)(struct binder_transaction *t, + struct binder_transaction_log_entry *e)); +extern void set_print_transaction_ext_cb(void (*fn)(struct seq_file *m, + struct binder_transaction *t)); #endif /* _LINUX_BINDER_INTERNAL_H */ diff --git a/drivers/android/binder_latency_tracer.c b/drivers/android/binder_latency_tracer.c new file mode 100644 index 0000000..c9626f5 --- /dev/null +++ b/drivers/android/binder_latency_tracer.c @@ -0,0 +1,100 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2019 MediaTek Inc. + */ + +#include +#include +#include "binder_alloc.h" +#include "binder_internal.h" +#include "binder_trace.h" + +/* + * probe_binder_free_transaction - Output info of a delay transaction + * @t: pointer to the over-time transaction + */ +void probe_binder_free_transaction(void *ignore, struct binder_transaction *t) +{ + struct rtc_time tm; + struct timespec *startime; + struct timespec cur, sub_t; + + ktime_get_ts(&cur); + startime = &t->timestamp; + sub_t = timespec_sub(cur, *startime); + + /* if transaction time is over than 2 sec, + * show timeout warning log. + */ + if (sub_t.tv_sec < 2) + return; + + rtc_time_to_tm(t->tv.tv_sec, &tm); + + spin_lock(&t->lock); + pr_info_ratelimited("%d: from %d:%d to %d:%d", + t->debug_id, + t->from ? t->from->proc->pid : 0, + t->from ? t->from->pid : 0, + t->to_proc ? t->to_proc->pid : 0, + t->to_thread ? t->to_thread->pid : 0); + spin_unlock(&t->lock); + + pr_info_ratelimited(" total %u.%03ld s code %u start %lu.%03ld android %d-%02d-%02d %02d:%02d:%02d.%03lu\n", + (unsigned int)sub_t.tv_sec, + (sub_t.tv_nsec / NSEC_PER_MSEC), + t->code, + (unsigned long)startime->tv_sec, + (startime->tv_nsec / NSEC_PER_MSEC), + (tm.tm_year + 1900), (tm.tm_mon + 1), tm.tm_mday, + tm.tm_hour, tm.tm_min, tm.tm_sec, + (unsigned long)(t->tv.tv_usec / USEC_PER_MSEC)); +} + +static void binder_update_info_cb(struct binder_transaction *t, + struct binder_transaction_log_entry *e) +{ + ktime_get_ts(&e->timestamp); + do_gettimeofday(&e->tv); + e->tv.tv_sec -= (sys_tz.tz_minuteswest * 60); + memcpy(&t->timestamp, &e->timestamp, sizeof(struct timespec)); + memcpy(&t->tv, &e->tv, sizeof(struct timeval)); +} + +static void print_binder_transaction_ext(struct seq_file *m, + struct binder_transaction *t) +{ + struct rtc_time tm; + + rtc_time_to_tm(t->tv.tv_sec, &tm); + seq_printf(m, + " start %lu.%06lu android %d-%02d-%02d %02d:%02d:%02d.%03lu", + (unsigned long)t->timestamp.tv_sec, + (t->timestamp.tv_nsec / NSEC_PER_USEC), + (tm.tm_year + 1900), (tm.tm_mon + 1), tm.tm_mday, + tm.tm_hour, tm.tm_min, tm.tm_sec, + (unsigned long)(t->tv.tv_usec / USEC_PER_MSEC)); + +} + +static int __init init_binder_latency_tracer(void) +{ + register_trace_binder_free_transaction( + probe_binder_free_transaction, NULL); + + set_binder_update_info_cb(binder_update_info_cb); + set_print_transaction_ext_cb(print_binder_transaction_ext); + return 0; +} + +static void exit_binder_latency_tracer(void) +{ + unregister_trace_binder_free_transaction( + probe_binder_free_transaction, NULL); +} + +module_init(init_binder_latency_tracer); +module_exit(exit_binder_latency_tracer); + +MODULE_LICENSE("GPL v2"); + diff --git a/drivers/android/binder_trace.h b/drivers/android/binder_trace.h index 6731c3c..c7c76c1 100644 --- a/drivers/android/binder_trace.h +++ b/drivers/android/binder_trace.h @@ -95,6 +95,42 @@ __entry->thread_todo) ); +TRACE_EVENT(binder_free_transaction, + TP_PROTO(struct binder_transaction *t), + TP_ARGS(t), + TP_STRUCT__entry( + __field(int, debug_id) + __field(int, from_proc) + __field(int, from_thread) + __field(int, to_proc) + __field(int, to_thread) + __field(unsigned int, code) + __field(unsigned int, flags) + __field(unsigned long, start_sec) + __field(unsigned long, start_nsec) + ), + TP_fast_assign( + __entry->debug_id = t->debug_id; + __entry->from_proc = t->from ? t->from->proc->pid : 0; + __entry->from_thread = t->from ? t->from->pid : 0; + __entry->to_proc = t->to_proc ? t->to_proc->pid : 0; + __entry->to_thread = t->to_thread ? t->to_thread->pid : 0; + __entry->code = t->code; + __entry->flags = t->flags; +#ifdef CONFIG_BINDER_USER_TRACKING + __entry->start_sec = t->timestamp.tv_sec; + __entry->start_nsec = t->timestamp.tv_nsec / NSEC_PER_MSEC; +#else + __entry->start_sec = 0; + __entry->start_nsec = 0; +#endif + ), + TP_printk("transaction=%d from %d:%d to %d:%d flags=0x%x code=0x%x start %lu.%03ld", + __entry->debug_id, __entry->from_proc, __entry->from_thread, + __entry->to_proc, __entry->to_thread, __entry->code, + __entry->flags, __entry->start_sec, __entry->start_nsec) +); + TRACE_EVENT(binder_transaction, TP_PROTO(bool reply, struct binder_transaction *t, struct binder_node *target_node), -- 1.7.9.5 _______________________________________________ Linux-mediatek mailing list Linux-mediatek@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-mediatek