From patchwork Mon Jan 28 23:44:54 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032319 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="Q9+uQZ1d"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR8c1Kt9z9sDK for ; Tue, 29 Jan 2019 10:45:52 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727171AbfA1Xpv (ORCPT ); Mon, 28 Jan 2019 18:45:51 -0500 Received: from mail-qk1-f194.google.com ([209.85.222.194]:34463 "EHLO mail-qk1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726746AbfA1Xpt (ORCPT ); Mon, 28 Jan 2019 18:45:49 -0500 Received: by mail-qk1-f194.google.com with SMTP id q8so10537930qke.1 for ; Mon, 28 Jan 2019 15:45:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=yZeRmIFd8ICXkWcdnTwJoB1P6cUI/ku+Px23SvmLDho=; b=Q9+uQZ1dhafO4f2flzWb55PEjJflPHFyaj/+LvtzI6kHkNUhtfk8JUSrLeqpeFA7rU Sb6Rf7FnqEe71wa29fTPlNTZpIbdiiWjZzI+HI9Or7pmVwHNdVeUx/Gz2jkrsGd+YLF4 K9mRhnd8BD9du4PeV8+RtbrwdgpLBGG8mOUrLVuMD6rjoBWsaa2uSP8+jsTwx++cTDfO HDuDHL+TJYDz7UivAFIzlnj/td3tf39tXvZD6wlddugTRsMK4Q3Jg0q6Mcc/7hBpOqD4 j3kSMEoTEBM10aypr/D0FEWzO6HuHGTBfikNxxSRki0sKYlLVcmdE6MXrji29ZPaeysS /D9Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=yZeRmIFd8ICXkWcdnTwJoB1P6cUI/ku+Px23SvmLDho=; b=lhFKqOImL1yA5dj6JgFjqaskUQvZ+3o8fJ/Z5Nn5MxPcFBReSPkf7HiGVJEDqsiEos xO7gPPCLfR8q1p5Uz7Qh3I6ELCtDPPYdh8IcYmrC/qfs4olhAYVKee56woBfWtQmL05s 6N7ybrTQ7AKz1fTd0xIVbCSF18fvsSlrJs4N3gGxr6nwny3i89rPdpqTe3/GV87KxIbJ dJcM8eDLxvCZm1b7jAYIFKikWzQJKSssTORbQ0oCaY/p8PGGmmXNtcTf9520lKjZMBhL sp/GG/tvG4IhmmIrgKiASpPYsPgtFndG9zg14H1Z2kEEIlpfzGvDxULoUckKcAGAcidK /ZXg== X-Gm-Message-State: AJcUukeA6eZDe8VcVcvXJUmT783kD27TgKAY5/uNMkcbdwIWKOePKIY0 uNwFyIn0CXFHs85+c5opbAfJ1A== X-Google-Smtp-Source: ALg8bN6XzKdla2g4WkoNK78ptUtNri6CM4g8CivUYedRLwrDGPRZVRJyrkID6dFN/NI6PXIFSFBWzw== X-Received: by 2002:a37:553:: with SMTP id 80mr22036510qkf.200.1548719148772; Mon, 28 Jan 2019 15:45:48 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.45.46 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:45:48 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 01/14] nfp: remove unused structure Date: Mon, 28 Jan 2019 15:44:54 -0800 Message-Id: <20190128234507.32028-2-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Remove struct nfp_pair, it used to be used for TC BPF offload, but now we only offload direct action mode which doesn't have explicit stats. Signed-off-by: Jakub Kicinski --- drivers/net/ethernet/netronome/nfp/nfp_net.h | 5 ----- 1 file changed, 5 deletions(-) diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net.h b/drivers/net/ethernet/netronome/nfp/nfp_net.h index be37c2d6151c..320ec3900a32 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_net.h +++ b/drivers/net/ethernet/netronome/nfp/nfp_net.h @@ -447,11 +447,6 @@ static inline bool nfp_net_fw_ver_eq(struct nfp_net_fw_version *fw_ver, fw_ver->minor == minor; } -struct nfp_stat_pair { - u64 pkts; - u64 bytes; -}; - /** * struct nfp_net_dp - NFP network device datapath data structure * @dev: Backpointer to struct device From patchwork Mon Jan 28 23:44:55 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032320 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="vZwRlpGu"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR8f6C85z9s9h for ; Tue, 29 Jan 2019 10:45:54 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727267AbfA1Xpx (ORCPT ); Mon, 28 Jan 2019 18:45:53 -0500 Received: from mail-qk1-f196.google.com ([209.85.222.196]:33601 "EHLO mail-qk1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726746AbfA1Xpw (ORCPT ); Mon, 28 Jan 2019 18:45:52 -0500 Received: by mail-qk1-f196.google.com with SMTP id d15so10548107qkj.0 for ; Mon, 28 Jan 2019 15:45:51 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ghTfldg2HtgRJGQ+1zRaxHR2e2RsGZkoDuLu7LfqW2A=; b=vZwRlpGu2mgVvG55FIA5gxtSbaOLeH3yxWFFA/NQSGZpFrM2YeV21VT3CsKC29E0NR OS366enSW//mojFLGuU6VxPgpi/FG6iTjsi6gLcLkMmaiupjEomhtvRA4ShXIUMsuWNG 96XC040Rl0jhzDDgB3zFmSVSBE5ijp/kUOpkAWxoMYKz0s3TQZFE8nCiwdrDVcOKHAfd OeJEbU4dPcf6LEXb6KN97OYP5uRldi7KVHAEXZqF3tEl6erK/7HhU+hE4/lmxiEH1iOY M2VvFRMiRe0PxpsErUCwgnaJLe2bHlQZ737HwM+laG7WlG0b1bKNqu5wYgA+2YJjegGK x7+g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ghTfldg2HtgRJGQ+1zRaxHR2e2RsGZkoDuLu7LfqW2A=; b=LW25bbwZwJTmWbpgpN79V9iyq7guWK9FIsxJ/DhJcqSmwWQ1HjQfUEbd9xOtRgIRs3 zxGKqody+TjhaSd95nMBt3movxkCPrJtutT7hAF83qQFsxPDPTifBZf2ktrtGSKHxz1k yqF0FOKuzcayMJodyids8kWctHHIBF/uAkQf/bELIKul0NtGaB6MO33Z6tff6Z3yeQRs k9QUtrcn1CeWhhxVJfNvfBNATUfNbeMMZJS4QwTAJHAlJ0dN0+MQs8zV92lENLNz/0Da KFRkRNavaC1yDMy5xmN9ZYIdOmYpD2uq3jC6fOequewJ5EgCWeMnUsRjBLSbYwQS/U+4 0/Gg== X-Gm-Message-State: AJcUukfWM9Guj+3qx8ZtHDZ3L3E96WvlePvqjK2LuxBYXim0q97e2XXC Ou0OxNPJltOLstbzqJDTaM4HbQ== X-Google-Smtp-Source: ALg8bN5I16+obkXZ2dvJAy9839AgzLDkT3zjTKOhdgBjLwlxXiveuD8g+8h+W8becH1yRXP0JajJIw== X-Received: by 2002:a37:8d81:: with SMTP id p123mr21235169qkd.241.1548719151085; Mon, 28 Jan 2019 15:45:51 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.45.48 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:45:50 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 02/14] nfp: constify parameter to nfp_port_from_netdev() Date: Mon, 28 Jan 2019 15:44:55 -0800 Message-Id: <20190128234507.32028-3-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Make nfp_port_from_netdev() take a const parameter, otherwise it can't be used with upcoming stats code. Signed-off-by: Jakub Kicinski --- drivers/net/ethernet/netronome/nfp/nfp_net.h | 2 +- drivers/net/ethernet/netronome/nfp/nfp_net_repr.h | 2 +- drivers/net/ethernet/netronome/nfp/nfp_port.c | 2 +- drivers/net/ethernet/netronome/nfp/nfp_port.h | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net.h b/drivers/net/ethernet/netronome/nfp/nfp_net.h index 320ec3900a32..93de25b39bc1 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_net.h +++ b/drivers/net/ethernet/netronome/nfp/nfp_net.h @@ -839,7 +839,7 @@ extern const char nfp_driver_version[]; extern const struct net_device_ops nfp_net_netdev_ops; -static inline bool nfp_netdev_is_nfp_net(struct net_device *netdev) +static inline bool nfp_netdev_is_nfp_net(const struct net_device *netdev) { return netdev->netdev_ops == &nfp_net_netdev_ops; } diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_repr.h b/drivers/net/ethernet/netronome/nfp/nfp_net_repr.h index e0f13dfe1f39..7f2df74c2a7f 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_net_repr.h +++ b/drivers/net/ethernet/netronome/nfp/nfp_net_repr.h @@ -75,7 +75,7 @@ enum nfp_repr_type { extern const struct net_device_ops nfp_repr_netdev_ops; -static inline bool nfp_netdev_is_nfp_repr(struct net_device *netdev) +static inline bool nfp_netdev_is_nfp_repr(const struct net_device *netdev) { return netdev->netdev_ops == &nfp_repr_netdev_ops; } diff --git a/drivers/net/ethernet/netronome/nfp/nfp_port.c b/drivers/net/ethernet/netronome/nfp/nfp_port.c index 86bc149ca231..81a23f9bdfc0 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_port.c +++ b/drivers/net/ethernet/netronome/nfp/nfp_port.c @@ -12,7 +12,7 @@ #include "nfp_net.h" #include "nfp_port.h" -struct nfp_port *nfp_port_from_netdev(struct net_device *netdev) +struct nfp_port *nfp_port_from_netdev(const struct net_device *netdev) { if (nfp_netdev_is_nfp_net(netdev)) { struct nfp_net *nn = netdev_priv(netdev); diff --git a/drivers/net/ethernet/netronome/nfp/nfp_port.h b/drivers/net/ethernet/netronome/nfp/nfp_port.h index b2479a2a49e5..24de9250d564 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_port.h +++ b/drivers/net/ethernet/netronome/nfp/nfp_port.h @@ -105,7 +105,7 @@ static inline bool nfp_port_is_vnic(const struct nfp_port *port) int nfp_port_set_features(struct net_device *netdev, netdev_features_t features); -struct nfp_port *nfp_port_from_netdev(struct net_device *netdev); +struct nfp_port *nfp_port_from_netdev(const struct net_device *netdev); struct nfp_port * nfp_port_from_id(struct nfp_pf *pf, enum nfp_port_type type, unsigned int id); struct nfp_eth_table_port *__nfp_port_get_eth_port(struct nfp_port *port); From patchwork Mon Jan 28 23:44:56 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032321 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="xefCVwEl"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR8k0ygbz9s9h for ; Tue, 29 Jan 2019 10:45:57 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727323AbfA1Xp4 (ORCPT ); Mon, 28 Jan 2019 18:45:56 -0500 Received: from mail-qk1-f193.google.com ([209.85.222.193]:44199 "EHLO mail-qk1-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726746AbfA1Xpz (ORCPT ); Mon, 28 Jan 2019 18:45:55 -0500 Received: by mail-qk1-f193.google.com with SMTP id o8so10489431qkk.11 for ; Mon, 28 Jan 2019 15:45:54 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=SNHKGqL5e2qmNnwkPGLlUC1NaWET707PnhYho+tCH48=; b=xefCVwElZZc8TnzR643OEkYQSMxbNjcdm3avP4Vy2rSfaSrYeFI7miJSqYS88G4esD i7RraBF+MVuBtLqI3dsyCF6NE8IgT0MTUOz//uway8O8XjozqnbwkDfG8gIY5xN1lBpq VPqszy93Cyf9/FoTOHbGqpSZPv50HnLrcaHny9cq15ygbDsQwqatY3nc6Y6zr9cUj96/ 9vt0NuyfHa+SCZfc6U587HOkLpuQUjdQaEBrxXC37lU/UjYPCwghZSvcLiBZkrXjtQFK IdjuByJn3LvdWHfD41BsP7Ox2sq8XZ7kN4B4qX4/Hj8GMtEwVP4nc6qlRk3fImeyN4R+ tRdw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=SNHKGqL5e2qmNnwkPGLlUC1NaWET707PnhYho+tCH48=; b=QCSUac7ZspHzxDD7F6IY+A/A/U/Xsmig9VxsoaZs2vT2X8YKgmqH+z/B0xNmNvSPAt doJg+LCYDyxgnB1ugNRVKhaRurpQe1TJTll5fLcIaVDvFZxV+I8Hex2AMEAOMmttSYqG prNyWqhhAo7hFwtMnq7K8ChwIY2dJkPmoM1+7flLSpLZ8UVxDlnV9Afw03yH10k+Omwv zWNsXAEToJtw1Gmnj7D4VRCeBp5jMS9D3JAXpbjrcsn1BGOsmw2R23b2b88QrRcOOwvu kTAIc9Tue/KQWw1WmAkNl2hm773dNWrC86/wfJH3ysgZq80p3V4fOPq/btzd4KSZMBEY 4pxw== X-Gm-Message-State: AJcUuke5unaTZZIhQwtFNz5WjxfvfWli2Twa0WAhEccTN5Q1j5Nl3eUp gN5z7/8khDj34STVvsxLyOUhFw== X-Google-Smtp-Source: ALg8bN71UGiVfkhGNqL6pH9hisHaWR+sygJlg6LLfxgbRpZDB8dp9b0uSkjuFBuELmS+AcJZumtlHg== X-Received: by 2002:a37:9a48:: with SMTP id c69mr20443419qke.51.1548719153713; Mon, 28 Jan 2019 15:45:53 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.45.51 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:45:53 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 03/14] net: hstats: add basic/core functionality Date: Mon, 28 Jan 2019 15:44:56 -0800 Message-Id: <20190128234507.32028-4-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add basic hierarchical stats. For now there is no hierarchies or other fancy features. An ndo is added, and drivers can return multiple groups of stats by adding the to them dump with rtnl_hstat_add_grp(). Each group has attributes (qualifiers) which designate the direction of the statistic (TX vs RX) and the source (device vs driver). A handful of common statistics maintained by Linux drivers is added. Dumping machinery is a little involved to make extensions easy. A simple stack-based machine is employed which will in due course help keep tracking of children and iteration over classifiers. Signed-off-by: Jakub Kicinski --- include/linux/netdevice.h | 9 + include/net/hstats.h | 94 +++++++ include/uapi/linux/if_link.h | 45 ++++ net/core/Makefile | 2 +- net/core/hstats.c | 497 +++++++++++++++++++++++++++++++++++ net/core/rtnetlink.c | 21 ++ 6 files changed, 667 insertions(+), 1 deletion(-) create mode 100644 include/net/hstats.h create mode 100644 net/core/hstats.c diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h index e675ef97a426..9f16036312f9 100644 --- a/include/linux/netdevice.h +++ b/include/linux/netdevice.h @@ -941,6 +941,8 @@ struct dev_ifalias { char ifalias[]; }; +struct rtnl_hstat_req; + /* * This structure defines the management hooks for network devices. * The following hooks can be defined; unless noted otherwise, they are @@ -1245,6 +1247,11 @@ struct dev_ifalias { * that got dropped are freed/returned via xdp_return_frame(). * Returns negative number, means general error invoking ndo, meaning * no frames were xmit'ed and core-caller will free all frames. + * int (*ndo_hstat_get_groups)(const struct net_device *dev, + * struct rtnl_hstat_req *req); + * This function is used to retrieve driver's groups of hierarchical stats. + * Driver should use rtnl_hstat_add_grp() to report its groups. + * See Documentation/networking/hstats.rst for details. */ struct net_device_ops { int (*ndo_init)(struct net_device *dev); @@ -1441,6 +1448,8 @@ struct net_device_ops { u32 flags); int (*ndo_xsk_async_xmit)(struct net_device *dev, u32 queue_id); + int (*ndo_hstat_get_groups)(const struct net_device *dev, + struct rtnl_hstat_req *req); }; /** diff --git a/include/net/hstats.h b/include/net/hstats.h new file mode 100644 index 000000000000..c2e8b379237a --- /dev/null +++ b/include/net/hstats.h @@ -0,0 +1,94 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +/* Copyright (C) 2019 Netronome Systems, Inc. */ + +#ifndef _NET_HSTATS_H +#define _NET_HSTATS_H + +#include +#include +#include + +struct net_device; +struct sk_buff; + +/* Internal driver/core qualifiers used as indexes in qualifier tables + * and translated into IFLA_HSTATS_QUAL_* in dumps. + */ +enum { + RTNL_HSTATS_QUAL_TYPE, + RTNL_HSTATS_QUAL_DIRECTION, + + RTNL_HSTATS_QUAL_CNT +}; + +struct hstat_dumper; +struct rtnl_hstat_group; + +struct rtnl_hstat_req { + int err; + struct sk_buff *skb; + struct hstat_dumper *dumper; +}; + +struct rtnl_hstat_qualifier { + unsigned int constant; +}; + +/** + * struct rtnl_hstat_group - node in the hstat hierarchy + * @qualifiers: attributes describing this group + * @stats_cnt: number of stats in the bitmask + * @stats: bitmask of stats present + * @get_stats: driver callback for dumping the stats + */ +struct rtnl_hstat_group { + /* Note: this is *not* indexed with IFLA_* attributes! */ + struct rtnl_hstat_qualifier qualifiers[RTNL_HSTATS_QUAL_CNT]; + /* Can't use bitmaps - words are variable length */ + unsigned int stats_cnt; + u64 stats[DIV_ROUND_UP(IFLA_HSTATS_STAT_MAX + 1, 64)]; + int (*get_stats)(struct net_device *dev, struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp); +}; + +void rtnl_hstat_add_grp(struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp); + +static inline void +rtnl_hstat_dump(struct rtnl_hstat_req *req, const int id, const u64 val) +{ + if (req->err) + return; + if (nla_put_u64_64bit(req->skb, id, val, IFLA_HSTATS_STAT_UNSPEC)) + req->err = -EMSGSIZE; +} + +size_t rtnl_get_link_hstats_size(const struct net_device *dev); +size_t rtnl_get_link_hstats(struct sk_buff *skb, struct net_device *dev, + int *prividx); + +enum { +#define RTNL_HSTAT_BIT(_name, _word) \ + RTNL_HSTATS_STAT_ ## _name ## _BIT = \ + BIT_ULL(IFLA_HSTATS_STAT_ ## _name - 1 - ((_word) * 64)) + + /* Common Linux stats */ + RTNL_HSTAT_BIT(LINUX_PKTS, 0), + RTNL_HSTAT_BIT(LINUX_BYTES, 0), + RTNL_HSTAT_BIT(LINUX_BUSY, 0), + RTNL_HSTAT_BIT(LINUX_CSUM_PARTIAL, 0), + RTNL_HSTAT_BIT(LINUX_CSUM_COMPLETE, 0), + RTNL_HSTAT_BIT(LINUX_CSUM_UNNECESSARY, 0), + RTNL_HSTAT_BIT(LINUX_SEGMENTATION_OFFLOAD_PKTS, 0), +#undef RTNL_HSTAT_BIT +}; + +/* Helper defines for common qualifier sets */ +#define RTNL_HSTATS_QUALS_BASIC(type, dir) \ + [RTNL_HSTATS_QUAL_TYPE] = { \ + .constant = IFLA_HSTATS_QUAL_TYPE_ ##type, \ + }, \ + [RTNL_HSTATS_QUAL_DIRECTION] = { \ + .constant = IFLA_HSTATS_QUAL_DIR_ ##dir, \ + } +#endif diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h index 5b225ff63b48..55fcef81e142 100644 --- a/include/uapi/linux/if_link.h +++ b/include/uapi/linux/if_link.h @@ -910,6 +910,7 @@ enum { IFLA_STATS_LINK_XSTATS_SLAVE, IFLA_STATS_LINK_OFFLOAD_XSTATS, IFLA_STATS_AF_SPEC, + IFLA_STATS_LINK_HSTATS, __IFLA_STATS_MAX, }; @@ -938,6 +939,50 @@ enum { }; #define IFLA_OFFLOAD_XSTATS_MAX (__IFLA_OFFLOAD_XSTATS_MAX - 1) +/* These are embedded into IFLA_STATS_LINK_HSTATS: + * See Documentation/networking/hstats.rst for details. + */ +enum { + IFLA_HSTATS_UNSPEC, + IFLA_HSTATS_GROUP, + IFLA_HSTATS_STATS, + IFLA_HSTATS_QUAL_TYPE, + IFLA_HSTATS_QUAL_DIRECTION, + __IFLA_HSTATS_MAX, +}; +#define IFLA_HSTATS_MAX (__IFLA_HSTATS_MAX - 1) + +enum { + IFLA_HSTATS_QUAL_TYPE_UNSPEC, + IFLA_HSTATS_QUAL_TYPE_DEV, + IFLA_HSTATS_QUAL_TYPE_DRV, + __IFLA_HSTATS_QUAL_TYPE_MAX, +}; +#define IFLA_HSTATS_QUAL_TYPE_MAX (__IFLA_HSTATS_QUAL_TYPE_MAX - 1) + +enum { + IFLA_HSTATS_QUAL_DIR_UNSPEC, + IFLA_HSTATS_QUAL_DIR_RX, + IFLA_HSTATS_QUAL_DIR_TX, + __IFLA_HSTATS_QUAL_DIR_MAX, +}; +#define IFLA_HSTATS_QUAL_DIR_MAX (__IFLA_HSTATS_QUAL_DIR_MAX - 1) + +enum { + IFLA_HSTATS_STAT_UNSPEC, + /* Common statistics */ + IFLA_HSTATS_STAT_LINUX_PKTS, /* 0 */ + IFLA_HSTATS_STAT_LINUX_BYTES, + IFLA_HSTATS_STAT_LINUX_BUSY, + IFLA_HSTATS_STAT_LINUX_CSUM_PARTIAL, + IFLA_HSTATS_STAT_LINUX_CSUM_COMPLETE, + IFLA_HSTATS_STAT_LINUX_CSUM_UNNECESSARY, + IFLA_HSTATS_STAT_LINUX_SEGMENTATION_OFFLOAD_PKTS, + + __IFLA_HSTATS_STAT_MAX, +}; +#define IFLA_HSTATS_STAT_MAX (__IFLA_HSTATS_STAT_MAX - 1) + /* XDP section */ #define XDP_FLAGS_UPDATE_IF_NOEXIST (1U << 0) diff --git a/net/core/Makefile b/net/core/Makefile index fccd31e0e7f7..30635dfbbe9b 100644 --- a/net/core/Makefile +++ b/net/core/Makefile @@ -11,7 +11,7 @@ obj-$(CONFIG_SYSCTL) += sysctl_net_core.o obj-y += dev.o ethtool.o dev_addr_lists.o dst.o netevent.o \ neighbour.o rtnetlink.o utils.o link_watch.o filter.o \ sock_diag.o dev_ioctl.o tso.o sock_reuseport.o \ - fib_notifier.o xdp.o + fib_notifier.o xdp.o hstats.o obj-y += net-sysfs.o obj-$(CONFIG_PAGE_POOL) += page_pool.o diff --git a/net/core/hstats.c b/net/core/hstats.c new file mode 100644 index 000000000000..183a1c5dd93a --- /dev/null +++ b/net/core/hstats.c @@ -0,0 +1,497 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +/* Copyright (C) 2019 Netronome Systems, Inc. */ + +#include +#include +#include +#include +#include +#include +#include + +/* We deploy a simple stack-based dumper to walk the hierarchies. + * This is the documentation format for quick analysis of the state machine: + * + * Header (in case there are move than one possibility): + * + * o | direct action 1 \ __ these are performed by the code + * r | direct action 2 / + * d | -------------- + * e | | STACK CMD 1 | \ __ these are popped from the stack and run + * r v | STACK CMD 2 | / in order after current handler completes + * ============== <---- top of the stack before current handler + */ +enum hstat_dumper_cmd { + /* open grp + * put const quals + * --------------- + * | DUMP STATS | + * | CLOSE grp | + * =============== + */ + HSTAT_DCMD_GRP_LOAD, + /* dump all statitics + */ + HSTAT_DCMD_GRP_DUMP, + /* close grp */ + HSTAT_DCMD_GRP_CLOSE, + /* count root group (netlink restart index) */ + HSTAT_DCMD_ROOT_GRP_DONE, +}; + +struct hstat_dumper { + struct sk_buff *skb; + struct net_device *dev; + /* For sizing we only have a const pointer to dev */ + const struct net_device *const_dev; + int err; + + /* For calculating skb size */ + bool sizing; + size_t size; + + int current_root_grp; + int last_completed_root_grp; + + u8 *cmd_stack; + size_t cmd_stack_top; + size_t cmd_stack_len; +}; + +struct hstat_dumper_cmd_simple { + u64 cmd; +}; + +struct hstat_dumper_cmd_grp_load { + const struct rtnl_hstat_group *grp; + u64 cmd; +}; + +struct hstat_dumper_cmd_grp_dump { + const struct rtnl_hstat_group *grp; + u64 cmd; +}; + +struct hstat_dumper_cmd_grp_close { + struct nlattr *nl_attr; + u64 cmd; +}; + +/* RTNL helpers */ +static const int rtnl_qual2ifla[RTNL_HSTATS_QUAL_CNT] = { + [RTNL_HSTATS_QUAL_TYPE] = IFLA_HSTATS_QUAL_TYPE, + [RTNL_HSTATS_QUAL_DIRECTION] = IFLA_HSTATS_QUAL_DIRECTION, +}; + +static bool rtnl_hstat_qualifier_present(const struct rtnl_hstat_qualifier *q) +{ + return q->constant; +} + +/* Dumper basics */ +static u64 hstat_dumper_peek_cmd(struct hstat_dumper *dumper) +{ + return *(u64 *)(dumper->cmd_stack + dumper->cmd_stack_top - 8); +} + +static int hstat_dumper_discard(struct hstat_dumper *dumper, size_t len) +{ + if (WARN_ON_ONCE(dumper->cmd_stack_top < len)) + return -EINVAL; + dumper->cmd_stack_top -= len; + return 0; +} + +static int hstat_dumper_pop(struct hstat_dumper *dumper, void *dst, size_t len) +{ + if (WARN_ON_ONCE(dumper->cmd_stack_top < len)) + return -EINVAL; + dumper->cmd_stack_top -= len; + memcpy(dst, dumper->cmd_stack + dumper->cmd_stack_top, len); + return 0; +} + +static bool hstat_dumper_done(struct hstat_dumper *dumper) +{ + return !dumper->cmd_stack_top; +} + +static int hstat_dumper_error(struct hstat_dumper *dumper) +{ + if (WARN_ON_ONCE(dumper->cmd_stack_top && dumper->cmd_stack_top < 8)) + return -EINVAL; + return 0; +} + +static struct hstat_dumper * +hstat_dumper_init(struct sk_buff *skb, const struct net_device *const_dev, + struct net_device *dev, int *prividx) +{ + struct hstat_dumper *dumper; + + dumper = kzalloc(sizeof(*dumper), GFP_KERNEL); + if (!dumper) + return NULL; + dumper->cmd_stack = kmalloc(8096, GFP_KERNEL); + if (!dumper->cmd_stack) { + kfree(dumper); + return NULL; + } + dumper->cmd_stack_len = 8096; + + dumper->skb = skb; + dumper->dev = dev; + dumper->const_dev = const_dev; + if (prividx) + dumper->last_completed_root_grp = *prividx; + else + dumper->sizing = true; + + return dumper; +} + +static void hstat_dumper_destroy(struct hstat_dumper *dumper) +{ + kfree(dumper->cmd_stack); + kfree(dumper); +} + +/* Dumper pushers */ +static int +__hstat_dumper_push_cmd(struct hstat_dumper *dumper, void *data, size_t len) +{ + /* All structures pushed must be multiple of 8 w/ cmd as last member */ + if (WARN_ON_ONCE(len % 8)) + return -EINVAL; + + while (dumper->cmd_stack_len - dumper->cmd_stack_top < len) { + void *st; + + st = krealloc(dumper->cmd_stack, dumper->cmd_stack_len * 2, + GFP_KERNEL); + if (!st) + return -ENOMEM; + + dumper->cmd_stack = st; + dumper->cmd_stack_len *= 2; + } + + memcpy(dumper->cmd_stack + dumper->cmd_stack_top, data, len); + dumper->cmd_stack_top += len; + return 0; +} + +static int +hstat_dumper_push_grp_load(struct hstat_dumper *dumper, + const struct rtnl_hstat_group *grp) +{ + struct hstat_dumper_cmd_grp_load cmd = { + .cmd = HSTAT_DCMD_GRP_LOAD, + .grp = grp, + }; + + return __hstat_dumper_push_cmd(dumper, &cmd, sizeof(cmd)); +} + +static int +hstat_dumper_push_dump(struct hstat_dumper *dumper, + const struct rtnl_hstat_group *grp) +{ + struct hstat_dumper_cmd_grp_dump cmd = { + .cmd = HSTAT_DCMD_GRP_DUMP, + .grp = grp, + }; + + return __hstat_dumper_push_cmd(dumper, &cmd, sizeof(cmd)); +} + +static int +hstat_dumper_push_grp_close(struct hstat_dumper *dumper, struct nlattr *nl_grp) +{ + struct hstat_dumper_cmd_grp_close cmd = { + .cmd = HSTAT_DCMD_GRP_CLOSE, + .nl_attr = nl_grp, + }; + + return __hstat_dumper_push_cmd(dumper, &cmd, sizeof(cmd)); +} + +static int +hstat_dumper_push_root_grp_done(struct hstat_dumper *dumper) +{ + struct hstat_dumper_cmd_simple cmd = { HSTAT_DCMD_ROOT_GRP_DONE }; + + return __hstat_dumper_push_cmd(dumper, &cmd, sizeof(cmd)); +} + +/* Dumper actions */ +static int hstat_dumper_open_grp(struct hstat_dumper *dumper) +{ + struct nlattr *nl_grp; + int err; + + if (dumper->sizing) { + dumper->size += nla_total_size(0); /* IFLA_HSTATS_GROUP */ + return 0; + } + + /* Open group nlattr and push onto the stack a close command */ + nl_grp = nla_nest_start(dumper->skb, IFLA_HSTATS_GROUP); + if (!nl_grp) + return -EMSGSIZE; + + err = hstat_dumper_push_grp_close(dumper, nl_grp); + if (err) { + nla_nest_cancel(dumper->skb, nl_grp); + return err; + } + + return 0; +} + +static int +hstat_dumper_grp_put_stats(struct hstat_dumper *dumper, + const struct rtnl_hstat_group *grp) +{ + struct rtnl_hstat_req dump_req; + struct nlattr *nl_stats; + int err; + + WARN_ON_ONCE(!grp->stats_cnt != !grp->get_stats); + + if (!grp->stats_cnt) + return 0; + + if (dumper->sizing) { + dumper->size += nla_total_size(0); + dumper->size += grp->stats_cnt * nla_total_size(8); + return 0; + } + + nl_stats = nla_nest_start(dumper->skb, IFLA_HSTATS_STATS); + if (!nl_stats) + return -EMSGSIZE; + + memset(&dump_req, 0, sizeof(dump_req)); + dump_req.dumper = dumper; + dump_req.skb = dumper->skb; + + err = grp->get_stats(dumper->dev, &dump_req, grp); + if (err) + goto err_cancel_stats; + err = dump_req.err; + if (err) + goto err_cancel_stats; + + nla_nest_end(dumper->skb, nl_stats); + return 0; + +err_cancel_stats: + nla_nest_cancel(dumper->skb, nl_stats); + return err; +} + +static int +hstat_dumper_put_qual(struct hstat_dumper *dumper, int i, u32 val) +{ + if (dumper->sizing) { + dumper->size += nla_total_size(sizeof(u32)); + return 0; + } + + return nla_put_u32(dumper->skb, rtnl_qual2ifla[i], val); +} + +/* Dumper handlers */ +static int hstat_dumper_grp_load(struct hstat_dumper *dumper) +{ + struct hstat_dumper_cmd_grp_load cmd; + int i, err; + + err = hstat_dumper_pop(dumper, &cmd, sizeof(cmd)); + if (err) + return err; + if (dumper->err) + return 0; + + if (dumper->current_root_grp < dumper->last_completed_root_grp) + return 0; + + err = hstat_dumper_open_grp(dumper); + if (err) + return err; + + for (i = 0; i < RTNL_HSTATS_QUAL_CNT; i++) { + const struct rtnl_hstat_qualifier *q; + + q = &cmd.grp->qualifiers[i]; + if (!rtnl_hstat_qualifier_present(q)) + continue; + + if (q->constant) { + err = hstat_dumper_put_qual(dumper, i, q->constant); + if (err) + return err; + } + } + + return hstat_dumper_push_dump(dumper, cmd.grp); +} + +static int hstat_dumper_grp_dump(struct hstat_dumper *dumper) +{ + struct hstat_dumper_cmd_grp_dump cmd; + int err; + + err = hstat_dumper_pop(dumper, &cmd, sizeof(cmd)); + if (err) + return err; + if (dumper->err) + return 0; + + err = hstat_dumper_grp_put_stats(dumper, cmd.grp); + if (err) + return err; + + return 0; +} + +static int hstat_dumper_grp_close(struct hstat_dumper *dumper) +{ + struct hstat_dumper_cmd_grp_close cmd; + int err; + + err = hstat_dumper_pop(dumper, &cmd, sizeof(cmd)); + if (err) + return err; + + if (!dumper->err) + nla_nest_end(dumper->skb, cmd.nl_attr); + else + nla_nest_cancel(dumper->skb, cmd.nl_attr); + return 0; +} + +static int hstat_dumper_root_grp_done(struct hstat_dumper *dumper) +{ + int err; + + err = hstat_dumper_discard(dumper, sizeof(u64)); + if (err) + return err; + if (dumper->err) + return 0; + + dumper->current_root_grp++; + return 0; +} + +static int hstat_dumper_run(struct hstat_dumper *dumper) +{ + do { + int err; + u64 cmd; + + err = hstat_dumper_error(dumper); + if (err) + return err; + if (hstat_dumper_done(dumper)) + return 0; + + cmd = hstat_dumper_peek_cmd(dumper); + switch (cmd) { + case HSTAT_DCMD_ROOT_GRP_DONE: + err = hstat_dumper_root_grp_done(dumper); + break; + case HSTAT_DCMD_GRP_LOAD: + err = hstat_dumper_grp_load(dumper); + break; + case HSTAT_DCMD_GRP_CLOSE: + err = hstat_dumper_grp_close(dumper); + break; + case HSTAT_DCMD_GRP_DUMP: + err = hstat_dumper_grp_dump(dumper); + break; + } + if (err && !dumper->err) + /* Record the errror hand keep invoking handlers, + * handlers will see the error and only do clean up. + */ + dumper->err = err; + } while (true); + + return dumper->err; +} + +/* Driver helpers */ +void +rtnl_hstat_add_grp(struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) +{ + if (!req->err) + req->err = hstat_dumper_push_root_grp_done(req->dumper); + if (!req->err) + req->err = hstat_dumper_push_grp_load(req->dumper, grp); +} +EXPORT_SYMBOL(rtnl_hstat_add_grp); + +/* Stack call points */ +static size_t +__rtnl_get_link_hstats(struct sk_buff *skb, const struct net_device *const_dev, + struct net_device *dev, int *prividx) +{ + struct hstat_dumper *dumper; + struct rtnl_hstat_req req; + ssize_t ret; + + if (!dev->netdev_ops || !dev->netdev_ops->ndo_hstat_get_groups) + return -ENODATA; + + dumper = hstat_dumper_init(skb, const_dev, dev, prividx); + if (!dumper) + return -ENOMEM; + + memset(&req, 0, sizeof(req)); + req.dumper = dumper; + + ret = dev->netdev_ops->ndo_hstat_get_groups(dev, &req); + if (ret < 0) + goto exit_dumper_destroy; + ret = req.err; + if (ret) + goto exit_dumper_destroy; + + if (hstat_dumper_done(dumper)) + return -ENODATA; + + ret = hstat_dumper_run(dumper); + if (prividx) { + if (ret) + *prividx = dumper->current_root_grp; + else + *prividx = 0; + } else if (ret >= 0) { + ret = dumper->size; + } + +exit_dumper_destroy: + hstat_dumper_destroy(dumper); + return ret; +} + +size_t rtnl_get_link_hstats_size(const struct net_device *dev) +{ + ssize_t ret; + + ret = __rtnl_get_link_hstats(NULL, dev, NULL, NULL); + return ret; +} + +size_t +rtnl_get_link_hstats(struct sk_buff *skb, struct net_device *dev, int *prividx) +{ + ssize_t ret; + + ret = __rtnl_get_link_hstats(skb, dev, dev, prividx); + return ret; +} diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c index f5a98082ac7a..a8112d0dca57 100644 --- a/net/core/rtnetlink.c +++ b/net/core/rtnetlink.c @@ -50,6 +50,7 @@ #include #include #include +#include #include #include #include @@ -4871,6 +4872,23 @@ static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev, *idxattr = 0; } + if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_HSTATS, *idxattr)) { + *idxattr = IFLA_STATS_LINK_HSTATS; + attr = nla_nest_start(skb, IFLA_STATS_LINK_HSTATS); + if (!attr) + goto nla_put_failure; + + err = rtnl_get_link_hstats(skb, dev, prividx); + if (err == -ENODATA) + nla_nest_cancel(skb, attr); + else + nla_nest_end(skb, attr); + + if (err && err != -ENODATA) + goto nla_put_failure; + *idxattr = 0; + } + nlmsg_end(skb, nlh); return 0; @@ -4946,6 +4964,9 @@ static size_t if_nlmsg_stats_size(const struct net_device *dev, rcu_read_unlock(); } + if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_HSTATS, 0)) + size += rtnl_get_link_hstats_size(dev); + return size; } From patchwork Mon Jan 28 23:44:57 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032322 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="Jp+B6jjH"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR8l6QXRz9s9h for ; Tue, 29 Jan 2019 10:45:59 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727403AbfA1Xp6 (ORCPT ); Mon, 28 Jan 2019 18:45:58 -0500 Received: from mail-qk1-f195.google.com ([209.85.222.195]:34468 "EHLO mail-qk1-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727268AbfA1Xp5 (ORCPT ); Mon, 28 Jan 2019 18:45:57 -0500 Received: by mail-qk1-f195.google.com with SMTP id q8so10538080qke.1 for ; Mon, 28 Jan 2019 15:45:56 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=XJTR61mvzcWx4iAAcdbjRJGoL5/5+ZxhlqmwMuAR3UE=; b=Jp+B6jjHAZ9Qr48NNPCIU4KIKtIvmgWMlHP8eqKV2HxC2FWL/R9IW7L+AXvJy7Cnsf SLjBQTh7Y2ucu8kpFTvQaWR+ZqS8iLMkYjXUauGtRpr0gAAlDmLiq3RosdetliunDdR6 ED2wWWUyxD0gXqxM3O//I3n/Moj+bf2wYRL/EAo7u3eWBVZbzYU1ifmdI0KqrtJ4iksk RZW1zQqys0afqFgtPePW+BrggiV0TyBZWVfYB16Wg5qOwZTzxaflcLOTRBCXG3jmr9CL QtCHpRJR6FUlSkn3qsiBAWc3ATR1JMt2pZln616QxBRBhMHd8+O8ZvdnhLuxQ5HFKO9T POTw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=XJTR61mvzcWx4iAAcdbjRJGoL5/5+ZxhlqmwMuAR3UE=; b=I568h7HFSnHtxL55aA+n+PLJm9WA9GXm/aUDwtlMnq6J07orWGzmxWWL9/718iJdkS hwwAaNfIV+rCSoNf06TVHy1U2pnnDk/Cue/BF0he5vDaWBdprmeFDssDv/JGXQgH1dGe 9GFhniDrPzUk33opsGtIltka+5N82mmgeLVag78k9iAfkNvl6y++qko1WhPIJG8Ag6y+ 2FcIAI+xF2iCtumobhvct036MsmjlhVNQ/ke5sg02snwZjax26lO9WMau9WICfxEs5jD kBIajv+NHSoDrkZ09CF/v3uD+SwzGG5NG7Ap3neDFcmLxeuInNb7z1Q/Z8c759R7+mmj 6dFw== X-Gm-Message-State: AJcUukf9WwrCCdygFDm4GjTI6dfvIlFLdY6lWDsyYgKHsUm0Eh7XKw2w 7UfmJWNW3O5+8zu3HCQacg1dig== X-Google-Smtp-Source: ALg8bN62T8WRkdUzfMU+Z8IQU/Hv4H9wRLJ20z0Y41Sf9LTh2NDnt2BQCrhcJmm9pTM5UYuSnSbnGQ== X-Received: by 2002:a05:620a:1013:: with SMTP id z19mr20811959qkj.65.1548719156047; Mon, 28 Jan 2019 15:45:56 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.45.53 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:45:55 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 04/14] net: hstats: allow hierarchies to be built Date: Mon, 28 Jan 2019 15:44:57 -0800 Message-Id: <20190128234507.32028-5-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Allow groups to have other groups attached as children. Child groups allow embedding different groups in the same root group and simplify definition of dependent stats (as qualifiers don't have to be repeated). Signed-off-by: Jakub Kicinski --- include/net/hstats.h | 6 ++++++ net/core/hstats.c | 14 ++++++++++++++ 2 files changed, 20 insertions(+) diff --git a/include/net/hstats.h b/include/net/hstats.h index c2e8b379237a..cbbdaf93d408 100644 --- a/include/net/hstats.h +++ b/include/net/hstats.h @@ -37,18 +37,24 @@ struct rtnl_hstat_qualifier { /** * struct rtnl_hstat_group - node in the hstat hierarchy * @qualifiers: attributes describing this group + * @has_children: @children array is present and NULL-terminated * @stats_cnt: number of stats in the bitmask * @stats: bitmask of stats present * @get_stats: driver callback for dumping the stats + * @children: NULL-terminated array of groups inheriting the qualifiers + * @has_children has to be set for core to parse the array */ struct rtnl_hstat_group { /* Note: this is *not* indexed with IFLA_* attributes! */ struct rtnl_hstat_qualifier qualifiers[RTNL_HSTATS_QUAL_CNT]; + bool has_children; /* Can't use bitmaps - words are variable length */ unsigned int stats_cnt; u64 stats[DIV_ROUND_UP(IFLA_HSTATS_STAT_MAX + 1, 64)]; int (*get_stats)(struct net_device *dev, struct rtnl_hstat_req *req, const struct rtnl_hstat_group *grp); + + const struct rtnl_hstat_group *children[]; }; void rtnl_hstat_add_grp(struct rtnl_hstat_req *req, diff --git a/net/core/hstats.c b/net/core/hstats.c index 183a1c5dd93a..b409dd40e0c9 100644 --- a/net/core/hstats.c +++ b/net/core/hstats.c @@ -31,6 +31,10 @@ enum hstat_dumper_cmd { */ HSTAT_DCMD_GRP_LOAD, /* dump all statitics + * --------------- + * | LOAD child0 | + * | LOAD child1 | + * =============== */ HSTAT_DCMD_GRP_DUMP, /* close grp */ @@ -353,6 +357,16 @@ static int hstat_dumper_grp_dump(struct hstat_dumper *dumper) if (err) return err; + if (cmd.grp->has_children) { + const struct rtnl_hstat_group *const *grp; + + for (grp = cmd.grp->children; *grp; grp++) { + err = hstat_dumper_push_grp_load(dumper, *grp); + if (err) + return err; + } + } + return 0; } From patchwork Mon Jan 28 23:44:58 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032323 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="b9qA32qk"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR8q5L52z9s9h for ; Tue, 29 Jan 2019 10:46:03 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727429AbfA1XqC (ORCPT ); Mon, 28 Jan 2019 18:46:02 -0500 Received: from mail-qk1-f194.google.com ([209.85.222.194]:43633 "EHLO mail-qk1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727404AbfA1Xp7 (ORCPT ); Mon, 28 Jan 2019 18:45:59 -0500 Received: by mail-qk1-f194.google.com with SMTP id z18so10493791qkj.10 for ; Mon, 28 Jan 2019 15:45:58 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=aCEApHHXpGnzzeucp40YRx+XZTTlhzb1bxUoT4t3YBA=; b=b9qA32qkc9GwrVGabOL4NnMjsH9ofZbye5ly3ymN5hiqT90f8agw7qRwcpMBJ+P86t dJ5ydlICvoBUvnfn58u0uFvis3tiDx/n2flYEazvDWmoqP/x2ReZz9Q4wu83CvyBhecM goFmqY4jS61otWvDTwEm7i1Aw/aBqW51hfjtdQyQvBhBPwJ/mwPO9tHKTvTkqdJv5sVM j0brI08OpqapVC2MsUUC0QX0gCA/t4tvcW9Fn6EDlmjpx10jlPaX9woM8RXr5GwkuDBM qMf6Tmty/OBYUpW6G0OA0etk86Jq5Z17Om4Nly63IXD+QE7xt8JRbR6sG2GdcQWqPe13 mMRA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=aCEApHHXpGnzzeucp40YRx+XZTTlhzb1bxUoT4t3YBA=; b=lj1XGROEaTJFqatKj3z+LkqabkUzqC+7UxG03aqMVTKRGhzg+P/wH4W9wX0xn9S2my Xcw3dKRGmCFvoFBBL535SwzktcctaE4tFTAfhwFffjqGsqPi7MVXSiGSPfX8Zacp8VQV +GIZBnSyxrLrFULvXcpN5CuzX9ktwf7r+JKsuQnCfQ7waj6rAjUnfEiajalEzCMvLCuu hJwtWmR44XPgk8Jyv54MRfVCyjJBN7Leg/d1unqz6aIXHvv4Be01SYk/78e+g/QXe9p0 EGA+8iGa2MgwQgCSfTeZ2s6NuYAVk9JbesnQ9yFsTD/yT6r/vhPJv5DEXKDC5NrzeCXb LG1A== X-Gm-Message-State: AJcUukfpWEaE0aoGjQH2ZD8G57xpxGoSfRJrlYARGwuIouNH5QDq0Of/ GSwS1LeZKxXDtt/twJE0CiqN4A== X-Google-Smtp-Source: ALg8bN4c4z2sbXFJTlcbgOJAxDyfKPf77n8srVAzjHrII/3n8BKejynWQMCp5hXoDUJNl4zrXEbJ7Q== X-Received: by 2002:a37:6801:: with SMTP id d1mr20815067qkc.283.1548719158446; Mon, 28 Jan 2019 15:45:58 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.45.56 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:45:57 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 05/14] nfp: very basic hstat support Date: Mon, 28 Jan 2019 15:44:58 -0800 Message-Id: <20190128234507.32028-6-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Expose basic vNIC device statistics via hstat. Signed-off-by: Jakub Kicinski --- drivers/net/ethernet/netronome/nfp/Makefile | 1 + .../net/ethernet/netronome/nfp/nfp_hstat.c | 70 +++++++++++++++++++ drivers/net/ethernet/netronome/nfp/nfp_net.h | 3 + .../ethernet/netronome/nfp/nfp_net_common.c | 1 + 4 files changed, 75 insertions(+) create mode 100644 drivers/net/ethernet/netronome/nfp/nfp_hstat.c diff --git a/drivers/net/ethernet/netronome/nfp/Makefile b/drivers/net/ethernet/netronome/nfp/Makefile index 47c708f08ade..4721abe9bfbf 100644 --- a/drivers/net/ethernet/netronome/nfp/Makefile +++ b/drivers/net/ethernet/netronome/nfp/Makefile @@ -19,6 +19,7 @@ nfp-objs := \ nfp_app.o \ nfp_app_nic.o \ nfp_devlink.o \ + nfp_hstat.o \ nfp_hwmon.o \ nfp_main.o \ nfp_net_common.o \ diff --git a/drivers/net/ethernet/netronome/nfp/nfp_hstat.c b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c new file mode 100644 index 000000000000..9480d3b6caa5 --- /dev/null +++ b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c @@ -0,0 +1,70 @@ +// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +/* Copyright (C) 2019 Netronome Systems, Inc. */ + +#include + +#include "nfp_net.h" + +/* NFD per-vNIC stats */ +static int +nfp_hstat_vnic_nfd_basic_get_rx(struct net_device *netdev, + struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) +{ + struct nfp_net *nn = netdev_priv(netdev); + + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_PKTS, + nn_readq(nn, NFP_NET_CFG_STATS_RX_FRAMES)); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_BYTES, + nn_readq(nn, NFP_NET_CFG_STATS_RX_OCTETS)); + return 0; +} + +static const struct rtnl_hstat_group nfp_hstat_vnic_nfd_rx = { + .qualifiers = { + RTNL_HSTATS_QUALS_BASIC(DEV, RX), + }, + + .get_stats = nfp_hstat_vnic_nfd_basic_get_rx, + .stats = { + [0] = RTNL_HSTATS_STAT_LINUX_PKTS_BIT | + RTNL_HSTATS_STAT_LINUX_BYTES_BIT, + }, + .stats_cnt = 2, +}; + +static int +nfp_hstat_vnic_nfd_basic_get_tx(struct net_device *netdev, + struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) +{ + struct nfp_net *nn = netdev_priv(netdev); + + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_PKTS, + nn_readq(nn, NFP_NET_CFG_STATS_TX_FRAMES)); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_BYTES, + nn_readq(nn, NFP_NET_CFG_STATS_TX_OCTETS)); + return 0; +} + +static const struct rtnl_hstat_group nfp_hstat_vnic_nfd_tx = { + .qualifiers = { + RTNL_HSTATS_QUALS_BASIC(DEV, TX), + }, + + .get_stats = nfp_hstat_vnic_nfd_basic_get_tx, + .stats = { + [0] = RTNL_HSTATS_STAT_LINUX_PKTS_BIT | + RTNL_HSTATS_STAT_LINUX_BYTES_BIT, + }, + .stats_cnt = 2, +}; + +int nfp_net_hstat_get_groups(const struct net_device *netdev, + struct rtnl_hstat_req *req) +{ + rtnl_hstat_add_grp(req, &nfp_hstat_vnic_nfd_rx); + rtnl_hstat_add_grp(req, &nfp_hstat_vnic_nfd_tx); + + return 0; +} diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net.h b/drivers/net/ethernet/netronome/nfp/nfp_net.h index 93de25b39bc1..08396a23edeb 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_net.h +++ b/drivers/net/ethernet/netronome/nfp/nfp_net.h @@ -105,6 +105,7 @@ struct nfp_eth_table_port; struct nfp_net; struct nfp_net_r_vector; struct nfp_port; +struct rtnl_hstat_req; /* Convenience macro for wrapping descriptor index on ring size */ #define D_IDX(ring, idx) ((idx) & ((ring)->cnt - 1)) @@ -910,4 +911,6 @@ static inline void nfp_net_debugfs_dir_clean(struct dentry **dir) } #endif /* CONFIG_NFP_DEBUG */ +int nfp_net_hstat_get_groups(const struct net_device *dev, + struct rtnl_hstat_req *req); #endif /* _NFP_NET_H_ */ diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c index 7d2d4241498f..87ebfc3f0471 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c +++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c @@ -3531,6 +3531,7 @@ const struct net_device_ops nfp_net_netdev_ops = { .ndo_udp_tunnel_add = nfp_net_add_vxlan_port, .ndo_udp_tunnel_del = nfp_net_del_vxlan_port, .ndo_bpf = nfp_net_xdp, + .ndo_hstat_get_groups = nfp_net_hstat_get_groups, }; /** From patchwork Mon Jan 28 23:44:59 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032324 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="zVigz3mh"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR8s57wVz9s9h for ; Tue, 29 Jan 2019 10:46:05 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727445AbfA1XqE (ORCPT ); Mon, 28 Jan 2019 18:46:04 -0500 Received: from mail-qt1-f196.google.com ([209.85.160.196]:39002 "EHLO mail-qt1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727325AbfA1XqC (ORCPT ); Mon, 28 Jan 2019 18:46:02 -0500 Received: by mail-qt1-f196.google.com with SMTP id u47so20374974qtj.6 for ; Mon, 28 Jan 2019 15:46:01 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=IPpI//gQIE+gEu8KwOR5ur0GrGND4UeGHUin+bcwhyc=; b=zVigz3mhI8SGFT2rkcxkpbw/FS0/kswQp9An2aBKMCDf3yWt2rvGFsh1QwYzxfDZTI fEOjd3/0tbWcRkmcomCJPOlhhe6mwYbIpiMWYtRWd1v3yXnY3BO6Wl/K05cMrLHUaUQK 0FczURe9TICY1eYdh53SN9MEU4YVr1k5HDUW69WwFc2pA1213HwddY3gBSW4eJEqIpAD Tj0h8SkdtMFtEElnIP/e1Flo1MKH9k10/dO04Iz56BAWpVJi31/LvgrEPpTk1CI4tuIU n5LhIh2AmjugkLVVaW5JJLDeDvTjpJ5KNyfZHyWg1hkLY/ZieenNiSmA+e3/I2/HK6K2 Z9og== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=IPpI//gQIE+gEu8KwOR5ur0GrGND4UeGHUin+bcwhyc=; b=nZi9vreOpzDrqJWlzAAZIBIWljR+oZxLmIsagLRQWfaGFt9MoucINKo96PCGAhRgSm UhAv3GDMOgZRws2rgUA2qZu7rBF7kV4jz7JRA4chRSGkz2JTUlbBXeVM7A14OpdJYDcf L24tBEmxEb3++m50fnwxe4oN3O0e7kxXjhEGCrurP4kZ6/vucBjjxcfzqN1ICM5QyuvM 3TMjdHGS/7087xDIwnKmugm4cvxSku0UlXNTrURTsFKAsHfMN6UWKESDo5f4VjlWj5M+ 3HdKbU/O6krWHahB7HnHFrmrkbiAXJmHToNfWVybNpC/v3PAF+uAGwd1668JSrfcChpY mumA== X-Gm-Message-State: AJcUukfp243mOUF1F0lbKC4k8tpbgM6xfRP1Qt5Zq8GbJ4db53L2sMcO Gf0GNF62CBdBZOBOcoMQCSuoOw== X-Google-Smtp-Source: ALg8bN5EV3iPGOBy3Q3GCeVI1qLdkLa1ea4gSOwrUu6bAOZzwlLVYlku10n7EZw+VtaREO659hOjEw== X-Received: by 2002:a0c:9311:: with SMTP id d17mr22513101qvd.54.1548719160751; Mon, 28 Jan 2019 15:46:00 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.45.58 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:46:00 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 06/14] net: hstats: allow iterators Date: Mon, 28 Jan 2019 15:44:59 -0800 Message-Id: <20190128234507.32028-7-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add support for iterative type of qualifiers. User can set min/max values in the group and the group will be dumped multiple times, each time driver can read the current state of the qualifier with rtnl_hstat_qual_get() to access the right statistics. Dump will look like this: [group] [const qualifiers] [group (iter #0)] [iter qualifiers] [stats] [group (iter #1)] [iter qualifiers] [stats] ... This means that if group contains iterative qualifiers it will itself never contain statistics, its statistics will only be reported in its subgroups where iterators have a value assigned. Dumper needs to keep track of which qualifiers where set in a given group (iterations may nest). Signed-off-by: Jakub Kicinski --- include/net/hstats.h | 9 ++ include/uapi/linux/if_link.h | 3 + net/core/hstats.c | 168 +++++++++++++++++++++++++++++++++-- 3 files changed, 173 insertions(+), 7 deletions(-) diff --git a/include/net/hstats.h b/include/net/hstats.h index cbbdaf93d408..00f4d9334422 100644 --- a/include/net/hstats.h +++ b/include/net/hstats.h @@ -17,6 +17,9 @@ struct sk_buff; enum { RTNL_HSTATS_QUAL_TYPE, RTNL_HSTATS_QUAL_DIRECTION, + RTNL_HSTATS_QUAL_QUEUE, + RTNL_HSTATS_QUAL_PRIORITY, + RTNL_HSTATS_QUAL_TC, RTNL_HSTATS_QUAL_CNT }; @@ -32,6 +35,10 @@ struct rtnl_hstat_req { struct rtnl_hstat_qualifier { unsigned int constant; + unsigned int min; + unsigned int max; + int (*get_max)(const struct net_device *dev, + const struct rtnl_hstat_group *grp); }; /** @@ -59,6 +66,8 @@ struct rtnl_hstat_group { void rtnl_hstat_add_grp(struct rtnl_hstat_req *req, const struct rtnl_hstat_group *grp); +bool rtnl_hstat_qual_is_set(struct rtnl_hstat_req *req, int qual); +int rtnl_hstat_qual_get(struct rtnl_hstat_req *req, int qual); static inline void rtnl_hstat_dump(struct rtnl_hstat_req *req, const int id, const u64 val) diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h index 55fcef81e142..b33d38ff5b47 100644 --- a/include/uapi/linux/if_link.h +++ b/include/uapi/linux/if_link.h @@ -948,6 +948,9 @@ enum { IFLA_HSTATS_STATS, IFLA_HSTATS_QUAL_TYPE, IFLA_HSTATS_QUAL_DIRECTION, + IFLA_HSTATS_QUAL_QUEUE, + IFLA_HSTATS_QUAL_PRIORITY, + IFLA_HSTATS_QUAL_TC, __IFLA_HSTATS_MAX, }; #define IFLA_HSTATS_MAX (__IFLA_HSTATS_MAX - 1) diff --git a/net/core/hstats.c b/net/core/hstats.c index b409dd40e0c9..c689ebfdaeaa 100644 --- a/net/core/hstats.c +++ b/net/core/hstats.c @@ -22,14 +22,28 @@ * ============== <---- top of the stack before current handler */ enum hstat_dumper_cmd { - /* open grp - * put const quals - * --------------- - * | DUMP STATS | - * | CLOSE grp | - * =============== + /* Non-iterative group: Iterative group: + * + * open grp open grp + * put const quals put const quals + * --------------- --------------- + * | DUMP STATS | | ITER | + * | CLOSE grp | | CLOSE grp | + * =============== =============== */ HSTAT_DCMD_GRP_LOAD, + /* Non-last iteration: Last iteration: + * + * open grp open grp + * put current quals put current quals + * increment quals --------------- + * --------------- | DUMP STATS | + * | DUMP STATS | | CLOSE grp | + * | CLOSE grp | =============== + * | ITER | + * =============== + */ + HSTAT_DCMD_GRP_ITER, /* dump all statitics * --------------- * | LOAD child0 | @@ -48,6 +62,8 @@ struct hstat_dumper { struct net_device *dev; /* For sizing we only have a const pointer to dev */ const struct net_device *const_dev; + u32 quals[RTNL_HSTATS_QUAL_CNT]; + unsigned long quals_set; int err; /* For calculating skb size */ @@ -62,6 +78,12 @@ struct hstat_dumper { size_t cmd_stack_len; }; +struct hstat_qualifier_state { + u32 cur; + u32 min; + u32 max; +}; + struct hstat_dumper_cmd_simple { u64 cmd; }; @@ -71,12 +93,19 @@ struct hstat_dumper_cmd_grp_load { u64 cmd; }; +struct hstat_dumper_cmd_grp_iter { + struct hstat_qualifier_state *quals; + const struct rtnl_hstat_group *grp; + u64 cmd; +}; + struct hstat_dumper_cmd_grp_dump { const struct rtnl_hstat_group *grp; u64 cmd; }; struct hstat_dumper_cmd_grp_close { + unsigned long quals_set; struct nlattr *nl_attr; u64 cmd; }; @@ -85,11 +114,14 @@ struct hstat_dumper_cmd_grp_close { static const int rtnl_qual2ifla[RTNL_HSTATS_QUAL_CNT] = { [RTNL_HSTATS_QUAL_TYPE] = IFLA_HSTATS_QUAL_TYPE, [RTNL_HSTATS_QUAL_DIRECTION] = IFLA_HSTATS_QUAL_DIRECTION, + [RTNL_HSTATS_QUAL_QUEUE] = IFLA_HSTATS_QUAL_QUEUE, + [RTNL_HSTATS_QUAL_PRIORITY] = IFLA_HSTATS_QUAL_PRIORITY, + [RTNL_HSTATS_QUAL_TC] = IFLA_HSTATS_QUAL_TC, }; static bool rtnl_hstat_qualifier_present(const struct rtnl_hstat_qualifier *q) { - return q->constant; + return q->constant || q->max || q->get_max; } /* Dumper basics */ @@ -197,6 +229,20 @@ hstat_dumper_push_grp_load(struct hstat_dumper *dumper, return __hstat_dumper_push_cmd(dumper, &cmd, sizeof(cmd)); } +static int +hstat_dumper_push_grp_iter(struct hstat_dumper *dumper, + const struct rtnl_hstat_group *grp, + struct hstat_qualifier_state *quals) +{ + struct hstat_dumper_cmd_grp_iter cmd = { + .cmd = HSTAT_DCMD_GRP_ITER, + .grp = grp, + .quals = quals, + }; + + return __hstat_dumper_push_cmd(dumper, &cmd, sizeof(cmd)); +} + static int hstat_dumper_push_dump(struct hstat_dumper *dumper, const struct rtnl_hstat_group *grp) @@ -215,6 +261,7 @@ hstat_dumper_push_grp_close(struct hstat_dumper *dumper, struct nlattr *nl_grp) struct hstat_dumper_cmd_grp_close cmd = { .cmd = HSTAT_DCMD_GRP_CLOSE, .nl_attr = nl_grp, + .quals_set = dumper->quals_set, }; return __hstat_dumper_push_cmd(dumper, &cmd, sizeof(cmd)); @@ -303,12 +350,18 @@ hstat_dumper_put_qual(struct hstat_dumper *dumper, int i, u32 val) return 0; } + /* Qualifiers cannot be overwritten once set */ + if (WARN_ON_ONCE(__test_and_set_bit(i, &dumper->quals_set))) + return -EINVAL; + dumper->quals[i] = val; + return nla_put_u32(dumper->skb, rtnl_qual2ifla[i], val); } /* Dumper handlers */ static int hstat_dumper_grp_load(struct hstat_dumper *dumper) { + struct hstat_qualifier_state *quals = NULL; struct hstat_dumper_cmd_grp_load cmd; int i, err; @@ -336,7 +389,89 @@ static int hstat_dumper_grp_load(struct hstat_dumper *dumper) err = hstat_dumper_put_qual(dumper, i, q->constant); if (err) return err; + } else { + int max; + + /* Each iteration point has its own set of iterators, + * this allows iterating different group over different + * sets of qualifiers. + */ + if (!quals) { + quals = kcalloc(RTNL_HSTATS_QUAL_CNT, + sizeof(*quals), GFP_KERNEL); + if (!quals) + return -ENOMEM; + } + + max = q->max ?: q->get_max(dumper->const_dev, cmd.grp); + if (max < 0) + return max; + + if (WARN_ON_ONCE(q->min > max)) + return -EINVAL; + quals[i].min = q->min; + quals[i].cur = q->min; + quals[i].max = max; + } + } + + if (quals) + return hstat_dumper_push_grp_iter(dumper, cmd.grp, quals); + else + return hstat_dumper_push_dump(dumper, cmd.grp); +} + +static int hstat_dumper_grp_iter(struct hstat_dumper *dumper) +{ + struct hstat_dumper_cmd_grp_iter cmd; + int i, err; + bool done; + + err = hstat_dumper_pop(dumper, &cmd, sizeof(cmd)); + if (err) + return err; + if (dumper->err) { + kfree(cmd.quals); + return 0; + } + + /* Find out if iteration is done */ + for (i = 0; i < RTNL_HSTATS_QUAL_CNT; i++) + if (cmd.quals[i].cur + 1 < cmd.quals[i].max) + break; + done = i == RTNL_HSTATS_QUAL_CNT; + if (!done) { + err = hstat_dumper_push_grp_iter(dumper, cmd.grp, cmd.quals); + if (err) + return err; + } + + err = hstat_dumper_open_grp(dumper); + if (err) + return err; + + for (i = 0; i < RTNL_HSTATS_QUAL_CNT; i++) { + if (!cmd.quals[i].max) + continue; + + err = hstat_dumper_put_qual(dumper, i, cmd.quals[i].cur); + if (err) + return err; + } + + if (!done) { + for (i = 0; i < RTNL_HSTATS_QUAL_CNT; i++) { + if (cmd.quals[i].cur >= cmd.quals[i].max) + continue; + + cmd.quals[i].cur++; + if (cmd.quals[i].cur == cmd.quals[i].max) + cmd.quals[i].cur = cmd.quals[i].min; + else + break; } + } else { + kfree(cmd.quals); } return hstat_dumper_push_dump(dumper, cmd.grp); @@ -379,6 +514,7 @@ static int hstat_dumper_grp_close(struct hstat_dumper *dumper) if (err) return err; + dumper->quals_set = cmd.quals_set; if (!dumper->err) nla_nest_end(dumper->skb, cmd.nl_attr); else @@ -417,6 +553,9 @@ static int hstat_dumper_run(struct hstat_dumper *dumper) case HSTAT_DCMD_ROOT_GRP_DONE: err = hstat_dumper_root_grp_done(dumper); break; + case HSTAT_DCMD_GRP_ITER: + err = hstat_dumper_grp_iter(dumper); + break; case HSTAT_DCMD_GRP_LOAD: err = hstat_dumper_grp_load(dumper); break; @@ -449,6 +588,21 @@ rtnl_hstat_add_grp(struct rtnl_hstat_req *req, } EXPORT_SYMBOL(rtnl_hstat_add_grp); +bool rtnl_hstat_qual_is_set(struct rtnl_hstat_req *req, int qual) +{ + return test_bit(qual, &req->dumper->quals_set); +} +EXPORT_SYMBOL(rtnl_hstat_qual_is_set); + +int rtnl_hstat_qual_get(struct rtnl_hstat_req *req, int qual) +{ + if (!test_bit(qual, &req->dumper->quals_set)) + return U32_MAX; + + return req->dumper->quals[qual]; +} +EXPORT_SYMBOL(rtnl_hstat_qual_get); + /* Stack call points */ static size_t __rtnl_get_link_hstats(struct sk_buff *skb, const struct net_device *const_dev, From patchwork Mon Jan 28 23:45:00 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032326 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="oXThJozc"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR8y2D4yz9s9h for ; Tue, 29 Jan 2019 10:46:10 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727467AbfA1XqH (ORCPT ); Mon, 28 Jan 2019 18:46:07 -0500 Received: from mail-qk1-f196.google.com ([209.85.222.196]:45322 "EHLO mail-qk1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727431AbfA1XqE (ORCPT ); Mon, 28 Jan 2019 18:46:04 -0500 Received: by mail-qk1-f196.google.com with SMTP id y78so10488010qka.12 for ; Mon, 28 Jan 2019 15:46:03 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=GCVsAGfpR0vVAh1ro8u6LOjM9fm28NRfZt1aBSVMFy0=; b=oXThJozcV3Niokynks5uhvcHvl+lQob72rqZMKfKJTB4RGGAKp4S1yQbZcTuMvqH1S SvMTxJcgm7K1OiFi8Re4Zl9aRFC5EtXp8cln7s/o+2COyI8CoYGegLhUll96nnPJpXWK HHPn69yTi78Cx7On1XJb9wSirJyvecjd0mv4jfmp+RApdM65kgmaHESi5jsmptUKkql6 P6RbE72sJi1asBNFvDUL4AQyJjV2Gf0djVkmznCBlHAi/o/9nrPq3FQcH9dja6F6ZDyh PXswzn0OUC5vo9O9A7wnOq8JuqX8Mgue85xZkIYPF8GxJtmFRgmrMJ0YEV6fZtqSNCoc SUcQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=GCVsAGfpR0vVAh1ro8u6LOjM9fm28NRfZt1aBSVMFy0=; b=PkN57aQRyW3xrMBnXFFa6da1ShdWsmfoQdffzLnodWMBvUzluZ+LR+X7mL6P4bTpgx yEc5ZVnVdXeKf16dfsN/PMPsDX+YWJ06jKYba8YE+0/eXO/2fOKjDjSUHrdZbMYZnMON 7DYskvcn5UDEq/P0AbuD2Cglp6Uqqk0v05QnSBwRG09pvPMnXcIPB7ju/awthVIFeR9G ZhBG2ghVXTPPtIDio4yajNoD5UhWgd6C+mpdKOqrNv0Nsoh7wQ9VgIaaoEEzWAuRzDdq wf6/u7pdQOtBmuIgawH0+teK/nwcSh9kcqAntFrGFvOXGkbHmMjIYtQpADMZZN3ft0ZO /bvw== X-Gm-Message-State: AJcUukdMLJriR6fw3Gj4eXqETc6nTaa147iTAxErpyBi/XJIEQ3cA6Bb q2nBkwyj/Wq0V/LuiXm5pm6+qw== X-Google-Smtp-Source: ALg8bN7g8nrAAc1KoV+deVjaHDpfWO9jWCrgv0wqFkW2aisa3pF3EtwU0jrbqQZWiXhHXQrIJG4y/A== X-Received: by 2002:a37:b201:: with SMTP id b1mr20789533qkf.306.1548719163094; Mon, 28 Jan 2019 15:46:03 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.46.00 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:46:02 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 07/14] net: hstats: help in iteration over directions Date: Mon, 28 Jan 2019 15:45:00 -0800 Message-Id: <20190128234507.32028-8-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Devices (or drivers) often keep the same statistics in both directions, aid iterating over such statistics with some helpers. Signed-off-by: Jakub Kicinski --- include/net/hstats.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/include/net/hstats.h b/include/net/hstats.h index 00f4d9334422..bb83f50768b1 100644 --- a/include/net/hstats.h +++ b/include/net/hstats.h @@ -69,6 +69,12 @@ void rtnl_hstat_add_grp(struct rtnl_hstat_req *req, bool rtnl_hstat_qual_is_set(struct rtnl_hstat_req *req, int qual); int rtnl_hstat_qual_get(struct rtnl_hstat_req *req, int qual); +static inline bool rtnl_hstat_is_rx(struct rtnl_hstat_req *req) +{ + return rtnl_hstat_qual_get(req, RTNL_HSTATS_QUAL_DIRECTION) == + IFLA_HSTATS_QUAL_DIR_RX; +} + static inline void rtnl_hstat_dump(struct rtnl_hstat_req *req, const int id, const u64 val) { @@ -106,4 +112,13 @@ enum { [RTNL_HSTATS_QUAL_DIRECTION] = { \ .constant = IFLA_HSTATS_QUAL_DIR_ ##dir, \ } + +#define RTNL_HSTATS_QUALS_BASIC_BIDIR(type) \ + [RTNL_HSTATS_QUAL_TYPE] = { \ + .constant = IFLA_HSTATS_QUAL_TYPE_ ##type, \ + }, \ + [RTNL_HSTATS_QUAL_DIRECTION] = { \ + .min = IFLA_HSTATS_QUAL_DIR_RX, \ + .max = IFLA_HSTATS_QUAL_DIR_TX + 1, \ + } #endif From patchwork Mon Jan 28 23:45:01 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032325 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="yaXGJRhW"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR8w4QzVz9s9h for ; Tue, 29 Jan 2019 10:46:08 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727474AbfA1XqH (ORCPT ); Mon, 28 Jan 2019 18:46:07 -0500 Received: from mail-qk1-f194.google.com ([209.85.222.194]:40581 "EHLO mail-qk1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727325AbfA1XqG (ORCPT ); Mon, 28 Jan 2019 18:46:06 -0500 Received: by mail-qk1-f194.google.com with SMTP id y16so10509606qki.7 for ; Mon, 28 Jan 2019 15:46:05 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=L1Jc44K8hC/875AN68A5rK1yGV4E8ktyOJctgzuqYmQ=; b=yaXGJRhW9ZQSbU7j9rADxKVnKn8OtAcQiwe2CVSW+ipRZA9oavd+SXM7L14p4Ns1/u +F/jR2Z3GGHpuU/ku2BHQdQGNRgNMBTHNqfd9IeUkvHJrbWr2A8g76HJEfWTY0dD+24u vde9asRJNfo8dO6gtfCxuni7F0Qh6/6iJa3IVRJ08BQJC6ZiCntpFO3B2DXpaPba8VtM HV8CtAHs6941Q752OpEV6mLGkBZeStMugB+AKBNZY9h9vwkxrA1LpRXWjc5IgJ3seQ3J taPPRzmS5E1587ueI+545oZkH3tXiSma45EHUsnSow6O2lcmORWaFX4QrAVwZI3WBt9E UoWQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=L1Jc44K8hC/875AN68A5rK1yGV4E8ktyOJctgzuqYmQ=; b=ZM5RhlyCWUmLkvuX51/MjEh78ZCJO/36ZsmNgmgi9Yq7APBSOQnE0qoOS3EzYoWrfZ I0/qeSp1XOwASNFC1VlfD+mVHWzgln9h9JQoIY77yjQ2kJv1g27oNK8VpnIma6CrhVaJ WSAm6/R4/2Nisf+JM3L3QpLctfniqvW3eOU7Sz4fppgu+LyuCyXLiDRcbRUtL6W2+0P2 IRUEbMK830b79/sMpj6kT9d59WQEiXfnsBzDUD0KRRVTZTRAF7mpOeV3cRGFmB45CMdr P5BmLMoAltbQIc/AXoc2hxmSZaOifCHkKAmfWnNI0CyGDzj2GmPTCbTDid2gIWrgTbVO v7Ug== X-Gm-Message-State: AJcUukdIKZUq4EX4A0FxxjBLF7sdkq5eioH29dcAgHieTj//T/62jBcg qzy4h+jCAK0o7hYYflwqJTGdiw== X-Google-Smtp-Source: ALg8bN7IazpG9P6hfGOCBPuv0YXiZxvvz8rSDmekqMo9bbrlcl/PUCkwflmhqcj1ybsQkiwyqXpqvg== X-Received: by 2002:a37:9584:: with SMTP id x126mr21523334qkd.36.1548719165397; Mon, 28 Jan 2019 15:46:05 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.46.03 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:46:04 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 08/14] nfp: hstats: make use of iteration for direction Date: Mon, 28 Jan 2019 15:45:01 -0800 Message-Id: <20190128234507.32028-9-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Basic RX and TX stats are the same, just at a slightly different offset, use iteration to save code. Signed-off-by: Jakub Kicinski --- .../net/ethernet/netronome/nfp/nfp_hstat.c | 48 +++++-------------- 1 file changed, 12 insertions(+), 36 deletions(-) diff --git a/drivers/net/ethernet/netronome/nfp/nfp_hstat.c b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c index 9480d3b6caa5..d339008333bc 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_hstat.c +++ b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c @@ -7,52 +7,29 @@ /* NFD per-vNIC stats */ static int -nfp_hstat_vnic_nfd_basic_get_rx(struct net_device *netdev, - struct rtnl_hstat_req *req, - const struct rtnl_hstat_group *grp) +nfp_hstat_vnic_nfd_basic_get(struct net_device *netdev, + struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) { struct nfp_net *nn = netdev_priv(netdev); + u32 off; - rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_PKTS, - nn_readq(nn, NFP_NET_CFG_STATS_RX_FRAMES)); - rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_BYTES, - nn_readq(nn, NFP_NET_CFG_STATS_RX_OCTETS)); - return 0; -} - -static const struct rtnl_hstat_group nfp_hstat_vnic_nfd_rx = { - .qualifiers = { - RTNL_HSTATS_QUALS_BASIC(DEV, RX), - }, - - .get_stats = nfp_hstat_vnic_nfd_basic_get_rx, - .stats = { - [0] = RTNL_HSTATS_STAT_LINUX_PKTS_BIT | - RTNL_HSTATS_STAT_LINUX_BYTES_BIT, - }, - .stats_cnt = 2, -}; - -static int -nfp_hstat_vnic_nfd_basic_get_tx(struct net_device *netdev, - struct rtnl_hstat_req *req, - const struct rtnl_hstat_group *grp) -{ - struct nfp_net *nn = netdev_priv(netdev); + off = rtnl_hstat_is_rx(req) ? + 0 : NFP_NET_CFG_STATS_TX_OCTETS - NFP_NET_CFG_STATS_RX_OCTETS; rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_PKTS, - nn_readq(nn, NFP_NET_CFG_STATS_TX_FRAMES)); + nn_readq(nn, NFP_NET_CFG_STATS_RX_FRAMES + off)); rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_BYTES, - nn_readq(nn, NFP_NET_CFG_STATS_TX_OCTETS)); + nn_readq(nn, NFP_NET_CFG_STATS_RX_OCTETS + off)); return 0; } -static const struct rtnl_hstat_group nfp_hstat_vnic_nfd_tx = { +static const struct rtnl_hstat_group nfp_hstat_vnic_nfd = { .qualifiers = { - RTNL_HSTATS_QUALS_BASIC(DEV, TX), + RTNL_HSTATS_QUALS_BASIC_BIDIR(DEV), }, - .get_stats = nfp_hstat_vnic_nfd_basic_get_tx, + .get_stats = nfp_hstat_vnic_nfd_basic_get, .stats = { [0] = RTNL_HSTATS_STAT_LINUX_PKTS_BIT | RTNL_HSTATS_STAT_LINUX_BYTES_BIT, @@ -63,8 +40,7 @@ static const struct rtnl_hstat_group nfp_hstat_vnic_nfd_tx = { int nfp_net_hstat_get_groups(const struct net_device *netdev, struct rtnl_hstat_req *req) { - rtnl_hstat_add_grp(req, &nfp_hstat_vnic_nfd_rx); - rtnl_hstat_add_grp(req, &nfp_hstat_vnic_nfd_tx); + rtnl_hstat_add_grp(req, &nfp_hstat_vnic_nfd); return 0; } From patchwork Mon Jan 28 23:45:02 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032327 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="qt+fVEAa"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR8z4nRfz9s9h for ; Tue, 29 Jan 2019 10:46:11 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727491AbfA1XqK (ORCPT ); Mon, 28 Jan 2019 18:46:10 -0500 Received: from mail-qt1-f193.google.com ([209.85.160.193]:46106 "EHLO mail-qt1-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727325AbfA1XqJ (ORCPT ); Mon, 28 Jan 2019 18:46:09 -0500 Received: by mail-qt1-f193.google.com with SMTP id y20so20316099qtm.13 for ; Mon, 28 Jan 2019 15:46:08 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=yYqvlAl5qt5ez0mS11W77ApeT/SksEftJ0DRu6kMQII=; b=qt+fVEAaZP5OskIT3TdBlKgji14thbrW2x3hM+XcGxzLAKPkPRtSr7GsatqpCoNBaM btO2g6+HHsPevOf24ISQ6cZ3zR7W2UJbtFPu1ZULzZtieH8eNkoUQplTWS5EB4/zt9R+ N4Sy70UAW2hgGxiSbQ46fWlrZ2lrX9lt4ErmeiAOAfIlRs97vPQmYNwkpq6Wiw69vyPo 2qRk9YdHRnkFbeD4615BLIRPRpuUYuTue3XknDYibBOwW8moDQZgTkwvtkHxS9roc6xU QAvCv9hSJk7UPWnIuVmeuuou6pzkowAFIkYtgbMyQkWGKFonQhqOCsDuICF7vjmy3g4B Gn9g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=yYqvlAl5qt5ez0mS11W77ApeT/SksEftJ0DRu6kMQII=; b=hc0Uy6Xumzq9vu79YPwZ2py4VhM0gEutYrZdPwFRzJsEyLXo2Y1XiWgwMgvn8H1D/h E0PsWQuhE9PWX4ULn6z2XbpdBzr+ry4XZ/q4QJgNJYTCQpD7KAWKWCeKi4nZu+Bz4mts LjpA6BywAB9ljZTp9hF8pbVHZHo3POZVJeTS+WYJ/7xH4eguBDR/pCbmrsAoCBB4gy9U YyJ68q+JkCt62lAONPNA42glW1KsxQW8ohhZQ8CbRx7X/AFCHFBSsMm648OyXtAGjc4V s/6HvYMLZcAz3JUEsHLbJ15KkbTOG04HCqjBgDMuZp/5zhiPTkQ1M9KsuU/ZwIp10OQa iYDg== X-Gm-Message-State: AJcUukeuWv0u/pqDyN0NIS+pjawAx08cEHT/byfEBaeyy/OhzLuUceEs uGPqoNl/lbhCcoTMZCCdTIQ/hg== X-Google-Smtp-Source: ALg8bN4hQGqOt6ukT9W3Z+1fxMFYoau6fOtl333cTlm1dalqv93TFq8oCZt4l0rAu43Ga1H3uo9DXA== X-Received: by 2002:a0c:cc8c:: with SMTP id f12mr22648155qvl.102.1548719167860; Mon, 28 Jan 2019 15:46:07 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.46.05 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:46:07 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 09/14] nfp: hstats: add driver and device per queue statistics Date: Mon, 28 Jan 2019 15:45:02 -0800 Message-Id: <20190128234507.32028-10-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Report basic stats for all queues, per-queue. Separate device and driver statistics into different groups. Signed-off-by: Jakub Kicinski --- .../net/ethernet/netronome/nfp/nfp_hstat.c | 133 ++++++++++++++++++ 1 file changed, 133 insertions(+) diff --git a/drivers/net/ethernet/netronome/nfp/nfp_hstat.c b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c index d339008333bc..9300996e756c 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_hstat.c +++ b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c @@ -37,9 +37,142 @@ static const struct rtnl_hstat_group nfp_hstat_vnic_nfd = { .stats_cnt = 2, }; +/* NFD per-Q stats */ +static int +nfp_hstat_vnic_nfd_get_queues(const struct net_device *dev, + const struct rtnl_hstat_group *grp) +{ + struct nfp_net *nn = netdev_priv(dev); + + return nn->max_r_vecs; +} + +static int +nfp_hstat_vnic_nfd_pq_get(struct net_device *dev, + struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) +{ + struct nfp_net *nn = netdev_priv(dev); + u32 queue, off; + + queue = rtnl_hstat_qual_get(req, RTNL_HSTATS_QUAL_QUEUE); + + off = NFP_NET_CFG_TXR_STATS(queue); + off += rtnl_hstat_is_rx(req) ? + 0 : NFP_NET_CFG_RXR_STATS_BASE - NFP_NET_CFG_TXR_STATS_BASE; + + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_PKTS, nn_readq(nn, off)); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_BYTES, + nn_readq(nn, off + 8)); + return 0; +} + +static const struct rtnl_hstat_group nfp_hstat_vnic_nfd_pq = { + .qualifiers = { + RTNL_HSTATS_QUALS_BASIC_BIDIR(DEV), + [RTNL_HSTATS_QUAL_QUEUE] = { + .get_max = nfp_hstat_vnic_nfd_get_queues, + }, + }, + + .get_stats = nfp_hstat_vnic_nfd_pq_get, + .stats = { + [0] = RTNL_HSTATS_STAT_LINUX_PKTS_BIT | + RTNL_HSTATS_STAT_LINUX_BYTES_BIT, + }, + .stats_cnt = 2, +}; + +/* vNIC software stats */ +static int +nfp_hstat_vnic_sw_rx_get(struct net_device *dev, struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) +{ + struct nfp_net *nn = netdev_priv(dev); + struct nfp_net_r_vector *r_vec; + + r_vec = &nn->r_vecs[rtnl_hstat_qual_get(req, RTNL_HSTATS_QUAL_QUEUE)]; + + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_PKTS, r_vec->rx_pkts); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_BYTES, r_vec->rx_bytes); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_CSUM_PARTIAL, + r_vec->hw_csum_rx_complete); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_CSUM_UNNECESSARY, + r_vec->hw_csum_rx_ok + r_vec->hw_csum_rx_inner_ok); + return 0; +} + +static const struct rtnl_hstat_group nfp_hstat_vnic_sw_rx = { + .qualifiers = { + RTNL_HSTATS_QUALS_BASIC(DRV, RX), + [RTNL_HSTATS_QUAL_QUEUE] = { + .get_max = nfp_hstat_vnic_nfd_get_queues, + }, + }, + + .get_stats = nfp_hstat_vnic_sw_rx_get, + .stats = { + [0] = RTNL_HSTATS_STAT_LINUX_PKTS_BIT | + RTNL_HSTATS_STAT_LINUX_BYTES_BIT | + RTNL_HSTATS_STAT_LINUX_CSUM_PARTIAL_BIT | + RTNL_HSTATS_STAT_LINUX_CSUM_UNNECESSARY_BIT, + + }, + .stats_cnt = 4, +}; + +static int +nfp_hstat_vnic_sw_tx_get(struct net_device *dev, struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) +{ + struct nfp_net *nn = netdev_priv(dev); + struct nfp_net_r_vector *r_vec; + + r_vec = &nn->r_vecs[rtnl_hstat_qual_get(req, RTNL_HSTATS_QUAL_QUEUE)]; + + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_PKTS, r_vec->tx_pkts); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_BYTES, r_vec->tx_bytes); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_BUSY, r_vec->tx_busy); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_CSUM_PARTIAL, + r_vec->hw_csum_tx + r_vec->hw_csum_tx_inner); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_SEGMENTATION_OFFLOAD_PKTS, + r_vec->tx_lso); + return 0; +} + +static const struct rtnl_hstat_group nfp_hstat_vnic_sw_tx = { + .qualifiers = { + RTNL_HSTATS_QUALS_BASIC(DRV, TX), + [RTNL_HSTATS_QUAL_QUEUE] = { + .get_max = nfp_hstat_vnic_nfd_get_queues, + }, + }, + + .get_stats = nfp_hstat_vnic_sw_tx_get, + .stats = { + [0] = RTNL_HSTATS_STAT_LINUX_PKTS_BIT | + RTNL_HSTATS_STAT_LINUX_BYTES_BIT | + RTNL_HSTATS_STAT_LINUX_BUSY_BIT | + RTNL_HSTATS_STAT_LINUX_CSUM_PARTIAL_BIT | + RTNL_HSTATS_STAT_LINUX_SEGMENTATION_OFFLOAD_PKTS_BIT, + }, + .stats_cnt = 5, +}; + +static const struct rtnl_hstat_group nfp_hstat_vnic_sw = { + .has_children = true, + .children = { + &nfp_hstat_vnic_sw_rx, + &nfp_hstat_vnic_sw_tx, + NULL, + }, +}; + int nfp_net_hstat_get_groups(const struct net_device *netdev, struct rtnl_hstat_req *req) { + rtnl_hstat_add_grp(req, &nfp_hstat_vnic_sw); + rtnl_hstat_add_grp(req, &nfp_hstat_vnic_nfd_pq); rtnl_hstat_add_grp(req, &nfp_hstat_vnic_nfd); return 0; From patchwork Mon Jan 28 23:45:03 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032328 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="R9i3zrtc"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR916pnxz9s9h for ; Tue, 29 Jan 2019 10:46:13 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727520AbfA1XqN (ORCPT ); Mon, 28 Jan 2019 18:46:13 -0500 Received: from mail-qt1-f196.google.com ([209.85.160.196]:38110 "EHLO mail-qt1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727495AbfA1XqL (ORCPT ); Mon, 28 Jan 2019 18:46:11 -0500 Received: by mail-qt1-f196.google.com with SMTP id p17so20396580qtl.5 for ; Mon, 28 Jan 2019 15:46:10 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=voXTLd+THOijaHSEH5sHow08f3veYBR93jOHr+H3FOk=; b=R9i3zrtcoRnKLjEVTrkIMiXWZyrOg1NvN5nP1qQ9cqzG9tiOWK38R4md5Sc6EJg0Vb e23x25AcNlza22CAv0/iSTjdSyUqs8qUW3fuocxrjvpZ+oyDJK4/mNcUebNUOyzG+CxP B6oybdWdAENWDH39rDUUf6H2gGrDBPEANvANig4Bbp/Tpbr90Cc9hJ5JrpQyH3YhuX5a 4TQOnQSR0flflzNtCr6S7HdW3V7YExyfk3V7HpLCXJZvD9iSqC2E1VipmOZz3vA5YkUb o6yOx8W5jXXdBdzDa+fG5EI1jdxLCrFAypmqRhCHOjjwBQaVwjAnNM0EgZ9z+b9yJ6me Zdyg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=voXTLd+THOijaHSEH5sHow08f3veYBR93jOHr+H3FOk=; b=TdUD9fM1P9Ff8InyCy7tKDcKwnrDT/Ss4kg0ASJ/GCrPts6jKSTLoBT96Tc1iGxgz2 0DvjJZgRJm2xKnrg6jQ+mwhcQ56D57g3mn0VIXCL7qsy+nJ7h2OSQdBBAtz55ayEY7mb 5Ejy/jALuiFBJjrU5uLJWU+IQ9+iDFcp89DnXTQ6m6I4IJPzy9BZF6DF+6fsaAqYR9Fe eIedY/WmIxLSqNOfr3ZQyQCzDu+PLKCpIryvmXpjq6FnEu/1kfJbbBtckNocgErpYRFS WzTAsj3Vg+HPQVqE/Bky0cMBz0aI3vHAvWH6W9RQ6OFunhU4k5522WlCn1Tx69hdIRQ/ wqtA== X-Gm-Message-State: AJcUukc3sWLdO0td8pgW+PLz9ul2WjuOmePQOKBC0ohvCr2Ts97X7AnW E2SpPUUKxJ4J/XAJlRqVYmX8pg== X-Google-Smtp-Source: ALg8bN512wqI017z4BX6bV45icBM1URgWhHfI5WvHT+OTcWwFaBy4Fz7P1LZFTVaSCG9I/n8Wqn5cQ== X-Received: by 2002:a0c:f8cb:: with SMTP id h11mr22845634qvo.134.1548719170203; Mon, 28 Jan 2019 15:46:10 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.46.07 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:46:09 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 10/14] net: hstats: add IEEE 802.3 and common IETF MIB/RMON stats Date: Mon, 28 Jan 2019 15:45:03 -0800 Message-Id: <20190128234507.32028-11-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add IDs for standard-based counters commonly maintained by ethernet hardware (IEEE 802.3, IETF RFC2819, IETF RFC2863). The lists are not intended to be complete, reserve some ID space for adding more stats in the middle if they are found useful later. Signed-off-by: Jakub Kicinski --- include/net/hstats.h | 50 ++++++++++++++++++++++++++++++++++++ include/uapi/linux/if_link.h | 50 ++++++++++++++++++++++++++++++++++++ 2 files changed, 100 insertions(+) diff --git a/include/net/hstats.h b/include/net/hstats.h index bb83f50768b1..dd6d5dc567cb 100644 --- a/include/net/hstats.h +++ b/include/net/hstats.h @@ -101,6 +101,56 @@ enum { RTNL_HSTAT_BIT(LINUX_CSUM_COMPLETE, 0), RTNL_HSTAT_BIT(LINUX_CSUM_UNNECESSARY, 0), RTNL_HSTAT_BIT(LINUX_SEGMENTATION_OFFLOAD_PKTS, 0), + + /* IETF RFC2819 ("Remote Network Monitoring MIB") */ + RTNL_HSTAT_BIT(RFC2819_etherStatsDropEvents, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsOctets, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsPkts, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsBroadcastPkts, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsMulticastPkts, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsCRCAlignErrors, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsUndersizePkts, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsOversizePkts, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsFragments, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsJabbers, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsCollisions, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsPkts64Octets, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsPkts65to127Octets, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsPkts128to255Octets, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsPkts256to511Octets, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsPkts512to1023Octets, 1), + RTNL_HSTAT_BIT(RFC2819_etherStatsPkts1024to1518Octets, 1), + /* Extensions to IETF RFC2819 */ + RTNL_HSTAT_BIT(RFC2819EXT_etherStatsPkts1024toMaxOctets, 1), + RTNL_HSTAT_BIT(RFC2819EXT_etherStatsPkts1519toMaxOctets, 1), + RTNL_HSTAT_BIT(RFC2819EXT_etherStatsPkts1024to2047Octets, 1), + RTNL_HSTAT_BIT(RFC2819EXT_etherStatsPkts2048to4095Octets, 1), + RTNL_HSTAT_BIT(RFC2819EXT_etherStatsPkts4096to8191Octets, 1), + RTNL_HSTAT_BIT(RFC2819EXT_etherStatsPkts8192toMaxOctets, 1), + + /* IETF RFC2863 ("The Interfaces Group MIB") */ + RTNL_HSTAT_BIT(RFC2863_UcastPkts, 1), + RTNL_HSTAT_BIT(RFC2863_Errors, 1), + RTNL_HSTAT_BIT(RFC2863_Discards, 1), + + /* IEEE 802.3 */ + RTNL_HSTAT_BIT(IEEE8023_FramesOK, 2), + RTNL_HSTAT_BIT(IEEE8023_OctetsOK, 2), + RTNL_HSTAT_BIT(IEEE8023_MulticastFramesOK, 2), + RTNL_HSTAT_BIT(IEEE8023_BroadcastFramesOK, 2), + RTNL_HSTAT_BIT(IEEE8023_FrameCheckSequenceErrors, 2), + RTNL_HSTAT_BIT(IEEE8023_AlignmentErrors, 2), + RTNL_HSTAT_BIT(IEEE8023_InRangeLengthErrors, 2), + RTNL_HSTAT_BIT(IEEE8023_OutOfRangeLengthField, 2), + RTNL_HSTAT_BIT(IEEE8023_FrameTooLongErrors, 2), + RTNL_HSTAT_BIT(IEEE8023_CollisionFrames, 2), + RTNL_HSTAT_BIT(IEEE8023_SQETestErrors, 2), + RTNL_HSTAT_BIT(IEEE8023_SymbolErrorDuringCarrier, 2), + RTNL_HSTAT_BIT(IEEE8023_MACControlFrames, 2), + RTNL_HSTAT_BIT(IEEE8023_UnsupportedOpcodes, 2), + RTNL_HSTAT_BIT(IEEE8023_PAUSEMACCtrlFrames, 2), + RTNL_HSTAT_BIT(IEEE8023_FECCorrectedBlocks, 2), + RTNL_HSTAT_BIT(IEEE8023_FECUncorrectableBlocks, 2), #undef RTNL_HSTAT_BIT }; diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h index b33d38ff5b47..c58468100a06 100644 --- a/include/uapi/linux/if_link.h +++ b/include/uapi/linux/if_link.h @@ -982,6 +982,56 @@ enum { IFLA_HSTATS_STAT_LINUX_CSUM_UNNECESSARY, IFLA_HSTATS_STAT_LINUX_SEGMENTATION_OFFLOAD_PKTS, + /* IETF RFC2819 ("Remote Network Monitoring MIB") */ + IFLA_HSTATS_STAT_RFC2819_etherStatsDropEvents = 65, /* 1 */ + IFLA_HSTATS_STAT_RFC2819_etherStatsOctets, + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts, + IFLA_HSTATS_STAT_RFC2819_etherStatsBroadcastPkts, + IFLA_HSTATS_STAT_RFC2819_etherStatsMulticastPkts, + IFLA_HSTATS_STAT_RFC2819_etherStatsCRCAlignErrors, + IFLA_HSTATS_STAT_RFC2819_etherStatsUndersizePkts, + IFLA_HSTATS_STAT_RFC2819_etherStatsOversizePkts, + IFLA_HSTATS_STAT_RFC2819_etherStatsFragments, + IFLA_HSTATS_STAT_RFC2819_etherStatsJabbers, + IFLA_HSTATS_STAT_RFC2819_etherStatsCollisions, + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts64Octets, + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts65to127Octets, + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts128to255Octets, + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts256to511Octets, + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts512to1023Octets, + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts1024to1518Octets, + /* Extensions to IETF RFC2819 */ + IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts1024toMaxOctets, + IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts1519toMaxOctets, + IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts1024to2047Octets, + IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts2048to4095Octets, + IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts4096to8191Octets, + IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts8192toMaxOctets, + + /* IETF RFC2863 ("The Interfaces Group MIB") */ + IFLA_HSTATS_STAT_RFC2863_UcastPkts = 97, + IFLA_HSTATS_STAT_RFC2863_Errors, + IFLA_HSTATS_STAT_RFC2863_Discards, + + /* IEEE 802.3 */ + IFLA_HSTATS_STAT_IEEE8023_FramesOK = 129, /* 2 */ + IFLA_HSTATS_STAT_IEEE8023_OctetsOK, + IFLA_HSTATS_STAT_IEEE8023_MulticastFramesOK, + IFLA_HSTATS_STAT_IEEE8023_BroadcastFramesOK, + IFLA_HSTATS_STAT_IEEE8023_FrameCheckSequenceErrors, + IFLA_HSTATS_STAT_IEEE8023_AlignmentErrors, + IFLA_HSTATS_STAT_IEEE8023_InRangeLengthErrors, + IFLA_HSTATS_STAT_IEEE8023_OutOfRangeLengthField, + IFLA_HSTATS_STAT_IEEE8023_FrameTooLongErrors, + IFLA_HSTATS_STAT_IEEE8023_CollisionFrames, + IFLA_HSTATS_STAT_IEEE8023_SQETestErrors, + IFLA_HSTATS_STAT_IEEE8023_SymbolErrorDuringCarrier, + IFLA_HSTATS_STAT_IEEE8023_MACControlFrames, + IFLA_HSTATS_STAT_IEEE8023_UnsupportedOpcodes, + IFLA_HSTATS_STAT_IEEE8023_PAUSEMACCtrlFrames, + IFLA_HSTATS_STAT_IEEE8023_FECCorrectedBlocks, + IFLA_HSTATS_STAT_IEEE8023_FECUncorrectableBlocks, + __IFLA_HSTATS_STAT_MAX, }; #define IFLA_HSTATS_STAT_MAX (__IFLA_HSTATS_STAT_MAX - 1) From patchwork Mon Jan 28 23:45:04 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032329 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="c75RF//o"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR952bvRz9s9h for ; Tue, 29 Jan 2019 10:46:17 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727536AbfA1XqQ (ORCPT ); Mon, 28 Jan 2019 18:46:16 -0500 Received: from mail-qt1-f195.google.com ([209.85.160.195]:36235 "EHLO mail-qt1-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727495AbfA1XqP (ORCPT ); Mon, 28 Jan 2019 18:46:15 -0500 Received: by mail-qt1-f195.google.com with SMTP id t13so20393397qtn.3 for ; Mon, 28 Jan 2019 15:46:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=GOXY1ml6n+Qm0lqmUQCF+fy0QJ0y4/G/i8aLHH/ZUkE=; b=c75RF//o/WR/mVBl0d9Q/Oi1tX8uTbPKerQ1Rvil4BEL0r2qxeOnkkJ7UsO1vGEZoX rEEaw5OboNkuF/Kfhq4ex/26n55fbOiSPmgrc8iFLbiA8PWlRJodXuPw1UFhyKgNt8Gp j4nXuAeIgghAYb9yHkbQZFI/C6W7P1Co9usynioJNAjdPQvtwVPQA5ed82ABSCKYzfRA S+0bfvtqzvB4Pag6Rf8gUHts0tcVpJp/cTmCJSwNkQkU//iROki4U7GkKtuNacW1VQPl Sox/HbI2mDJlOItsgr7qTQ9cUIJuQxtz0vGJvtk/d2C62qJ0CW1weCsBCtolOyoy0aF6 /vAw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=GOXY1ml6n+Qm0lqmUQCF+fy0QJ0y4/G/i8aLHH/ZUkE=; b=hYk7NI0RHMGqlYQE0w9IcZQo1gpsg/PaKYIad23sCCwaO7B8uxKamVBoISx7RFwKq/ dSCpZOpk62RNpm0robl+0i6HKo7558zOXoYXRKRsVrAz59XsVn+YoOEq0nVw5/wq5i12 HWY2SRuQPc97k/RIZYw0ywQeghGvASmD1B0okUlb883XQokRMr0xt+qRDMXNtugCm6bZ TXG4kjffmQFUxAvkXfX6QZkpZu61jT4R9XdOVlcuOU39jli403JiVIl36lvQm/zJl+EC 5SeQ4gs3wlBcBwnNFy/0oHU+NdjEKfoqMOIGxIgb5SRwSCboJEBHyJKsN60aW4o1sa+A D2Fw== X-Gm-Message-State: AJcUukeZQbtaqtxVafg3zqrOaRuuzqOoRLtYfoLSHtS+9Z/Z86r0ZWqn mPP1SBo+498RHWMrYfzzyGVUcg== X-Google-Smtp-Source: ALg8bN5gTV0q8OnYAdsdTALep9ZbM/EpOP9lHUaQkHJhVppBcDN7Q05Mfs1LlBPdKwvkCJcv90VJXg== X-Received: by 2002:aed:2342:: with SMTP id i2mr24049531qtc.341.1548719172794; Mon, 28 Jan 2019 15:46:12 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.46.10 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:46:12 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 11/14] nfp: hstats: add IEEE/RMON ethernet port/MAC stats Date: Mon, 28 Jan 2019 15:45:04 -0800 Message-Id: <20190128234507.32028-12-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add groups for MAC statistics, NFP's MAC/PHY maintains a mix of IEEE 802.3 and RMON-compatible statistics. Use the RMON stats for driver drops and error counters as well. Since the MAC stats are quite large initialize the hstat bitmap when driver is loaded. Signed-off-by: Jakub Kicinski --- .../net/ethernet/netronome/nfp/nfp_hstat.c | 257 +++++++++++++++++- drivers/net/ethernet/netronome/nfp/nfp_main.c | 1 + drivers/net/ethernet/netronome/nfp/nfp_main.h | 2 + 3 files changed, 257 insertions(+), 3 deletions(-) diff --git a/drivers/net/ethernet/netronome/nfp/nfp_hstat.c b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c index 9300996e756c..cd97cd2676f6 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_hstat.c +++ b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c @@ -4,6 +4,217 @@ #include #include "nfp_net.h" +#include "nfp_port.h" + +/* MAC stats */ +static const struct nfp_stat_pair { + u32 attr; + u32 offset; +} nfp_mac_stats_rx[] = { + { + IFLA_HSTATS_STAT_RFC2819_etherStatsOctets, + NFP_MAC_STATS_RX_IN_OCTETS + }, { + IFLA_HSTATS_STAT_IEEE8023_FrameTooLongErrors, + NFP_MAC_STATS_RX_FRAME_TOO_LONG_ERRORS + }, { + IFLA_HSTATS_STAT_IEEE8023_InRangeLengthErrors, + NFP_MAC_STATS_RX_RANGE_LENGTH_ERRORS + }, + /* missing NFP_MAC_STATS_RX_VLAN_RECEIVED_OK, no standard counter */ + { + IFLA_HSTATS_STAT_RFC2863_Errors, + NFP_MAC_STATS_RX_IN_ERRORS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsBroadcastPkts, + NFP_MAC_STATS_RX_IN_BROADCAST_PKTS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsDropEvents, + NFP_MAC_STATS_RX_DROP_EVENTS + }, { + IFLA_HSTATS_STAT_IEEE8023_AlignmentErrors, + NFP_MAC_STATS_RX_ALIGNMENT_ERRORS + }, { + IFLA_HSTATS_STAT_IEEE8023_PAUSEMACCtrlFrames, + NFP_MAC_STATS_RX_PAUSE_MAC_CTRL_FRAMES + }, { + IFLA_HSTATS_STAT_IEEE8023_FramesOK, + NFP_MAC_STATS_RX_FRAMES_RECEIVED_OK + }, { + IFLA_HSTATS_STAT_IEEE8023_FrameCheckSequenceErrors, + NFP_MAC_STATS_RX_FRAME_CHECK_SEQUENCE_ERRORS + }, { + IFLA_HSTATS_STAT_RFC2863_UcastPkts, + NFP_MAC_STATS_RX_UNICAST_PKTS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsMulticastPkts, + NFP_MAC_STATS_RX_MULTICAST_PKTS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts, + NFP_MAC_STATS_RX_PKTS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsUndersizePkts, + NFP_MAC_STATS_RX_UNDERSIZE_PKTS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts64Octets, + NFP_MAC_STATS_RX_PKTS_64_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts65to127Octets, + NFP_MAC_STATS_RX_PKTS_65_TO_127_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts512to1023Octets, + NFP_MAC_STATS_RX_PKTS_512_TO_1023_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts1024to1518Octets, + NFP_MAC_STATS_RX_PKTS_1024_TO_1518_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsJabbers, + NFP_MAC_STATS_RX_JABBERS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsFragments, + NFP_MAC_STATS_RX_FRAGMENTS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts128to255Octets, + NFP_MAC_STATS_RX_PKTS_128_TO_255_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts256to511Octets, + NFP_MAC_STATS_RX_PKTS_256_TO_511_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts1519toMaxOctets, + NFP_MAC_STATS_RX_PKTS_1519_TO_MAX_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsOversizePkts, + NFP_MAC_STATS_RX_OVERSIZE_PKTS + }, { + IFLA_HSTATS_STAT_IEEE8023_MACControlFrames, + NFP_MAC_STATS_RX_MAC_CTRL_FRAMES_RECEIVED + } +}, nfp_mac_stats_tx[] = { + { + IFLA_HSTATS_STAT_RFC2819_etherStatsOctets, + NFP_MAC_STATS_TX_OUT_OCTETS + }, + /* missing NFP_MAC_STATS_TX_VLAN_TRANSMITTED_OK, no standard counter */ + { + IFLA_HSTATS_STAT_RFC2863_Errors, + NFP_MAC_STATS_TX_OUT_ERRORS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsBroadcastPkts, + NFP_MAC_STATS_TX_BROADCAST_PKTS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts64Octets, + NFP_MAC_STATS_TX_PKTS_64_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts256to511Octets, + NFP_MAC_STATS_TX_PKTS_256_TO_511_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts512to1023Octets, + NFP_MAC_STATS_TX_PKTS_512_TO_1023_OCTETS + }, { + IFLA_HSTATS_STAT_IEEE8023_PAUSEMACCtrlFrames, + NFP_MAC_STATS_TX_PAUSE_MAC_CTRL_FRAMES + }, { + IFLA_HSTATS_STAT_IEEE8023_FramesOK, + NFP_MAC_STATS_TX_FRAMES_TRANSMITTED_OK + }, { + IFLA_HSTATS_STAT_RFC2863_UcastPkts, + NFP_MAC_STATS_TX_UNICAST_PKTS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsMulticastPkts, + NFP_MAC_STATS_TX_MULTICAST_PKTS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts65to127Octets, + NFP_MAC_STATS_TX_PKTS_65_TO_127_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts128to255Octets, + NFP_MAC_STATS_TX_PKTS_128_TO_255_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819_etherStatsPkts1024to1518Octets, + NFP_MAC_STATS_TX_PKTS_1024_TO_1518_OCTETS + }, { + IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts1519toMaxOctets, + NFP_MAC_STATS_TX_PKTS_1519_TO_MAX_OCTETS + } +}; + +static int +nfp_hstat_mac_get(struct net_device *netdev, struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) +{ + const struct nfp_stat_pair *pairs; + struct nfp_port *port; + unsigned int dir, i; + + port = nfp_port_from_netdev(netdev); + if (!__nfp_port_get_eth_port(port) || !port->eth_stats) + return -EINVAL; + + dir = rtnl_hstat_qual_get(req, RTNL_HSTATS_QUAL_DIRECTION); + pairs = dir == IFLA_HSTATS_QUAL_DIR_RX ? + nfp_mac_stats_rx : nfp_mac_stats_tx; + + for (i = 0; i < grp->stats_cnt; i++) + rtnl_hstat_dump(req, pairs[i].attr, + readq(port->eth_stats + pairs[i].offset)); + return 0; +} + +static struct rtnl_hstat_group nfp_hstat_mac_rx __ro_after_init = { + .qualifiers = { + RTNL_HSTATS_QUALS_BASIC(DEV, RX), + }, + + .get_stats = nfp_hstat_mac_get, +}; + +static struct rtnl_hstat_group nfp_hstat_mac_tx __ro_after_init = { + .qualifiers = { + RTNL_HSTATS_QUALS_BASIC(DEV, TX), + }, + + .get_stats = nfp_hstat_mac_get, +}; + +static const struct rtnl_hstat_group nfp_hstat_mac = { + .has_children = true, + .children = { + &nfp_hstat_mac_rx, + &nfp_hstat_mac_tx, + NULL, + }, +}; + +static int +nfp_hstat_mac_head_drop(struct net_device *netdev, struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) +{ + struct nfp_port *port; + unsigned int off, dir; + + port = nfp_port_from_netdev(netdev); + if (!__nfp_port_get_eth_port(port) || !port->eth_stats) + return -EINVAL; + + dir = rtnl_hstat_qual_get(req, RTNL_HSTATS_QUAL_DIRECTION); + off = dir == IFLA_HSTATS_QUAL_DIR_RX ? + NFP_MAC_STATS_RX_MAC_HEAD_DROP : NFP_MAC_STATS_TX_QUEUE_DROP; + + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_RFC2819_etherStatsDropEvents, + readq(port->eth_stats + off)); + return 0; +} + +static const struct rtnl_hstat_group nfp_hstat_tm = { + .qualifiers = { + RTNL_HSTATS_QUALS_BASIC_BIDIR(DEV), + }, + + .get_stats = nfp_hstat_mac_head_drop, + .stats = { + [1] = RTNL_HSTATS_STAT_RFC2819_etherStatsDropEvents_BIT, + }, + .stats_cnt = 1, +}; /* NFD per-vNIC stats */ static int @@ -21,6 +232,10 @@ nfp_hstat_vnic_nfd_basic_get(struct net_device *netdev, nn_readq(nn, NFP_NET_CFG_STATS_RX_FRAMES + off)); rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_BYTES, nn_readq(nn, NFP_NET_CFG_STATS_RX_OCTETS + off)); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_RFC2863_Errors, + nn_readq(nn, NFP_NET_CFG_STATS_RX_ERRORS + off)); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_RFC2863_Discards, + nn_readq(nn, NFP_NET_CFG_STATS_RX_DISCARDS + off)); return 0; } @@ -33,8 +248,10 @@ static const struct rtnl_hstat_group nfp_hstat_vnic_nfd = { .stats = { [0] = RTNL_HSTATS_STAT_LINUX_PKTS_BIT | RTNL_HSTATS_STAT_LINUX_BYTES_BIT, + [2] = RTNL_HSTATS_STAT_RFC2863_Errors_BIT | + RTNL_HSTATS_STAT_RFC2863_Discards_BIT, }, - .stats_cnt = 2, + .stats_cnt = 4, }; /* NFD per-Q stats */ @@ -99,6 +316,8 @@ nfp_hstat_vnic_sw_rx_get(struct net_device *dev, struct rtnl_hstat_req *req, r_vec->hw_csum_rx_complete); rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_CSUM_UNNECESSARY, r_vec->hw_csum_rx_ok + r_vec->hw_csum_rx_inner_ok); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_RFC2819_etherStatsDropEvents, + r_vec->rx_drops); return 0; } @@ -116,9 +335,10 @@ static const struct rtnl_hstat_group nfp_hstat_vnic_sw_rx = { RTNL_HSTATS_STAT_LINUX_BYTES_BIT | RTNL_HSTATS_STAT_LINUX_CSUM_PARTIAL_BIT | RTNL_HSTATS_STAT_LINUX_CSUM_UNNECESSARY_BIT, + [1] = RTNL_HSTATS_STAT_RFC2819_etherStatsDropEvents_BIT, }, - .stats_cnt = 4, + .stats_cnt = 5, }; static int @@ -137,6 +357,7 @@ nfp_hstat_vnic_sw_tx_get(struct net_device *dev, struct rtnl_hstat_req *req, r_vec->hw_csum_tx + r_vec->hw_csum_tx_inner); rtnl_hstat_dump(req, IFLA_HSTATS_STAT_LINUX_SEGMENTATION_OFFLOAD_PKTS, r_vec->tx_lso); + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_RFC2863_Errors, r_vec->tx_errors); return 0; } @@ -155,8 +376,9 @@ static const struct rtnl_hstat_group nfp_hstat_vnic_sw_tx = { RTNL_HSTATS_STAT_LINUX_BUSY_BIT | RTNL_HSTATS_STAT_LINUX_CSUM_PARTIAL_BIT | RTNL_HSTATS_STAT_LINUX_SEGMENTATION_OFFLOAD_PKTS_BIT, + [1] = RTNL_HSTATS_STAT_RFC2863_Errors_BIT, }, - .stats_cnt = 5, + .stats_cnt = 6, }; static const struct rtnl_hstat_group nfp_hstat_vnic_sw = { @@ -171,9 +393,38 @@ static const struct rtnl_hstat_group nfp_hstat_vnic_sw = { int nfp_net_hstat_get_groups(const struct net_device *netdev, struct rtnl_hstat_req *req) { + struct nfp_port *port; + rtnl_hstat_add_grp(req, &nfp_hstat_vnic_sw); rtnl_hstat_add_grp(req, &nfp_hstat_vnic_nfd_pq); rtnl_hstat_add_grp(req, &nfp_hstat_vnic_nfd); + port = nfp_port_from_netdev(netdev); + if (__nfp_port_get_eth_port(port) && port->eth_stats) { + rtnl_hstat_add_grp(req, &nfp_hstat_tm); + rtnl_hstat_add_grp(req, &nfp_hstat_mac); + } + return 0; } + +void __init nfp_net_hstat_init(void) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(nfp_mac_stats_rx); i++) { + unsigned int attr; + + attr = nfp_mac_stats_rx[i].attr; + nfp_hstat_mac_rx.stats[attr / 64] |= BIT_ULL(attr % 64); + } + nfp_hstat_mac_rx.stats_cnt = ARRAY_SIZE(nfp_mac_stats_rx); + + for (i = 0; i < ARRAY_SIZE(nfp_mac_stats_tx); i++) { + unsigned int attr; + + attr = nfp_mac_stats_tx[i].attr; + nfp_hstat_mac_tx.stats[attr / 64] |= BIT_ULL(attr % 64); + } + nfp_hstat_mac_tx.stats_cnt = ARRAY_SIZE(nfp_mac_stats_tx); +} diff --git a/drivers/net/ethernet/netronome/nfp/nfp_main.c b/drivers/net/ethernet/netronome/nfp/nfp_main.c index 6c10e8d119e4..4e366fde3478 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_main.c +++ b/drivers/net/ethernet/netronome/nfp/nfp_main.c @@ -724,6 +724,7 @@ static int __init nfp_main_init(void) nfp_driver_name); nfp_net_debugfs_create(); + nfp_net_hstat_init(); err = pci_register_driver(&nfp_pci_driver); if (err < 0) diff --git a/drivers/net/ethernet/netronome/nfp/nfp_main.h b/drivers/net/ethernet/netronome/nfp/nfp_main.h index a3613a2e0aa5..367afb869df6 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_main.h +++ b/drivers/net/ethernet/netronome/nfp/nfp_main.h @@ -145,6 +145,8 @@ extern struct pci_driver nfp_netvf_pci_driver; extern const struct devlink_ops nfp_devlink_ops; +void nfp_net_hstat_init(void); + int nfp_net_pci_probe(struct nfp_pf *pf); void nfp_net_pci_remove(struct nfp_pf *pf); From patchwork Mon Jan 28 23:45:05 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032330 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="CUGiONRj"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR962W4hz9sDK for ; Tue, 29 Jan 2019 10:46:18 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727559AbfA1XqR (ORCPT ); Mon, 28 Jan 2019 18:46:17 -0500 Received: from mail-qt1-f196.google.com ([209.85.160.196]:41474 "EHLO mail-qt1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727500AbfA1XqQ (ORCPT ); Mon, 28 Jan 2019 18:46:16 -0500 Received: by mail-qt1-f196.google.com with SMTP id l12so20367375qtf.8 for ; Mon, 28 Jan 2019 15:46:15 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=r7ec2bDNQAGIdLyljmIGjWli6Ejo1jwXIGswqYk6Rbo=; b=CUGiONRjevMkE5VGoZI8fS570rneaXks5PZOfIXpr1ki3uzPjZ9neOpIqg7QX+q9os R0fE+Evx8SZ/AsJ9VkTxI5QN/hpKdOxTDTMyHcp6/3/yP+XFiPSRlf6leGqXBpf7WUc3 5guR+3kU45kAQfDgTdEEPOOlCzklzxTZeZD6O/B+7z9WepKFzCabSvLc34lqHnroD9WI B5sjjlWsB04EF6tJOw9wbjwQNuXM82gMpZhAdakZZi2FIqmmcP8QGfCUI9N8KI+JjAuV bv+NAqDBZbosIIdBfciW3px+OH9daQpr2cxLwtrzWg29+1CQ/tzqKraYmMrO6lXqdJWZ wUMA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=r7ec2bDNQAGIdLyljmIGjWli6Ejo1jwXIGswqYk6Rbo=; b=UFj9LVxq2I/iP0GtAhs7sf7PMFea4y7PIkOqc1sT7GTm+RPqlnFNDW317v0zaQHhuZ zy3lGjusIT4d1MmZC/tiodeAUdv0gY4Pvw3H1O/0iqdW2BeArFrtMgXgj4ks9qR2UUDP lSHrA5AxX0KGFWcEnq7/zksYF8mr6IJ4HS5AxrpssHNQXuBa+J7qw1TGBr8xXZGVTh3Y z3yXC5HiCDcX//3dQ3s9PLufG3OC4v80O+WFO12L7o0sxm7tTl29ENV8V4jGVihTHN1f YOAYF3BGEWqtRzZTUja6uaDdoZ0vK3V4Rt91KCNGflBO3PLeQjJEZz1u6klMA/zQEm64 lXjg== X-Gm-Message-State: AJcUukeJL1vKpkWSGERss+V8e/M7UXVAKkHmr+FjLNmJ2DanSE45BEMo o16WvqkQW00tnexI6FFi/CL+gg== X-Google-Smtp-Source: ALg8bN67+t3N2Z3lMJzhe7hrNw3tvua9D6KEninr1pBoioQ8etLRdrOekpPLzRIWGpXjeTa98aH7CA== X-Received: by 2002:ac8:42c1:: with SMTP id g1mr23923360qtm.118.1548719175145; Mon, 28 Jan 2019 15:46:15 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.46.12 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:46:14 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 12/14] net: hstats: add markers for partial groups Date: Mon, 28 Jan 2019 15:45:05 -0800 Message-Id: <20190128234507.32028-13-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Hstats try to be hierarchy-neutral to the consumer, i.e. if users only care about total statistics they should be able to add given statistic throughout the hierarchy. Events can't be counted multiple times (inside one root group, that's why multiple are allowed), and they can't be missing. Sometimes, however, HW doesn't give use enough information, or software may not see all events it wants to count. Add an attribute to indicate to user space that given statistic group does not report all events reliably. Signed-off-by: Jakub Kicinski --- include/net/hstats.h | 2 ++ include/uapi/linux/if_link.h | 9 +++++++++ net/core/hstats.c | 17 +++++++++++++++++ 3 files changed, 28 insertions(+) diff --git a/include/net/hstats.h b/include/net/hstats.h index dd6d5dc567cb..3e10694d3d66 100644 --- a/include/net/hstats.h +++ b/include/net/hstats.h @@ -45,6 +45,7 @@ struct rtnl_hstat_qualifier { * struct rtnl_hstat_group - node in the hstat hierarchy * @qualifiers: attributes describing this group * @has_children: @children array is present and NULL-terminated + * @partial_flags: partial flags * @stats_cnt: number of stats in the bitmask * @stats: bitmask of stats present * @get_stats: driver callback for dumping the stats @@ -54,6 +55,7 @@ struct rtnl_hstat_qualifier { struct rtnl_hstat_group { /* Note: this is *not* indexed with IFLA_* attributes! */ struct rtnl_hstat_qualifier qualifiers[RTNL_HSTATS_QUAL_CNT]; + u8 partial_flags; bool has_children; /* Can't use bitmaps - words are variable length */ unsigned int stats_cnt; diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h index c58468100a06..28ac4574bb0e 100644 --- a/include/uapi/linux/if_link.h +++ b/include/uapi/linux/if_link.h @@ -946,6 +946,7 @@ enum { IFLA_HSTATS_UNSPEC, IFLA_HSTATS_GROUP, IFLA_HSTATS_STATS, + IFLA_HSTATS_PARTIAL, IFLA_HSTATS_QUAL_TYPE, IFLA_HSTATS_QUAL_DIRECTION, IFLA_HSTATS_QUAL_QUEUE, @@ -955,6 +956,14 @@ enum { }; #define IFLA_HSTATS_MAX (__IFLA_HSTATS_MAX - 1) +enum { + IFLA_HSTATS_PARTIAL_UNSPEC, + IFLA_HSTATS_PARTIAL_CLASSIFIER = 1, + IFLA_HSTATS_PARTIAL_SLOWPATH = 2, + __IFLA_HSTATS_PARTIAL_MAX, +}; +#define IFLA_HSTATS_PARTIAL_MAX (__IFLA_HSTATS_PARTIAL_MAX - 1) + enum { IFLA_HSTATS_QUAL_TYPE_UNSPEC, IFLA_HSTATS_QUAL_TYPE_DEV, diff --git a/net/core/hstats.c b/net/core/hstats.c index c689ebfdaeaa..c9b7264d98dc 100644 --- a/net/core/hstats.c +++ b/net/core/hstats.c @@ -358,6 +358,17 @@ hstat_dumper_put_qual(struct hstat_dumper *dumper, int i, u32 val) return nla_put_u32(dumper->skb, rtnl_qual2ifla[i], val); } +static int +hstat_dumper_put_partials(struct hstat_dumper *dumper, u32 val) +{ + if (dumper->sizing) { + dumper->size += nla_total_size(sizeof(u32)); + return 0; + } + + return nla_put_u32(dumper->skb, IFLA_HSTATS_PARTIAL, val); +} + /* Dumper handlers */ static int hstat_dumper_grp_load(struct hstat_dumper *dumper) { @@ -378,6 +389,12 @@ static int hstat_dumper_grp_load(struct hstat_dumper *dumper) if (err) return err; + if (cmd.grp->partial_flags) { + err = hstat_dumper_put_partials(dumper, cmd.grp->partial_flags); + if (err) + return err; + } + for (i = 0; i < RTNL_HSTATS_QUAL_CNT; i++) { const struct rtnl_hstat_qualifier *q; From patchwork Mon Jan 28 23:45:06 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032331 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="No/kVtul"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR9C0V2mz9s9h for ; Tue, 29 Jan 2019 10:46:23 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727575AbfA1XqV (ORCPT ); Mon, 28 Jan 2019 18:46:21 -0500 Received: from mail-qt1-f194.google.com ([209.85.160.194]:46069 "EHLO mail-qt1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727500AbfA1XqS (ORCPT ); Mon, 28 Jan 2019 18:46:18 -0500 Received: by mail-qt1-f194.google.com with SMTP id e5so20319795qtr.12 for ; Mon, 28 Jan 2019 15:46:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=U1OzMF1gF2mBEsbVbZSdiA0ukJHj/pm4ddqnZUggyX8=; b=No/kVtulQ45sM54ArT1kpry5q1htYfgia5qKXRmxPfwYAhe00imA081q6SqJy/IvjT KVFjW1R4dRuzNrcrLvpwQLH0lH0xMGlIUF3EYfFzlsprrtK3T7J+BDNt1e52EZNeTCzj p+wAXPAS4bd6Tv+Fx5deQjyxMLpjSDI2g4ARHvbY/fhA5C35VNmy4e8LzDGFJc+Q3wLZ CR10yOkW5HUzM682QxDZmnb6AwGHvVSfwbx3FcvfUMBxaopsZ/wouJ30KFodN+qUvOvV 9NuBP2mre/LhGq7G3ipYCAyDNrhsoZWZmL3+8R0FsGNDyVitjcURGqt3ryp9naAl3unW p+AA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=U1OzMF1gF2mBEsbVbZSdiA0ukJHj/pm4ddqnZUggyX8=; b=HlxglBEPh+dVslv283XdWA8HMNyK92jzSSIbeGzGd4Qf7z+XjUD2fd0+sz404QEo4n dKvMPr+KkFTgTZQK4yj7Sq5vIjVkdCRePlQnOycBnqu4gvgw3DtzGLisw/WaIdHz7yZ5 p4yr3vRBw1z9wGuTFz2s9cbYyrPaZjZ+YhdC5hOwMVEW7n7JaHKpt7tBfCYpko0oQBZ4 +OCjzr7fu4QyP3kFDotLOWIAO4Z653MzkEpSqQwKAxlLNN5Xd1rrUv2HhdYtwym29e0w 31sHagU90G7AHbqUnNOl0g31EenO/Vp7ZSJ7bkPsIiRT57BLjr3oMUYbZ8ZusGnwgQ99 l9eg== X-Gm-Message-State: AJcUukfxnVOv2j6/4N/8eR79DO3a3wMrwrmyKIcemYdfZVKJtIK8O0pK SvoNliN4QoSzvjJ3xXaFpT8mBQ== X-Google-Smtp-Source: ALg8bN5akcr3A4C6K2ZkWhZ4tylRhjlpr8W1oR7R4yOytbfT5GLO3LxMyeylh+sQajvAwm7BfwBcig== X-Received: by 2002:a0c:cb09:: with SMTP id o9mr22125598qvk.96.1548719177717; Mon, 28 Jan 2019 15:46:17 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.46.15 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:46:16 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 13/14] nfp: hstats: add a partial group of per-8021Q prio stats Date: Mon, 28 Jan 2019 15:45:06 -0800 Message-Id: <20190128234507.32028-14-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org The MAC maintains counts of PFC per-prio pause frames. Unfortunately, I couldn't find such counters in any standard, so add a partial group (HW doesn't give us "non-PFC" count) with those counters. Signed-off-by: Jakub Kicinski --- .../net/ethernet/netronome/nfp/nfp_hstat.c | 44 +++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/drivers/net/ethernet/netronome/nfp/nfp_hstat.c b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c index cd97cd2676f6..ced4edca8b73 100644 --- a/drivers/net/ethernet/netronome/nfp/nfp_hstat.c +++ b/drivers/net/ethernet/netronome/nfp/nfp_hstat.c @@ -216,6 +216,49 @@ static const struct rtnl_hstat_group nfp_hstat_tm = { .stats_cnt = 1, }; +static int +nfp_hstat_mac_pp_pause(struct net_device *netdev, struct rtnl_hstat_req *req, + const struct rtnl_hstat_group *grp) +{ + static const u32 remap_rx[] = { + 0xe0, 0xe8, 0xb0, 0xb8, 0xf0, 0xf7, 0x100, 0x108 + }; + static const u32 remap_tx[] = { + 0x1c0, 0x1c8, 0x1e0, 0x1e8, 0x1d0, 0x1d8, 0x1f0, 0x1f8 + }; + struct nfp_port *port; + const u32 *remap; + u8 dir, prio; + + port = nfp_port_from_netdev(netdev); + if (!__nfp_port_get_eth_port(port) || !port->eth_stats) + return -EINVAL; + + prio = rtnl_hstat_qual_get(req, RTNL_HSTATS_QUAL_PRIORITY); + dir = rtnl_hstat_qual_get(req, RTNL_HSTATS_QUAL_DIRECTION); + remap = dir == IFLA_HSTATS_QUAL_DIR_RX ? remap_rx : remap_tx; + + rtnl_hstat_dump(req, IFLA_HSTATS_STAT_IEEE8023_PAUSEMACCtrlFrames, + readq(port->eth_stats + remap[prio])); + return 0; +} + +static const struct rtnl_hstat_group nfp_hstat_pp_pause = { + .qualifiers = { + RTNL_HSTATS_QUALS_BASIC_BIDIR(DEV), + [RTNL_HSTATS_QUAL_PRIORITY] = { + .max = 8, + }, + }, + .partial_flags = IFLA_HSTATS_PARTIAL_CLASSIFIER, + + .get_stats = nfp_hstat_mac_pp_pause, + .stats = { + [1] = RTNL_HSTATS_STAT_IEEE8023_PAUSEMACCtrlFrames_BIT, + }, + .stats_cnt = 1, +}; + /* NFD per-vNIC stats */ static int nfp_hstat_vnic_nfd_basic_get(struct net_device *netdev, @@ -402,6 +445,7 @@ int nfp_net_hstat_get_groups(const struct net_device *netdev, port = nfp_port_from_netdev(netdev); if (__nfp_port_get_eth_port(port) && port->eth_stats) { rtnl_hstat_add_grp(req, &nfp_hstat_tm); + rtnl_hstat_add_grp(req, &nfp_hstat_pp_pause); rtnl_hstat_add_grp(req, &nfp_hstat_mac); } From patchwork Mon Jan 28 23:45:07 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Kicinski X-Patchwork-Id: 1032332 X-Patchwork-Delegate: davem@davemloft.net Return-Path: X-Original-To: patchwork-incoming-netdev@ozlabs.org Delivered-To: patchwork-incoming-netdev@ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=netdev-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=netronome.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=netronome-com.20150623.gappssmtp.com header.i=@netronome-com.20150623.gappssmtp.com header.b="QKhbQFF+"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 43pR9F4r8fz9s9h for ; Tue, 29 Jan 2019 10:46:25 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727593AbfA1XqY (ORCPT ); Mon, 28 Jan 2019 18:46:24 -0500 Received: from mail-qt1-f181.google.com ([209.85.160.181]:35047 "EHLO mail-qt1-f181.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727578AbfA1XqX (ORCPT ); Mon, 28 Jan 2019 18:46:23 -0500 Received: by mail-qt1-f181.google.com with SMTP id v11so20406876qtc.2 for ; Mon, 28 Jan 2019 15:46:22 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=netronome-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=3WzdSwrvXxKc2CWlvKo1p++9UlhT+68vLJujB1SMyc8=; b=QKhbQFF+2QNxMbIlUFS3Yc5m+KedqPAdtGVHNBbdPLztMnRZ5SdIylDAgD6PZ9ARt/ nDEAKxr5VIb0LmYihb7JQBUzz4/YR/KLz7DRdpAdwIikGBo4AXUfG7z3Jx+tRMOeA2km 0/5Mn/JQg9PLpKT/ZA498PYu6MFvGVzs5hMvPA2MyL9Xw5fLlMTyLaq7a82gmKa/TVqI hwORzBd/yfMl0VkOpfUpKQ39VXDTw+DlV+rRamdyzcpFCNMICQdPxrIRb3nkxFDU7zVG Q4mZB6CLmcChmSPWy2uMIhYeDD/HV/G+TC66U5BLs46OT5vHvk2Hof5GCoryQD5G2y3f hOfg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=3WzdSwrvXxKc2CWlvKo1p++9UlhT+68vLJujB1SMyc8=; b=E7hbkVCiW6KKMAj3a8qeA7PmDdTnCKLI+sPIK3MI8l7SzpvURCpe05H6rslWqPJu0q 6WzR8ch6BjEFAJtJOTeFj35wcKf//PJEY17cj1QatvbbbSK8FTaM7zzNEK+amXgGD5CJ 7m6d91wyEk+eJ4XYkIJCseWNpplbpUfPpqJJsULjROPXqKIGlpDNEn8H3KNJoc/NCm47 0jDkL5sj192cRlGoeGyw0pUunpQ9oBRgQ9SH8SwcZUF4ZmNPJNfCUwiRKuJ1SxLm17d/ 2EScAxhh4dapG8JTnEiiMuimdrREFZdss6VV45DSOKDldrCPzjV7Xapfu7JjXInlLSll 7bpA== X-Gm-Message-State: AJcUukeS/uM0gqNNr3YGWec2DaG7HNxf5MiWUorDLJ+A996/I9yUocQ8 blP4zXhsse1Z/W/puawbjGa5Kg== X-Google-Smtp-Source: ALg8bN54kJQPXGmfVGDDXFWZyoImOSmXvRDdaAi4A6K1Mc9MWgiEYhPB/OFVa4orwzj6IW48bOIqvA== X-Received: by 2002:ac8:2281:: with SMTP id f1mr23267673qta.197.1548719181428; Mon, 28 Jan 2019 15:46:21 -0800 (PST) Received: from jkicinski-Precision-T1700.netronome.com ([66.60.152.14]) by smtp.gmail.com with ESMTPSA id k81sm34336320qkk.18.2019.01.28.15.46.17 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 28 Jan 2019 15:46:20 -0800 (PST) From: Jakub Kicinski To: davem@davemloft.net Cc: oss-drivers@netronome.com, netdev@vger.kernel.org, jiri@resnulli.us, f.fainelli@gmail.com, andrew@lunn.ch, mkubecek@suse.cz, dsahern@gmail.com, simon.horman@netronome.com, jesse.brandeburg@intel.com, maciejromanfijalkowski@gmail.com, vasundhara-v.volam@broadcom.com, michael.chan@broadcom.com, shalomt@mellanox.com, idosch@mellanox.com, Jakub Kicinski Subject: [RFC 14/14] Documentation: networking: describe new hstat API Date: Mon, 28 Jan 2019 15:45:07 -0800 Message-Id: <20190128234507.32028-15-jakub.kicinski@netronome.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <20190128234507.32028-1-jakub.kicinski@netronome.com> References: <20190128234507.32028-1-jakub.kicinski@netronome.com> MIME-Version: 1.0 Sender: netdev-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: netdev@vger.kernel.org Add hstat documentation for users and driver developers. Signed-off-by: Jakub Kicinski --- Documentation/networking/hstats.rst | 590 ++++++++++++++++++ .../networking/hstats_flow_example.dot | 11 + Documentation/networking/index.rst | 1 + 3 files changed, 602 insertions(+) create mode 100644 Documentation/networking/hstats.rst create mode 100644 Documentation/networking/hstats_flow_example.dot diff --git a/Documentation/networking/hstats.rst b/Documentation/networking/hstats.rst new file mode 100644 index 000000000000..8856770a4909 --- /dev/null +++ b/Documentation/networking/hstats.rst @@ -0,0 +1,590 @@ +.. SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) + +================================= +Netlink device hierarchical stats +================================= + +Overview +======== + +*hstats* are standardized driver statistics. Both device and host driver +statistics can be exposed. + +*hstats* are a partial replacement for `ethtool -S`, standard-based statistics +and statistics common across many drivers should be added to *hstats*. +Once statistic is exposed via *hstats* it should not be added to `ethtool -S` +(drivers which already expose it can keep doing so, but no new driver allowed). + +Apart from common statistics identifiers *hstats* provide: + - clear indication if statistic is maintained (unlike more compact + fixed-structure stats, e.g. `struct rtnl_link_stats64`); + - hierarchical structure (see :ref:`groups` and :ref:`hierarchies`); + - exposes :ref:`qualifiers` - these are attributes of the statistics which + help determine the source of the statistics; + - provide flexible grouping mechanism which should reduce code duplication + amongst drivers. + +Netlink message structure +========================= + +Basic structure of the `IFLA_STATS_LINK_HSTATS` attribute looks like this: + +:: + + [IFLA_STATS_LINK_HSTATS] + [IFLA_HSTATS_GROUP] + [IFLA_HSTATS_QUAL_xxx] + [IFLA_HSTATS_QUAL_yyy] + [IFLA_HSTATS_STATS] + [IFLA_HSTATS_STAT_a] + [IFLA_HSTATS_STAT_b] + [IFLA_HSTATS_GROUP] + [IFLA_HSTATS_QUAL_zzz] + [IFLA_HSTATS_STATS] + [IFLA_HSTATS_STAT_c] + [IFLA_HSTATS_STAT_d] + [IFLA_HSTATS_GROUP] + [IFLA_HSTATS_QUAL_zzz] + [IFLA_HSTATS_STATS] + [IFLA_HSTATS_STAT_c] + [IFLA_HSTATS_STAT_d] + +.. _groups: + +Groups +------ + +`IFLA_STATS_LINK_HSTATS` may contain zero or more `IFLA_HSTATS_GROUP`. + +The statistics within a root level `IFLA_HSTATS_GROUP` must not count +events multiple times. + +The statistics within a root level `IFLA_HSTATS_GROUP` must include all +of the events, excluding groups where `IFLA_HSTATS_PARTIAL` attribute is +present and set to non-zero value or children of such groups +(see :ref:`partials`). This removes the need to sum up statistics in the +kernel, for example statistics maintained per queue by the driver can +be reported only per queue and user space can do the adding. + +The purpose of multiple root level groups is to allow users tracking the flow +of packets through pipelines. Let's consider the following RX NIC pipeline: + +.. _example_flow: + +.. kernel-figure:: hstats_flow_example.dot + :alt: statistics flow + + Example device statistics flow diagram + +Each rectangle represents a root level `IFLA_STATS_LINK_HSTATS`. Users should +be able to add all `IFLA_HSTATS_STAT_IEEE8023_FramesOK` within each of those +groups, and compare them to see at which stage of the processing pipeline +packets disappear. + +.. _qualifiers: + +Qualifiers +---------- + +Each `IFLA_HSTATS_GROUP` may have a set of qualifiers. Qualifiers are +attributes which apply to the statistics like being a device statistic, +being an RX statistic, or counting events/packets of a specific queue. +See :ref:`qualifiers_list`. + +.. _hierarchies: + +Hierarchies +----------- + +Each `IFLA_HSTATS_GROUP` can have further `IFLA_HSTATS_GROUP` s nested inside. +Qualifiers of a parent group apply to the child group. The hierarchies have no +perscribed meaning, or set structure. They are mostly present for the +convenience of the driver authors. + +.. _partials: + +Partial groups +-------------- + +`IFLA_HSTATS_PARTIAL` attribute declares groups contents as incomplete. +As explained in :ref:`groups` if a statistic is present it's sum within +a root group must add up to total number of events seen at a given stage +of processing. This mostly relates to iterative qualifiers like +:ref:`qual_queue` or :ref:`qual_prio`. + +Counting events multiple times towards different statistics, including +similar statistics from different families (e.g. IEEE stats vs IETF stats) +is perfectly normal and acceptable. + +`IFLA_HSTATS_PARTIAL` is inherited to children the same as :ref:`qualifiers`. +It can carry one of the following flags: + +IFLA_HSTATS_PARTIAL_CLASSIFIER +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Statistics from this group contain more detailed breakdown which may not +be complete. + +For example, HW may maintain the number of packets received per priority, +but packets received without a priority tag may not be counted separately. +Since non-tagged packets are not counted the sum of statistics will not +be complete. + +IFLA_HSTATS_PARTIAL_SLOWPATH +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Statistics from this group count slow path events. This attribute is used +if hardware is capable of offload packet forwarding. Some packets may still +reach the CPU for example if they were purposefully trapped for monitoring, +or no forwarding rule matched. + +User space guidelines +===================== + +User space `hstat` tool can be used to query statistics. This tools is part +of the `iproute2` package. + +Device driver guidelines +======================== + +Defining groups +--------------- + +The definition of a group of statistics has four sections: + +.. code-block:: c + + static const struct rtnl_hstat_group my_group = { + /* Qualifiers */ + .qualifiers = { + [RTNL_HSTATS_QUAL_TYPE] = { + .constant = IFLA_HSTATS_QUAL_TYPE_DEV, + }, + [RTNL_HSTATS_QUAL_DIRECTION] = { + .constant = IFLA_HSTATS_QUAL_DIR_RX, + }, + }, + /* Partials */ + .partial_flags = IFLA_HSTATS_PARTIAL_CLASSIFIER, + + /* Statistics */ + .get_stats = nfp_hstat_vnic_nfd_basic_get, + .stats = { + /* Word 0 stats */ + [0] = RTNL_HSTATS_STAT_LINUX_CSUM_COMPLETE_BIT, + /* Word 1 stats */ + [1] = RTNL_HSTATS_STAT_RFC2819_etherStatsPkts_BIT | + RTNL_HSTATS_STAT_RFC2819_etherStatsOctets_BIT, + }, + .stats_cnt = 3, + + /* Child groups */ + .has_children = true, + .children = { + &my_child_group, + NULL + }, + }; + +Each section can be omitted, i.e. group may not specify any qualifiers, +statistics or have no children. :ref:`qual_type` and :ref:`qual_direction` +qualifiers must be specified before any statistics is declared, that is to +say current group or one of parent groups must set them before any statistics +are reported. + +If any qualifier is iterative (`max` or `get_max` set instead of `constant`) +the group will be dumped `max` times, the driver can find out about parameters +of current invocation with `rtnl_hstat_qual_get` helper. + +Partial flags are optional, and mark group as incomplete (see :ref:`partials`). + +Statistics are dumped by invoking `get_stats` callback. Driver should report +the statistics with `rtnl_hstat_dump` helper. The list of reported statistics +contains all the statistics driver will dump. It is used for sizing netlink +replies and filtering. Drivers must not dump more statistics or different +statistics than defined. The definition of the bitmap requires a little bit +of care, as there is currently no automatic way to assign statistics to the +correct 64 bit word. + +.. note:: + Qualifier constants and parameters to `rtnl_hstat_dump` take constants + defined in include/uapi/linux/if_link.h, other constants come from + include/net/hstats.h and have the `RTNL_` prefix. + +If any child groups are attached the `has_children` member must be set to `true` +and `children` table must be NULL-terminated. Child groups may be used in +different parent groups, but care has to be taken to never create loops. + +Root groups should generally not have the direction set as a constant. +Most root groups should contain both RX and TX subgroups, rather than having +RX-only root groups and TX-only root groups. + +Reporting groups +---------------- + +Drivers have to define one or more `rtnl_hstat_group`. + +They should then implement `ndo_hstat_get_groups` callback. Inside the callback +they can report every statistic group via `rtnl_hstat_add_grp` helper. + +Counter resets +-------------- + +Counters should not reset their values while the driver is bound to the device, +e.g. when link is brought down. + +Counters may reset on driver load/probe or when device is explicitly reset +via devlink. + +For iterative qualifiers like queues or priorities drivers should maintain +statistics for all queues ever allocated (or simply always report for max). + +.. _qualifiers_list: + +List of qualifiers +================== + +.. _qual_type: + +Type +---- + +Indicates the source of the statistic. Statistics can either be maintained +by the device or the driver. Statistics may be calculated based on multiple +counters (e.g. two counters may need to be added), but such calculation must +not include statistics of different types. + +IFLA_HSTATS_QUAL_TYPE_DEV +~~~~~~~~~~~~~~~~~~~~~~~~~ +Device statistic, counter is maintained by the device and only reported by +the driver. There is currently no distinction between hardware and +microcode/firmware statistics. + +IFLA_HSTATS_QUAL_TYPE_DRV +~~~~~~~~~~~~~~~~~~~~~~~~~ +Driver statistic, fully maintained by software. + +.. _qual_direction: + +Direction +--------- + +Direction allows drivers to indicate whether statistics is counting incoming +or outgoing frames. This is useful as it limmits the number of statistic IDs +which have to be defined, but also often allows drivers to simplify the +reporting if HW maintains the statitics for both directions in the same format, +just in a different location. + +Direction and PCIe ports +~~~~~~~~~~~~~~~~~~~~~~~~ +For PCIe port netdevs (representors) all statistics are expressed from +device's prespective. If frame is submitted for transmission on a PCIe +interface it will be seen as "received" by the port (representor). + +This means it is possible to see transmission side-only statistics in receive +direction and vice versa (e.g. `IFLA_HSTATS_STAT_LINUX_CSUM_PARTIAL`). + +Device statistics reported on port (representor) interfaces, count the total +number of events on given device port. This includes both frames forwarded +via the "fast path" and explicitly directed to the device port from the +port (representor) interface. + +Driver statistics necessarily count only the "fallback path" frames, and +should always be reported with `IFLA_HSTATS_PARTIAL` set to +`IFLA_HSTATS_PARTIAL_SLOWPATH`. + +IFLA_HSTATS_QUAL_DIR_RX +~~~~~~~~~~~~~~~~~~~~~~~ +received + +IFLA_HSTATS_QUAL_DIR_TX +~~~~~~~~~~~~~~~~~~~~~~~ +transmitted + +.. _qual_queue: + +Queue +----- + +Queue (or channel) is a Receive Side Scaling construct allowing multiple +consumers and producers to communicate with the device. It is usually +applicable to the PCIe interface "side" of the device. + +Number of reported queues is in no way indicative of how many queues are +currently enabled on the system. + +.. _qual_prio: + +Priority +-------- + +Priority is defined as Layer 2 IEEE 802.1Q frame priority. + +Traffic class +------------- + +Traffic class is any non-Layer 2 queuing and priritization. + +List of statistics +================== + +All statistics are 64 bits. + +Common statistics +----------------- + +Statistics from this section are not based on any standard but rather ones +which commonly appear in Linux drivers. + +The fact that statistic ID is assigned for some event does not constitute +a recommendation that given statistic is implemented by drivers. Maintaining +statistics has a performance cost associated and should be considered carefully. + +.. _stat_linux_pkts: + +IFLA_HSTATS_STAT_LINUX_PKTS +~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Number of packets which were successfully handed over to the next layer. +This means packets passed up during reception and passed down during +transmission. This differs from both IETF and IEEE definition of basic +packet counters, which generally count at the same layer boundary in both +directions. + +No error or discard counters are included in this counter. + +IFLA_HSTATS_STAT_LINUX_BYTES +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Same as :ref:`stat_linux_pkts` but counts bytes instead of packets. + +IFLA_HSTATS_STAT_LINUX_BUSY +~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Number of times the driver returned `NETDEV_TX_BUSY` to the stack from +in TX handler. + +This statistic is defined in to-device direction only. + +IFLA_HSTATS_STAT_LINUX_CSUM_PARTIAL +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Number of successfully handled descriptors with CHECKSUM_PARTIAL offload to +the hardware. + +This statistic is defined in to-device direction only. + +IFLA_HSTATS_STAT_LINUX_CSUM_COMPLETE +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Number of successfully handled descriptors indicating CHECKSUM_COMPLETE. + +This statistic is defined in from-device direction only. + +IFLA_HSTATS_STAT_LINUX_CSUM_UNNECESSARY +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Number of successfully handled descriptors indicating CHECKSUM_UNNECESSARY. + +This statistic is defined in from-device direction only. + +IFLA_HSTATS_STAT_LINUX_SEGMENTATION_OFFLOAD_PKTS +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Number of successfully handled segmentation- and reassembly-offload descriptors, +regardless of transport protocol (TSO, USO, etc.) + +For transmission it means the number of frames requiring segmentation submitted +successfully to the device's transmission function (driver) or number of +correctly parsed descriptors for such packets (device). + +For reception it can be used to count Generic Receive Offload frames, but *not* +Large Receive Offload frames. + +This statistic is incremented once per each frame pre-segmentation as seen +by the Linux stack, not once per each frame on the wire. + +IETF RFC2819 statistics +----------------------- +IETF RFC2819 ("Remote Network Monitoring MIB")-compatible statistics. + +IFLA_HSTATS_STAT_RFC2819_etherStatsDropEvents +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsDropEvents counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsOctets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsOctets counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsPkts +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsPkts counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsBroadcastPkts +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsBroadcastPkts counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsMulticastPkts +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsMulticastPkts counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsCRCAlignErrors +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsCRCAlignErrors counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsUndersizePkts +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsUndersizePkts counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsOversizePkts +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsOversizePkts counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsFragments +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsFragments counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsJabbers +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsJabbers counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsCollisions +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsCollisions counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsPkts64Octets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsPkts64Octets counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsPkts65to127Octets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsPkts65to127Octets counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsPkts128to255Octets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsPkts128to255Octets counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsPkts256to511Octets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsPkts256to511Octets counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsPkts512to1023Octets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsPkts512to1023Octets counter + +IFLA_HSTATS_STAT_RFC2819_etherStatsPkts1024to1518Octets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +etherStatsPkts1024to1518Octets counter + +Extended size statistics +------------------------ +IETF RFC2819 defines simple packet-size based statistics for packets between +64 and 1518 octets. However, larger frames are commonly supported. This +sroup defines additional packet-size based statistics. + +IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts1024toMaxOctets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Definition follows etherStatsPkts65to127Octets with lower range bound of 1024, +and no higher bound. + +IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts1519toMaxOctets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Definition follows etherStatsPkts65to127Octets with lower range bound of 1519, +and no higher bound. + +IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts1024to2047Octets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Definition follows etherStatsPkts65to127Octets with lower range bound of 1024, +and higher bound of 2047. + +IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts2048to4095Octets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Definition follows etherStatsPkts65to127Octets with lower range bound of 2048, +and higher bound of 4095. + +IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts4096to8191Octets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Definition follows etherStatsPkts65to127Octets with lower range bound of 4096, +and higher bound of 8191. + +IFLA_HSTATS_STAT_RFC2819EXT_etherStatsPkts8192toMaxOctets +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Definition follows etherStatsPkts65to127Octets with lower range bound of 8192, +and no higher bound. + +IETF RFC2863 statistics +----------------------- +IETF RFC2863 ("The Interfaces Group MIB")-compatible statistics. + +IFLA_HSTATS_STAT_RFC2863_errors +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`ifInErrors` or `ifOutErrors` depending on :ref:`qual_direction`. + +IFLA_HSTATS_STAT_RFC2863_discards +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`ifInDiscards` or `ifOutDiscards` depending on :ref:`qual_direction`. + +IEEE 802.3 statistics +--------------------- +IEEE 802.3 standard statistics. Statistics which indicate two corresponding +IEEE 802.3 attributes can be used in both directions, those which only +mention a single attribute are undefined in the other direction. + +IFLA_HSTATS_STAT_IEEE8023_FramesOK +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aFramesReceivedOK` or `aFramesTransmittedOK` depending +on :ref:`qual_direction`. + +IFLA_HSTATS_STAT_IEEE8023_OctetsOK +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aOctetsReceivedOK` or `aOctetsTransmittedOK` depending +on :ref:`qual_direction`. + +IFLA_HSTATS_STAT_IEEE8023_MulticastFramesOK +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aMulticastFramesReceivedOK` or `aMulticastFramesXmittedOK` depending +on :ref:`qual_direction`. + +IFLA_HSTATS_STAT_IEEE8023_BroadcastFramesOK +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aBroadcastFramesReceivedOK` or `aBroadcastFramesXmittedOK` depending +on :ref:`qual_direction`. + +IFLA_HSTATS_STAT_IEEE8023_FrameCheckSequenceErrors +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aFrameCheckSequenceErrors` + +IFLA_HSTATS_STAT_IEEE8023_AlignmentErrors +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aAlignmentErrors` + +IFLA_HSTATS_STAT_IEEE8023_InRangeLengthErrors +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aInRangeLengthErrors` + +IFLA_HSTATS_STAT_IEEE8023_OutOfRangeLengthField +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aOutOfRangeLengthField` + +IFLA_HSTATS_STAT_IEEE8023_FrameTooLongErrors +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aFrameTooLongErrors` + +IFLA_HSTATS_STAT_IEEE8023_SymbolErrorDuringCarrier +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aSymbolErrorDuringCarrier` + +IFLA_HSTATS_STAT_IEEE8023_MACControlFrames +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aMACControlFramesReceived` or `aMACControlFramesTransmitted` depending +on :ref:`qual_direction`. + +IFLA_HSTATS_STAT_IEEE8023_UnsupportedOpcodes +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aUnsupportedOpcodesReceived` + +IFLA_HSTATS_STAT_IEEE8023_PAUSEMACCtrlFrames +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aPAUSEMACCtrlFramesReceived` or `aPAUSEMACCtrlFramesTransmitted` depending +on :ref:`qual_direction`. + +IFLA_HSTATS_STAT_IEEE8023_FECCorrectedBlocks +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aFECCorrectedBlocks` + +IFLA_HSTATS_STAT_IEEE8023_FECUncorrectableBlocks +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +`aFECUncorrectableBlocks` diff --git a/Documentation/networking/hstats_flow_example.dot b/Documentation/networking/hstats_flow_example.dot new file mode 100644 index 000000000000..7dbb41adf5f6 --- /dev/null +++ b/Documentation/networking/hstats_flow_example.dot @@ -0,0 +1,11 @@ +digraph L { + node [shape=record]; + rankdir=RL; + + a [label="Device\n\nbasic ingress\nstats",color=blue] + b [label="Device\n\nper-priority\nstats",color=blue] + c [label="Device\n\nper-queue\nPCI interface\nstats",color=blue] + d [label="Host\n\nper-queue\nstats",color=forestgreen] + + a -> b -> c -> d +} \ No newline at end of file diff --git a/Documentation/networking/index.rst b/Documentation/networking/index.rst index 59e86de662cd..b075de41e401 100644 --- a/Documentation/networking/index.rst +++ b/Documentation/networking/index.rst @@ -32,6 +32,7 @@ Linux Networking Documentation alias bridge snmp_counter + hstats .. only:: subproject