From patchwork Fri Nov 11 08:20:02 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Madalin Bucur X-Patchwork-Id: 693595 Return-Path: X-Original-To: patchwork-incoming@ozlabs.org Delivered-To: patchwork-incoming@ozlabs.org Received: from lists.ozlabs.org (lists.ozlabs.org [103.22.144.68]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3tFY3J4NFbz9t1L for ; Fri, 11 Nov 2016 19:28:44 +1100 (AEDT) Received: from lists.ozlabs.org (lists.ozlabs.org [IPv6:2401:3900:2:1::3]) by lists.ozlabs.org (Postfix) with ESMTP id 3tFY3J3ZvNzDw27 for ; Fri, 11 Nov 2016 19:28:44 +1100 (AEDT) X-Original-To: linuxppc-dev@lists.ozlabs.org Delivered-To: linuxppc-dev@lists.ozlabs.org Received: from NAM02-CY1-obe.outbound.protection.outlook.com (mail-cys01nam02on0070.outbound.protection.outlook.com [104.47.37.70]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-SHA384 (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 3tFXsp5dnpzDvqB for ; Fri, 11 Nov 2016 19:20:30 +1100 (AEDT) Received: from CY4PR03CA0003.namprd03.prod.outlook.com (10.168.162.13) by DM2PR0301MB0749.namprd03.prod.outlook.com (10.160.97.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.1.707.6; Fri, 11 Nov 2016 08:20:26 +0000 Received: from BL2FFO11FD047.protection.gbl (2a01:111:f400:7c09::141) by CY4PR03CA0003.outlook.office365.com (2603:10b6:903:33::13) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.1.669.12 via Frontend Transport; Fri, 11 Nov 2016 08:20:25 +0000 Authentication-Results: spf=fail (sender IP is 192.88.158.2) smtp.mailfrom=nxp.com; infinera.com; dkim=none (message not signed) header.d=none; infinera.com; dmarc=fail action=none header.from=nxp.com; Received-SPF: Fail (protection.outlook.com: domain of nxp.com does not designate 192.88.158.2 as permitted sender) receiver=protection.outlook.com; client-ip=192.88.158.2; helo=az84smr01.freescale.net; Received: from az84smr01.freescale.net (192.88.158.2) by BL2FFO11FD047.mail.protection.outlook.com (10.173.161.209) with Microsoft SMTP Server (version=TLS1_0, cipher=TLS_RSA_WITH_AES_256_CBC_SHA) id 15.1.707.3 via Frontend Transport; Fri, 11 Nov 2016 08:20:25 +0000 X-IncomingTopHeaderMarker: OriginalChecksum:; UpperCasedChecksum:; SizeAsReceived:882; Count:11 Received: from fsr-fed2164-101.ea.freescale.net (fsr-fed2164-101.ea.freescale.net [10.171.73.197]) by az84smr01.freescale.net (8.14.3/8.14.0) with ESMTP id uAB8K7eU009839; Fri, 11 Nov 2016 01:20:22 -0700 From: Madalin Bucur To: Subject: [PATCH net-next v7 05/10] dpaa_eth: add ethtool statistics Date: Fri, 11 Nov 2016 10:20:02 +0200 Message-ID: <1478852407-27420-6-git-send-email-madalin.bucur@nxp.com> X-Mailer: git-send-email 2.1.0 In-Reply-To: <1478852407-27420-1-git-send-email-madalin.bucur@nxp.com> References: <1478852407-27420-1-git-send-email-madalin.bucur@nxp.com> X-IncomingHeaderCount: 11 X-EOPAttributedMessage: 0 X-Matching-Connectors: 131233260255840697; (91ab9b29-cfa4-454e-5278-08d120cd25b8); () X-Forefront-Antispam-Report: CIP:192.88.158.2; IPV:NLI; CTRY:US; EFV:NLI; SFV:NSPM; SFS:(10009020)(6009001)(7916002)(2980300002)(1110001)(1109001)(339900001)(189002)(199003)(6916009)(2950100002)(110136003)(5003940100001)(76176999)(50986999)(43066003)(33646002)(6666003)(189998001)(97736004)(53806999)(626004)(356003)(5660300001)(586003)(50466002)(305945005)(47776003)(7846002)(48376002)(4326007)(68736007)(8936002)(104016004)(3450700001)(50226002)(2351001)(87936001)(2906002)(85426001)(105606002)(77096005)(36756003)(86362001)(8676002)(575784001)(81156014)(81166006)(106466001)(69596002); DIR:OUT; SFP:1101; SCL:1; SRVR:DM2PR0301MB0749; H:az84smr01.freescale.net; FPR:; SPF:Fail; PTR:InfoDomainNonexistent; MX:1; A:1; LANG:en; X-Microsoft-Exchange-Diagnostics: 1; BL2FFO11FD047; 1:UH15oBzqgxjpTkISJe2iptzCI26Qb14gIdU8JaceFUSc7z/pd2Jerlquz65O6/WHYtER5wFd/d7QreknNdF3I0S+W87PnFeSpXX+Zovc2FGLbSII/QqAiIrOnEu/u8HFDhMAfu4ga1EfK+wTDtc1z1DD5f8DoryfEdxFXqi2BstUr+F9g7VSvj9iZhgFVrBic7ONr+94Oeivm0d9Pez+FdJXl78B/0vRFCmkiSD3yyh+OvOSMz98eSYJefEMuQFkI8bGb7o9kz279WCN+zv8Tb4grx/Lymv83b0qkPzUd4aXXX8NtTDwP3Ljj1Bah+JNb3GqV+EAsr+wGieGj42gXMpy2Z4s6HefdCzO8RUBbzEf5+UvNk0xHUKgHKzzjsYDy12OFGOUB+yG3Vqz/DYyOtTN7Uw5Zmy2CYYk4tofGXaEKD7ogcCBta+kmEUXrIzgr3WiOYrkejy/r7zjYKnOIHUnE4Npiu1x13PNhNJSJTCZZFsjinf8zbytM4PIikEdaKJ0Mzcp9q4LaobkWXAxQg7QArePVDWwCExYPghWuvNZ+noHWwVYfQRMmcZbGLlB6+j7UBN6ABaUXg2IIUAF9EcYVcOD9dWbWLWcRCqCPa4UcLL3b5hiDodtDaXK+ig7 MIME-Version: 1.0 X-Microsoft-Exchange-Diagnostics: 1; DM2PR0301MB0749; 2:U0o8WojRXlL9OCt2po20NKvs//tUmiH5RLvkVAsfHDwXdUwrvJXOrzhuG0VlLy0SRSFqjkq3Idq8ho2g354mY1scMP1G3OKB1a9cRqGJ7tAewhdiI+0PqZXMkDY6k0hliL+zckD390CMQjLqdH9/x8gwGopvroB4kqWXeUs8mcA=; 3:pqxK/+E9HzN/RrvW0q7/15cCvSz/vkh1UB1EOVFbyxei5pvz+rU/rGQCIsqcmj9qxayxUhlJW4WnKK8rEkb6dooYPYEK25AgJwsRCmsK7qaSvdVJtiyTnv3wrRVPSutODrBSOAtp06xBNWMAAv3PF0DvAK+PJ1bT8PcaqbYJDK3zOTa7Jekg3MrleLbwj+LFgIcVHCsfu1V4EAEa3dGiGD7OBH78hYk/xNRBLbx0khMZqxlA7eamHyCSiTGttKUpZKSkZVhlTdsjoAgTpdiRdA== X-MS-Office365-Filtering-Correlation-Id: d1b25080-93b1-4029-09b9-08d40a0b96bb X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(22001); SRVR:DM2PR0301MB0749; X-Microsoft-Exchange-Diagnostics: 1; DM2PR0301MB0749; 25:3MxVerEqCL55ZoUFsnE5M2yMrLcG/VjwfdNP2Un/2RbmCOXrTpe8M6Za8kBJhaHAW0dOu0DOtx1/Ba3qwtm8AtGYErI8E8ebebwhwqM2n1PEI345M/hl2Xue/e7WYMpyJlwKy1wSyhZZO5pAMlQW4w0G/Iz7raV6XAxiQzh4wgnQfcs3Y3SAekB3sXnCDn0HKEJT4r5gdEyure4ByMzZdTTtG/EcrQMX8RIixIMoPBWOJd2bt+Yo2wrhReUxwQ5E8j5Ojracr908f5ZVcZf7J9JoyzDGx+BidC/XM9tgbT6nGiQjr3QYbruTNNayoPA4xUHhKb9jrmJNB5h8kwfqowXtE1cLPlkWzcluhQ0plHVyTh5BKYZyS9WgW0AMvM+DjvwPZ9+u2+s2QKdTPyafsoLz2QYDTV5bGDy0T3vrRVAuyo9lfwqAJ+onBHN+MEt2kPm/kq/yAbiMU9Iyy+qNIYafmr12OM5bLTkOaq1iD3bopFJCPW0e4RYtCv15GQnCQnSdtiiQftib/B4G2obF4VzNpNp1lvV3mZLoF/EtO9KR+2UYVrnPTPKjmp3Lu9pTQ0Lva89Qmb8rx1aLcyZ2QLhDvBLHEPC3epCsOeU2CANEsQLUv/fjixxASrbPuCxhu5331XR90coC3w7oMEscR+SRQNAbqy0uWhEwrk+aAsspy0JIaNXCOfUvT20DSSwlVFrFSw6ZboLJKqk1ThEhxkMOR3VzYzuXl8z0u/PhqTZnRYI80jgVIfwBBonqPpXAJmue44nP4qXWV/zP9oboab8/vWBNyxVOIhy7TL1bS3cyU5HuyYZUGqwkuv0LVeIU X-Microsoft-Exchange-Diagnostics: 1; DM2PR0301MB0749; 31:ZTKwwJx0Rl/GFTb6FVhhGhEfHzxz1fTGT8aCrtRKXakx/IIpa74pJX4E+g9TDO7I8FfLjl93a4cx1aiiFt5oTghgEWh2FlIrqxtZREGuINcnqJTBAQ/7a60pTJJyJ1kc0YAPmsmdOURFdLNBGmltvhzTM2yGQAOJwDidA9+4cni6fvxORst50vVWFS/a5+0v9TbNm5WrkYiWkVyC+hA9Q8bKGu/zRJHUsboa5gKpUSYf59sVstYylAtrvMzEsJMVst7Yq4Hz7MQNxHcSWeT9Z+sfVDrUTaQD4fbXhCl3A3Y=; 4:U2KUan3QXR/v99ul9Z2OTER6ve9tw3zW5fL4Kf2K9NAfHzT8n+J3rJ9BzVvQMOfm/s4zmv+BM/asQDy3MS3Xt7YE8wpn0l9mdPOvwu1wwm07VLJkc5rZcZq6lcWZx6K7bo9iXTaTvNaJmywjB2r6so1QPsd3xZT+j30hBachByCUN5Q3sV+ztMG3xMoI8d+ywsXSkKa0J1wrqzeJeo+MhYKajAT/JCfw/2RUIxCEWkGAFBHakKF7RtZeSBzwIcCAiGk7Gdo1B952RMyTvTRIai7mAuN7pMYJYkvbbEiGKyh/H1xKlji2coptaIFmHWspZZYtfHX0LYFg1K1MZWr/vLeOxVv2MsUawvzLbGn3FFi1BdCFvXpaookfwWUNm0ZCLehYQ4FcRpVA2dMQOhRpNK6l5eDs3PF2s81BrD3nTZlQ+ZojDzCy+kCYbB3j71xQ3aUaE8h6yKY5CQyjNn6p1dbG6HtipZElXhO7XC6Scav0p+6eqZ4taRo+nS4us5C3jGVxhc5m+ABy+pE+AhnJadp4Dxp8X/T1IF3wlY0h9HNJWmM94QWHiyVKz+skqrAJfJdZ3Q5GdrECx+K6WY/uTA== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197)(275809806118684); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6040176)(601004)(2401047)(13024025)(13017025)(13015025)(13023025)(8121501046)(5005006)(13018025)(3002001)(10201501046)(6055026); SRVR:DM2PR0301MB0749; BCL:0; PCL:0; RULEID:(400006); SRVR:DM2PR0301MB0749; X-Forefront-PRVS: 012349AD1C X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DM2PR0301MB0749; 23:L4a+Ay9/2zv1tJJnCkaHyYQ2G6RRtsxLcL1ETio?= =?us-ascii?Q?RJIX/tKLCKG3aJzOPoAqorhv42/cwV3n8lfL49LdPybO0brC0zaVCneBUqmZ?= =?us-ascii?Q?iNsscQ89JK4jQZXHIXl4vEwNLLKH6zz8UBFPD1NKc+SCzNUY1bLoCcThsEgb?= =?us-ascii?Q?nCmoBXRM2rq5uJ+CccARcZFbEVjmEbkThzBd+iItJNFnXoTJrTZDtc1uXHOv?= =?us-ascii?Q?Z64oYMQD6Cg8m9xlF9EoSedTcr8/LAPVClJqPtqzYQK4/OKcniCZ8uStL20e?= =?us-ascii?Q?HCTIFuqxGRX8Qlai/s+lK3dt4FB5XqLGeRV6T7FVIKydYI6MTQT/JImEvgwz?= =?us-ascii?Q?MButecDkJWd9y+BfPXXNqN8H0KwF8FmGLeRRN7Tiu/gY90VeCuBvPUqPBG8K?= =?us-ascii?Q?9aDuVNDhiGthKRTonHL577vsxeiwd+W8QQ3rqD+drFTpOJYE2n4K1DFJ7ada?= =?us-ascii?Q?T5GxzsCiYLsoLIpDxd+iR6zeueUePwVgtcqfz9nYvx3Hv6n5aJR1ACZ+njv8?= =?us-ascii?Q?gErYbWtmb85YYmqoqs7YHf0ooluSawdfRP+BTEZy9Ww/cRzL8FPpDJczjlqD?= =?us-ascii?Q?B4k6z7yobPFz3MPTfsbI30pHNA+amT+JPCt35D4XGpaNxw8FkIG60ZfUymVV?= =?us-ascii?Q?nyPdLCImfNTAwDjVrTnMVnPiExGUWI2H2nTvyuItoqhd7CaytHsLQEAgAE1w?= =?us-ascii?Q?+60Z/uc6I3tqZiUZsqAabb8Jbe2Pjl6XqObfYy5i3c5F8XWqTy1ACFmPd4kK?= =?us-ascii?Q?fMwEtDqte8WTvsiMuarv0t8w1VUOzFHC/hi8+YgZKDxIFiUhYOkTqWUgKGtn?= =?us-ascii?Q?k7VZ50lWdkWWHHaaYM3ET2F28+OvYYj5xXTYeWtz0tgwgRlzJqQb5OD/mT3V?= =?us-ascii?Q?ptpD32gIiKe6Hjsq5p0brKgc7gRrOzxSO4AWTpa1LVgQAAJbVO53TE7RR+Fx?= =?us-ascii?Q?BtRL1xXCNfov0P5oqtzgvjgyMek+a0W6qFERnoLLDKwFGtwCE/m7Z/MWt+4A?= =?us-ascii?Q?4OTMVzBqhoKDrKm/D4Sh5sJ+lp5s7qRC3tZ+WWWu4NlxuRmnzuLibjszjYyZ?= =?us-ascii?Q?FDdi96qngrFWa30/B8k4+aDxLc3P92Of4Pkbuj4LxDHKITnJzv7JGRAh+Anu?= =?us-ascii?Q?dOT38OgCLDxsoY/cjHiG4ew8xXW6UrQtZ0Hftkbd33g3fYLIoPKZRfw=3D?= =?us-ascii?Q?=3D?= X-Microsoft-Exchange-Diagnostics: 1; DM2PR0301MB0749; 6:JCIob9qOaPnq/WDCkoXGpUquIwnF7SboG8N5c5ch98tCZ3gRWaiQH3GVbAfjyTIlztKHeZFcrhi9CvmtD3s9lifDyk8WIzlrX0tIiLrz3ZZKUswXkeD1UaQEWX6Jq3EXM7CHuOP8PCX+ob/iMzwtk69HNy+5riKnO9SLX+T7UmpASv+ecsFDqdST3ZVvbM5mjn2QTMrm+6+OMPBAusfdwd9pPcFlEKm2f38BMFFBPlae0ad8Zqi9/hJtgOBPHGkzjMcDVJ+N5xQkF0eKKE/iV3EKcb6FU0nVgBImRUnaafK0PoJJNs/smEGnwHUSC81n; 5:UKp9wQKooRg83Tu3bD76KFuaikZPNZ+8JuhGoIG4igrrEs3mejW6uV9S6aTB7UN3KNPthw/vHOYuBvWN0DRN3r62zj9omv7BDCShC6PTVAtadqLgMXbXS7lbBVPPqyZlOYRSn47YATqprlt3aYIsXePDs9tlYl0ajmPzG+1EPLFzXEesYuCyvR0hDsTAplmN; 24:josyXT6V0K/eRYw5JQi8hGqUcrBcnwECeuA2PXMrMfAFIxLJ+943IFvJt7BIUHW9awu8HDiAtgnl+Q52EtA4H1KkBJQqW1446S2fqrREz2I= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; DM2PR0301MB0749; 7:wuEzktnUgWeFs1xWdXleHl1Ao2xYK9RJGp8rTwt3T3d12KhNeEMQa3xYY7pkgXu15mCukJswOWyyDYhPXjRGY51pQ3/+iCyUGJcsEbssXTY7JUmuDj/ZAo7cz895f3YjGEGb8HKXIR04ya7KdcXNVlHLpajThd6ihgDdXT9gCtlu5XTFde8OkmMYL6iHtEvG6IhdOAmKGZoabZmwyYzUjMO4G8I5nPpL1xvbyFP72A437BwOHYl2IMvgHZuau+oE4yBzgbd5gGJuONUvmbowx2ivvdx7wBVsx3X9/m/W3xlNCo3f1Tqu7anScPEyL66RlPMnw75PCLl6YX5FxVZvlLIiBSVhJycuoKVktIFBupI= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 11 Nov 2016 08:20:25.3500 (UTC) X-MS-Exchange-CrossTenant-Id: 5afe0b00-7697-4969-b663-5eab37d5f47e X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=5afe0b00-7697-4969-b663-5eab37d5f47e; Ip=[192.88.158.2]; Helo=[az84smr01.freescale.net] X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: DM2PR0301MB0749 X-BeenThere: linuxppc-dev@lists.ozlabs.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: madalin.bucur@nxp.com Cc: pebolle@tiscali.nl, linux-kernel@vger.kernel.org, ppc@mindchasers.com, oss@buserror.net, joe@perches.com, linuxppc-dev@lists.ozlabs.org, davem@davemloft.net Errors-To: linuxppc-dev-bounces+patchwork-incoming=ozlabs.org@lists.ozlabs.org Sender: "Linuxppc-dev" Add a series of counters to be exported through ethtool: - add detailed counters for reception errors; - add detailed counters for QMan enqueue reject events; - count the number of fragmented skbs received from the stack; - count all frames received on the Tx confirmation path; - add congestion group statistics; - count the number of interrupts for each CPU. Signed-off-by: Ioana Ciornei Signed-off-by: Madalin Bucur --- drivers/net/ethernet/freescale/dpaa/dpaa_eth.c | 54 +++++- drivers/net/ethernet/freescale/dpaa/dpaa_eth.h | 33 ++++ drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c | 199 +++++++++++++++++++++ 3 files changed, 284 insertions(+), 2 deletions(-) diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c index 84aa0a77..d59a08c 100644 --- a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c +++ b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c @@ -705,10 +705,15 @@ static void dpaa_eth_cgscn(struct qman_portal *qm, struct qman_cgr *cgr, struct dpaa_priv *priv = (struct dpaa_priv *)container_of(cgr, struct dpaa_priv, cgr_data.cgr); - if (congested) + if (congested) { + priv->cgr_data.congestion_start_jiffies = jiffies; netif_tx_stop_all_queues(priv->net_dev); - else + priv->cgr_data.cgr_congested_count++; + } else { + priv->cgr_data.congested_jiffies += + (jiffies - priv->cgr_data.congestion_start_jiffies); netif_tx_wake_all_queues(priv->net_dev); + } } static int dpaa_eth_cgr_init(struct dpaa_priv *priv) @@ -1222,6 +1227,37 @@ static void dpaa_fd_release(const struct net_device *net_dev, dpaa_bman_release(dpaa_bp, &bmb, 1); } +static void count_ern(struct dpaa_percpu_priv *percpu_priv, + const union qm_mr_entry *msg) +{ + switch (msg->ern.rc & QM_MR_RC_MASK) { + case QM_MR_RC_CGR_TAILDROP: + percpu_priv->ern_cnt.cg_tdrop++; + break; + case QM_MR_RC_WRED: + percpu_priv->ern_cnt.wred++; + break; + case QM_MR_RC_ERROR: + percpu_priv->ern_cnt.err_cond++; + break; + case QM_MR_RC_ORPWINDOW_EARLY: + percpu_priv->ern_cnt.early_window++; + break; + case QM_MR_RC_ORPWINDOW_LATE: + percpu_priv->ern_cnt.late_window++; + break; + case QM_MR_RC_FQ_TAILDROP: + percpu_priv->ern_cnt.fq_tdrop++; + break; + case QM_MR_RC_ORPWINDOW_RETIRED: + percpu_priv->ern_cnt.fq_retired++; + break; + case QM_MR_RC_ORP_ZERO: + percpu_priv->ern_cnt.orp_zero++; + break; + } +} + /* Turn on HW checksum computation for this outgoing frame. * If the current protocol is not something we support in this regard * (or if the stack has already computed the SW checksum), we do nothing. @@ -1887,6 +1923,7 @@ static int dpaa_start_xmit(struct sk_buff *skb, struct net_device *net_dev) likely(skb_shinfo(skb)->nr_frags < DPAA_SGT_MAX_ENTRIES)) { /* Just create a S/G fd based on the skb */ err = skb_to_sg_fd(priv, skb, &fd); + percpu_priv->tx_frag_skbuffs++; } else { /* If the egress skb contains more fragments than we support * we have no choice but to linearize it ourselves. @@ -1923,6 +1960,15 @@ static void dpaa_rx_error(struct net_device *net_dev, percpu_priv->stats.rx_errors++; + if (fd->status & FM_FD_ERR_DMA) + percpu_priv->rx_errors.dme++; + if (fd->status & FM_FD_ERR_PHYSICAL) + percpu_priv->rx_errors.fpe++; + if (fd->status & FM_FD_ERR_SIZE) + percpu_priv->rx_errors.fse++; + if (fd->status & FM_FD_ERR_PRS_HDR_ERR) + percpu_priv->rx_errors.phe++; + dpaa_fd_release(net_dev, fd); } @@ -1978,6 +2024,8 @@ static void dpaa_tx_conf(struct net_device *net_dev, percpu_priv->stats.tx_errors++; } + percpu_priv->tx_confirm++; + skb = dpaa_cleanup_tx_fd(priv, fd); consume_skb(skb); @@ -1992,6 +2040,7 @@ static inline int dpaa_eth_napi_schedule(struct dpaa_percpu_priv *percpu_priv, percpu_priv->np.p = portal; napi_schedule(&percpu_priv->np.napi); + percpu_priv->in_interrupt++; return 1; } return 0; @@ -2176,6 +2225,7 @@ static void egress_ern(struct qman_portal *portal, percpu_priv->stats.tx_dropped++; percpu_priv->stats.tx_fifo_errors++; + count_ern(percpu_priv, msg); skb = dpaa_cleanup_tx_fd(priv, fd); dev_kfree_skb_any(skb); diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.h b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.h index d6ab335..711fb06 100644 --- a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.h +++ b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.h @@ -95,6 +95,25 @@ struct dpaa_bp { atomic_t refs; }; +struct dpaa_rx_errors { + u64 dme; /* DMA Error */ + u64 fpe; /* Frame Physical Error */ + u64 fse; /* Frame Size Error */ + u64 phe; /* Header Error */ +}; + +/* Counters for QMan ERN frames - one counter per rejection code */ +struct dpaa_ern_cnt { + u64 cg_tdrop; /* Congestion group taildrop */ + u64 wred; /* WRED congestion */ + u64 err_cond; /* Error condition */ + u64 early_window; /* Order restoration, frame too early */ + u64 late_window; /* Order restoration, frame too late */ + u64 fq_tdrop; /* FQ taildrop */ + u64 fq_retired; /* FQ is retired */ + u64 orp_zero; /* ORP disabled */ +}; + struct dpaa_napi_portal { struct napi_struct napi; struct qman_portal *p; @@ -104,7 +123,13 @@ struct dpaa_napi_portal { struct dpaa_percpu_priv { struct net_device *net_dev; struct dpaa_napi_portal np; + u64 in_interrupt; + u64 tx_confirm; + /* fragmented (non-linear) skbuffs received from the stack */ + u64 tx_frag_skbuffs; struct rtnl_link_stats64 stats; + struct dpaa_rx_errors rx_errors; + struct dpaa_ern_cnt ern_cnt; }; struct dpaa_buffer_layout { @@ -133,6 +158,14 @@ struct dpaa_priv { * (and the same) congestion group. */ struct qman_cgr cgr; + /* If congested, when it began. Used for performance stats. */ + u32 congestion_start_jiffies; + /* Number of jiffies the Tx port was congested. */ + u32 congested_jiffies; + /* Counter for the number of times the CGR + * entered congestion state + */ + u32 cgr_congested_count; } cgr_data; /* Use a per-port CGR for ingress traffic. */ bool use_ingress_cgr; diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c b/drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c index 3580a62..27e7044 100644 --- a/drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c +++ b/drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c @@ -36,6 +36,42 @@ #include "dpaa_eth.h" #include "mac.h" +static const char dpaa_stats_percpu[][ETH_GSTRING_LEN] = { + "interrupts", + "rx packets", + "tx packets", + "tx confirm", + "tx S/G", + "tx error", + "rx error", +}; + +static char dpaa_stats_global[][ETH_GSTRING_LEN] = { + /* dpa rx errors */ + "rx dma error", + "rx frame physical error", + "rx frame size error", + "rx header error", + + /* demultiplexing errors */ + "qman cg_tdrop", + "qman wred", + "qman error cond", + "qman early window", + "qman late window", + "qman fq tdrop", + "qman fq retired", + "qman orp disabled", + + /* congestion related stats */ + "congestion time (ms)", + "entered congestion", + "congested (0/1)" +}; + +#define DPAA_STATS_PERCPU_LEN ARRAY_SIZE(dpaa_stats_percpu) +#define DPAA_STATS_GLOBAL_LEN ARRAY_SIZE(dpaa_stats_global) + static int dpaa_get_settings(struct net_device *net_dev, struct ethtool_cmd *et_cmd) { @@ -205,6 +241,166 @@ static int dpaa_set_pauseparam(struct net_device *net_dev, return err; } +static int dpaa_get_sset_count(struct net_device *net_dev, int type) +{ + unsigned int total_stats, num_stats; + + num_stats = num_online_cpus() + 1; + total_stats = num_stats * (DPAA_STATS_PERCPU_LEN + DPAA_BPS_NUM) + + DPAA_STATS_GLOBAL_LEN; + + switch (type) { + case ETH_SS_STATS: + return total_stats; + default: + return -EOPNOTSUPP; + } +} + +static void copy_stats(struct dpaa_percpu_priv *percpu_priv, int num_cpus, + int crr_cpu, u64 *bp_count, u64 *data) +{ + int num_values = num_cpus + 1; + int crr = 0, j; + + /* update current CPU's stats and also add them to the total values */ + data[crr * num_values + crr_cpu] = percpu_priv->in_interrupt; + data[crr++ * num_values + num_cpus] += percpu_priv->in_interrupt; + + data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_packets; + data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_packets; + + data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_packets; + data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_packets; + + data[crr * num_values + crr_cpu] = percpu_priv->tx_confirm; + data[crr++ * num_values + num_cpus] += percpu_priv->tx_confirm; + + data[crr * num_values + crr_cpu] = percpu_priv->tx_frag_skbuffs; + data[crr++ * num_values + num_cpus] += percpu_priv->tx_frag_skbuffs; + + data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_errors; + data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_errors; + + data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_errors; + data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_errors; + + for (j = 0; j < DPAA_BPS_NUM; j++) { + data[crr * num_values + crr_cpu] = bp_count[j]; + data[crr++ * num_values + num_cpus] += bp_count[j]; + } +} + +static void dpaa_get_ethtool_stats(struct net_device *net_dev, + struct ethtool_stats *stats, u64 *data) +{ + u64 bp_count[DPAA_BPS_NUM], cg_time, cg_num; + struct dpaa_percpu_priv *percpu_priv; + struct dpaa_rx_errors rx_errors; + unsigned int num_cpus, offset; + struct dpaa_ern_cnt ern_cnt; + struct dpaa_bp *dpaa_bp; + struct dpaa_priv *priv; + int total_stats, i, j; + bool cg_status; + + total_stats = dpaa_get_sset_count(net_dev, ETH_SS_STATS); + priv = netdev_priv(net_dev); + num_cpus = num_online_cpus(); + + memset(&bp_count, 0, sizeof(bp_count)); + memset(&rx_errors, 0, sizeof(struct dpaa_rx_errors)); + memset(&ern_cnt, 0, sizeof(struct dpaa_ern_cnt)); + memset(data, 0, total_stats * sizeof(u64)); + + for_each_online_cpu(i) { + percpu_priv = per_cpu_ptr(priv->percpu_priv, i); + for (j = 0; j < DPAA_BPS_NUM; j++) { + dpaa_bp = priv->dpaa_bps[j]; + if (!dpaa_bp->percpu_count) + continue; + bp_count[j] = *(per_cpu_ptr(dpaa_bp->percpu_count, i)); + } + rx_errors.dme += percpu_priv->rx_errors.dme; + rx_errors.fpe += percpu_priv->rx_errors.fpe; + rx_errors.fse += percpu_priv->rx_errors.fse; + rx_errors.phe += percpu_priv->rx_errors.phe; + + ern_cnt.cg_tdrop += percpu_priv->ern_cnt.cg_tdrop; + ern_cnt.wred += percpu_priv->ern_cnt.wred; + ern_cnt.err_cond += percpu_priv->ern_cnt.err_cond; + ern_cnt.early_window += percpu_priv->ern_cnt.early_window; + ern_cnt.late_window += percpu_priv->ern_cnt.late_window; + ern_cnt.fq_tdrop += percpu_priv->ern_cnt.fq_tdrop; + ern_cnt.fq_retired += percpu_priv->ern_cnt.fq_retired; + ern_cnt.orp_zero += percpu_priv->ern_cnt.orp_zero; + + copy_stats(percpu_priv, num_cpus, i, bp_count, data); + } + + offset = (num_cpus + 1) * (DPAA_STATS_PERCPU_LEN + DPAA_BPS_NUM); + memcpy(data + offset, &rx_errors, sizeof(struct dpaa_rx_errors)); + + offset += sizeof(struct dpaa_rx_errors) / sizeof(u64); + memcpy(data + offset, &ern_cnt, sizeof(struct dpaa_ern_cnt)); + + /* gather congestion related counters */ + cg_num = 0; + cg_status = 0; + cg_time = jiffies_to_msecs(priv->cgr_data.congested_jiffies); + if (qman_query_cgr_congested(&priv->cgr_data.cgr, &cg_status) == 0) { + cg_num = priv->cgr_data.cgr_congested_count; + + /* reset congestion stats (like QMan API does */ + priv->cgr_data.congested_jiffies = 0; + priv->cgr_data.cgr_congested_count = 0; + } + + offset += sizeof(struct dpaa_ern_cnt) / sizeof(u64); + data[offset++] = cg_time; + data[offset++] = cg_num; + data[offset++] = cg_status; +} + +static void dpaa_get_strings(struct net_device *net_dev, u32 stringset, + u8 *data) +{ + unsigned int i, j, num_cpus, size; + char string_cpu[ETH_GSTRING_LEN]; + u8 *strings; + + memset(string_cpu, 0, sizeof(string_cpu)); + strings = data; + num_cpus = num_online_cpus(); + size = DPAA_STATS_GLOBAL_LEN * ETH_GSTRING_LEN; + + for (i = 0; i < DPAA_STATS_PERCPU_LEN; i++) { + for (j = 0; j < num_cpus; j++) { + snprintf(string_cpu, ETH_GSTRING_LEN, "%s [CPU %d]", + dpaa_stats_percpu[i], j); + memcpy(strings, string_cpu, ETH_GSTRING_LEN); + strings += ETH_GSTRING_LEN; + } + snprintf(string_cpu, ETH_GSTRING_LEN, "%s [TOTAL]", + dpaa_stats_percpu[i]); + memcpy(strings, string_cpu, ETH_GSTRING_LEN); + strings += ETH_GSTRING_LEN; + } + for (i = 0; i < DPAA_BPS_NUM; i++) { + for (j = 0; j < num_cpus; j++) { + snprintf(string_cpu, ETH_GSTRING_LEN, + "bpool %c [CPU %d]", 'a' + i, j); + memcpy(strings, string_cpu, ETH_GSTRING_LEN); + strings += ETH_GSTRING_LEN; + } + snprintf(string_cpu, ETH_GSTRING_LEN, "bpool %c [TOTAL]", + 'a' + i); + memcpy(strings, string_cpu, ETH_GSTRING_LEN); + strings += ETH_GSTRING_LEN; + } + memcpy(strings, dpaa_stats_global, size); +} + const struct ethtool_ops dpaa_ethtool_ops = { .get_settings = dpaa_get_settings, .set_settings = dpaa_set_settings, @@ -215,4 +411,7 @@ const struct ethtool_ops dpaa_ethtool_ops = { .get_pauseparam = dpaa_get_pauseparam, .set_pauseparam = dpaa_set_pauseparam, .get_link = ethtool_op_get_link, + .get_sset_count = dpaa_get_sset_count, + .get_ethtool_stats = dpaa_get_ethtool_stats, + .get_strings = dpaa_get_strings, };