From nobody Fri Dec 19 15:59:28 2025 Received: from mail-yx1-f42.google.com (mail-yx1-f42.google.com [74.125.224.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 147D21C5D6A for ; Thu, 6 Nov 2025 00:26:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.224.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762388777; cv=none; b=qx85V9gNUveDgWdbLyn5sWpDBEu7D342IMeglD2Yd/9oMLx66vaZQEslp9rxtvvHaxoFAuN3c+D/YP5cRRJi1evEZ6klGIDYXeypB/EYDpD1LfZe/21wcJVrIrWYlg57zWojDSYaDIxll58Sk1gVHhL6/3ivCDVz2NbrAmV5Up8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762388777; c=relaxed/simple; bh=za45gZn58io3q7G6R6uiLs/BWVajHmLqJcwZnfN5KLw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=rQXHBybpuO3zOg3HDMuy0acsZgKoPAoUwRiJpMdWTBj/AOVJ7qE3M3dymmuPRTugX4Tip1eKhuvxBccKjR2N79gPReLWtt/UuscJFEvOGtZYoTTzSQSassVzohftdknrHSY7bssLAadGGMojVx0/ZvuMHLMiD2WbxRwSNoWhMJg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=T3d4viBJ; arc=none smtp.client-ip=74.125.224.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="T3d4viBJ" Received: by mail-yx1-f42.google.com with SMTP id 956f58d0204a3-63f95dc176fso455853d50.1 for ; Wed, 05 Nov 2025 16:26:14 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1762388774; x=1762993574; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=s2wQ5QxA+Nt4F/G4CAuMI2bjmJWmfwgXVieJdAcKAY0=; b=T3d4viBJTbj43qAWpPl1nIc2bz7A6+sGBSIQUqg9mWEY6aqqYjoXYgEkUPubCMaq5J 2e7bH2ZwOsusIs7iFum/YzOM1J3N2xxP+Qde6kjH64rtFJUHTX18Q+ODqipJ1ThFyagF BUuvY+xmNdIAGcNXtf4jQWdyo3/jnb3MJRMLTL02jLII0xtnJifJshkX8xrJN14V4tKi qRtFLhPoT0pQZoCuYzF+5EedCQJ3RBa350apbld/lungBaG5643m7m5Fq/fje5lRSYJz GuES+P5k1rIixYmSJvM43ipWOL+nGKydenU8MW9ReI0OZ3Vfnr53RfnBiB4CePwekx1u P12Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762388774; x=1762993574; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=s2wQ5QxA+Nt4F/G4CAuMI2bjmJWmfwgXVieJdAcKAY0=; b=rFglNpPVqMsXy+YkQR4/9aSZy95L0Curpz6e/eeZ221HEnldJju/W5MuKl7/ar+WMv S4cw5QEg07b2GeY+wfuFNXFrOcEiqo9kJa113uq8MO+cEuy0cTyBL4eQyXyoj0IHJT6a fokb8XR45SCPi0j6qg6R49pFQD2JYGB/HV0jLRwR9Ae3BUvXGhDc/xlJL8iFWuvP8U1R zVo7CYlg+qO7rvoprv7YN5jaNYGlBCRDV1ZfESFVzAlquV1OGBVAdjT+23edKCsfz2wI 1fq0+QbkcYMZ1thJaHQAdPOw12REPoQQzSFwZGXvpNC20g7tVcyB2gzGUCsfeFbQeLVS QKDQ== X-Forwarded-Encrypted: i=1; AJvYcCUoAR/RlAsuS3tVEeE3cA4fvhr40DscnMxTCQLSlu9f/jGw0SswsHyhfw9t1Stn5Om9OzftxEpZMGib1IU=@vger.kernel.org X-Gm-Message-State: AOJu0YzIRt+Xz63vauKgmwkloKsLs0r4XtEbooDZtdOz+HsSMb822EXy Q4j8hA1qU+WgSRn3+qYf3hiCXVoYMd8TLkyaL1Q+43UMNe373jRI3IN/ X-Gm-Gg: ASbGncteWmyEoNFSIzdoA3WFyZsVvNSifK+pulgpvpSUvrec+SZuGLfRBUN7pAvJWsz auVrcE5q3ppvZtyTF72B9+65QfYJIft/Z/eOE+3I6Ocv/zr3f5WoTmM/hw/U9E95rMIta87lBBO xGVZk/jBxzbF6Aw9Emj+Jby8l3n13DOEYRZ5BGy2b97eTf7T+02uvOGZzZIHUe9lbMzp91xD8RN ul95NECBYyjpknabH0NDX3I1seMnvkgzTbBvPfCSE/ZFEu61UwTxhxWpq2s3S9ab+voHwr3lmtD h+NdbzzICIINTo6TzfS46Da1YAnukqxOIcMOZJQ45zEF+y9chIE4Eybq93BoBj5Uqhb3+ZSLFzf k6u5aV9aIVfuY4MnSxThuyvDLLteJ/rwNJZKsr+iaoQBNrW3OmZ3tKN1RKP8+p6rwrdCM6D2KBO 6zgIc8TA39DA== X-Google-Smtp-Source: AGHT+IE59zLZZYyAmzryk94tw8TktRRSTJ6JnEVpxnemBG5Bk+jMcvGOFztXLqAXDxrgMv9zYV/INA== X-Received: by 2002:a05:690e:4082:b0:63d:bfad:6c7 with SMTP id 956f58d0204a3-63fd35b4528mr3942831d50.58.1762388773845; Wed, 05 Nov 2025 16:26:13 -0800 (PST) Received: from localhost ([2a03:2880:25ff:13::]) by smtp.gmail.com with ESMTPSA id 00721157ae682-787b1400351sm3511567b3.20.2025.11.05.16.26.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 05 Nov 2025 16:26:13 -0800 (PST) From: Daniel Zahka To: "David S . Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Donald Hunter , Andrew Lunn , Shuah Khan , Boris Pismenny , Saeed Mahameed , Leon Romanovsky , Tariq Toukan , Mark Bloch Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org Subject: [PATCH net-next v3 4/5] net/mlx5e: Add PSP stats support for Rx/Tx flows Date: Wed, 5 Nov 2025 16:26:05 -0800 Message-ID: <20251106002608.1578518-5-daniel.zahka@gmail.com> X-Mailer: git-send-email 2.47.3 In-Reply-To: <20251106002608.1578518-1-daniel.zahka@gmail.com> References: <20251106002608.1578518-1-daniel.zahka@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Jakub Kicinski Add all statistics described under the "Implementation Requirements" section of the PSP Architecture Specification: Rx successfully decrypted PSP packets: psp_rx_pkts : Number of packets decrypted successfully psp_rx_bytes : Number of bytes decrypted successfully Rx PSP authentication failure statistics: psp_rx_pkts_auth_fail : Number of PSP packets that failed authentication psp_rx_bytes_auth_fail : Number of PSP bytes that failed authentication Rx PSP bad frame error statistics: psp_rx_pkts_frame_err; psp_rx_bytes_frame_err; Rx PSP drop statistics: psp_rx_pkts_drop : Number of PSP packets dropped psp_rx_bytes_drop : Number of PSP bytes dropped Tx successfully encrypted PSP packets: psp_tx_pkts : Number of packets encrypted successfully psp_tx_bytes : Number of bytes encrypted successfully Tx drops: tx_drop : Number of misc psp related drops The above can be seen using the ynl cli: ./pyynl/cli.py --spec netlink/specs/psp.yaml --dump get-stats Signed-off-by: Jakub Kicinski Signed-off-by: Raed Salem Signed-off-by: Rahul Rameshbabu Signed-off-by: Daniel Zahka --- Notes: v3: - simplify error path in accel_psp_fs_init_tx() - avoid casting argument in mlx5e_accel_psp_fs_get_stats_fill() - delete unused member stats member in mlx5e_psp v2: - use %pe to print PTR_ERR() .../mellanox/mlx5/core/en_accel/psp.c | 233 ++++++++++++++++-- .../mellanox/mlx5/core/en_accel/psp.h | 16 ++ .../mellanox/mlx5/core/en_accel/psp_rxtx.c | 1 + .../net/ethernet/mellanox/mlx5/core/en_main.c | 5 + 4 files changed, 240 insertions(+), 15 deletions(-) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp.c b/drive= rs/net/ethernet/mellanox/mlx5/core/en_accel/psp.c index 8565cfe8d7dc..38e7c77cc851 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp.c @@ -28,12 +28,15 @@ struct mlx5e_psp_tx { struct mlx5_flow_handle *rule; struct mutex mutex; /* Protect PSP TX steering */ u32 refcnt; + struct mlx5_fc *tx_counter; }; =20 struct mlx5e_psp_rx_err { struct mlx5_flow_table *ft; struct mlx5_flow_handle *rule; - struct mlx5_flow_handle *drop_rule; + struct mlx5_flow_handle *auth_fail_rule; + struct mlx5_flow_handle *err_rule; + struct mlx5_flow_handle *bad_rule; struct mlx5_modify_hdr *copy_modify_hdr; }; =20 @@ -50,6 +53,10 @@ struct mlx5e_accel_fs_psp_prot { =20 struct mlx5e_accel_fs_psp { struct mlx5e_accel_fs_psp_prot fs_prot[ACCEL_FS_PSP_NUM_TYPES]; + struct mlx5_fc *rx_counter; + struct mlx5_fc *rx_auth_fail_counter; + struct mlx5_fc *rx_err_counter; + struct mlx5_fc *rx_bad_counter; }; =20 struct mlx5e_psp_fs { @@ -72,9 +79,19 @@ static enum mlx5_traffic_types fs_psp2tt(enum accel_fs_p= sp_type i) static void accel_psp_fs_rx_err_del_rules(struct mlx5e_psp_fs *fs, struct mlx5e_psp_rx_err *rx_err) { - if (rx_err->drop_rule) { - mlx5_del_flow_rules(rx_err->drop_rule); - rx_err->drop_rule =3D NULL; + if (rx_err->bad_rule) { + mlx5_del_flow_rules(rx_err->bad_rule); + rx_err->bad_rule =3D NULL; + } + + if (rx_err->err_rule) { + mlx5_del_flow_rules(rx_err->err_rule); + rx_err->err_rule =3D NULL; + } + + if (rx_err->auth_fail_rule) { + mlx5_del_flow_rules(rx_err->auth_fail_rule); + rx_err->auth_fail_rule =3D NULL; } =20 if (rx_err->rule) { @@ -117,6 +134,7 @@ static int accel_psp_fs_rx_err_add_rule(struct mlx5e_ps= p_fs *fs, { u8 action[MLX5_UN_SZ_BYTES(set_add_copy_action_in_auto)] =3D {}; struct mlx5_core_dev *mdev =3D fs->mdev; + struct mlx5_flow_destination dest[2]; struct mlx5_flow_act flow_act =3D {}; struct mlx5_modify_hdr *modify_hdr; struct mlx5_flow_handle *fte; @@ -147,10 +165,14 @@ static int accel_psp_fs_rx_err_add_rule(struct mlx5e_= psp_fs *fs, accel_psp_setup_syndrome_match(spec, PSP_OK); /* create fte */ flow_act.action =3D MLX5_FLOW_CONTEXT_ACTION_MOD_HDR | - MLX5_FLOW_CONTEXT_ACTION_FWD_DEST; + MLX5_FLOW_CONTEXT_ACTION_FWD_DEST | + MLX5_FLOW_CONTEXT_ACTION_COUNT; flow_act.modify_hdr =3D modify_hdr; - fte =3D mlx5_add_flow_rules(rx_err->ft, spec, &flow_act, - &fs_prot->default_dest, 1); + dest[0].type =3D fs_prot->default_dest.type; + dest[0].ft =3D fs_prot->default_dest.ft; + dest[1].type =3D MLX5_FLOW_DESTINATION_TYPE_COUNTER; + dest[1].counter =3D fs->rx_fs->rx_counter; + fte =3D mlx5_add_flow_rules(rx_err->ft, spec, &flow_act, dest, 2); if (IS_ERR(fte)) { err =3D PTR_ERR(fte); mlx5_core_err(mdev, "fail to add psp rx err copy rule err=3D%d\n", err); @@ -158,22 +180,69 @@ static int accel_psp_fs_rx_err_add_rule(struct mlx5e_= psp_fs *fs, } rx_err->rule =3D fte; =20 - /* add default drop rule */ + /* add auth fail drop rule */ memset(spec, 0, sizeof(*spec)); memset(&flow_act, 0, sizeof(flow_act)); + accel_psp_setup_syndrome_match(spec, PSP_ICV_FAIL); /* create fte */ - flow_act.action =3D MLX5_FLOW_CONTEXT_ACTION_DROP; - fte =3D mlx5_add_flow_rules(rx_err->ft, spec, &flow_act, NULL, 0); + flow_act.action =3D MLX5_FLOW_CONTEXT_ACTION_DROP | + MLX5_FLOW_CONTEXT_ACTION_COUNT; + dest[0].type =3D MLX5_FLOW_DESTINATION_TYPE_COUNTER; + dest[0].counter =3D fs->rx_fs->rx_auth_fail_counter; + fte =3D mlx5_add_flow_rules(rx_err->ft, spec, &flow_act, dest, 1); if (IS_ERR(fte)) { err =3D PTR_ERR(fte); - mlx5_core_err(mdev, "fail to add psp rx err drop rule err=3D%d\n", err); + mlx5_core_err(mdev, "fail to add psp rx auth fail drop rule err=3D%d\n", + err); goto out_drop_rule; } - rx_err->drop_rule =3D fte; + rx_err->auth_fail_rule =3D fte; + + /* add framing drop rule */ + memset(spec, 0, sizeof(*spec)); + memset(&flow_act, 0, sizeof(flow_act)); + accel_psp_setup_syndrome_match(spec, PSP_BAD_TRAILER); + /* create fte */ + flow_act.action =3D MLX5_FLOW_CONTEXT_ACTION_DROP | + MLX5_FLOW_CONTEXT_ACTION_COUNT; + dest[0].type =3D MLX5_FLOW_DESTINATION_TYPE_COUNTER; + dest[0].counter =3D fs->rx_fs->rx_err_counter; + fte =3D mlx5_add_flow_rules(rx_err->ft, spec, &flow_act, dest, 1); + if (IS_ERR(fte)) { + err =3D PTR_ERR(fte); + mlx5_core_err(mdev, "fail to add psp rx framing err drop rule err=3D%d\n= ", + err); + goto out_drop_auth_fail_rule; + } + rx_err->err_rule =3D fte; + + /* add misc. errors drop rule */ + memset(spec, 0, sizeof(*spec)); + memset(&flow_act, 0, sizeof(flow_act)); + /* create fte */ + flow_act.action =3D MLX5_FLOW_CONTEXT_ACTION_DROP | + MLX5_FLOW_CONTEXT_ACTION_COUNT; + dest[0].type =3D MLX5_FLOW_DESTINATION_TYPE_COUNTER; + dest[0].counter =3D fs->rx_fs->rx_bad_counter; + fte =3D mlx5_add_flow_rules(rx_err->ft, spec, &flow_act, dest, 1); + if (IS_ERR(fte)) { + err =3D PTR_ERR(fte); + mlx5_core_err(mdev, "fail to add psp rx misc. err drop rule err=3D%d\n", + err); + goto out_drop_error_rule; + } + rx_err->bad_rule =3D fte; + rx_err->copy_modify_hdr =3D modify_hdr; =20 goto out_spec; =20 +out_drop_error_rule: + mlx5_del_flow_rules(rx_err->err_rule); + rx_err->err_rule =3D NULL; +out_drop_auth_fail_rule: + mlx5_del_flow_rules(rx_err->auth_fail_rule); + rx_err->auth_fail_rule =3D NULL; out_drop_rule: mlx5_del_flow_rules(rx_err->rule); rx_err->rule =3D NULL; @@ -461,6 +530,10 @@ static void accel_psp_fs_cleanup_rx(struct mlx5e_psp_f= s *fs) return; =20 accel_psp =3D fs->rx_fs; + mlx5_fc_destroy(fs->mdev, accel_psp->rx_bad_counter); + mlx5_fc_destroy(fs->mdev, accel_psp->rx_err_counter); + mlx5_fc_destroy(fs->mdev, accel_psp->rx_auth_fail_counter); + mlx5_fc_destroy(fs->mdev, accel_psp->rx_counter); for (i =3D 0; i < ACCEL_FS_PSP_NUM_TYPES; i++) { fs_prot =3D &accel_psp->fs_prot[i]; mutex_destroy(&fs_prot->prot_mutex); @@ -474,7 +547,10 @@ static int accel_psp_fs_init_rx(struct mlx5e_psp_fs *f= s) { struct mlx5e_accel_fs_psp_prot *fs_prot; struct mlx5e_accel_fs_psp *accel_psp; + struct mlx5_core_dev *mdev =3D fs->mdev; + struct mlx5_fc *flow_counter; enum accel_fs_psp_type i; + int err; =20 accel_psp =3D kzalloc(sizeof(*accel_psp), GFP_KERNEL); if (!accel_psp) @@ -485,9 +561,68 @@ static int accel_psp_fs_init_rx(struct mlx5e_psp_fs *f= s) mutex_init(&fs_prot->prot_mutex); } =20 + flow_counter =3D mlx5_fc_create(mdev, false); + if (IS_ERR(flow_counter)) { + mlx5_core_warn(mdev, + "fail to create psp rx flow counter err=3D%pe\n", + flow_counter); + err =3D PTR_ERR(flow_counter); + goto out_err; + } + accel_psp->rx_counter =3D flow_counter; + + flow_counter =3D mlx5_fc_create(mdev, false); + if (IS_ERR(flow_counter)) { + mlx5_core_warn(mdev, + "fail to create psp rx auth fail flow counter err=3D%pe\n", + flow_counter); + err =3D PTR_ERR(flow_counter); + goto out_counter_err; + } + accel_psp->rx_auth_fail_counter =3D flow_counter; + + flow_counter =3D mlx5_fc_create(mdev, false); + if (IS_ERR(flow_counter)) { + mlx5_core_warn(mdev, + "fail to create psp rx error flow counter err=3D%pe\n", + flow_counter); + err =3D PTR_ERR(flow_counter); + goto out_auth_fail_counter_err; + } + accel_psp->rx_err_counter =3D flow_counter; + + flow_counter =3D mlx5_fc_create(mdev, false); + if (IS_ERR(flow_counter)) { + mlx5_core_warn(mdev, + "fail to create psp rx bad flow counter err=3D%pe\n", + flow_counter); + err =3D PTR_ERR(flow_counter); + goto out_err_counter_err; + } + accel_psp->rx_bad_counter =3D flow_counter; + fs->rx_fs =3D accel_psp; =20 return 0; + +out_err_counter_err: + mlx5_fc_destroy(mdev, accel_psp->rx_err_counter); + accel_psp->rx_err_counter =3D NULL; +out_auth_fail_counter_err: + mlx5_fc_destroy(mdev, accel_psp->rx_auth_fail_counter); + accel_psp->rx_auth_fail_counter =3D NULL; +out_counter_err: + mlx5_fc_destroy(mdev, accel_psp->rx_counter); + accel_psp->rx_counter =3D NULL; +out_err: + for (i =3D 0; i < ACCEL_FS_PSP_NUM_TYPES; i++) { + fs_prot =3D &accel_psp->fs_prot[i]; + mutex_destroy(&fs_prot->prot_mutex); + } + kfree(accel_psp); + fs->rx_fs =3D NULL; + + return err; } =20 void mlx5_accel_psp_fs_cleanup_rx_tables(struct mlx5e_priv *priv) @@ -532,6 +667,7 @@ static int accel_psp_fs_tx_create_ft_table(struct mlx5e= _psp_fs *fs) { int inlen =3D MLX5_ST_SZ_BYTES(create_flow_group_in); struct mlx5_flow_table_attr ft_attr =3D {}; + struct mlx5_flow_destination dest =3D {}; struct mlx5_core_dev *mdev =3D fs->mdev; struct mlx5_flow_act flow_act =3D {}; u32 *in, *mc, *outer_headers_c; @@ -580,8 +716,11 @@ static int accel_psp_fs_tx_create_ft_table(struct mlx5= e_psp_fs *fs) flow_act.crypto.type =3D MLX5_FLOW_CONTEXT_ENCRYPT_DECRYPT_TYPE_PSP; flow_act.flags |=3D FLOW_ACT_NO_APPEND; flow_act.action =3D MLX5_FLOW_CONTEXT_ACTION_ALLOW | - MLX5_FLOW_CONTEXT_ACTION_CRYPTO_ENCRYPT; - rule =3D mlx5_add_flow_rules(ft, spec, &flow_act, NULL, 0); + MLX5_FLOW_CONTEXT_ACTION_CRYPTO_ENCRYPT | + MLX5_FLOW_CONTEXT_ACTION_COUNT; + dest.type =3D MLX5_FLOW_DESTINATION_TYPE_COUNTER; + dest.counter =3D tx_fs->tx_counter; + rule =3D mlx5_add_flow_rules(ft, spec, &flow_act, &dest, 1); if (IS_ERR(rule)) { err =3D PTR_ERR(rule); mlx5_core_err(mdev, "PSP: fail to add psp tx flow rule, err =3D %d\n", e= rr); @@ -650,6 +789,7 @@ static void accel_psp_fs_cleanup_tx(struct mlx5e_psp_fs= *fs) if (!tx_fs) return; =20 + mlx5_fc_destroy(fs->mdev, tx_fs->tx_counter); mutex_destroy(&tx_fs->mutex); WARN_ON(tx_fs->refcnt); kfree(tx_fs); @@ -658,10 +798,12 @@ static void accel_psp_fs_cleanup_tx(struct mlx5e_psp_= fs *fs) =20 static int accel_psp_fs_init_tx(struct mlx5e_psp_fs *fs) { + struct mlx5_core_dev *mdev =3D fs->mdev; struct mlx5_flow_namespace *ns; + struct mlx5_fc *flow_counter; struct mlx5e_psp_tx *tx_fs; =20 - ns =3D mlx5_get_flow_namespace(fs->mdev, MLX5_FLOW_NAMESPACE_EGRESS_IPSEC= ); + ns =3D mlx5_get_flow_namespace(mdev, MLX5_FLOW_NAMESPACE_EGRESS_IPSEC); if (!ns) return -EOPNOTSUPP; =20 @@ -669,12 +811,55 @@ static int accel_psp_fs_init_tx(struct mlx5e_psp_fs *= fs) if (!tx_fs) return -ENOMEM; =20 + flow_counter =3D mlx5_fc_create(mdev, false); + if (IS_ERR(flow_counter)) { + mlx5_core_warn(mdev, + "fail to create psp tx flow counter err=3D%pe\n", + flow_counter); + kfree(tx_fs); + return PTR_ERR(flow_counter); + } + tx_fs->tx_counter =3D flow_counter; mutex_init(&tx_fs->mutex); tx_fs->ns =3D ns; fs->tx_fs =3D tx_fs; return 0; } =20 +static void +mlx5e_accel_psp_fs_get_stats_fill(struct mlx5e_priv *priv, + struct mlx5e_psp_stats *stats) +{ + struct mlx5e_psp_tx *tx_fs =3D priv->psp->fs->tx_fs; + struct mlx5_core_dev *mdev =3D priv->mdev; + struct mlx5e_accel_fs_psp *accel_psp; + + accel_psp =3D (struct mlx5e_accel_fs_psp *)priv->psp->fs->rx_fs; + + if (tx_fs->tx_counter) + mlx5_fc_query(mdev, tx_fs->tx_counter, &stats->psp_tx_pkts, + &stats->psp_tx_bytes); + + if (accel_psp->rx_counter) + mlx5_fc_query(mdev, accel_psp->rx_counter, &stats->psp_rx_pkts, + &stats->psp_rx_bytes); + + if (accel_psp->rx_auth_fail_counter) + mlx5_fc_query(mdev, accel_psp->rx_auth_fail_counter, + &stats->psp_rx_pkts_auth_fail, + &stats->psp_rx_bytes_auth_fail); + + if (accel_psp->rx_err_counter) + mlx5_fc_query(mdev, accel_psp->rx_err_counter, + &stats->psp_rx_pkts_frame_err, + &stats->psp_rx_bytes_frame_err); + + if (accel_psp->rx_bad_counter) + mlx5_fc_query(mdev, accel_psp->rx_bad_counter, + &stats->psp_rx_pkts_drop, + &stats->psp_rx_bytes_drop); +} + void mlx5_accel_psp_fs_cleanup_tx_tables(struct mlx5e_priv *priv) { if (!priv->psp) @@ -849,12 +1034,30 @@ mlx5e_psp_key_rotate(struct psp_dev *psd, struct net= link_ext_ack *exack) return mlx5e_psp_rotate_key(priv->mdev); } =20 +static void +mlx5e_psp_get_stats(struct psp_dev *psd, struct psp_dev_stats *stats) +{ + struct mlx5e_priv *priv =3D netdev_priv(psd->main_netdev); + struct mlx5e_psp_stats nstats; + + mlx5e_accel_psp_fs_get_stats_fill(priv, &nstats); + stats->rx_packets =3D nstats.psp_rx_pkts; + stats->rx_bytes =3D nstats.psp_rx_bytes; + stats->rx_auth_fail =3D nstats.psp_rx_pkts_auth_fail; + stats->rx_error =3D nstats.psp_rx_pkts_frame_err; + stats->rx_bad =3D nstats.psp_rx_pkts_drop; + stats->tx_packets =3D nstats.psp_tx_pkts; + stats->tx_bytes =3D nstats.psp_tx_bytes; + stats->tx_error =3D atomic_read(&priv->psp->tx_drop); +} + static struct psp_dev_ops mlx5_psp_ops =3D { .set_config =3D mlx5e_psp_set_config, .rx_spi_alloc =3D mlx5e_psp_rx_spi_alloc, .tx_key_add =3D mlx5e_psp_assoc_add, .tx_key_del =3D mlx5e_psp_assoc_del, .key_rotate =3D mlx5e_psp_key_rotate, + .get_stats =3D mlx5e_psp_get_stats, }; =20 void mlx5e_psp_unregister(struct mlx5e_priv *priv) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp.h b/drive= rs/net/ethernet/mellanox/mlx5/core/en_accel/psp.h index 42bb671fb2cb..6b62fef0d9a7 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp.h +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp.h @@ -7,11 +7,27 @@ #include #include "en.h" =20 +struct mlx5e_psp_stats { + u64 psp_rx_pkts; + u64 psp_rx_bytes; + u64 psp_rx_pkts_auth_fail; + u64 psp_rx_bytes_auth_fail; + u64 psp_rx_pkts_frame_err; + u64 psp_rx_bytes_frame_err; + u64 psp_rx_pkts_drop; + u64 psp_rx_bytes_drop; + u64 psp_tx_pkts; + u64 psp_tx_bytes; + u64 psp_tx_pkts_drop; + u64 psp_tx_bytes_drop; +}; + struct mlx5e_psp { struct psp_dev *psp; struct psp_dev_caps caps; struct mlx5e_psp_fs *fs; atomic_t tx_key_cnt; + atomic_t tx_drop; }; =20 static inline bool mlx5_is_psp_device(struct mlx5_core_dev *mdev) diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp_rxtx.c b/= drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp_rxtx.c index 828bff1137af..c17ea0fcd8ef 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp_rxtx.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_accel/psp_rxtx.c @@ -186,6 +186,7 @@ bool mlx5e_psp_handle_tx_skb(struct net_device *netdev, /* psp_encap of the packet */ if (!psp_dev_encapsulate(net, skb, psp_st->spi, psp_st->ver, 0)) { kfree_skb_reason(skb, SKB_DROP_REASON_PSP_OUTPUT); + atomic_inc(&priv->psp->tx_drop); return false; } if (skb_is_gso(skb)) { diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/ne= t/ethernet/mellanox/mlx5/core/en_main.c index 7b7a0060979d..3fdb1de94c9b 100644 --- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c @@ -4011,6 +4011,11 @@ void mlx5e_fold_sw_stats64(struct mlx5e_priv *priv, = struct rtnl_link_stats64 *s) s->rx_bytes +=3D rq_stats->bytes; s->multicast +=3D rq_stats->mcast_packets; } + +#ifdef CONFIG_MLX5_EN_PSP + if (priv->psp) + s->tx_dropped +=3D atomic_read(&priv->psp->tx_drop); +#endif } =20 void --=20 2.47.3