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=-11.4 required=3.0 tests=BAYES_00,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,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable 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 60808C433E3 for ; Tue, 28 Jul 2020 03:20:16 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 3184A207CD for ; Tue, 28 Jul 2020 03:20:16 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="FTu30law" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726979AbgG1DUO (ORCPT ); Mon, 27 Jul 2020 23:20:14 -0400 Received: from mailgw02.mediatek.com ([210.61.82.184]:61870 "EHLO mailgw02.mediatek.com" rhost-flags-OK-FAIL-OK-FAIL) by vger.kernel.org with ESMTP id S1726620AbgG1DUL (ORCPT ); Mon, 27 Jul 2020 23:20:11 -0400 X-UUID: 2cc1c471494f453bb2412d9b4df64ba1-20200728 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=pneX9c+Nf642/lsLtl0xOpkT7L9EnCYziae9xk67Zrg=; b=FTu30lawI1annMATkWbpxJCP3hTTDWKTvU4QdmfmSYPqipUZIs9qAHtUdi8FtlOwKIX4UoUBnaPfhzgN56MU67LSUXAb6QfHgtxzo0V/hRM/D4fFU6TNjjQhfYqqXyJ+H2sbOQQnBrqlz54Ud0zoMuLYDjAeRyjnHPKZGiDhNPw=; X-UUID: 2cc1c471494f453bb2412d9b4df64ba1-20200728 Received: from mtkcas08.mediatek.inc [(172.21.101.126)] by mailgw02.mediatek.com (envelope-from ) (Cellopoint E-mail Firewall v4.1.10 Build 0809 with TLS) with ESMTP id 1986657232; Tue, 28 Jul 2020 11:20:05 +0800 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs08n1.mediatek.inc (172.21.101.55) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Tue, 28 Jul 2020 11:20:03 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Tue, 28 Jul 2020 11:20:01 +0800 From: Frankie Chang To: Todd Kjos CC: Greg Kroah-Hartman , Joel Fernandes , Martijn Coenen , =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Christian Brauner , , , , Jian-Min Liu , Frankie Chang Subject: [PATCH v6 3/3] binder: add transaction latency tracer Date: Tue, 28 Jul 2020 11:20:01 +0800 Message-ID: <1595906401-11985-4-git-send-email-Frankie.Chang@mediatek.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1595906401-11985-1-git-send-email-Frankie.Chang@mediatek.com> References: <1595252430.5899.6.camel@mtkswgap22> <1595906401-11985-1-git-send-email-Frankie.Chang@mediatek.com> MIME-Version: 1.0 Content-Type: text/plain 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 RnJvbTogIkZyYW5raWUuQ2hhbmciIDxGcmFua2llLkNoYW5nQG1lZGlhdGVrLmNvbT4NCg0KUmVj b3JkIHN0YXJ0L2VuZCB0aW1lc3RhbXAgZm9yIGJpbmRlciB0cmFuc2FjdGlvbi4NCldoZW4gdHJh bnNhY3Rpb24gaXMgY29tcGxldGVkIG9yIHRyYW5zYWN0aW9uIGlzIGZyZWUsDQppdCB3b3VsZCBi ZSBjaGVja2VkIGlmIHRyYW5zYWN0aW9uIGxhdGVuY3kgb3ZlciB0aHJlc2hvbGQNCihkZWZhdWx0 IDIgc2VjKSwgaWYgeWVzLCBwcmludGluZyByZWxhdGVkIGluZm9ybWF0aW9uIGZvciB0cmFjaW5n Lg0KDQovKiBJbXBsZW1lbnQgZGV0YWlscyAqLw0KLSBBZGQgbGF0ZW5jeSB0cmFjZXIgbW9kdWxl IHRvIG1vbml0b3IgdHJhbnNhY3Rpb24NCiAgYnkgYXR0YWNoaW5nIHRvIG5ldyB0cmFjZXBvaW50 cyBpbnRyb2R1Y2VkDQogIHdoZW4gdHJhbnNhY3Rpb25zIGFyZSBhbGxvY2F0ZWQgYW5kIGZyZWVk Lg0KICBUaGUgdHJhY2VfYmluZGVyX3R4bl9sYXRlbmN5X2ZyZWUgd291bGQgbm90IGJlIGVuYWJs ZWQNCiAgYnkgZGVmYXVsdC4gTW9uaXRvcmluZyB3aGljaCB0cmFuc2FjdGlvbiBpcyB0b28gc2xv dyB0bw0KICBjYXVzZSBzb21lIG9mIGV4Y2VwdGlvbnMgaXMgaW1wb3J0YW50LiBTbyB3ZSBob29r IHRoZQ0KICB0cmFjZXBvaW50IHRvIGNhbGwgdGhlIG1vbml0b3IgZnVuY3Rpb24uDQoNCi0gU2lu Y2Ugc29tZSBvZiBtb2R1bGVzIHdvdWxkIHRyaWdnZXIgdGltZW91dCBORQ0KICBpZiB0aGVpciBi aW5kZXIgdHJhbnNhY3Rpb24gZG9uJ3QgZmluaXNoIGluIHRpbWUsDQogIHN1Y2ggYXMgYXVkaW8g dGltZW91dCAoNSBzZWMpLCBldmVuIEJUIGNvbW1hbmQNCiAgdGltZW91dCAoMiBzZWMpLCBldGMu DQogIFRoZXJlZm9yZSwgc2V0dGluZyB0aGUgdGltZW91dCB0aHJlc2hvbGQgYXMgZGVmYXVsdA0K ICAyIHNlY29uZHMgY291bGQgYmUgaGVscGZ1bCB0byBkZWJ1Zy4NCiAgQnV0IHRoaXMgdGltZW91 dCB0aHJlc2hvbGQgaXMgY29uZmlndXJhYmxlLCB0byBsZXQNCiAgYWxsIHVzZXJzIGRldGVybWlu ZSB0aGUgbW9yZSBzdWl0YWJsZSB0aHJlc2hvbGQuDQoNCi0gVGhlIHJlYXNvbiB3aHkgcHJpbnRp bmcgdGhlIHJlbGF0ZWQgaW5mb3JtYXRpb24gdG8NCiAga2VybmVsIGluZm9ybWF0aW9uIGxvZyBi dXQgbm90IHRyYWNlIGJ1ZmZlciBpcyB0aGF0DQogIHNvbWUgYWJub3JtYWwgdHJhbnNhY3Rpb25z IG1heSBiZSBwZW5kaW5nIGZvciBhIGxvbmcNCiAgdGltZSBhZ28sIHRoZXkgY291bGQgbm90IGJl IHJlY29yZGVkIGR1ZSB0byBidWZmZXINCiAgbGltaXRlZC4NCg0KU2lnbmVkLW9mZi1ieTogRnJh bmtpZS5DaGFuZyA8RnJhbmtpZS5DaGFuZ0BtZWRpYXRlay5jb20+DQotLS0NCiBkcml2ZXJzL2Fu ZHJvaWQvS2NvbmZpZyAgICAgICAgICAgICAgICAgfCAgICA4ICsrKw0KIGRyaXZlcnMvYW5kcm9p ZC9NYWtlZmlsZSAgICAgICAgICAgICAgICB8ICAgIDEgKw0KIGRyaXZlcnMvYW5kcm9pZC9iaW5k ZXIuYyAgICAgICAgICAgICAgICB8ICAgIDIgKw0KIGRyaXZlcnMvYW5kcm9pZC9iaW5kZXJfaW50 ZXJuYWwuaCAgICAgICB8ICAgMTMgKysrKw0KIGRyaXZlcnMvYW5kcm9pZC9iaW5kZXJfbGF0ZW5j eV90cmFjZXIuYyB8ICAxMTIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKw0KIGRyaXZl cnMvYW5kcm9pZC9iaW5kZXJfdHJhY2UuaCAgICAgICAgICB8ICAgMjYgKysrKysrLQ0KIDYgZmls ZXMgY2hhbmdlZCwgMTU5IGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pDQogY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvYW5kcm9pZC9iaW5kZXJfbGF0ZW5jeV90cmFjZXIuYw0KDQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9hbmRyb2lkL0tjb25maWcgYi9kcml2ZXJzL2FuZHJvaWQvS2NvbmZp Zw0KaW5kZXggNmZkZjJhYi4uOTFmZmYxZSAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvYW5kcm9pZC9L Y29uZmlnDQorKysgYi9kcml2ZXJzL2FuZHJvaWQvS2NvbmZpZw0KQEAgLTU0LDYgKzU0LDE0IEBA IGNvbmZpZyBBTkRST0lEX0JJTkRFUl9JUENfU0VMRlRFU1QNCiAJICBleGhhdXN0aXZlbHkgd2l0 aCBjb21iaW5hdGlvbnMgb2YgdmFyaW91cyBidWZmZXIgc2l6ZXMgYW5kDQogCSAgYWxpZ25tZW50 cy4NCiANCitjb25maWcgQklOREVSX1RSQU5TQUNUSU9OX0xBVEVOQ1lfVFJBQ0tJTkcNCisJdHJp c3RhdGUgIkFuZHJvaWQgQmluZGVyIHRyYW5zYWN0aW9uIHRyYWNraW5nIg0KKwloZWxwDQorCSAg VXNlZCBmb3IgdHJhY2sgYWJub3JtYWwgYmluZGVyIHRyYW5zYWN0aW9uIHdoaWNoIGlzIG92ZXIg dGhyZXNob2xkLA0KKwkgIHdoZW4gdGhlIHRyYW5zYWN0aW9uIGlzIGRvbmUgb3IgYmUgZnJlZSwg dGhpcyB0cmFuc2FjdGlvbiB3b3VsZCBiZQ0KKwkgIGNoZWNrZWQgd2hldGhlciBpdCBleGVjdXRl ZCBvdmVydGltZS4NCisJICBJZiB5ZXMsIHByaW50aW5nIG91dCB0aGUgZGV0YWlsZWQgaW5mby4N CisNCiBlbmRpZiAjIGlmIEFORFJPSUQNCiANCiBlbmRtZW51DQpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9hbmRyb2lkL01ha2VmaWxlIGIvZHJpdmVycy9hbmRyb2lkL01ha2VmaWxlDQppbmRleCBjOWQz ZDBjOS4uYzJmZmRiNiAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvYW5kcm9pZC9NYWtlZmlsZQ0KKysr IGIvZHJpdmVycy9hbmRyb2lkL01ha2VmaWxlDQpAQCAtNCwzICs0LDQgQEAgY2NmbGFncy15ICs9 IC1JJChzcmMpCQkJIyBuZWVkZWQgZm9yIHRyYWNlIGV2ZW50cw0KIG9iai0kKENPTkZJR19BTkRS T0lEX0JJTkRFUkZTKQkJKz0gYmluZGVyZnMubw0KIG9iai0kKENPTkZJR19BTkRST0lEX0JJTkRF Ul9JUEMpCSs9IGJpbmRlci5vIGJpbmRlcl9hbGxvYy5vDQogb2JqLSQoQ09ORklHX0FORFJPSURf QklOREVSX0lQQ19TRUxGVEVTVCkgKz0gYmluZGVyX2FsbG9jX3NlbGZ0ZXN0Lm8NCitvYmotJChD T05GSUdfQklOREVSX1RSQU5TQUNUSU9OX0xBVEVOQ1lfVFJBQ0tJTkcpCSs9IGJpbmRlcl9sYXRl bmN5X3RyYWNlci5vDQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hbmRyb2lkL2JpbmRlci5jIGIvZHJp dmVycy9hbmRyb2lkL2JpbmRlci5jDQppbmRleCAxZTZmYzQwLi4wOTU2NDAzIDEwMDY0NA0KLS0t IGEvZHJpdmVycy9hbmRyb2lkL2JpbmRlci5jDQorKysgYi9kcml2ZXJzL2FuZHJvaWQvYmluZGVy LmMNCkBAIC0yNjU4LDYgKzI2NTgsNyBAQCBzdGF0aWMgdm9pZCBiaW5kZXJfdHJhbnNhY3Rpb24o c3RydWN0IGJpbmRlcl9wcm9jICpwcm9jLA0KIAkJcmV0dXJuX2Vycm9yX2xpbmUgPSBfX0xJTkVf XzsNCiAJCWdvdG8gZXJyX2FsbG9jX3RfZmFpbGVkOw0KIAl9DQorCXRyYWNlX2JpbmRlcl90eG5f bGF0ZW5jeV9hbGxvYyh0KTsNCiAJSU5JVF9MSVNUX0hFQUQoJnQtPmZkX2ZpeHVwcyk7DQogCWJp bmRlcl9zdGF0c19jcmVhdGVkKEJJTkRFUl9TVEFUX1RSQU5TQUNUSU9OKTsNCiAJc3Bpbl9sb2Nr X2luaXQoJnQtPmxvY2spOw0KQEAgLTUxNDcsNiArNTE0OCw3IEBAIHN0YXRpYyB2b2lkIHByaW50 X2JpbmRlcl90cmFuc2FjdGlvbl9pbG9ja2VkKHN0cnVjdCBzZXFfZmlsZSAqbSwNCiAJCSAgIHRv X3Byb2MgPyB0b19wcm9jLT5waWQgOiAwLA0KIAkJICAgdC0+dG9fdGhyZWFkID8gdC0+dG9fdGhy ZWFkLT5waWQgOiAwLA0KIAkJICAgdC0+Y29kZSwgdC0+ZmxhZ3MsIHQtPnByaW9yaXR5LCB0LT5u ZWVkX3JlcGx5KTsNCisJdHJhY2VfYmluZGVyX3R4bl9sYXRlbmN5X2luZm8obSwgdCk7DQogCXNw aW5fdW5sb2NrKCZ0LT5sb2NrKTsNCiANCiAJaWYgKHByb2MgIT0gdG9fcHJvYykgew0KZGlmZiAt LWdpdCBhL2RyaXZlcnMvYW5kcm9pZC9iaW5kZXJfaW50ZXJuYWwuaCBiL2RyaXZlcnMvYW5kcm9p ZC9iaW5kZXJfaW50ZXJuYWwuaA0KaW5kZXggNWI2NTQxMy4uNTk2ZGIwMCAxMDA2NDQNCi0tLSBh L2RyaXZlcnMvYW5kcm9pZC9iaW5kZXJfaW50ZXJuYWwuaA0KKysrIGIvZHJpdmVycy9hbmRyb2lk L2JpbmRlcl9pbnRlcm5hbC5oDQpAQCAtMTMsNiArMTMsMTEgQEANCiAjaW5jbHVkZSA8bGludXgv dWlkZ2lkLmg+DQogI2luY2x1ZGUgImJpbmRlcl9hbGxvYy5oIg0KIA0KKyNpZiBJU19FTkFCTEVE KENPTkZJR19CSU5ERVJfVFJBTlNBQ1RJT05fTEFURU5DWV9UUkFDS0lORykNCisjaW5jbHVkZSA8 bGludXgvcnRjLmg+DQorI2luY2x1ZGUgPGxpbnV4L3RpbWUuaD4NCisjZW5kaWYNCisNCiBzdHJ1 Y3QgYmluZGVyX2NvbnRleHQgew0KIAlzdHJ1Y3QgYmluZGVyX25vZGUgKmJpbmRlcl9jb250ZXh0 X21ncl9ub2RlOw0KIAlzdHJ1Y3QgbXV0ZXggY29udGV4dF9tZ3Jfbm9kZV9sb2NrOw0KQEAgLTUy MSw2ICs1MjYsMTQgQEAgc3RydWN0IGJpbmRlcl90cmFuc2FjdGlvbiB7DQogCSAqIGR1cmluZyB0 aHJlYWQgdGVhcmRvd24NCiAJICovDQogCXNwaW5sb2NrX3QgbG9jazsNCisJLyoqDQorCSAqIEB0 aW1lc3RhbXAgYW5kIEB0diBhcmUgdXNlZCB0byByZWNvcmQgdGhlIHRpbWUNCisJICogdGhhdCB0 aGUgYmluZGVyIHRyYW5zYWN0aW9uIHN0YXJ0dXANCisJICovDQorI2lmIElTX0VOQUJMRUQoQ09O RklHX0JJTkRFUl9UUkFOU0FDVElPTl9MQVRFTkNZX1RSQUNLSU5HKQ0KKwlzdHJ1Y3QgdGltZXNw ZWM2NCB0aW1lc3RhbXA7DQorCXN0cnVjdCB0aW1ldmFsIHR2Ow0KKyNlbmRpZg0KIH07DQogDQog LyoqDQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hbmRyb2lkL2JpbmRlcl9sYXRlbmN5X3RyYWNlci5j IGIvZHJpdmVycy9hbmRyb2lkL2JpbmRlcl9sYXRlbmN5X3RyYWNlci5jDQpuZXcgZmlsZSBtb2Rl IDEwMDY0NA0KaW5kZXggMDAwMDAwMC4uYjMzOWFlMQ0KLS0tIC9kZXYvbnVsbA0KKysrIGIvZHJp dmVycy9hbmRyb2lkL2JpbmRlcl9sYXRlbmN5X3RyYWNlci5jDQpAQCAtMCwwICsxLDExMiBAQA0K Ky8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wDQorLyoNCisgKiBDb3B5cmlnaHQg KEMpIDIwMTkgTWVkaWFUZWsgSW5jLg0KKyAqLw0KKw0KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUu aD4NCisjaW5jbHVkZSA8dWFwaS9saW51eC9hbmRyb2lkL2JpbmRlci5oPg0KKyNpbmNsdWRlICJi aW5kZXJfaW50ZXJuYWwuaCINCisjaW5jbHVkZSAiYmluZGVyX3RyYWNlLmgiDQorDQorLyoqDQor ICogVGhlIHJlYXNvbiBzZXR0aW5nIHRoZSBiaW5kZXJfdHhuX2xhdGVuY3lfdGhyZXNob2xkIHRv IDIgc2VjDQorICogaXMgdGhhdCBtb3N0IG9mIHRpbWVvdXQgYWJvcnQgaXMgZ3JlYXRlciBvciBl cXVhbCB0byAyIHNlYy4NCisgKiBNYWtpbmcgaXQgY29uZmlndXJhYmxlIHRvIGxldCBhbGwgdXNl cnMgZGV0ZXJtaW5lIHdoaWNoDQorICogdGhyZXNob2xkIGlzIG1vcmUgc3VpdGFibGUuDQorICov DQorc3RhdGljIHVpbnQzMl90IGJpbmRlcl90eG5fbGF0ZW5jeV90aHJlc2hvbGQgPSAyOw0KK21v ZHVsZV9wYXJhbV9uYW1lZCh0aHJlc2hvbGQsIGJpbmRlcl90eG5fbGF0ZW5jeV90aHJlc2hvbGQs DQorCQkJdWludCwgMDY0NCk7DQorDQorLyoNCisgKiBwcm9iZV9iaW5kZXJfdHhuX2xhdGVuY3lf ZnJlZSAtIE91dHB1dCBpbmZvIG9mIGEgZGVsYXkgdHJhbnNhY3Rpb24NCisgKiBAdDogICAgICAg ICAgcG9pbnRlciB0byB0aGUgb3Zlci10aW1lIHRyYW5zYWN0aW9uDQorICovDQordm9pZCBwcm9i ZV9iaW5kZXJfdHhuX2xhdGVuY3lfZnJlZSh2b2lkICppZ25vcmUsIHN0cnVjdCBiaW5kZXJfdHJh bnNhY3Rpb24gKnQpDQorew0KKwlzdHJ1Y3QgcnRjX3RpbWUgdG07DQorCXN0cnVjdCB0aW1lc3Bl YzY0ICpzdGFydGltZTsNCisJc3RydWN0IHRpbWVzcGVjNjQgY3VyLCBzdWJfdDsNCisNCisJa3Rp bWVfZ2V0X3RzNjQoJmN1cik7DQorCXN0YXJ0aW1lID0gJnQtPnRpbWVzdGFtcDsNCisJc3ViX3Qg PSB0aW1lc3BlYzY0X3N1YihjdXIsICpzdGFydGltZSk7DQorDQorCS8qIGlmIHRyYW5zYWN0aW9u IHRpbWUgaXMgb3ZlciB0aGFuIGJpbmRlcl90eG5fbGF0ZW5jeV90aHJlc2hvbGQgKHNlYyksDQor CSAqIHNob3cgdGltZW91dCB3YXJuaW5nIGxvZy4NCisJICovDQorCWlmIChzdWJfdC50dl9zZWMg PCBiaW5kZXJfdHhuX2xhdGVuY3lfdGhyZXNob2xkKQ0KKwkJcmV0dXJuOw0KKw0KKwlydGNfdGlt ZV90b190bSh0LT50di50dl9zZWMsICZ0bSk7DQorDQorCXByX2luZm9fcmF0ZWxpbWl0ZWQoIiVk OiBmcm9tICVkOiVkIHRvICVkOiVkIiwNCisJCQl0LT5kZWJ1Z19pZCwNCisJCQl0LT5mcm9tID8g dC0+ZnJvbS0+cHJvYy0+cGlkIDogMCwNCisJCQl0LT5mcm9tID8gdC0+ZnJvbS0+cGlkIDogMCwN CisJCQl0LT50b19wcm9jID8gdC0+dG9fcHJvYy0+cGlkIDogMCwNCisJCQl0LT50b190aHJlYWQg PyB0LT50b190aHJlYWQtPnBpZCA6IDApOw0KKw0KKwlwcl9pbmZvX3JhdGVsaW1pdGVkKCIgdG90 YWwgJXUuJTAzbGQgcyBjb2RlICV1IHN0YXJ0ICVsdS4lMDNsZCBhbmRyb2lkICVkLSUwMmQtJTAy ZCAlMDJkOiUwMmQ6JTAyZC4lMDNsdVxuIiwNCisJCQkodW5zaWduZWQgaW50KXN1Yl90LnR2X3Nl YywNCisJCQkoc3ViX3QudHZfbnNlYyAvIE5TRUNfUEVSX01TRUMpLA0KKwkJCXQtPmNvZGUsDQor CQkJKHVuc2lnbmVkIGxvbmcpc3RhcnRpbWUtPnR2X3NlYywNCisJCQkoc3RhcnRpbWUtPnR2X25z ZWMgLyBOU0VDX1BFUl9NU0VDKSwNCisJCQkodG0udG1feWVhciArIDE5MDApLCAodG0udG1fbW9u ICsgMSksIHRtLnRtX21kYXksDQorCQkJdG0udG1faG91ciwgdG0udG1fbWluLCB0bS50bV9zZWMs DQorCQkJKHVuc2lnbmVkIGxvbmcpKHQtPnR2LnR2X3VzZWMgLyBVU0VDX1BFUl9NU0VDKSk7DQor fQ0KKw0KK3N0YXRpYyB2b2lkIHByb2JlX2JpbmRlcl90eG5fbGF0ZW5jeV9hbGxvYyh2b2lkICpp Z25vcmUsDQorCQkJCQlzdHJ1Y3QgYmluZGVyX3RyYW5zYWN0aW9uICp0KQ0KK3sNCisJc3RydWN0 IHRpbWVzcGVjNjQgbm93Ow0KKwlrdGltZV9nZXRfdHM2NCgmdC0+dGltZXN0YW1wKTsNCisJa3Rp bWVfZ2V0X3JlYWxfdHM2NCgmbm93KTsNCisJdC0+dHYudHZfc2VjID0gbm93LnR2X3NlYzsNCisJ dC0+dHYudHZfc2VjIC09IChzeXNfdHoudHpfbWludXRlc3dlc3QgKiA2MCk7DQorCXQtPnR2LnR2 X3VzZWMgPSBub3cudHZfbnNlYy8xMDAwOw0KK30NCisNCitzdGF0aWMgdm9pZCBwcm9iZV9iaW5k ZXJfdHhuX2xhdGVuY3lfaW5mbyh2b2lkICppZ25vcmUsIHN0cnVjdCBzZXFfZmlsZSAqbSwNCisJ CQkJCXN0cnVjdCBiaW5kZXJfdHJhbnNhY3Rpb24gKnQpDQorew0KKwlzdHJ1Y3QgcnRjX3RpbWUg dG07DQorDQorCXJ0Y190aW1lX3RvX3RtKHQtPnR2LnR2X3NlYywgJnRtKTsNCisJc2VxX3ByaW50 ZihtLA0KKwkJICAgIiBzdGFydCAlbHUuJTA2bHUgYW5kcm9pZCAlZC0lMDJkLSUwMmQgJTAyZDol MDJkOiUwMmQuJTAzbHUiLA0KKwkJICAgKHVuc2lnbmVkIGxvbmcpdC0+dGltZXN0YW1wLnR2X3Nl YywNCisJCSAgICh0LT50aW1lc3RhbXAudHZfbnNlYyAvIE5TRUNfUEVSX1VTRUMpLA0KKwkJICAg KHRtLnRtX3llYXIgKyAxOTAwKSwgKHRtLnRtX21vbiArIDEpLCB0bS50bV9tZGF5LA0KKwkJICAg dG0udG1faG91ciwgdG0udG1fbWluLCB0bS50bV9zZWMsDQorCQkgICAodW5zaWduZWQgbG9uZyko dC0+dHYudHZfdXNlYyAvIFVTRUNfUEVSX01TRUMpKTsNCit9DQorDQorc3RhdGljIGludCBfX2lu aXQgaW5pdF9iaW5kZXJfbGF0ZW5jeV90cmFjZXIodm9pZCkNCit7DQorCXJlZ2lzdGVyX3RyYWNl X2JpbmRlcl90eG5fbGF0ZW5jeV9mcmVlKA0KKwkJCXByb2JlX2JpbmRlcl90eG5fbGF0ZW5jeV9m cmVlLCBOVUxMKTsNCisJcmVnaXN0ZXJfdHJhY2VfYmluZGVyX3R4bl9sYXRlbmN5X2FsbG9jKA0K KwkJCXByb2JlX2JpbmRlcl90eG5fbGF0ZW5jeV9hbGxvYywgTlVMTCk7DQorCXJlZ2lzdGVyX3Ry YWNlX2JpbmRlcl90eG5fbGF0ZW5jeV9pbmZvKA0KKwkJCXByb2JlX2JpbmRlcl90eG5fbGF0ZW5j eV9pbmZvLCBOVUxMKTsNCisNCisJcmV0dXJuIDA7DQorfQ0KKw0KK3N0YXRpYyB2b2lkIGV4aXRf YmluZGVyX2xhdGVuY3lfdHJhY2VyKHZvaWQpDQorew0KKwl1bnJlZ2lzdGVyX3RyYWNlX2JpbmRl cl90eG5fbGF0ZW5jeV9mcmVlKA0KKwkJCXByb2JlX2JpbmRlcl90eG5fbGF0ZW5jeV9mcmVlLCBO VUxMKTsNCisJdW5yZWdpc3Rlcl90cmFjZV9iaW5kZXJfdHhuX2xhdGVuY3lfYWxsb2MoDQorCQkJ cHJvYmVfYmluZGVyX3R4bl9sYXRlbmN5X2FsbG9jLCBOVUxMKTsNCisJdW5yZWdpc3Rlcl90cmFj ZV9iaW5kZXJfdHhuX2xhdGVuY3lfaW5mbygNCisJCQlwcm9iZV9iaW5kZXJfdHhuX2xhdGVuY3lf aW5mbywgTlVMTCk7DQorfQ0KKw0KK21vZHVsZV9pbml0KGluaXRfYmluZGVyX2xhdGVuY3lfdHJh Y2VyKTsNCittb2R1bGVfZXhpdChleGl0X2JpbmRlcl9sYXRlbmN5X3RyYWNlcik7DQorDQorTU9E VUxFX0xJQ0VOU0UoIkdQTCB2MiIpOw0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYW5kcm9pZC9iaW5k ZXJfdHJhY2UuaCBiL2RyaXZlcnMvYW5kcm9pZC9iaW5kZXJfdHJhY2UuaA0KaW5kZXggOGFjODdk MS4uNDA1ZDQ5MyAxMDA2NDQNCi0tLSBhL2RyaXZlcnMvYW5kcm9pZC9iaW5kZXJfdHJhY2UuaA0K KysrIGIvZHJpdmVycy9hbmRyb2lkL2JpbmRlcl90cmFjZS5oDQpAQCAtOTUsNiArOTUsMTcgQEAN CiAJCSAgX19lbnRyeS0+dGhyZWFkX3RvZG8pDQogKTsNCiANCitERUNMQVJFX1RSQUNFKGJpbmRl cl90eG5fbGF0ZW5jeV9hbGxvYywNCisJVFBfUFJPVE8oc3RydWN0IGJpbmRlcl90cmFuc2FjdGlv biAqdCksDQorCVRQX0FSR1ModCwgZSkNCispOw0KKw0KK0RFQ0xBUkVfVFJBQ0UoYmluZGVyX3R4 bl9sYXRlbmN5X2luZm8sDQorCVRQX1BST1RPKHN0cnVjdCBzZXFfZmlsZSAqbSwNCisJCSBzdHJ1 Y3QgYmluZGVyX3RyYW5zYWN0aW9uICp0KSwNCisJVFBfQVJHUyhtLCB0KQ0KKyk7DQorDQogVFJB Q0VfRVZFTlQoYmluZGVyX3R4bl9sYXRlbmN5X2ZyZWUsDQogCVRQX1BST1RPKHN0cnVjdCBiaW5k ZXJfdHJhbnNhY3Rpb24gKnQpLA0KIAlUUF9BUkdTKHQpLA0KQEAgLTEwNiw2ICsxMTcsOCBAQA0K IAkJX19maWVsZChpbnQsIHRvX3RocmVhZCkNCiAJCV9fZmllbGQodW5zaWduZWQgaW50LCBjb2Rl KQ0KIAkJX19maWVsZCh1bnNpZ25lZCBpbnQsIGZsYWdzKQ0KKwkJX19maWVsZCh1bnNpZ25lZCBs b25nLCBzdGFydF9zZWMpDQorCQlfX2ZpZWxkKHVuc2lnbmVkIGxvbmcsIHN0YXJ0X25zZWMpDQog CSksDQogCVRQX2Zhc3RfYXNzaWduKA0KIAkJX19lbnRyeS0+ZGVidWdfaWQgPSB0LT5kZWJ1Z19p ZDsNCkBAIC0xMTUsMTEgKzEyOCwxOCBAQA0KIAkJX19lbnRyeS0+dG9fdGhyZWFkID0gdC0+dG9f dGhyZWFkID8gdC0+dG9fdGhyZWFkLT5waWQgOiAwOw0KIAkJX19lbnRyeS0+Y29kZSA9IHQtPmNv ZGU7DQogCQlfX2VudHJ5LT5mbGFncyA9IHQtPmZsYWdzOw0KLQkpLA0KLQlUUF9wcmludGsoInRy YW5zYWN0aW9uPSVkIGZyb20gJWQ6JWQgdG8gJWQ6JWQgZmxhZ3M9MHgleCBjb2RlPTB4JXgiLA0K KyNpZiBJU19FTkFCTEVEKENPTkZJR19CSU5ERVJfVFJBTlNBQ1RJT05fTEFURU5DWV9UUkFDS0lO RykNCisJCV9fZW50cnktPnN0YXJ0X3NlYyA9IHQtPnRpbWVzdGFtcC50dl9zZWM7DQorCQlfX2Vu dHJ5LT5zdGFydF9uc2VjID0gdC0+dGltZXN0YW1wLnR2X25zZWMgLyBOU0VDX1BFUl9NU0VDOw0K KyNlbHNlDQorCQlfX2VudHJ5LT5zdGFydF9zZWMgPSAwOw0KKwkJX19lbnRyeS0+c3RhcnRfbnNl YyA9IDA7DQorI2VuZGlmDQorCSksDQorCVRQX3ByaW50aygidHJhbnNhY3Rpb249JWQgZnJvbSAl ZDolZCB0byAlZDolZCBmbGFncz0weCV4IGNvZGU9MHgleCBzdGFydCAlbHUuJTAzbGQiLA0KIAkJ ICBfX2VudHJ5LT5kZWJ1Z19pZCwgX19lbnRyeS0+ZnJvbV9wcm9jLCBfX2VudHJ5LT5mcm9tX3Ro cmVhZCwNCiAJCSAgX19lbnRyeS0+dG9fcHJvYywgX19lbnRyeS0+dG9fdGhyZWFkLCBfX2VudHJ5 LT5jb2RlLA0KLQkJICBfX2VudHJ5LT5mbGFncykNCisJCSAgX19lbnRyeS0+ZmxhZ3MsIF9fZW50 cnktPnN0YXJ0X3NlYywgX19lbnRyeS0+c3RhcnRfbnNlYykNCiApOw0KIA0KIFRSQUNFX0VWRU5U KGJpbmRlcl90cmFuc2FjdGlvbiwNCi0tIA0KMS43LjkuNQ0K 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=-13.0 required=3.0 tests=BAYES_00,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, URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable 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 0D222C433E1 for ; Tue, 28 Jul 2020 03:22:47 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (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 BDF262072E for ; Tue, 28 Jul 2020 03:22:46 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="WgytFLo5"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=mediatek.com header.i=@mediatek.com header.b="Be/WSWRM" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BDF262072E 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=merlin.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=6cAGqJa4bFMuHxxrmrtJlvNRFf8NwNEbV71pVIcPtU8=; b=WgytFLo5aIbBJ+nGjVvPTfT4A JGGfilZPkdj7V08RjHgopEj0CmE2YaKUVsIO+4NxWD0G3/Lpf3+62ozrVKgpUnsE8TSlbmNxrO94I VeiNSgCOUR0Jxf0eraKKHpn8BI64LXFdGSYAlPLZqp/FierK9v1L+WjvIO52lu3wJ1fh/VHvPv1Tc /ddUFW5jQnKJr9LOUDcgof2umEi7kjuizn8bECbXiG8POPsmG0ZqCLnE+A4/sDvMzyUzOA+u9MFYA 9nPLCPCGDbzggiX70huXI8yre5sjphj9ucezc4lc3zTRsti3kQ3Bdo0zfMchefYnkhA9ogG6HdQL1 OZHpXOpbw==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1k0GCH-0002S9-Fn; Tue, 28 Jul 2020 03:22:33 +0000 Received: from mailgw02.mediatek.com ([216.200.240.185]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1k0GCE-0002Qs-MT for linux-mediatek@lists.infradead.org; Tue, 28 Jul 2020 03:22:32 +0000 X-UUID: 97cb074de06142bf96710bea4be6152a-20200727 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=pneX9c+Nf642/lsLtl0xOpkT7L9EnCYziae9xk67Zrg=; b=Be/WSWRMTDc6eQinwCC7+P1KgdtsmIm7IBnmRoLFRTw1du1urp3/AnDqVSlTYLhvnZY/gRWJnjxhXaKB3hxzJ2MAA+8waOBfZcZ6MjHi54PLauNgmMqZjGqKsi1bR/m3RfdzexTjnVCFkH1t1wlz1fXl5tnFGmTGcK16okz4Veo=; X-UUID: 97cb074de06142bf96710bea4be6152a-20200727 Received: from mtkcas66.mediatek.inc [(172.29.193.44)] by mailgw02.mediatek.com (envelope-from ) (musrelay.mediatek.com ESMTP with TLS) with ESMTP id 1437841211; Mon, 27 Jul 2020 19:22:22 -0800 Received: from mtkmbs08n1.mediatek.inc (172.21.101.55) by MTKMBS62N2.mediatek.inc (172.29.193.42) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Mon, 27 Jul 2020 20:20:07 -0700 Received: from MTKCAS06.mediatek.inc (172.21.101.30) by mtkmbs08n1.mediatek.inc (172.21.101.55) with Microsoft SMTP Server (TLS) id 15.0.1497.2; Tue, 28 Jul 2020 11:20:03 +0800 Received: from mtkswgap22.mediatek.inc (172.21.77.33) by MTKCAS06.mediatek.inc (172.21.101.73) with Microsoft SMTP Server id 15.0.1497.2 via Frontend Transport; Tue, 28 Jul 2020 11:20:01 +0800 From: Frankie Chang To: Todd Kjos Subject: [PATCH v6 3/3] binder: add transaction latency tracer Date: Tue, 28 Jul 2020 11:20:01 +0800 Message-ID: <1595906401-11985-4-git-send-email-Frankie.Chang@mediatek.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1595906401-11985-1-git-send-email-Frankie.Chang@mediatek.com> References: <1595252430.5899.6.camel@mtkswgap22> <1595906401-11985-1-git-send-email-Frankie.Chang@mediatek.com> MIME-Version: 1.0 X-MTK: N X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200727_232230_973162_88C11547 X-CRM114-Status: GOOD ( 26.85 ) 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: wsd_upstream@mediatek.com, Greg Kroah-Hartman , linux-kernel@vger.kernel.org, =?UTF-8?q?Arve=20Hj=C3=B8nnev=C3=A5g?= , Jian-Min Liu , linux-mediatek@lists.infradead.org, Joel Fernandes , 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 From: "Frankie.Chang" Record start/end timestamp for binder transaction. When transaction is completed or transaction is free, it would be checked if transaction latency over threshold (default 2 sec), if yes, printing related information for tracing. /* Implement details */ - Add latency tracer module to monitor transaction by attaching to new tracepoints introduced when transactions are allocated and freed. The trace_binder_txn_latency_free 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. - Since some of modules would trigger timeout NE if their binder transaction don't finish in time, such as audio timeout (5 sec), even BT command timeout (2 sec), etc. Therefore, setting the timeout threshold as default 2 seconds could be helpful to debug. But this timeout threshold is configurable, to let all users determine the more suitable threshold. - The reason why printing the related information to kernel information log but not trace buffer is that some abnormal transactions may be pending for a long time ago, they could not be recorded due to buffer limited. Signed-off-by: Frankie.Chang --- drivers/android/Kconfig | 8 +++ drivers/android/Makefile | 1 + drivers/android/binder.c | 2 + drivers/android/binder_internal.h | 13 ++++ drivers/android/binder_latency_tracer.c | 112 +++++++++++++++++++++++++++++++ drivers/android/binder_trace.h | 26 ++++++- 6 files changed, 159 insertions(+), 3 deletions(-) create mode 100644 drivers/android/binder_latency_tracer.c diff --git a/drivers/android/Kconfig b/drivers/android/Kconfig index 6fdf2ab..91fff1e 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_TRANSACTION_LATENCY_TRACKING + tristate "Android Binder transaction tracking" + help + Used for track abnormal binder transaction which is over threshold, + when the transaction is done or be free, this transaction would be + checked whether it executed overtime. + If yes, printing out the detailed info. + endif # if ANDROID endmenu diff --git a/drivers/android/Makefile b/drivers/android/Makefile index c9d3d0c9..c2ffdb6 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_TRANSACTION_LATENCY_TRACKING) += binder_latency_tracer.o diff --git a/drivers/android/binder.c b/drivers/android/binder.c index 1e6fc40..0956403 100644 --- a/drivers/android/binder.c +++ b/drivers/android/binder.c @@ -2658,6 +2658,7 @@ static void binder_transaction(struct binder_proc *proc, return_error_line = __LINE__; goto err_alloc_t_failed; } + trace_binder_txn_latency_alloc(t); INIT_LIST_HEAD(&t->fd_fixups); binder_stats_created(BINDER_STAT_TRANSACTION); spin_lock_init(&t->lock); @@ -5147,6 +5148,7 @@ static void print_binder_transaction_ilocked(struct seq_file *m, to_proc ? to_proc->pid : 0, t->to_thread ? t->to_thread->pid : 0, t->code, t->flags, t->priority, t->need_reply); + trace_binder_txn_latency_info(m, t); spin_unlock(&t->lock); if (proc != to_proc) { diff --git a/drivers/android/binder_internal.h b/drivers/android/binder_internal.h index 5b65413..596db00 100644 --- a/drivers/android/binder_internal.h +++ b/drivers/android/binder_internal.h @@ -13,6 +13,11 @@ #include #include "binder_alloc.h" +#if IS_ENABLED(CONFIG_BINDER_TRANSACTION_LATENCY_TRACKING) +#include +#include +#endif + struct binder_context { struct binder_node *binder_context_mgr_node; struct mutex context_mgr_node_lock; @@ -521,6 +526,14 @@ struct binder_transaction { * during thread teardown */ spinlock_t lock; + /** + * @timestamp and @tv are used to record the time + * that the binder transaction startup + */ +#if IS_ENABLED(CONFIG_BINDER_TRANSACTION_LATENCY_TRACKING) + struct timespec64 timestamp; + struct timeval tv; +#endif }; /** diff --git a/drivers/android/binder_latency_tracer.c b/drivers/android/binder_latency_tracer.c new file mode 100644 index 0000000..b339ae1 --- /dev/null +++ b/drivers/android/binder_latency_tracer.c @@ -0,0 +1,112 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (C) 2019 MediaTek Inc. + */ + +#include +#include +#include "binder_internal.h" +#include "binder_trace.h" + +/** + * The reason setting the binder_txn_latency_threshold to 2 sec + * is that most of timeout abort is greater or equal to 2 sec. + * Making it configurable to let all users determine which + * threshold is more suitable. + */ +static uint32_t binder_txn_latency_threshold = 2; +module_param_named(threshold, binder_txn_latency_threshold, + uint, 0644); + +/* + * probe_binder_txn_latency_free - Output info of a delay transaction + * @t: pointer to the over-time transaction + */ +void probe_binder_txn_latency_free(void *ignore, struct binder_transaction *t) +{ + struct rtc_time tm; + struct timespec64 *startime; + struct timespec64 cur, sub_t; + + ktime_get_ts64(&cur); + startime = &t->timestamp; + sub_t = timespec64_sub(cur, *startime); + + /* if transaction time is over than binder_txn_latency_threshold (sec), + * show timeout warning log. + */ + if (sub_t.tv_sec < binder_txn_latency_threshold) + return; + + rtc_time_to_tm(t->tv.tv_sec, &tm); + + 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); + + 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 probe_binder_txn_latency_alloc(void *ignore, + struct binder_transaction *t) +{ + struct timespec64 now; + ktime_get_ts64(&t->timestamp); + ktime_get_real_ts64(&now); + t->tv.tv_sec = now.tv_sec; + t->tv.tv_sec -= (sys_tz.tz_minuteswest * 60); + t->tv.tv_usec = now.tv_nsec/1000; +} + +static void probe_binder_txn_latency_info(void *ignore, 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_txn_latency_free( + probe_binder_txn_latency_free, NULL); + register_trace_binder_txn_latency_alloc( + probe_binder_txn_latency_alloc, NULL); + register_trace_binder_txn_latency_info( + probe_binder_txn_latency_info, NULL); + + return 0; +} + +static void exit_binder_latency_tracer(void) +{ + unregister_trace_binder_txn_latency_free( + probe_binder_txn_latency_free, NULL); + unregister_trace_binder_txn_latency_alloc( + probe_binder_txn_latency_alloc, NULL); + unregister_trace_binder_txn_latency_info( + probe_binder_txn_latency_info, 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 8ac87d1..405d493 100644 --- a/drivers/android/binder_trace.h +++ b/drivers/android/binder_trace.h @@ -95,6 +95,17 @@ __entry->thread_todo) ); +DECLARE_TRACE(binder_txn_latency_alloc, + TP_PROTO(struct binder_transaction *t), + TP_ARGS(t, e) +); + +DECLARE_TRACE(binder_txn_latency_info, + TP_PROTO(struct seq_file *m, + struct binder_transaction *t), + TP_ARGS(m, t) +); + TRACE_EVENT(binder_txn_latency_free, TP_PROTO(struct binder_transaction *t), TP_ARGS(t), @@ -106,6 +117,8 @@ __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; @@ -115,11 +128,18 @@ __entry->to_thread = t->to_thread ? t->to_thread->pid : 0; __entry->code = t->code; __entry->flags = t->flags; - ), - TP_printk("transaction=%d from %d:%d to %d:%d flags=0x%x code=0x%x", +#if IS_ENABLED(CONFIG_BINDER_TRANSACTION_LATENCY_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->flags, __entry->start_sec, __entry->start_nsec) ); TRACE_EVENT(binder_transaction, -- 1.7.9.5 _______________________________________________ Linux-mediatek mailing list Linux-mediatek@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-mediatek