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=-16.5 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_INVALID,DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,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 E8981C433E0 for ; Wed, 27 Jan 2021 08:30:28 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 91CB22073C for ; Wed, 27 Jan 2021 08:30:28 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 91CB22073C Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=google.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id D803B6E7E6; Wed, 27 Jan 2021 08:29:51 +0000 (UTC) Received: from mail-qt1-x849.google.com (mail-qt1-x849.google.com [IPv6:2607:f8b0:4864:20::849]) by gabe.freedesktop.org (Postfix) with ESMTPS id 846976E1B6 for ; Tue, 26 Jan 2021 20:42:46 +0000 (UTC) Received: by mail-qt1-x849.google.com with SMTP id r18so6316171qta.19 for ; Tue, 26 Jan 2021 12:42:46 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:message-id:mime-version:subject:from:to:cc :content-transfer-encoding; bh=umYZWS6Z3IFyoIqy8XevcEiFUNU/mgfont74aC5M2Jc=; b=AWgEG6Ah8p3uAxFd6JEWWNre1+V5M/uGxqKboxz6qcAU+fOOJ7+YJAydnzKtguqFbV 01wfe5GD1w+KTe7xPJECSCDQ56Yj7Y6wYi9UB5T1gaZjcDyv72dWWxesOj/W2Xfo9BM9 srq0wAzZkiSYauKcdHkpZIbNYn+kUd1xIt31idgtKrw0T9X41owDPQFIfb4OZ3TU9msf TXCQJKcO4d03EDFfhfmza4ahkxIQFYjoddqWYSzaJdY7L7WGhpX6f83nlfxtYTQFB2yk wX69wd/8+bkZZW+SLcwuHMojL6vtuvi3a7/dWfGtOlMyWiyP8S/Q4nYLpaF5IfFr47Of Dy2w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:message-id:mime-version:subject:from :to:cc:content-transfer-encoding; bh=umYZWS6Z3IFyoIqy8XevcEiFUNU/mgfont74aC5M2Jc=; b=j1yaR04+5oWQoybzLN2nmlnd1ph3xyrCrZgsf6JaLl8DW1QZxNvmM5pvHUvoCyJ0PE 7kdtCcMNiJjwtCAPdrrMOMQnBSKFxmJGjkwygJAN6xfuEzbgJgnOui1XJN30/zdbf4C1 oeWAssykuFzaxGxYfCvM1INPcU8UWD/aCQsVJ/td18fATBqToC7pIcWPtSicvZYpzldY rYD4VLpeSmsitcSAeeq1A90TYVMdv8/xnmWpQcSXyvuQuovjySgrymkpEHclI89dNRJR Lf4y+Q524LDBNqhkNUbtBpWq1+A/plXMJttGnpJSitn95D9BfSp3bjWAjxznkiYhl3X9 2v4Q== X-Gm-Message-State: AOAM533MrtBXcOzq/4SZh7/4dTy2YSYpwazcK63hbk7R94ZNpdCvBs4b nP1c7UC2nkKCf2VAUTzYffdQCHIMxPc= X-Google-Smtp-Source: ABdhPJzAOsjnC7BvX6mcgN85oLU15vxw1W7G6I3DBxunGl56ldwJ+Q5XqJMqXfq3nrG6/YoYxGvG++ZtGug= X-Received: from hridya.mtv.corp.google.com ([2620:15c:211:200:7220:84ff:fe09:5ea6]) (user=hridya job=sendgmr) by 2002:ad4:5b82:: with SMTP id 2mr7324332qvp.53.1611693765254; Tue, 26 Jan 2021 12:42:45 -0800 (PST) Date: Tue, 26 Jan 2021 12:42:36 -0800 Message-Id: <20210126204240.418297-1-hridya@google.com> Mime-Version: 1.0 X-Mailer: git-send-email 2.30.0.280.ga3ce27912f-goog Subject: [PATCH v3] dmabuf: Add the capability to expose DMA-BUF stats in sysfs From: Hridya Valsaraju To: Sumit Semwal , "=?UTF-8?q?Christian=20K=C3=B6nig?=" , Hridya Valsaraju , linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org X-Mailman-Approved-At: Wed, 27 Jan 2021 08:29:46 +0000 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kernel test robot , gregkh@linuxfoundation.org, surenb@google.com, hyesoo.yu@samsung.com, kernel-team@android.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" VGhpcyBwYXRjaCBhbGxvd3Mgc3RhdGlzdGljcyB0byBiZSBlbmFibGVkIGZvciBlYWNoIERNQS1C VUYgaW4Kc3lzZnMgYnkgZW5hYmxpbmcgdGhlIGNvbmZpZyBDT05GSUdfRE1BQlVGX1NZU0ZTX1NU QVRTLgoKVGhlIGZvbGxvd2luZyBzdGF0cyB3aWxsIGJlIGV4cG9zZWQgYnkgdGhlIGludGVyZmFj ZToKCi9zeXMva2VybmVsL2RtYWJ1Zi9idWZmZXJzLzxpbm9kZV9udW1iZXI+L2V4cG9ydGVyX25h bWUKL3N5cy9rZXJuZWwvZG1hYnVmL2J1ZmZlcnMvPGlub2RlX251bWJlcj4vc2l6ZQovc3lzL2tl cm5lbC9kbWFidWYvYnVmZmVycy88aW5vZGVfbnVtYmVyPi9hdHRhY2htZW50cy88YXR0YWNoX3Vp ZD4vZGV2aWNlCi9zeXMva2VybmVsL2RtYWJ1Zi9idWZmZXJzLzxpbm9kZV9udW1iZXI+L2F0dGFj aG1lbnRzLzxhdHRhY2hfdWlkPi9tYXBfY291bnRlcgoKVGhlIGlub2RlX251bWJlciBpcyB1bmlx dWUgZm9yIGVhY2ggRE1BLUJVRiBhbmQgd2FzIGFkZGVkIGVhcmxpZXIgWzFdCmluIG9yZGVyIHRv IGFsbG93IHVzZXJzcGFjZSB0byB0cmFjayBETUEtQlVGIHVzYWdlIGFjcm9zcyBkaWZmZXJlbnQK cHJvY2Vzc2VzLgoKQ3VycmVudGx5LCB0aGlzIGluZm9ybWF0aW9uIGlzIGV4cG9zZWQgaW4KL3N5 cy9rZXJuZWwvZGVidWcvZG1hX2J1Zi9idWZpbmZvLgpIb3dldmVyLCBzaW5jZSBkZWJ1Z2ZzIGlz IGNvbnNpZGVyZWQgdW5zYWZlIHRvIGJlIG1vdW50ZWQgaW4gcHJvZHVjdGlvbiwKaXQgaXMgYmVp bmcgZHVwbGljYXRlZCBpbiBzeXNmcy4KClRoaXMgaW5mb3JtYXRpb24gd2lsbCBiZSB1c2VkIHRv IGRlcml2ZSBETUEtQlVGCnBlci1leHBvcnRlciBzdGF0cyBhbmQgcGVyLWRldmljZSB1c2FnZSBz dGF0cyBmb3IgQW5kcm9pZCBCdWcgcmVwb3J0cy4KVGhlIGNvcnJlc3BvbmRpbmcgdXNlcnNwYWNl IGNoYW5nZXMgY2FuIGJlIGZvdW5kIGF0IFsyXS4KVGVsZW1ldHJ5IHRvb2xzIHdpbGwgYWxzbyBj YXB0dXJlIHRoaXMgaW5mb3JtYXRpb24oYWxvbmcgd2l0aCBvdGhlcgptZW1vcnkgbWV0cmljcykg cGVyaW9kaWNhbGx5IGFzIHdlbGwgYXMgb24gaW1wb3J0YW50IGV2ZW50cyBsaWtlIGEKZm9yZWdy b3VuZCBhcHAga2lsbCAod2hpY2ggbWlnaHQgaGF2ZSBiZWVuIHRyaWdnZXJlZCBieSBMb3cgTWVt b3J5CktpbGxlcikuIEl0IHdpbGwgYWxzbyBjb250cmlidXRlIHRvIHByb3ZpZGUgYSBzbmFwc2hv dCBvZiB0aGUgc3lzdGVtCm1lbW9yeSB1c2FnZSBvbiBvdGhlciBldmVudHMgc3VjaCBhcyBPT00g a2lsbHMgYW5kIEFwcGxpY2F0aW9uIE5vdApSZXNwb25kaW5nIGV2ZW50cy4KCkEgc2hlbGwgc2Ny aXB0IHRoYXQgY2FuIGJlIHJ1biBvbiBhIGNsYXNzaWMgTGludXggZW52aXJvbm1lbnQgdG8gcmVh ZApvdXQgdGhlIERNQS1CVUYgc3RhdGlzdGljcyBjYW4gYmUgZm91bmQgYXQgWzNdKHN1Z2dlc3Rl ZCBieSBKb2huClN0dWx0eikuCgpUaGUgcGF0Y2ggY29udGFpbnMgdGhlIGZvbGxvd2luZyBpbXBy b3ZlbWVudHMgb3ZlciB0aGUgcHJldmlvdXMgdmVyc2lvbjoKMSkgRWFjaCBhdHRhY2htZW50IGlz IHJlcHJlc2VudGVkIGJ5IGl0cyBvd24gZGlyZWN0b3J5IHRvIGFsbG93IGNyZWF0aW5nCmEgc3lt bGluayB0byB0aGUgaW1wb3J0aW5nIGRldmljZSBhbmQgdG8gYWxzbyBwcm92aWRlIHJvb20gZm9y IGZ1dHVyZQpleHBhbnNpb24uCjIpIFRoZSBudW1iZXIgb2YgZGlzdGluY3QgbWFwcGluZ3Mgb2Yg ZWFjaCBhdHRhY2htZW50IGlzIGV4cG9zZWQgaW4gYQpzZXBhcmF0ZSBmaWxlLgozKSBUaGUgcGVy LWJ1ZmZlciBzdGF0aXN0aWNzIGFyZSBub3cgaW4gL3N5cy9rZXJuZWwvZG1hYnVmL2J1ZmZlcnMK aW5vcmRlciB0byBtYWtlIHRoZSBpbnRlcmZhY2UgZXhwYW5kYWJsZSBpbiBmdXR1cmUuCgpBbGwg b2YgdGhlIGltcHJvdmVtZW50cyBhYm92ZSBhcmUgYmFzZWQgb24gc3VnZ2VzdGlvbnMvZmVlZGJh Y2sgZnJvbQpEYW5pZWwgVmV0dGVyIGFuZCBDaHJpc3RpYW4gS8O2bmlnLgoKWzFdOiBodHRwczov L2xvcmUua2VybmVsLm9yZy9wYXRjaHdvcmsvcGF0Y2gvMTA4ODc5MS8KWzJdOiBodHRwczovL2Fu ZHJvaWQtcmV2aWV3Lmdvb2dsZXNvdXJjZS5jb20vcS90b3BpYzolMjJkbWFidWYtc3lzZnMlMjIr KHN0YXR1czpvcGVuJTIwT1IlMjBzdGF0dXM6bWVyZ2VkKQpbM106IGh0dHBzOi8vYW5kcm9pZC1y ZXZpZXcuZ29vZ2xlc291cmNlLmNvbS9jL3BsYXRmb3JtL3N5c3RlbS9tZW1vcnkvbGlibWVtaW5m by8rLzE1NDk3MzQKClNpZ25lZC1vZmYtYnk6IEhyaWR5YSBWYWxzYXJhanUgPGhyaWR5YUBnb29n bGUuY29tPgpSZXBvcnRlZC1ieToga2VybmVsIHRlc3Qgcm9ib3QgPGxrcEBpbnRlbC5jb20+Ci0t LQpDaGFuZ2VzIGluIHYzOgpGaXggYSB3YXJuaW5nIHJlcG9ydGVkIGJ5IHRoZSBrZXJuZWwgdGVz dCByb2JvdC4KCkNoYW5nZXMgaW4gdjI6Ci1Nb3ZlIHN0YXRpc3RpY3MgdG8gL3N5cy9rZXJuZWwv ZG1hYnVmL2J1ZmZlcnMgaW4gb2RlciB0byBhbGxvdyBhZGRpdGlvbgpvZiBvdGhlciBETUEtQlVG LXJlbGF0ZWQgc3lzZnMgc3RhdHMgaW4gZnV0dXJlLiBCYXNlZCBvbiBmZWVkYmFjayBmcm9tCkRh bmllbCBWZXR0ZXIuCi1FYWNoIGF0dGFjaG1lbnQgaGFzIGl0cyBvd24gZGlyZWN0b3J5IHRvIHJl cHJlc2VudCBhdHRhY2hpbmcgZGV2aWNlcyBhcwpzeW1saW5rcyBhbmQgdG8gaW50cm9kdWNlIG1h cF9jb3VudCBhcyBhIHNlcGFyYXRlIGZpbGUuIEJhc2VkIG9uCmZlZWRiYWNrIGZyb20gRGFuaWVs IFZldHRlciBhbmQgQ2hyaXN0aWFuIEvDtm5pZy4gVGhhbmsgeW91IGJvdGghCi1Db21taXQgbWVz c2FnZXMgdXBkYXRlZCB0byBwb2ludCB0byB1c2Vyc3BhY2UgY29kZSBpbiBBT1NQIHRoYXQgd2ls bApyZWFkIHRoZSBETUEtQlVGIHN5c2ZzIHN0YXRzLgoKCiAuLi4vQUJJL3Rlc3Rpbmcvc3lzZnMt a2VybmVsLWRtYWJ1Zi1idWZmZXJzICAgfCAgNTIgKysrKwogZHJpdmVycy9kbWEtYnVmL0tjb25m aWcgICAgICAgICAgICAgICAgICAgICAgIHwgIDExICsKIGRyaXZlcnMvZG1hLWJ1Zi9NYWtlZmls ZSAgICAgICAgICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi1z eXNmcy1zdGF0cy5jICAgICAgICAgfCAyODUgKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2Rt YS1idWYvZG1hLWJ1Zi1zeXNmcy1zdGF0cy5oICAgICAgICAgfCAgNjIgKysrKwogZHJpdmVycy9k bWEtYnVmL2RtYS1idWYuYyAgICAgICAgICAgICAgICAgICAgIHwgIDM3ICsrKwogaW5jbHVkZS9s aW51eC9kbWEtYnVmLmggICAgICAgICAgICAgICAgICAgICAgIHwgIDIwICsrCiA3IGZpbGVzIGNo YW5nZWQsIDQ2OCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlv bi9BQkkvdGVzdGluZy9zeXNmcy1rZXJuZWwtZG1hYnVmLWJ1ZmZlcnMKIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi1zeXNmcy1zdGF0cy5jCiBjcmVhdGUgbW9kZSAx MDA2NDQgZHJpdmVycy9kbWEtYnVmL2RtYS1idWYtc3lzZnMtc3RhdHMuaAoKZGlmZiAtLWdpdCBh L0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMta2VybmVsLWRtYWJ1Zi1idWZmZXJzIGIv RG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9zeXNmcy1rZXJuZWwtZG1hYnVmLWJ1ZmZlcnMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi42ZjdjNjUyMDlmMDcKLS0tIC9k ZXYvbnVsbAorKysgYi9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLWtlcm5lbC1kbWFi dWYtYnVmZmVycwpAQCAtMCwwICsxLDUyIEBACitXaGF0OgkJL3N5cy9rZXJuZWwvZG1hYnVmL2J1 ZmZlcnMKK0RhdGU6CQlKYW51YXJ5IDIwMjEKK0tlcm5lbFZlcnNpb246CXY1LjEyCitDb250YWN0 OglIcmlkeWEgVmFsc2FyYWp1IDxocmlkeWFAZ29vZ2xlLmNvbT4KK0Rlc2NyaXB0aW9uOglUaGUg L3N5cy9rZXJuZWwvZG1hYnVmL2J1ZmZlcnMgZGlyZWN0b3J5IGNvbnRhaW5zIGEKKwkJc25hcHNo b3Qgb2YgdGhlIGludGVybmFsIHN0YXRlIG9mIGV2ZXJ5IERNQS1CVUYuCisJCS9zeXMva2VybmVs L2RtYWJ1Zi9idWZmZXJzLzxpbm9kZV9udW1iZXI+IHdpbGwgY29udGFpbiB0aGUKKwkJc3RhdGlz dGljcyBmb3IgdGhlIERNQS1CVUYgd2l0aCB0aGUgdW5pcXVlIGlub2RlIG51bWJlcgorCQk8aW5v ZGVfbnVtYmVyPgorVXNlcnM6CQlrZXJuZWwgbWVtb3J5IHR1bmluZy9kZWJ1Z2dpbmcgdG9vbHMK KworV2hhdDoJCS9zeXMva2VybmVsL2RtYWJ1Zi9idWZmZXJzLzxpbm9kZV9udW1iZXI+L2V4cG9y dGVyX25hbWUKK0RhdGU6CQlKYW51YXJ5IDIwMjEKK0tlcm5lbFZlcnNpb246CXY1LjEyCitDb250 YWN0OglIcmlkeWEgVmFsc2FyYWp1IDxocmlkeWFAZ29vZ2xlLmNvbT4KK0Rlc2NyaXB0aW9uOglU aGlzIGZpbGUgaXMgcmVhZC1vbmx5IGFuZCBjb250YWlucyB0aGUgbmFtZSBvZiB0aGUgZXhwb3J0 ZXIgb2YKKwkJdGhlIERNQS1CVUYuCisKK1doYXQ6CQkvc3lzL2tlcm5lbC9kbWFidWYvYnVmZmVy cy88aW5vZGVfbnVtYmVyPi9zaXplCitEYXRlOgkJSmFudWFyeSAyMDIxCitLZXJuZWxWZXJzaW9u Ogl2NS4xMgorQ29udGFjdDoJSHJpZHlhIFZhbHNhcmFqdSA8aHJpZHlhQGdvb2dsZS5jb20+CitE ZXNjcmlwdGlvbjoJVGhpcyBmaWxlIGlzIHJlYWQtb25seSBhbmQgc3BlY2lmaWVzIHRoZSBzaXpl IG9mIHRoZSBETUEtQlVGIGluCisJCWJ5dGVzLgorCitXaGF0OgkJL3N5cy9rZXJuZWwvZG1hYnVm L2J1ZmZlcnMvPGlub2RlX251bWJlcj4vYXR0YWNobWVudHMKK0RhdGU6CQlKYW51YXJ5IDIwMjEK K0tlcm5lbFZlcnNpb246CXY1LjEyCitDb250YWN0OglIcmlkeWEgVmFsc2FyYWp1IDxocmlkeWFA Z29vZ2xlLmNvbT4KK0Rlc2NyaXB0aW9uOglUaGlzIGRpcmVjdG9yeSB3aWxsIGNvbnRhaW4gc3Vi ZGlyZWN0b3JpZXMgcmVwcmVzZW50aW5nIGV2ZXJ5CisJCWF0dGFjaG1lbnQgb2YgdGhlIERNQS1C VUYuCisKK1doYXQ6CQkvc3lzL2tlcm5lbC9kbWFidWYvYnVmZmVycy88aW5vZGVfbnVtYmVyPi9h dHRhY2htZW50cy88YXR0YWNobWVudF91aWQ+CitEYXRlOgkJSmFudWFyeSAyMDIxCitLZXJuZWxW ZXJzaW9uOgl2NS4xMgorQ29udGFjdDoJSHJpZHlhIFZhbHNhcmFqdSA8aHJpZHlhQGdvb2dsZS5j b20+CitEZXNjcmlwdGlvbjoJVGhpcyBkaXJlY3Rvcnkgd2lsbCBjb250YWluIGluZm9ybWF0aW9u IG9uIHRoZSBhdHRhY2hpbmcgZGV2aWNlCisJCWFuZCB0aGUgbnVtYmVyIG9mIGN1cnJlbnQgZGlz dGluY3QgZGV2aWNlIG1hcHBpbmdzLgorCitXaGF0OgkJL3N5cy9rZXJuZWwvZG1hYnVmL2J1ZmZl cnMvPGlub2RlX251bWJlcj4vYXR0YWNobWVudHMvPGF0dGFjaG1lbnRfdWlkPi9kZXZpY2UKK0Rh dGU6CQlKYW51YXJ5IDIwMjEKK0tlcm5lbFZlcnNpb246CXY1LjEyCitDb250YWN0OglIcmlkeWEg VmFsc2FyYWp1IDxocmlkeWFAZ29vZ2xlLmNvbT4KK0Rlc2NyaXB0aW9uOglUaGlzIGZpbGUgaXMg cmVhZC1vbmx5IGFuZCBpcyBhIHN5bWxpbmsgdG8gdGhlIGF0dGFjaGluZyBkZXZpY2VzJ3MKKwkJ c3lzZnMgZW50cnkuCisKK1doYXQ6CQkvc3lzL2tlcm5lbC9kbWFidWYvYnVmZmVycy88aW5vZGVf bnVtYmVyPi9hdHRhY2htZW50cy88YXR0YWNobWVudF91aWQ+L21hcF9jb3VudGVyCitEYXRlOgkJ SmFudWFyeSAyMDIxCitLZXJuZWxWZXJzaW9uOgl2NS4xMgorQ29udGFjdDoJSHJpZHlhIFZhbHNh cmFqdSA8aHJpZHlhQGdvb2dsZS5jb20+CitEZXNjcmlwdGlvbjoJVGhpcyBmaWxlIGlzIHJlYWQt b25seSBhbmQgY29udGFpbnMgYSBtYXBfY291bnRlciBpbmRpY2F0aW5nIHRoZQorCQludW1iZXIg b2YgZGlzdGluY3QgZGV2aWNlIG1hcHBpbmdzIG9mIHRoZSBhdHRhY2htZW50LgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9kbWEtYnVmL0tjb25maWcgYi9kcml2ZXJzL2RtYS1idWYvS2NvbmZpZwppbmRl eCA0ZjgyMjRhNmFjOTUuLjI3ZTZhMmRhZmVhYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9kbWEtYnVm L0tjb25maWcKKysrIGIvZHJpdmVycy9kbWEtYnVmL0tjb25maWcKQEAgLTY0LDYgKzY0LDE3IEBA IG1lbnVjb25maWcgRE1BQlVGX0hFQVBTCiAJICBhbGxvd3MgdXNlcnNwYWNlIHRvIGFsbG9jYXRl IGRtYS1idWZzIHRoYXQgY2FuIGJlIHNoYXJlZAogCSAgYmV0d2VlbiBkcml2ZXJzLgogCittZW51 Y29uZmlnIERNQUJVRl9TWVNGU19TVEFUUworCWJvb2wgIkRNQS1CVUYgc3lzZnMgc3RhdGlzdGlj cyIKKwlzZWxlY3QgRE1BX1NIQVJFRF9CVUZGRVIKKwloZWxwCisJICAgQ2hvb3NlIHRoaXMgb3B0 aW9uIHRvIGVuYWJsZSBETUEtQlVGIHN5c2ZzIHN0YXRpc3RpY3MKKwkgICBpbiBsb2NhdGlvbiAv c3lzL2tlcm5lbC9kbWFidWYvYnVmZmVycy4KKworCSAgIC9zeXMva2VybmVsL2RtYWJ1Zi9idWZm ZXJzLzxpbm9kZV9udW1iZXI+IHdpbGwgY29udGFpbgorCSAgIHN0YXRpc3RpY3MgZm9yIHRoZSBE TUEtQlVGIHdpdGggdGhlIHVuaXF1ZSBpbm9kZSBudW1iZXIKKwkgICA8aW5vZGVfbnVtYmVyPi4K Kwogc291cmNlICJkcml2ZXJzL2RtYS1idWYvaGVhcHMvS2NvbmZpZyIKIAogZW5kbWVudQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL01ha2VmaWxlIGIvZHJpdmVycy9kbWEtYnVmL01ha2Vm aWxlCmluZGV4IDk5NWUwNWY2MDlmZi4uNDBkODFmMjNjYWNmIDEwMDY0NAotLS0gYS9kcml2ZXJz L2RtYS1idWYvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9kbWEtYnVmL01ha2VmaWxlCkBAIC02LDYg KzYsNyBAQCBvYmotJChDT05GSUdfRE1BQlVGX0hFQVBTKQkrPSBoZWFwcy8KIG9iai0kKENPTkZJ R19TWU5DX0ZJTEUpCQkrPSBzeW5jX2ZpbGUubwogb2JqLSQoQ09ORklHX1NXX1NZTkMpCQkrPSBz d19zeW5jLm8gc3luY19kZWJ1Zy5vCiBvYmotJChDT05GSUdfVURNQUJVRikJCSs9IHVkbWFidWYu bworb2JqLSQoQ09ORklHX0RNQUJVRl9TWVNGU19TVEFUUykgKz0gZG1hLWJ1Zi1zeXNmcy1zdGF0 cy5vCiAKIGRtYWJ1Zl9zZWxmdGVzdHMteSA6PSBcCiAJc2VsZnRlc3QubyBcCmRpZmYgLS1naXQg YS9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi1zeXNmcy1zdGF0cy5jIGIvZHJpdmVycy9kbWEtYnVm L2RtYS1idWYtc3lzZnMtc3RhdHMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLjVkYzJlMTdmMzA1NAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9k bWEtYnVmLXN5c2ZzLXN0YXRzLmMKQEAgLTAsMCArMSwyODUgQEAKKy8vIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKKy8qCisgKiBETUEtQlVGIHN5c2ZzIHN0YXRpc3RpY3Mu CisgKgorICogQ29weXJpZ2h0IChDKSAyMDIxIEdvb2dsZSBMTEMuCisgKi8KKworI2luY2x1ZGUg PGxpbnV4L2RtYS1idWYuaD4KKyNpbmNsdWRlIDxsaW51eC9kbWEtcmVzdi5oPgorI2luY2x1ZGUg PGxpbnV4L2tvYmplY3QuaD4KKyNpbmNsdWRlIDxsaW51eC9wcmludGsuaD4KKyNpbmNsdWRlIDxs aW51eC9zbGFiLmg+CisjaW5jbHVkZSA8bGludXgvc3lzZnMuaD4KKworI2luY2x1ZGUgImRtYS1i dWYtc3lzZnMtc3RhdHMuaCIKKworI2RlZmluZSB0b19kbWFfYnVmX2VudHJ5X2Zyb21fa29iaih4 KSBjb250YWluZXJfb2YoeCwgc3RydWN0IGRtYV9idWZfc3lzZnNfZW50cnksIGtvYmopCisKK3N0 cnVjdCBkbWFfYnVmX3N0YXRzX2F0dHJpYnV0ZSB7CisJc3RydWN0IGF0dHJpYnV0ZSBhdHRyOwor CXNzaXplX3QgKCpzaG93KShzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAorCQkJc3RydWN0IGRtYV9i dWZfc3RhdHNfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpOworfTsKKyNkZWZpbmUgdG9fZG1h X2J1Zl9zdGF0c19hdHRyKHgpIGNvbnRhaW5lcl9vZih4LCBzdHJ1Y3QgZG1hX2J1Zl9zdGF0c19h dHRyaWJ1dGUsIGF0dHIpCisKK3N0YXRpYyBzc2l6ZV90IGRtYV9idWZfc3RhdHNfYXR0cmlidXRl X3Nob3coc3RydWN0IGtvYmplY3QgKmtvYmosCisJCQkJCSAgICBzdHJ1Y3QgYXR0cmlidXRlICph dHRyLAorCQkJCQkgICAgY2hhciAqYnVmKQoreworCXN0cnVjdCBkbWFfYnVmX3N0YXRzX2F0dHJp YnV0ZSAqYXR0cmlidXRlOworCXN0cnVjdCBkbWFfYnVmX3N5c2ZzX2VudHJ5ICpzeXNmc19lbnRy eTsKKwlzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmOworCisJYXR0cmlidXRlID0gdG9fZG1hX2J1Zl9z dGF0c19hdHRyKGF0dHIpOworCXN5c2ZzX2VudHJ5ID0gdG9fZG1hX2J1Zl9lbnRyeV9mcm9tX2tv Ymooa29iaik7CisJZG1hYnVmID0gc3lzZnNfZW50cnktPmRtYWJ1ZjsKKworCWlmICghZG1hYnVm IHx8ICFhdHRyaWJ1dGUtPnNob3cpCisJCXJldHVybiAtRUlPOworCisJcmV0dXJuIGF0dHJpYnV0 ZS0+c2hvdyhkbWFidWYsIGF0dHJpYnV0ZSwgYnVmKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVj dCBzeXNmc19vcHMgZG1hX2J1Zl9zdGF0c19zeXNmc19vcHMgPSB7CisJLnNob3cgPSBkbWFfYnVm X3N0YXRzX2F0dHJpYnV0ZV9zaG93LAorfTsKKworc3RhdGljIHNzaXplX3QgZXhwb3J0ZXJfbmFt ZV9zaG93KHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCisJCQkJICBzdHJ1Y3QgZG1hX2J1Zl9zdGF0 c19hdHRyaWJ1dGUgKmF0dHIsCisJCQkJICBjaGFyICpidWYpCit7CisJcmV0dXJuIHN5c2ZzX2Vt aXQoYnVmLCAiJXNcbiIsIGRtYWJ1Zi0+ZXhwX25hbWUpOworfQorCitzdGF0aWMgc3NpemVfdCBz aXplX3Nob3coc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwKKwkJCSBzdHJ1Y3QgZG1hX2J1Zl9zdGF0 c19hdHRyaWJ1dGUgKmF0dHIsCisJCQkgY2hhciAqYnVmKQoreworCXJldHVybiBzeXNmc19lbWl0 KGJ1ZiwgIiV6dVxuIiwgZG1hYnVmLT5zaXplKTsKK30KKworc3RhdGljIHN0cnVjdCBkbWFfYnVm X3N0YXRzX2F0dHJpYnV0ZSBleHBvcnRlcl9uYW1lX2F0dHJpYnV0ZSA9CisJX19BVFRSX1JPKGV4 cG9ydGVyX25hbWUpOworc3RhdGljIHN0cnVjdCBkbWFfYnVmX3N0YXRzX2F0dHJpYnV0ZSBzaXpl X2F0dHJpYnV0ZSA9IF9fQVRUUl9STyhzaXplKTsKKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUg KmRtYV9idWZfc3RhdHNfZGVmYXVsdF9hdHRyc1tdID0geworCSZleHBvcnRlcl9uYW1lX2F0dHJp YnV0ZS5hdHRyLAorCSZzaXplX2F0dHJpYnV0ZS5hdHRyLAorCU5VTEwsCit9OworQVRUUklCVVRF X0dST1VQUyhkbWFfYnVmX3N0YXRzX2RlZmF1bHQpOworCitzdGF0aWMgdm9pZCBkbWFfYnVmX3N5 c2ZzX3JlbGVhc2Uoc3RydWN0IGtvYmplY3QgKmtvYmopCit7CisJc3RydWN0IGRtYV9idWZfc3lz ZnNfZW50cnkgKnN5c2ZzX2VudHJ5OworCisJc3lzZnNfZW50cnkgPSB0b19kbWFfYnVmX2VudHJ5 X2Zyb21fa29iaihrb2JqKTsKKwlrZnJlZShzeXNmc19lbnRyeSk7Cit9CisKK3N0YXRpYyBzdHJ1 Y3Qga29ial90eXBlIGRtYV9idWZfa3R5cGUgPSB7CisJLnN5c2ZzX29wcyA9ICZkbWFfYnVmX3N0 YXRzX3N5c2ZzX29wcywKKwkucmVsZWFzZSA9IGRtYV9idWZfc3lzZnNfcmVsZWFzZSwKKwkuZGVm YXVsdF9ncm91cHMgPSBkbWFfYnVmX3N0YXRzX2RlZmF1bHRfZ3JvdXBzLAorfTsKKworI2RlZmlu ZSB0b19kbWFfYnVmX2F0dGFjaF9lbnRyeV9mcm9tX2tvYmooeCkgY29udGFpbmVyX29mKHgsIHN0 cnVjdCBkbWFfYnVmX2F0dGFjaF9zeXNmc19lbnRyeSwga29iaikKKworc3RydWN0IGRtYV9idWZf YXR0YWNoX3N0YXRzX2F0dHJpYnV0ZSB7CisJc3RydWN0IGF0dHJpYnV0ZSBhdHRyOworCXNzaXpl X3QgKCpzaG93KShzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lzZnNfZW50cnkgKnN5c2ZzX2VudHJ5 LAorCQkJc3RydWN0IGRtYV9idWZfYXR0YWNoX3N0YXRzX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAq YnVmKTsKK307CisjZGVmaW5lIHRvX2RtYV9idWZfYXR0YWNoX3N0YXRzX2F0dHIoeCkgY29udGFp bmVyX29mKHgsIHN0cnVjdCBkbWFfYnVmX2F0dGFjaF9zdGF0c19hdHRyaWJ1dGUsIGF0dHIpCisK K3N0YXRpYyBzc2l6ZV90IGRtYV9idWZfYXR0YWNoX3N0YXRzX2F0dHJpYnV0ZV9zaG93KHN0cnVj dCBrb2JqZWN0ICprb2JqLAorCQkJCQkJICAgc3RydWN0IGF0dHJpYnV0ZSAqYXR0ciwKKwkJCQkJ CSAgIGNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3RhdHNfYXR0cmlidXRl ICphdHRyaWJ1dGU7CisJc3RydWN0IGRtYV9idWZfYXR0YWNoX3N5c2ZzX2VudHJ5ICpzeXNmc19l bnRyeTsKKworCWF0dHJpYnV0ZSA9IHRvX2RtYV9idWZfYXR0YWNoX3N0YXRzX2F0dHIoYXR0cik7 CisJc3lzZnNfZW50cnkgPSB0b19kbWFfYnVmX2F0dGFjaF9lbnRyeV9mcm9tX2tvYmooa29iaik7 CisKKwlpZiAoIWF0dHJpYnV0ZS0+c2hvdykKKwkJcmV0dXJuIC1FSU87CisKKwlyZXR1cm4gYXR0 cmlidXRlLT5zaG93KHN5c2ZzX2VudHJ5LCBhdHRyaWJ1dGUsIGJ1Zik7Cit9CisKK3N0YXRpYyBj b25zdCBzdHJ1Y3Qgc3lzZnNfb3BzIGRtYV9idWZfYXR0YWNoX3N0YXRzX3N5c2ZzX29wcyA9IHsK Kwkuc2hvdyA9IGRtYV9idWZfYXR0YWNoX3N0YXRzX2F0dHJpYnV0ZV9zaG93LAorfTsKKworc3Rh dGljIHNzaXplX3QgbWFwX2NvdW50ZXJfc2hvdyhzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lzZnNf ZW50cnkgKnN5c2ZzX2VudHJ5LAorCQkJCXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9zdGF0c19hdHRy aWJ1dGUgKmF0dHIsCisJCQkJY2hhciAqYnVmKQoreworCXJldHVybiBzeXNmc19lbWl0KGJ1Ziwg IiV1XG4iLCBzeXNmc19lbnRyeS0+bWFwX2NvdW50ZXIpOworfQorCitzdGF0aWMgc3RydWN0IGRt YV9idWZfYXR0YWNoX3N0YXRzX2F0dHJpYnV0ZSBtYXBfY291bnRlcl9hdHRyaWJ1dGUgPQorCV9f QVRUUl9STyhtYXBfY291bnRlcik7CisKK3N0YXRpYyBzdHJ1Y3QgYXR0cmlidXRlICpkbWFfYnVm X2F0dGFjaF9zdGF0c19kZWZhdWx0X2F0dHJzW10gPSB7CisJJm1hcF9jb3VudGVyX2F0dHJpYnV0 ZS5hdHRyLAorCU5VTEwsCit9OworQVRUUklCVVRFX0dST1VQUyhkbWFfYnVmX2F0dGFjaF9zdGF0 c19kZWZhdWx0KTsKKworc3RhdGljIHZvaWQgZG1hX2J1Zl9hdHRhY2hfc3lzZnNfcmVsZWFzZShz dHJ1Y3Qga29iamVjdCAqa29iaikKK3sKKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lzZnNfZW50 cnkgKnN5c2ZzX2VudHJ5OworCisJc3lzZnNfZW50cnkgPSB0b19kbWFfYnVmX2F0dGFjaF9lbnRy eV9mcm9tX2tvYmooa29iaik7CisJa2ZyZWUoc3lzZnNfZW50cnkpOworfQorCitzdGF0aWMgc3Ry dWN0IGtvYmpfdHlwZSBkbWFfYnVmX2F0dGFjaF9rdHlwZSA9IHsKKwkuc3lzZnNfb3BzID0gJmRt YV9idWZfYXR0YWNoX3N0YXRzX3N5c2ZzX29wcywKKwkucmVsZWFzZSA9IGRtYV9idWZfYXR0YWNo X3N5c2ZzX3JlbGVhc2UsCisJLmRlZmF1bHRfZ3JvdXBzID0gZG1hX2J1Zl9hdHRhY2hfc3RhdHNf ZGVmYXVsdF9ncm91cHMsCit9OworCit2b2lkIGRtYV9idWZfYXR0YWNoX3N0YXRzX3RlYXJkb3du KHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaCkKK3sKKwlzdHJ1Y3QgZG1hX2J1Zl9h dHRhY2hfc3lzZnNfZW50cnkgKnN5c2ZzX2VudHJ5OworCisJc3lzZnNfZW50cnkgPSBhdHRhY2gt PnN5c2ZzX2VudHJ5OworCWlmICghc3lzZnNfZW50cnkpCisJCXJldHVybjsKKworCXN5c2ZzX2Rl bGV0ZV9saW5rKCZzeXNmc19lbnRyeS0+a29iaiwgJmF0dGFjaC0+ZGV2LT5rb2JqLCAiZGV2aWNl Iik7CisKKwlrb2JqZWN0X2RlbCgmc3lzZnNfZW50cnktPmtvYmopOworCWtvYmplY3RfcHV0KCZz eXNmc19lbnRyeS0+a29iaik7Cit9CisKK2ludCBkbWFfYnVmX2F0dGFjaF9zdGF0c19zZXR1cChz dHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gsCisJCQkgICAgICAgdW5zaWduZWQgaW50 IHVpZCkKK3sKKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lzZnNfZW50cnkgKnN5c2ZzX2VudHJ5 OworCWludCByZXQ7CisJc3RydWN0IGRtYV9idWYgKmRtYWJ1ZjsKKworCWlmICghYXR0YWNoKQor CQlyZXR1cm4gLUVJTlZBTDsKKworCWRtYWJ1ZiA9IGF0dGFjaC0+ZG1hYnVmOworCisJc3lzZnNf ZW50cnkgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lzZnNfZW50cnkp LAorCQkJICAgICAgR0ZQX0tFUk5FTCk7CisJaWYgKCFzeXNmc19lbnRyeSkKKwkJcmV0dXJuIC1F Tk9NRU07CisKKwlzeXNmc19lbnRyeS0+a29iai5rc2V0ID0gZG1hYnVmLT5zeXNmc19lbnRyeS0+ YXR0YWNoX3N0YXRzX2tzZXQ7CisKKwlhdHRhY2gtPnN5c2ZzX2VudHJ5ID0gc3lzZnNfZW50cnk7 CisKKwlyZXQgPSBrb2JqZWN0X2luaXRfYW5kX2FkZCgmc3lzZnNfZW50cnktPmtvYmosICZkbWFf YnVmX2F0dGFjaF9rdHlwZSwKKwkJCQkgICBOVUxMLCAiJXUiLCB1aWQpOworCWlmIChyZXQpCisJ CWdvdG8ga29ial9lcnI7CisKKwlyZXQgPSBzeXNmc19jcmVhdGVfbGluaygmc3lzZnNfZW50cnkt PmtvYmosICZhdHRhY2gtPmRldi0+a29iaiwKKwkJCQkiZGV2aWNlIik7CisJaWYgKHJldCkKKwkJ Z290byBsaW5rX2VycjsKKworCXJldHVybiAwOworCitsaW5rX2VycjoKKwlrb2JqZWN0X2RlbCgm c3lzZnNfZW50cnktPmtvYmopOwora29ial9lcnI6CisJa29iamVjdF9wdXQoJnN5c2ZzX2VudHJ5 LT5rb2JqKTsKKwlhdHRhY2gtPnN5c2ZzX2VudHJ5ID0gTlVMTDsKKworCXJldHVybiByZXQ7Cit9 Cit2b2lkIGRtYV9idWZfc3RhdHNfdGVhcmRvd24oc3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKK3sK KwlzdHJ1Y3QgZG1hX2J1Zl9zeXNmc19lbnRyeSAqc3lzZnNfZW50cnk7CisKKwlzeXNmc19lbnRy eSA9IGRtYWJ1Zi0+c3lzZnNfZW50cnk7CisJaWYgKCFzeXNmc19lbnRyeSkKKwkJcmV0dXJuOwor CisJa3NldF91bnJlZ2lzdGVyKHN5c2ZzX2VudHJ5LT5hdHRhY2hfc3RhdHNfa3NldCk7CisJa29i amVjdF9kZWwoJnN5c2ZzX2VudHJ5LT5rb2JqKTsKKwlrb2JqZWN0X3B1dCgmc3lzZnNfZW50cnkt PmtvYmopOworfQorCitzdGF0aWMgc3RydWN0IGtzZXQgKmRtYV9idWZfc3RhdHNfa3NldDsKK3N0 YXRpYyBzdHJ1Y3Qga3NldCAqZG1hX2J1Zl9wZXJfYnVmZmVyX3N0YXRzX2tzZXQ7CitpbnQgZG1h X2J1Zl9pbml0X3N5c2ZzX3N0YXRpc3RpY3Modm9pZCkKK3sKKwlkbWFfYnVmX3N0YXRzX2tzZXQg PSBrc2V0X2NyZWF0ZV9hbmRfYWRkKCJkbWFidWYiLCBOVUxMLCBrZXJuZWxfa29iaik7CisJaWYg KCFkbWFfYnVmX3N0YXRzX2tzZXQpCisJCXJldHVybiAtRU5PTUVNOworCisJZG1hX2J1Zl9wZXJf YnVmZmVyX3N0YXRzX2tzZXQgPSBrc2V0X2NyZWF0ZV9hbmRfYWRkKCJidWZmZXJzIiwgTlVMTCwK KwkJCQkJCQkgICAgJmRtYV9idWZfc3RhdHNfa3NldC0+a29iaik7CisJaWYgKCFkbWFfYnVmX3Bl cl9idWZmZXJfc3RhdHNfa3NldCkgeworCQlrc2V0X3VucmVnaXN0ZXIoZG1hX2J1Zl9zdGF0c19r c2V0KTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3ZvaWQgZG1h X2J1Zl91bmluaXRfc3lzZnNfc3RhdGlzdGljcyh2b2lkKQoreworCWtzZXRfdW5yZWdpc3Rlcihk bWFfYnVmX3Blcl9idWZmZXJfc3RhdHNfa3NldCk7CisJa3NldF91bnJlZ2lzdGVyKGRtYV9idWZf c3RhdHNfa3NldCk7Cit9CisKK2ludCBkbWFfYnVmX3N0YXRzX3NldHVwKHN0cnVjdCBkbWFfYnVm ICpkbWFidWYpCit7CisJc3RydWN0IGRtYV9idWZfc3lzZnNfZW50cnkgKnN5c2ZzX2VudHJ5Owor CWludCByZXQ7CisJc3RydWN0IGtzZXQgKmF0dGFjaF9zdGF0c19rc2V0OworCisJaWYgKCFkbWFi dWYgfHwgIWRtYWJ1Zi0+ZmlsZSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoIWRtYWJ1Zi0+ ZXhwX25hbWUpIHsKKwkJcHJfZXJyKCJleHBvcnRlciBuYW1lIG11c3Qgbm90IGJlIGVtcHR5IGlm IHN0YXRzIG5lZWRlZFxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXN5c2ZzX2VudHJ5 ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGRtYV9idWZfc3lzZnNfZW50cnkpLCBHRlBfS0VSTkVM KTsKKwlpZiAoIXN5c2ZzX2VudHJ5KQorCQlyZXR1cm4gLUVOT01FTTsKKworCXN5c2ZzX2VudHJ5 LT5rb2JqLmtzZXQgPSBkbWFfYnVmX3Blcl9idWZmZXJfc3RhdHNfa3NldDsKKwlzeXNmc19lbnRy eS0+ZG1hYnVmID0gZG1hYnVmOworCisJZG1hYnVmLT5zeXNmc19lbnRyeSA9IHN5c2ZzX2VudHJ5 OworCisJLyogY3JlYXRlIHRoZSBkaXJlY3RvcnkgZm9yIGJ1ZmZlciBzdGF0cyAqLworCXJldCA9 IGtvYmplY3RfaW5pdF9hbmRfYWRkKCZzeXNmc19lbnRyeS0+a29iaiwgJmRtYV9idWZfa3R5cGUs IE5VTEwsCisJCQkJICAgIiVsdSIsIGZpbGVfaW5vZGUoZG1hYnVmLT5maWxlKS0+aV9pbm8pOwor CWlmIChyZXQpCisJCWdvdG8gZXJyX3N5c2ZzX2RtYWJ1ZjsKKworCS8qIGNyZWF0ZSB0aGUgZGly ZWN0b3J5IGZvciBhdHRhY2htZW50IHN0YXRzICovCisJYXR0YWNoX3N0YXRzX2tzZXQgPSBrc2V0 X2NyZWF0ZV9hbmRfYWRkKCJhdHRhY2htZW50cyIsIE5VTEwsCisJCQkJCQkmc3lzZnNfZW50cnkt PmtvYmopOworCWlmICghYXR0YWNoX3N0YXRzX2tzZXQpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJ Z290byBlcnJfc3lzZnNfYXR0YWNoOworCX0KKworCXN5c2ZzX2VudHJ5LT5hdHRhY2hfc3RhdHNf a3NldCA9IGF0dGFjaF9zdGF0c19rc2V0OworCisJcmV0dXJuIDA7CisKK2Vycl9zeXNmc19hdHRh Y2g6CisJa29iamVjdF9kZWwoJnN5c2ZzX2VudHJ5LT5rb2JqKTsKK2Vycl9zeXNmc19kbWFidWY6 CisJa29iamVjdF9wdXQoJnN5c2ZzX2VudHJ5LT5rb2JqKTsKKwlkbWFidWYtPnN5c2ZzX2VudHJ5 ID0gTlVMTDsKKwlyZXR1cm4gcmV0OworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9kbWEtYnVmL2Rt YS1idWYtc3lzZnMtc3RhdHMuaCBiL2RyaXZlcnMvZG1hLWJ1Zi9kbWEtYnVmLXN5c2ZzLXN0YXRz LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi41ZjQ3MDMyNDkxMTcK LS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi1zeXNmcy1zdGF0cy5o CkBAIC0wLDAgKzEsNjIgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9u bHkgKi8KKy8qCisgKiBETUEtQlVGIHN5c2ZzIHN0YXRpc3RpY3MuCisgKgorICogQ29weXJpZ2h0 IChDKSAyMDIxIEdvb2dsZSBMTEMuCisgKi8KKworI2lmbmRlZiBfRE1BX0JVRl9TWVNGU19TVEFU U19ICisjZGVmaW5lIF9ETUFfQlVGX1NZU0ZTX1NUQVRTX0gKKworI2lmZGVmIENPTkZJR19ETUFC VUZfU1lTRlNfU1RBVFMKKworaW50IGRtYV9idWZfaW5pdF9zeXNmc19zdGF0aXN0aWNzKHZvaWQp Owordm9pZCBkbWFfYnVmX3VuaW5pdF9zeXNmc19zdGF0aXN0aWNzKHZvaWQpOworCitpbnQgZG1h X2J1Zl9zdGF0c19zZXR1cChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmKTsKK2ludCBkbWFfYnVmX2F0 dGFjaF9zdGF0c19zZXR1cChzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gsCisJCQkg ICAgICAgdW5zaWduZWQgaW50IHVpZCk7CitzdGF0aWMgaW5saW5lIHZvaWQgZG1hX2J1Zl91cGRh dGVfYXR0YWNobWVudF9tYXBfY291bnQoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNo LAorCQkJCQkJICAgICAgIGludCBkZWx0YSkKK3sKKwlzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2hfc3lz ZnNfZW50cnkgKmVudHJ5ID0gYXR0YWNoLT5zeXNmc19lbnRyeTsKKworCWVudHJ5LT5tYXBfY291 bnRlciArPSBkZWx0YTsKK30KK3ZvaWQgZG1hX2J1Zl9zdGF0c190ZWFyZG93bihzdHJ1Y3QgZG1h X2J1ZiAqZG1hYnVmKTsKK3ZvaWQgZG1hX2J1Zl9hdHRhY2hfc3RhdHNfdGVhcmRvd24oc3RydWN0 IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoKTsKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50 IGRtYV9idWZfdXBkYXRlX2F0dGFjaF91aWQoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKK3sKKwlz dHJ1Y3QgZG1hX2J1Zl9zeXNmc19lbnRyeSAqZW50cnkgPSBkbWFidWYtPnN5c2ZzX2VudHJ5Owor CisJcmV0dXJuIGVudHJ5LT5hdHRhY2htZW50X3VpZCsrOworfQorI2Vsc2UKKworc3RhdGljIGlu bGluZSBpbnQgZG1hX2J1Zl9pbml0X3N5c2ZzX3N0YXRpc3RpY3Modm9pZCkKK3sKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGRtYV9idWZfdW5pbml0X3N5c2ZzX3N0YXRpc3Rp Y3Modm9pZCkge30KKworc3RhdGljIGlubGluZSBpbnQgZG1hX2J1Zl9zdGF0c19zZXR1cChzdHJ1 Y3QgZG1hX2J1ZiAqZG1hYnVmKQoreworCXJldHVybiAwOworfQorc3RhdGljIGlubGluZSBpbnQg ZG1hX2J1Zl9hdHRhY2hfc3RhdHNfc2V0dXAoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0 YWNoLAorCQkJCQkgICAgIHVuc2lnbmVkIGludCB1aWQpCit7CisJcmV0dXJuIDA7Cit9CisKK3N0 YXRpYyBpbmxpbmUgdm9pZCBkbWFfYnVmX3N0YXRzX3RlYXJkb3duKHN0cnVjdCBkbWFfYnVmICpk bWFidWYpIHt9CitzdGF0aWMgaW5saW5lIHZvaWQgZG1hX2J1Zl9hdHRhY2hfc3RhdHNfdGVhcmRv d24oc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNoKSB7fQorc3RhdGljIGlubGluZSB2 b2lkIGRtYV9idWZfdXBkYXRlX2F0dGFjaG1lbnRfbWFwX2NvdW50KHN0cnVjdCBkbWFfYnVmX2F0 dGFjaG1lbnQgKmF0dGFjaCwKKwkJCQkJCSAgICAgICBpbnQgZGVsdGEpIHt9CitzdGF0aWMgaW5s aW5lIHVuc2lnbmVkIGludCBkbWFfYnVmX3VwZGF0ZV9hdHRhY2hfdWlkKHN0cnVjdCBkbWFfYnVm ICpkbWFidWYpCit7CisJcmV0dXJuIDA7Cit9CisjZW5kaWYKKyNlbmRpZiAvLyBfRE1BX0JVRl9T WVNGU19TVEFUU19ICmRpZmYgLS1naXQgYS9kcml2ZXJzL2RtYS1idWYvZG1hLWJ1Zi5jIGIvZHJp dmVycy9kbWEtYnVmL2RtYS1idWYuYwppbmRleCA5YWQ2Mzk3YWFhOTcuLjI5ZjllYTE4ZWI0NyAx MDA2NDQKLS0tIGEvZHJpdmVycy9kbWEtYnVmL2RtYS1idWYuYworKysgYi9kcml2ZXJzL2RtYS1i dWYvZG1hLWJ1Zi5jCkBAIC0yOSw2ICsyOSw4IEBACiAjaW5jbHVkZSA8dWFwaS9saW51eC9kbWEt YnVmLmg+CiAjaW5jbHVkZSA8dWFwaS9saW51eC9tYWdpYy5oPgogCisjaW5jbHVkZSAiZG1hLWJ1 Zi1zeXNmcy1zdGF0cy5oIgorCiBzdGF0aWMgaW5saW5lIGludCBpc19kbWFfYnVmX2ZpbGUoc3Ry dWN0IGZpbGUgKik7CiAKIHN0cnVjdCBkbWFfYnVmX2xpc3QgewpAQCAtNzksNiArODEsNyBAQCBz dGF0aWMgdm9pZCBkbWFfYnVmX3JlbGVhc2Uoc3RydWN0IGRlbnRyeSAqZGVudHJ5KQogCWlmIChk bWFidWYtPnJlc3YgPT0gKHN0cnVjdCBkbWFfcmVzdiAqKSZkbWFidWZbMV0pCiAJCWRtYV9yZXN2 X2ZpbmkoZG1hYnVmLT5yZXN2KTsKIAorCWRtYV9idWZfc3RhdHNfdGVhcmRvd24oZG1hYnVmKTsK IAltb2R1bGVfcHV0KGRtYWJ1Zi0+b3duZXIpOwogCWtmcmVlKGRtYWJ1Zi0+bmFtZSk7CiAJa2Zy ZWUoZG1hYnVmKTsKQEAgLTU3OSw2ICs1ODIsMTAgQEAgc3RydWN0IGRtYV9idWYgKmRtYV9idWZf ZXhwb3J0KGNvbnN0IHN0cnVjdCBkbWFfYnVmX2V4cG9ydF9pbmZvICpleHBfaW5mbykKIAlmaWxl LT5mX21vZGUgfD0gRk1PREVfTFNFRUs7CiAJZG1hYnVmLT5maWxlID0gZmlsZTsKIAorCXJldCA9 IGRtYV9idWZfc3RhdHNfc2V0dXAoZG1hYnVmKTsKKwlpZiAocmV0KQorCQlnb3RvIGVycl9zeXNm czsKKwogCW11dGV4X2luaXQoJmRtYWJ1Zi0+bG9jayk7CiAJSU5JVF9MSVNUX0hFQUQoJmRtYWJ1 Zi0+YXR0YWNobWVudHMpOwogCkBAIC01ODgsNiArNTk1LDE0IEBAIHN0cnVjdCBkbWFfYnVmICpk bWFfYnVmX2V4cG9ydChjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9leHBvcnRfaW5mbyAqZXhwX2luZm8p CiAKIAlyZXR1cm4gZG1hYnVmOwogCitlcnJfc3lzZnM6CisJLyoKKwkgKiBTZXQgZmlsZS0+Zl9w YXRoLmRlbnRyeS0+ZF9mc2RhdGEgdG8gTlVMTCBzbyB0aGF0IHdoZW4KKwkgKiBkbWFfYnVmX3Jl bGVhc2UoKSBnZXRzIGludm9rZWQgYnkgZGVudHJ5X29wcywgaXQgZXhpdHMKKwkgKiBlYXJseSBi ZWZvcmUgY2FsbGluZyB0aGUgcmVsZWFzZSgpIGRtYV9idWYgb3AuCisJICovCisJZmlsZS0+Zl9w YXRoLmRlbnRyeS0+ZF9mc2RhdGEgPSBOVUxMOworCWZwdXQoZmlsZSk7CiBlcnJfZG1hYnVmOgog CWtmcmVlKGRtYWJ1Zik7CiBlcnJfbW9kdWxlOgpAQCAtNjkyLDYgKzcwNyw3IEBAIGRtYV9idWZf ZHluYW1pY19hdHRhY2goc3RydWN0IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0IGRldmljZSAqZGV2 LAogewogCXN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgKmF0dGFjaDsKIAlpbnQgcmV0OworCXVu c2lnbmVkIGludCBhdHRhY2hfdWlkOwogCiAJaWYgKFdBUk5fT04oIWRtYWJ1ZiB8fCAhZGV2KSkK IAkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CkBAIC03MTcsOCArNzMzLDEzIEBAIGRtYV9idWZf ZHluYW1pY19hdHRhY2goc3RydWN0IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0IGRldmljZSAqZGV2 LAogCX0KIAlkbWFfcmVzdl9sb2NrKGRtYWJ1Zi0+cmVzdiwgTlVMTCk7CiAJbGlzdF9hZGQoJmF0 dGFjaC0+bm9kZSwgJmRtYWJ1Zi0+YXR0YWNobWVudHMpOworCWF0dGFjaF91aWQgPSBkbWFfYnVm X3VwZGF0ZV9hdHRhY2hfdWlkKGRtYWJ1Zik7CiAJZG1hX3Jlc3ZfdW5sb2NrKGRtYWJ1Zi0+cmVz dik7CiAKKwlyZXQgPSBkbWFfYnVmX2F0dGFjaF9zdGF0c19zZXR1cChhdHRhY2gsIGF0dGFjaF91 aWQpOworCWlmIChyZXQpCisJCWdvdG8gZXJyX3N5c2ZzOworCiAJLyogV2hlbiBlaXRoZXIgdGhl IGltcG9ydGVyIG9yIHRoZSBleHBvcnRlciBjYW4ndCBoYW5kbGUgZHluYW1pYwogCSAqIG1hcHBp bmdzIHdlIGNhY2hlIHRoZSBtYXBwaW5nIGhlcmUgdG8gYXZvaWQgaXNzdWVzIHdpdGggdGhlCiAJ ICogcmVzZXJ2YXRpb24gb2JqZWN0IGxvY2suCkBAIC03NDUsNiArNzY2LDcgQEAgZG1hX2J1Zl9k eW5hbWljX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3QgZGV2aWNlICpkZXYs CiAJCQlkbWFfcmVzdl91bmxvY2soYXR0YWNoLT5kbWFidWYtPnJlc3YpOwogCQlhdHRhY2gtPnNn dCA9IHNndDsKIAkJYXR0YWNoLT5kaXIgPSBETUFfQklESVJFQ1RJT05BTDsKKwkJZG1hX2J1Zl91 cGRhdGVfYXR0YWNobWVudF9tYXBfY291bnQoYXR0YWNoLCAxIC8qIGRlbHRhICovKTsKIAl9CiAK IAlyZXR1cm4gYXR0YWNoOwpAQCAtNzYxLDYgKzc4Myw3IEBAIGRtYV9idWZfZHluYW1pY19hdHRh Y2goc3RydWN0IGRtYV9idWYgKmRtYWJ1Ziwgc3RydWN0IGRldmljZSAqZGV2LAogCWlmIChkbWFf YnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpKQogCQlkbWFfcmVzdl91bmxvY2soYXR0YWNo LT5kbWFidWYtPnJlc3YpOwogCitlcnJfc3lzZnM6CiAJZG1hX2J1Zl9kZXRhY2goZG1hYnVmLCBh dHRhY2gpOwogCXJldHVybiBFUlJfUFRSKHJldCk7CiB9CkBAIC03OTksNiArODIyLDcgQEAgdm9p ZCBkbWFfYnVmX2RldGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3QgZG1hX2J1Zl9h dHRhY2htZW50ICphdHRhY2gpCiAJCQlkbWFfcmVzdl9sb2NrKGF0dGFjaC0+ZG1hYnVmLT5yZXN2 LCBOVUxMKTsKIAogCQlkbWFidWYtPm9wcy0+dW5tYXBfZG1hX2J1ZihhdHRhY2gsIGF0dGFjaC0+ c2d0LCBhdHRhY2gtPmRpcik7CisJCWRtYV9idWZfdXBkYXRlX2F0dGFjaG1lbnRfbWFwX2NvdW50 KGF0dGFjaCwgLTEgLyogZGVsdGEgKi8pOwogCiAJCWlmIChkbWFfYnVmX2lzX2R5bmFtaWMoYXR0 YWNoLT5kbWFidWYpKSB7CiAJCQlkbWFfYnVmX3VucGluKGF0dGFjaCk7CkBAIC04MTIsNiArODM2 LDcgQEAgdm9pZCBkbWFfYnVmX2RldGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLCBzdHJ1Y3Qg ZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gpCiAJaWYgKGRtYWJ1Zi0+b3BzLT5kZXRhY2gpCiAJ CWRtYWJ1Zi0+b3BzLT5kZXRhY2goZG1hYnVmLCBhdHRhY2gpOwogCisJZG1hX2J1Zl9hdHRhY2hf c3RhdHNfdGVhcmRvd24oYXR0YWNoKTsKIAlrZnJlZShhdHRhY2gpOwogfQogRVhQT1JUX1NZTUJP TF9HUEwoZG1hX2J1Zl9kZXRhY2gpOwpAQCAtOTM4LDYgKzk2Myw5IEBAIHN0cnVjdCBzZ190YWJs ZSAqZG1hX2J1Zl9tYXBfYXR0YWNobWVudChzdHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRh Y2gsCiAJfQogI2VuZGlmIC8qIENPTkZJR19ETUFfQVBJX0RFQlVHICovCiAKKwlpZiAoIUlTX0VS UihzZ190YWJsZSkpCisJCWRtYV9idWZfdXBkYXRlX2F0dGFjaG1lbnRfbWFwX2NvdW50KGF0dGFj aCwgMSAvKiBkZWx0YSAqLyk7CisKIAlyZXR1cm4gc2dfdGFibGU7CiB9CiBFWFBPUlRfU1lNQk9M X0dQTChkbWFfYnVmX21hcF9hdHRhY2htZW50KTsKQEAgLTk3NSw2ICsxMDAzLDggQEAgdm9pZCBk bWFfYnVmX3VubWFwX2F0dGFjaG1lbnQoc3RydWN0IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNo LAogCWlmIChkbWFfYnVmX2lzX2R5bmFtaWMoYXR0YWNoLT5kbWFidWYpICYmCiAJICAgICFJU19F TkFCTEVEKENPTkZJR19ETUFCVUZfTU9WRV9OT1RJRlkpKQogCQlkbWFfYnVmX3VucGluKGF0dGFj aCk7CisKKwlkbWFfYnVmX3VwZGF0ZV9hdHRhY2htZW50X21hcF9jb3VudChhdHRhY2gsIC0xIC8q IGRlbHRhICovKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKGRtYV9idWZfdW5tYXBfYXR0YWNobWVu dCk7CiAKQEAgLTE0MTIsNiArMTQ0MiwxMiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZG1hX2J1Zl91 bmluaXRfZGVidWdmcyh2b2lkKQogCiBzdGF0aWMgaW50IF9faW5pdCBkbWFfYnVmX2luaXQodm9p ZCkKIHsKKwlpbnQgcmV0OworCisJcmV0ID0gZG1hX2J1Zl9pbml0X3N5c2ZzX3N0YXRpc3RpY3Mo KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCiAJZG1hX2J1Zl9tbnQgPSBrZXJuX21vdW50 KCZkbWFfYnVmX2ZzX3R5cGUpOwogCWlmIChJU19FUlIoZG1hX2J1Zl9tbnQpKQogCQlyZXR1cm4g UFRSX0VSUihkbWFfYnVmX21udCk7CkBAIC0xNDI3LDUgKzE0NjMsNiBAQCBzdGF0aWMgdm9pZCBf X2V4aXQgZG1hX2J1Zl9kZWluaXQodm9pZCkKIHsKIAlkbWFfYnVmX3VuaW5pdF9kZWJ1Z2ZzKCk7 CiAJa2Vybl91bm1vdW50KGRtYV9idWZfbW50KTsKKwlkbWFfYnVmX3VuaW5pdF9zeXNmc19zdGF0 aXN0aWNzKCk7CiB9CiBfX2V4aXRjYWxsKGRtYV9idWZfZGVpbml0KTsKZGlmZiAtLWdpdCBhL2lu Y2x1ZGUvbGludXgvZG1hLWJ1Zi5oIGIvaW5jbHVkZS9saW51eC9kbWEtYnVmLmgKaW5kZXggY2Y3 MjY5OWNiMmJjLi40YWU1Y2MzOGE0YTcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZG1hLWJ1 Zi5oCisrKyBiL2luY2x1ZGUvbGludXgvZG1hLWJ1Zi5oCkBAIC0yOTQsNiArMjk0LDkgQEAgc3Ry dWN0IGRtYV9idWZfb3BzIHsKICAqIEBwb2xsOiBmb3IgdXNlcnNwYWNlIHBvbGwgc3VwcG9ydAog ICogQGNiX2V4Y2w6IGZvciB1c2Vyc3BhY2UgcG9sbCBzdXBwb3J0CiAgKiBAY2Jfc2hhcmVkOiBm b3IgdXNlcnNwYWNlIHBvbGwgc3VwcG9ydAorICogQHN5c2ZzX2VudHJ5OiBmb3IgZXhwb3Npbmcg aW5mb3JtYXRpb24gYWJvdXQgdGhpcyBidWZmZXIgaW4gc3lzZnMuCisgKiBUaGUgYXR0YWNobWVu dF91aWQgbWVtYmVyIG9mIEBzeXNmc19lbnRyeSBpcyBwcm90ZWN0ZWQgYnkgZG1hX3Jlc3YgbG9j aworICogYW5kIGlzIGluY3JlbWVudGVkIG9uIGVhY2ggYXR0YWNoLgogICoKICAqIFRoaXMgcmVw cmVzZW50cyBhIHNoYXJlZCBidWZmZXIsIGNyZWF0ZWQgYnkgY2FsbGluZyBkbWFfYnVmX2V4cG9y dCgpLiBUaGUKICAqIHVzZXJzcGFjZSByZXByZXNlbnRhdGlvbiBpcyBhIG5vcm1hbCBmaWxlIGRl c2NyaXB0b3IsIHdoaWNoIGNhbiBiZSBjcmVhdGVkIGJ5CkBAIC0zMjksNiArMzMyLDE1IEBAIHN0 cnVjdCBkbWFfYnVmIHsKIAogCQlfX3BvbGxfdCBhY3RpdmU7CiAJfSBjYl9leGNsLCBjYl9zaGFy ZWQ7CisjaWZkZWYgQ09ORklHX0RNQUJVRl9TWVNGU19TVEFUUworCS8qIGZvciBzeXNmcyBzdGF0 cyAqLworCXN0cnVjdCBkbWFfYnVmX3N5c2ZzX2VudHJ5IHsKKwkJc3RydWN0IGtvYmplY3Qga29i ajsKKwkJc3RydWN0IGRtYV9idWYgKmRtYWJ1ZjsKKwkJdW5zaWduZWQgaW50IGF0dGFjaG1lbnRf dWlkOworCQlzdHJ1Y3Qga3NldCAqYXR0YWNoX3N0YXRzX2tzZXQ7CisJfSAqc3lzZnNfZW50cnk7 CisjZW5kaWYKIH07CiAKIC8qKgpAQCAtMzc4LDYgKzM5MCw3IEBAIHN0cnVjdCBkbWFfYnVmX2F0 dGFjaF9vcHMgewogICogQGltcG9ydGVyX29wczogaW1wb3J0ZXIgb3BlcmF0aW9ucyBmb3IgdGhp cyBhdHRhY2htZW50LCBpZiBwcm92aWRlZAogICogZG1hX2J1Zl9tYXAvdW5tYXBfYXR0YWNobWVu dCgpIG11c3QgYmUgY2FsbGVkIHdpdGggdGhlIGRtYV9yZXN2IGxvY2sgaGVsZC4KICAqIEBpbXBv cnRlcl9wcml2OiBpbXBvcnRlciBzcGVjaWZpYyBhdHRhY2htZW50IGRhdGEuCisgKiBAc3lzZnNf ZW50cnk6IEZvciBleHBvc2luZyBpbmZvcm1hdGlvbiBhYm91dCB0aGlzIGF0dGFjaG1lbnQgaW4g c3lzZnMuCiAgKgogICogVGhpcyBzdHJ1Y3R1cmUgaG9sZHMgdGhlIGF0dGFjaG1lbnQgaW5mb3Jt YXRpb24gYmV0d2VlbiB0aGUgZG1hX2J1ZiBidWZmZXIKICAqIGFuZCBpdHMgdXNlciBkZXZpY2Uo cykuIFRoZSBsaXN0IGNvbnRhaW5zIG9uZSBhdHRhY2htZW50IHN0cnVjdCBwZXIgZGV2aWNlCkBA IC0zOTgsNiArNDExLDEzIEBAIHN0cnVjdCBkbWFfYnVmX2F0dGFjaG1lbnQgewogCWNvbnN0IHN0 cnVjdCBkbWFfYnVmX2F0dGFjaF9vcHMgKmltcG9ydGVyX29wczsKIAl2b2lkICppbXBvcnRlcl9w cml2OwogCXZvaWQgKnByaXY7CisjaWZkZWYgQ09ORklHX0RNQUJVRl9TWVNGU19TVEFUUworCS8q IGZvciBzeXNmcyBzdGF0cyAqLworCXN0cnVjdCBkbWFfYnVmX2F0dGFjaF9zeXNmc19lbnRyeSB7 CisJCXN0cnVjdCBrb2JqZWN0IGtvYmo7CisJCXVuc2lnbmVkIGludCBtYXBfY291bnRlcjsKKwl9 ICpzeXNmc19lbnRyeTsKKyNlbmRpZgogfTsKIAogLyoqCi0tIAoyLjMwLjAuMjgwLmdhM2NlMjc5 MTJmLWdvb2cKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpo dHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= 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=-26.2 required=3.0 tests=BAYES_00,DKIMWL_WL_MED, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT,USER_IN_DEF_DKIM_WL 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 6AE8CC433DB for ; Wed, 27 Jan 2021 11:48:58 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1B99E207B6 for ; Wed, 27 Jan 2021 11:48:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S314081AbhAZW4Z (ORCPT ); Tue, 26 Jan 2021 17:56:25 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41626 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2391461AbhAZUn0 (ORCPT ); Tue, 26 Jan 2021 15:43:26 -0500 Received: from mail-qk1-x749.google.com (mail-qk1-x749.google.com [IPv6:2607:f8b0:4864:20::749]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4A428C0613D6 for ; Tue, 26 Jan 2021 12:42:46 -0800 (PST) Received: by mail-qk1-x749.google.com with SMTP id v190so12058350qkc.15 for ; Tue, 26 Jan 2021 12:42:46 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=sender:date:message-id:mime-version:subject:from:to:cc :content-transfer-encoding; bh=umYZWS6Z3IFyoIqy8XevcEiFUNU/mgfont74aC5M2Jc=; b=AWgEG6Ah8p3uAxFd6JEWWNre1+V5M/uGxqKboxz6qcAU+fOOJ7+YJAydnzKtguqFbV 01wfe5GD1w+KTe7xPJECSCDQ56Yj7Y6wYi9UB5T1gaZjcDyv72dWWxesOj/W2Xfo9BM9 srq0wAzZkiSYauKcdHkpZIbNYn+kUd1xIt31idgtKrw0T9X41owDPQFIfb4OZ3TU9msf TXCQJKcO4d03EDFfhfmza4ahkxIQFYjoddqWYSzaJdY7L7WGhpX6f83nlfxtYTQFB2yk wX69wd/8+bkZZW+SLcwuHMojL6vtuvi3a7/dWfGtOlMyWiyP8S/Q4nYLpaF5IfFr47Of Dy2w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:message-id:mime-version:subject:from :to:cc:content-transfer-encoding; bh=umYZWS6Z3IFyoIqy8XevcEiFUNU/mgfont74aC5M2Jc=; b=IL1jTnCHnDqSezUizahzeV5EO7NDLNvrl0iH4QRueupjaQJkzmyeeJ2Xf1NwtuKZ2V J7LGD6PWKMdvL+cTEG0QvQWOp7DVo/7HmJRttoyQj3CnBM3e1pmLYvUnZhxpZpTY5xwq g2c18HR9OFDN3kMlfSRK0xdD09FMW3LwpAo6sIVT6Q9mCo6mJofCCgYvuAUZXHWkiO9g yNUBFAxJJqjvgueN4V4NYX3dn3GUgfC8lv7q1R7BgGxqgs//kod9eWG4WYqSIElApEaM 9RfLpYkFVyaaxXGh/iSYWOFzBG5P6eKsoRM/NUTBnrsp9yQwkrB8cTFBNtdvJc2or3BD 8A9w== X-Gm-Message-State: AOAM530NMOyGBOvXG/3GAFXOjA1lk9k/Drn+FN/2rdggNM4W1lw6/PPa KPPcn8R5Ik84SBAek6KENcrLjwFei2c= X-Google-Smtp-Source: ABdhPJzAOsjnC7BvX6mcgN85oLU15vxw1W7G6I3DBxunGl56ldwJ+Q5XqJMqXfq3nrG6/YoYxGvG++ZtGug= Sender: "hridya via sendgmr" X-Received: from hridya.mtv.corp.google.com ([2620:15c:211:200:7220:84ff:fe09:5ea6]) (user=hridya job=sendgmr) by 2002:ad4:5b82:: with SMTP id 2mr7324332qvp.53.1611693765254; Tue, 26 Jan 2021 12:42:45 -0800 (PST) Date: Tue, 26 Jan 2021 12:42:36 -0800 Message-Id: <20210126204240.418297-1-hridya@google.com> Mime-Version: 1.0 X-Mailer: git-send-email 2.30.0.280.ga3ce27912f-goog Subject: [PATCH v3] dmabuf: Add the capability to expose DMA-BUF stats in sysfs From: Hridya Valsaraju To: Sumit Semwal , "=?UTF-8?q?Christian=20K=C3=B6nig?=" , Hridya Valsaraju , linux-kernel@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org Cc: kernel-team@android.com, gregkh@linuxfoundation.org, john.stultz@linaro.org, surenb@google.com, hyesoo.yu@samsung.com, kernel test robot Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org This patch allows statistics to be enabled for each DMA-BUF in sysfs by enabling the config CONFIG_DMABUF_SYSFS_STATS. The following stats will be exposed by the interface: /sys/kernel/dmabuf/buffers//exporter_name /sys/kernel/dmabuf/buffers//size /sys/kernel/dmabuf/buffers//attachments//device /sys/kernel/dmabuf/buffers//attachments//map_coun= ter The inode_number is unique for each DMA-BUF and was added earlier [1] in order to allow userspace to track DMA-BUF usage across different processes. Currently, this information is exposed in /sys/kernel/debug/dma_buf/bufinfo. However, since debugfs is considered unsafe to be mounted in production, it is being duplicated in sysfs. This information will be used to derive DMA-BUF per-exporter stats and per-device usage stats for Android Bug reports. The corresponding userspace changes can be found at [2]. Telemetry tools will also capture this information(along with other memory metrics) periodically as well as on important events like a foreground app kill (which might have been triggered by Low Memory Killer). It will also contribute to provide a snapshot of the system memory usage on other events such as OOM kills and Application Not Responding events. A shell script that can be run on a classic Linux environment to read out the DMA-BUF statistics can be found at [3](suggested by John Stultz). The patch contains the following improvements over the previous version: 1) Each attachment is represented by its own directory to allow creating a symlink to the importing device and to also provide room for future expansion. 2) The number of distinct mappings of each attachment is exposed in a separate file. 3) The per-buffer statistics are now in /sys/kernel/dmabuf/buffers inorder to make the interface expandable in future. All of the improvements above are based on suggestions/feedback from Daniel Vetter and Christian K=C3=B6nig. [1]: https://lore.kernel.org/patchwork/patch/1088791/ [2]: https://android-review.googlesource.com/q/topic:%22dmabuf-sysfs%22+(st= atus:open%20OR%20status:merged) [3]: https://android-review.googlesource.com/c/platform/system/memory/libme= minfo/+/1549734 Signed-off-by: Hridya Valsaraju Reported-by: kernel test robot --- Changes in v3: Fix a warning reported by the kernel test robot. Changes in v2: -Move statistics to /sys/kernel/dmabuf/buffers in oder to allow addition of other DMA-BUF-related sysfs stats in future. Based on feedback from Daniel Vetter. -Each attachment has its own directory to represent attaching devices as symlinks and to introduce map_count as a separate file. Based on feedback from Daniel Vetter and Christian K=C3=B6nig. Thank you both! -Commit messages updated to point to userspace code in AOSP that will read the DMA-BUF sysfs stats. .../ABI/testing/sysfs-kernel-dmabuf-buffers | 52 ++++ drivers/dma-buf/Kconfig | 11 + drivers/dma-buf/Makefile | 1 + drivers/dma-buf/dma-buf-sysfs-stats.c | 285 ++++++++++++++++++ drivers/dma-buf/dma-buf-sysfs-stats.h | 62 ++++ drivers/dma-buf/dma-buf.c | 37 +++ include/linux/dma-buf.h | 20 ++ 7 files changed, 468 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-kernel-dmabuf-buffers create mode 100644 drivers/dma-buf/dma-buf-sysfs-stats.c create mode 100644 drivers/dma-buf/dma-buf-sysfs-stats.h diff --git a/Documentation/ABI/testing/sysfs-kernel-dmabuf-buffers b/Docume= ntation/ABI/testing/sysfs-kernel-dmabuf-buffers new file mode 100644 index 000000000000..6f7c65209f07 --- /dev/null +++ b/Documentation/ABI/testing/sysfs-kernel-dmabuf-buffers @@ -0,0 +1,52 @@ +What: /sys/kernel/dmabuf/buffers +Date: January 2021 +KernelVersion: v5.12 +Contact: Hridya Valsaraju +Description: The /sys/kernel/dmabuf/buffers directory contains a + snapshot of the internal state of every DMA-BUF. + /sys/kernel/dmabuf/buffers/ will contain the + statistics for the DMA-BUF with the unique inode number + +Users: kernel memory tuning/debugging tools + +What: /sys/kernel/dmabuf/buffers//exporter_name +Date: January 2021 +KernelVersion: v5.12 +Contact: Hridya Valsaraju +Description: This file is read-only and contains the name of the exporter = of + the DMA-BUF. + +What: /sys/kernel/dmabuf/buffers//size +Date: January 2021 +KernelVersion: v5.12 +Contact: Hridya Valsaraju +Description: This file is read-only and specifies the size of the DMA-BUF = in + bytes. + +What: /sys/kernel/dmabuf/buffers//attachments +Date: January 2021 +KernelVersion: v5.12 +Contact: Hridya Valsaraju +Description: This directory will contain subdirectories representing every + attachment of the DMA-BUF. + +What: /sys/kernel/dmabuf/buffers//attachments/ +Date: January 2021 +KernelVersion: v5.12 +Contact: Hridya Valsaraju +Description: This directory will contain information on the attaching devi= ce + and the number of current distinct device mappings. + +What: /sys/kernel/dmabuf/buffers//attachments//device +Date: January 2021 +KernelVersion: v5.12 +Contact: Hridya Valsaraju +Description: This file is read-only and is a symlink to the attaching devi= ces's + sysfs entry. + +What: /sys/kernel/dmabuf/buffers//attachments//map_counter +Date: January 2021 +KernelVersion: v5.12 +Contact: Hridya Valsaraju +Description: This file is read-only and contains a map_counter indicating = the + number of distinct device mappings of the attachment. diff --git a/drivers/dma-buf/Kconfig b/drivers/dma-buf/Kconfig index 4f8224a6ac95..27e6a2dafeaa 100644 --- a/drivers/dma-buf/Kconfig +++ b/drivers/dma-buf/Kconfig @@ -64,6 +64,17 @@ menuconfig DMABUF_HEAPS allows userspace to allocate dma-bufs that can be shared between drivers. =20 +menuconfig DMABUF_SYSFS_STATS + bool "DMA-BUF sysfs statistics" + select DMA_SHARED_BUFFER + help + Choose this option to enable DMA-BUF sysfs statistics + in location /sys/kernel/dmabuf/buffers. + + /sys/kernel/dmabuf/buffers/ will contain + statistics for the DMA-BUF with the unique inode number + . + source "drivers/dma-buf/heaps/Kconfig" =20 endmenu diff --git a/drivers/dma-buf/Makefile b/drivers/dma-buf/Makefile index 995e05f609ff..40d81f23cacf 100644 --- a/drivers/dma-buf/Makefile +++ b/drivers/dma-buf/Makefile @@ -6,6 +6,7 @@ obj-$(CONFIG_DMABUF_HEAPS) +=3D heaps/ obj-$(CONFIG_SYNC_FILE) +=3D sync_file.o obj-$(CONFIG_SW_SYNC) +=3D sw_sync.o sync_debug.o obj-$(CONFIG_UDMABUF) +=3D udmabuf.o +obj-$(CONFIG_DMABUF_SYSFS_STATS) +=3D dma-buf-sysfs-stats.o =20 dmabuf_selftests-y :=3D \ selftest.o \ diff --git a/drivers/dma-buf/dma-buf-sysfs-stats.c b/drivers/dma-buf/dma-bu= f-sysfs-stats.c new file mode 100644 index 000000000000..5dc2e17f3054 --- /dev/null +++ b/drivers/dma-buf/dma-buf-sysfs-stats.c @@ -0,0 +1,285 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * DMA-BUF sysfs statistics. + * + * Copyright (C) 2021 Google LLC. + */ + +#include +#include +#include +#include +#include +#include + +#include "dma-buf-sysfs-stats.h" + +#define to_dma_buf_entry_from_kobj(x) container_of(x, struct dma_buf_sysfs= _entry, kobj) + +struct dma_buf_stats_attribute { + struct attribute attr; + ssize_t (*show)(struct dma_buf *dmabuf, + struct dma_buf_stats_attribute *attr, char *buf); +}; +#define to_dma_buf_stats_attr(x) container_of(x, struct dma_buf_stats_attr= ibute, attr) + +static ssize_t dma_buf_stats_attribute_show(struct kobject *kobj, + struct attribute *attr, + char *buf) +{ + struct dma_buf_stats_attribute *attribute; + struct dma_buf_sysfs_entry *sysfs_entry; + struct dma_buf *dmabuf; + + attribute =3D to_dma_buf_stats_attr(attr); + sysfs_entry =3D to_dma_buf_entry_from_kobj(kobj); + dmabuf =3D sysfs_entry->dmabuf; + + if (!dmabuf || !attribute->show) + return -EIO; + + return attribute->show(dmabuf, attribute, buf); +} + +static const struct sysfs_ops dma_buf_stats_sysfs_ops =3D { + .show =3D dma_buf_stats_attribute_show, +}; + +static ssize_t exporter_name_show(struct dma_buf *dmabuf, + struct dma_buf_stats_attribute *attr, + char *buf) +{ + return sysfs_emit(buf, "%s\n", dmabuf->exp_name); +} + +static ssize_t size_show(struct dma_buf *dmabuf, + struct dma_buf_stats_attribute *attr, + char *buf) +{ + return sysfs_emit(buf, "%zu\n", dmabuf->size); +} + +static struct dma_buf_stats_attribute exporter_name_attribute =3D + __ATTR_RO(exporter_name); +static struct dma_buf_stats_attribute size_attribute =3D __ATTR_RO(size); + +static struct attribute *dma_buf_stats_default_attrs[] =3D { + &exporter_name_attribute.attr, + &size_attribute.attr, + NULL, +}; +ATTRIBUTE_GROUPS(dma_buf_stats_default); + +static void dma_buf_sysfs_release(struct kobject *kobj) +{ + struct dma_buf_sysfs_entry *sysfs_entry; + + sysfs_entry =3D to_dma_buf_entry_from_kobj(kobj); + kfree(sysfs_entry); +} + +static struct kobj_type dma_buf_ktype =3D { + .sysfs_ops =3D &dma_buf_stats_sysfs_ops, + .release =3D dma_buf_sysfs_release, + .default_groups =3D dma_buf_stats_default_groups, +}; + +#define to_dma_buf_attach_entry_from_kobj(x) container_of(x, struct dma_bu= f_attach_sysfs_entry, kobj) + +struct dma_buf_attach_stats_attribute { + struct attribute attr; + ssize_t (*show)(struct dma_buf_attach_sysfs_entry *sysfs_entry, + struct dma_buf_attach_stats_attribute *attr, char *buf); +}; +#define to_dma_buf_attach_stats_attr(x) container_of(x, struct dma_buf_att= ach_stats_attribute, attr) + +static ssize_t dma_buf_attach_stats_attribute_show(struct kobject *kobj, + struct attribute *attr, + char *buf) +{ + struct dma_buf_attach_stats_attribute *attribute; + struct dma_buf_attach_sysfs_entry *sysfs_entry; + + attribute =3D to_dma_buf_attach_stats_attr(attr); + sysfs_entry =3D to_dma_buf_attach_entry_from_kobj(kobj); + + if (!attribute->show) + return -EIO; + + return attribute->show(sysfs_entry, attribute, buf); +} + +static const struct sysfs_ops dma_buf_attach_stats_sysfs_ops =3D { + .show =3D dma_buf_attach_stats_attribute_show, +}; + +static ssize_t map_counter_show(struct dma_buf_attach_sysfs_entry *sysfs_e= ntry, + struct dma_buf_attach_stats_attribute *attr, + char *buf) +{ + return sysfs_emit(buf, "%u\n", sysfs_entry->map_counter); +} + +static struct dma_buf_attach_stats_attribute map_counter_attribute =3D + __ATTR_RO(map_counter); + +static struct attribute *dma_buf_attach_stats_default_attrs[] =3D { + &map_counter_attribute.attr, + NULL, +}; +ATTRIBUTE_GROUPS(dma_buf_attach_stats_default); + +static void dma_buf_attach_sysfs_release(struct kobject *kobj) +{ + struct dma_buf_attach_sysfs_entry *sysfs_entry; + + sysfs_entry =3D to_dma_buf_attach_entry_from_kobj(kobj); + kfree(sysfs_entry); +} + +static struct kobj_type dma_buf_attach_ktype =3D { + .sysfs_ops =3D &dma_buf_attach_stats_sysfs_ops, + .release =3D dma_buf_attach_sysfs_release, + .default_groups =3D dma_buf_attach_stats_default_groups, +}; + +void dma_buf_attach_stats_teardown(struct dma_buf_attachment *attach) +{ + struct dma_buf_attach_sysfs_entry *sysfs_entry; + + sysfs_entry =3D attach->sysfs_entry; + if (!sysfs_entry) + return; + + sysfs_delete_link(&sysfs_entry->kobj, &attach->dev->kobj, "device"); + + kobject_del(&sysfs_entry->kobj); + kobject_put(&sysfs_entry->kobj); +} + +int dma_buf_attach_stats_setup(struct dma_buf_attachment *attach, + unsigned int uid) +{ + struct dma_buf_attach_sysfs_entry *sysfs_entry; + int ret; + struct dma_buf *dmabuf; + + if (!attach) + return -EINVAL; + + dmabuf =3D attach->dmabuf; + + sysfs_entry =3D kzalloc(sizeof(struct dma_buf_attach_sysfs_entry), + GFP_KERNEL); + if (!sysfs_entry) + return -ENOMEM; + + sysfs_entry->kobj.kset =3D dmabuf->sysfs_entry->attach_stats_kset; + + attach->sysfs_entry =3D sysfs_entry; + + ret =3D kobject_init_and_add(&sysfs_entry->kobj, &dma_buf_attach_ktype, + NULL, "%u", uid); + if (ret) + goto kobj_err; + + ret =3D sysfs_create_link(&sysfs_entry->kobj, &attach->dev->kobj, + "device"); + if (ret) + goto link_err; + + return 0; + +link_err: + kobject_del(&sysfs_entry->kobj); +kobj_err: + kobject_put(&sysfs_entry->kobj); + attach->sysfs_entry =3D NULL; + + return ret; +} +void dma_buf_stats_teardown(struct dma_buf *dmabuf) +{ + struct dma_buf_sysfs_entry *sysfs_entry; + + sysfs_entry =3D dmabuf->sysfs_entry; + if (!sysfs_entry) + return; + + kset_unregister(sysfs_entry->attach_stats_kset); + kobject_del(&sysfs_entry->kobj); + kobject_put(&sysfs_entry->kobj); +} + +static struct kset *dma_buf_stats_kset; +static struct kset *dma_buf_per_buffer_stats_kset; +int dma_buf_init_sysfs_statistics(void) +{ + dma_buf_stats_kset =3D kset_create_and_add("dmabuf", NULL, kernel_kobj); + if (!dma_buf_stats_kset) + return -ENOMEM; + + dma_buf_per_buffer_stats_kset =3D kset_create_and_add("buffers", NULL, + &dma_buf_stats_kset->kobj); + if (!dma_buf_per_buffer_stats_kset) { + kset_unregister(dma_buf_stats_kset); + return -ENOMEM; + } + + return 0; +} + +void dma_buf_uninit_sysfs_statistics(void) +{ + kset_unregister(dma_buf_per_buffer_stats_kset); + kset_unregister(dma_buf_stats_kset); +} + +int dma_buf_stats_setup(struct dma_buf *dmabuf) +{ + struct dma_buf_sysfs_entry *sysfs_entry; + int ret; + struct kset *attach_stats_kset; + + if (!dmabuf || !dmabuf->file) + return -EINVAL; + + if (!dmabuf->exp_name) { + pr_err("exporter name must not be empty if stats needed\n"); + return -EINVAL; + } + + sysfs_entry =3D kzalloc(sizeof(struct dma_buf_sysfs_entry), GFP_KERNEL); + if (!sysfs_entry) + return -ENOMEM; + + sysfs_entry->kobj.kset =3D dma_buf_per_buffer_stats_kset; + sysfs_entry->dmabuf =3D dmabuf; + + dmabuf->sysfs_entry =3D sysfs_entry; + + /* create the directory for buffer stats */ + ret =3D kobject_init_and_add(&sysfs_entry->kobj, &dma_buf_ktype, NULL, + "%lu", file_inode(dmabuf->file)->i_ino); + if (ret) + goto err_sysfs_dmabuf; + + /* create the directory for attachment stats */ + attach_stats_kset =3D kset_create_and_add("attachments", NULL, + &sysfs_entry->kobj); + if (!attach_stats_kset) { + ret =3D -ENOMEM; + goto err_sysfs_attach; + } + + sysfs_entry->attach_stats_kset =3D attach_stats_kset; + + return 0; + +err_sysfs_attach: + kobject_del(&sysfs_entry->kobj); +err_sysfs_dmabuf: + kobject_put(&sysfs_entry->kobj); + dmabuf->sysfs_entry =3D NULL; + return ret; +} diff --git a/drivers/dma-buf/dma-buf-sysfs-stats.h b/drivers/dma-buf/dma-bu= f-sysfs-stats.h new file mode 100644 index 000000000000..5f4703249117 --- /dev/null +++ b/drivers/dma-buf/dma-buf-sysfs-stats.h @@ -0,0 +1,62 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * DMA-BUF sysfs statistics. + * + * Copyright (C) 2021 Google LLC. + */ + +#ifndef _DMA_BUF_SYSFS_STATS_H +#define _DMA_BUF_SYSFS_STATS_H + +#ifdef CONFIG_DMABUF_SYSFS_STATS + +int dma_buf_init_sysfs_statistics(void); +void dma_buf_uninit_sysfs_statistics(void); + +int dma_buf_stats_setup(struct dma_buf *dmabuf); +int dma_buf_attach_stats_setup(struct dma_buf_attachment *attach, + unsigned int uid); +static inline void dma_buf_update_attachment_map_count(struct dma_buf_atta= chment *attach, + int delta) +{ + struct dma_buf_attach_sysfs_entry *entry =3D attach->sysfs_entry; + + entry->map_counter +=3D delta; +} +void dma_buf_stats_teardown(struct dma_buf *dmabuf); +void dma_buf_attach_stats_teardown(struct dma_buf_attachment *attach); +static inline unsigned int dma_buf_update_attach_uid(struct dma_buf *dmabu= f) +{ + struct dma_buf_sysfs_entry *entry =3D dmabuf->sysfs_entry; + + return entry->attachment_uid++; +} +#else + +static inline int dma_buf_init_sysfs_statistics(void) +{ + return 0; +} + +static inline void dma_buf_uninit_sysfs_statistics(void) {} + +static inline int dma_buf_stats_setup(struct dma_buf *dmabuf) +{ + return 0; +} +static inline int dma_buf_attach_stats_setup(struct dma_buf_attachment *at= tach, + unsigned int uid) +{ + return 0; +} + +static inline void dma_buf_stats_teardown(struct dma_buf *dmabuf) {} +static inline void dma_buf_attach_stats_teardown(struct dma_buf_attachment= *attach) {} +static inline void dma_buf_update_attachment_map_count(struct dma_buf_atta= chment *attach, + int delta) {} +static inline unsigned int dma_buf_update_attach_uid(struct dma_buf *dmabu= f) +{ + return 0; +} +#endif +#endif // _DMA_BUF_SYSFS_STATS_H diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c index 9ad6397aaa97..29f9ea18eb47 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -29,6 +29,8 @@ #include #include =20 +#include "dma-buf-sysfs-stats.h" + static inline int is_dma_buf_file(struct file *); =20 struct dma_buf_list { @@ -79,6 +81,7 @@ static void dma_buf_release(struct dentry *dentry) if (dmabuf->resv =3D=3D (struct dma_resv *)&dmabuf[1]) dma_resv_fini(dmabuf->resv); =20 + dma_buf_stats_teardown(dmabuf); module_put(dmabuf->owner); kfree(dmabuf->name); kfree(dmabuf); @@ -579,6 +582,10 @@ struct dma_buf *dma_buf_export(const struct dma_buf_ex= port_info *exp_info) file->f_mode |=3D FMODE_LSEEK; dmabuf->file =3D file; =20 + ret =3D dma_buf_stats_setup(dmabuf); + if (ret) + goto err_sysfs; + mutex_init(&dmabuf->lock); INIT_LIST_HEAD(&dmabuf->attachments); =20 @@ -588,6 +595,14 @@ struct dma_buf *dma_buf_export(const struct dma_buf_ex= port_info *exp_info) =20 return dmabuf; =20 +err_sysfs: + /* + * Set file->f_path.dentry->d_fsdata to NULL so that when + * dma_buf_release() gets invoked by dentry_ops, it exits + * early before calling the release() dma_buf op. + */ + file->f_path.dentry->d_fsdata =3D NULL; + fput(file); err_dmabuf: kfree(dmabuf); err_module: @@ -692,6 +707,7 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct d= evice *dev, { struct dma_buf_attachment *attach; int ret; + unsigned int attach_uid; =20 if (WARN_ON(!dmabuf || !dev)) return ERR_PTR(-EINVAL); @@ -717,8 +733,13 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct = device *dev, } dma_resv_lock(dmabuf->resv, NULL); list_add(&attach->node, &dmabuf->attachments); + attach_uid =3D dma_buf_update_attach_uid(dmabuf); dma_resv_unlock(dmabuf->resv); =20 + ret =3D dma_buf_attach_stats_setup(attach, attach_uid); + if (ret) + goto err_sysfs; + /* When either the importer or the exporter can't handle dynamic * mappings we cache the mapping here to avoid issues with the * reservation object lock. @@ -745,6 +766,7 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct d= evice *dev, dma_resv_unlock(attach->dmabuf->resv); attach->sgt =3D sgt; attach->dir =3D DMA_BIDIRECTIONAL; + dma_buf_update_attachment_map_count(attach, 1 /* delta */); } =20 return attach; @@ -761,6 +783,7 @@ dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct d= evice *dev, if (dma_buf_is_dynamic(attach->dmabuf)) dma_resv_unlock(attach->dmabuf->resv); =20 +err_sysfs: dma_buf_detach(dmabuf, attach); return ERR_PTR(ret); } @@ -799,6 +822,7 @@ void dma_buf_detach(struct dma_buf *dmabuf, struct dma_= buf_attachment *attach) dma_resv_lock(attach->dmabuf->resv, NULL); =20 dmabuf->ops->unmap_dma_buf(attach, attach->sgt, attach->dir); + dma_buf_update_attachment_map_count(attach, -1 /* delta */); =20 if (dma_buf_is_dynamic(attach->dmabuf)) { dma_buf_unpin(attach); @@ -812,6 +836,7 @@ void dma_buf_detach(struct dma_buf *dmabuf, struct dma_= buf_attachment *attach) if (dmabuf->ops->detach) dmabuf->ops->detach(dmabuf, attach); =20 + dma_buf_attach_stats_teardown(attach); kfree(attach); } EXPORT_SYMBOL_GPL(dma_buf_detach); @@ -938,6 +963,9 @@ struct sg_table *dma_buf_map_attachment(struct dma_buf_= attachment *attach, } #endif /* CONFIG_DMA_API_DEBUG */ =20 + if (!IS_ERR(sg_table)) + dma_buf_update_attachment_map_count(attach, 1 /* delta */); + return sg_table; } EXPORT_SYMBOL_GPL(dma_buf_map_attachment); @@ -975,6 +1003,8 @@ void dma_buf_unmap_attachment(struct dma_buf_attachmen= t *attach, if (dma_buf_is_dynamic(attach->dmabuf) && !IS_ENABLED(CONFIG_DMABUF_MOVE_NOTIFY)) dma_buf_unpin(attach); + + dma_buf_update_attachment_map_count(attach, -1 /* delta */); } EXPORT_SYMBOL_GPL(dma_buf_unmap_attachment); =20 @@ -1412,6 +1442,12 @@ static inline void dma_buf_uninit_debugfs(void) =20 static int __init dma_buf_init(void) { + int ret; + + ret =3D dma_buf_init_sysfs_statistics(); + if (ret) + return ret; + dma_buf_mnt =3D kern_mount(&dma_buf_fs_type); if (IS_ERR(dma_buf_mnt)) return PTR_ERR(dma_buf_mnt); @@ -1427,5 +1463,6 @@ static void __exit dma_buf_deinit(void) { dma_buf_uninit_debugfs(); kern_unmount(dma_buf_mnt); + dma_buf_uninit_sysfs_statistics(); } __exitcall(dma_buf_deinit); diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index cf72699cb2bc..4ae5cc38a4a7 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -294,6 +294,9 @@ struct dma_buf_ops { * @poll: for userspace poll support * @cb_excl: for userspace poll support * @cb_shared: for userspace poll support + * @sysfs_entry: for exposing information about this buffer in sysfs. + * The attachment_uid member of @sysfs_entry is protected by dma_resv lock + * and is incremented on each attach. * * This represents a shared buffer, created by calling dma_buf_export(). T= he * userspace representation is a normal file descriptor, which can be crea= ted by @@ -329,6 +332,15 @@ struct dma_buf { =20 __poll_t active; } cb_excl, cb_shared; +#ifdef CONFIG_DMABUF_SYSFS_STATS + /* for sysfs stats */ + struct dma_buf_sysfs_entry { + struct kobject kobj; + struct dma_buf *dmabuf; + unsigned int attachment_uid; + struct kset *attach_stats_kset; + } *sysfs_entry; +#endif }; =20 /** @@ -378,6 +390,7 @@ struct dma_buf_attach_ops { * @importer_ops: importer operations for this attachment, if provided * dma_buf_map/unmap_attachment() must be called with the dma_resv lock he= ld. * @importer_priv: importer specific attachment data. + * @sysfs_entry: For exposing information about this attachment in sysfs. * * This structure holds the attachment information between the dma_buf buf= fer * and its user device(s). The list contains one attachment struct per dev= ice @@ -398,6 +411,13 @@ struct dma_buf_attachment { const struct dma_buf_attach_ops *importer_ops; void *importer_priv; void *priv; +#ifdef CONFIG_DMABUF_SYSFS_STATS + /* for sysfs stats */ + struct dma_buf_attach_sysfs_entry { + struct kobject kobj; + unsigned int map_counter; + } *sysfs_entry; +#endif }; =20 /** --=20 2.30.0.280.ga3ce27912f-goog