Added new tool to configure congestion in MH

Signed-off-by: Adham Masarwah <[email protected]>

Author: adham-mellanox

mstflint.spec.in

@@ -105,6 +105,7 @@ rm -rf $RPM_BUILD_ROOT
 %{_bindir}/mstmcra
 %{_bindir}/mstconfig
 %{_bindir}/mstfwreset
+%{_bindir}/mstcongestion
 %if %{enablefwmgr}
  %{_bindir}/mstfwmanager
 %{CONF_DIR}/ca-bundle.crt

reg_access/reg_access.c

@@ -49,6 +49,7 @@
 #define REG_ID_MNVGN 0x9035
 #define REG_ID_MLCOK 0x402D
 
+#define REG_ID_MPEGC 0x9056
 
 #define REG_ID_MCDA  0x9063
 #define REG_ID_MCQS  0x9060
@@ -57,6 +58,7 @@
 #define REG_ID_MCAM  0x907f
 #define REG_ID_MQIS  0x9064
 
+
 // TODO: get correct register ID for mfrl mfai
 #define REG_ID_MFRL 0x9028
 #define REG_ID_MFAI 0x9029
@@ -445,6 +447,13 @@ reg_access_status_t reg_access_mqis(mfile *mf, reg_access_method_t method, struc
                                     reg_access_hca, reg_size, r_size_reg, w_size_reg, reg_access_hca_mqis_reg_size, info_string, read_length);
 }
 
+
+
+reg_access_status_t reg_access_mpegc(mfile *mf, reg_access_method_t method, struct reg_access_hca_mpegc_reg *mpegc)
+{
+//    reg_access_hca_mpegc_reg_dump(mpegc, stdout)s;
+    REG_ACCCESS(mf, method, REG_ID_MPEGC, mpegc, mpegc_reg, reg_access_hca);
+}
 /************************************
 * Function: reg_access_err2str
 ************************************/

reg_access/reg_access.h

@@ -78,6 +78,7 @@ reg_access_status_t reg_access_nvqgc(mfile *mf, reg_access_method_t method, stru
 reg_access_status_t reg_access_mvts(mfile *mf, reg_access_method_t method, struct tools_open_mvts *mvts);
 reg_access_status_t reg_access_mnvgn(mfile *mf, reg_access_method_t method, struct tools_open_mnvgn *mnvgn, int *status);
 reg_access_status_t reg_access_mfmc(mfile *mf, reg_access_method_t method, struct tools_open_mfmc *mfmc);
+reg_access_status_t reg_access_mpegc(mfile *mf, reg_access_method_t method, struct reg_access_hca_mpegc_reg *mpegc);
 
 reg_access_status_t reg_access_mcam(mfile *mf, reg_access_method_t method, struct tools_open_mcam *mcam);
 reg_access_status_t reg_access_secure_host(mfile *mf, reg_access_method_t method, struct tools_open_mlock *mlock);

small_utils/Makefile.am

@@ -41,7 +41,8 @@ bin_PROGRAMS = mstmread \
 					mstmwrite \
 					mstmcra \
 					mstmtserver \
-					mstvpd
+					mstvpd \
+					mstcongestion
 
 bin_SCRIPTS = mstfwreset
 
@@ -52,6 +53,13 @@ mstmwrite_SOURCES = mwrite.c
 mstvpd_SOURCES = vpd.c
 mstvpd_LDADD = $(top_srcdir)/mvpd/libmvpd.a $(top_srcdir)/${MTCR_CONF_DIR}/libmtcr_ul.a ${LDL}
 
+mstcongestion_SOURCES = congestion.cpp
+mstcongestion_LDADD = $(top_srcdir)/cmdif/libcmdif.a \
+                      $(top_srcdir)/reg_access/libreg_access.a \
+                      $(top_srcdir)/tools_layouts/libtools_layouts.a \
+                      $(top_srcdir)/cmdparser/libcmdparser.a \
+                      $(top_srcdir)/${MTCR_CONF_DIR}/libmtcr_ul.a ${LDL}
+
 mstmcra_SOURCES  = mcra.c
 
 mstmtserver_SOURCES = mtserver.c tcp.c tcp.h

small_utils/congestion.cpp

@@ -0,0 +1,272 @@
+/*
+ * Copyright (C) Jan 2013 Mellanox Technologies Ltd. All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include "congestion.h"
+#include "reg_access/reg_access.h"
+#include "common/tools_version.h"
+#include <stdlib.h>
+#include <iostream>
+
+using namespace std;
+
+enum {
+    BIT_TX_LOSSY_OPER = 1,
+    BIT_TX_SENSE = 1 << 3,
+    BIT_MARK_TX_CQE = 1 << 4,
+    BIT_MARK_TX_CNP = 1 << 5,
+};
+
+int main(int argc, char **argv)
+{
+    CongestionUI congestObject;
+    if (!congestObject.run(argc, argv)) {
+        cout << "-E- Failed to perform the operation: " << congestObject.getError() << endl;
+        return 1;
+    } else {
+        if (congestObject.getSuccess() != "") {
+            cout << "-I- " << congestObject.getSuccess() << endl;
+        }
+    }
+    return 0;
+}
+
+
+CongestionUI::CongestionUI() :
+            CommandLineRequester("mstcongestion [OPTIONS]"),
+            _cmdParser("mstcongestion")
+{
+    _mf = NULL;
+    _action = ACTION_NA;
+    _mode = MODE_NA;
+    _query = false;
+    _ops = 0;
+    _dynamicSupp = 0;
+    _markCqeSupp = 0;
+    _markCnpSupp = 0;
+    initCmdParser();
+}
+
+CongestionUI::~CongestionUI()
+{
+    if (_mf) {
+        mclose(_mf);
+        _mf = NULL;
+    }
+}
+
+void CongestionUI::initCmdParser()
+{
+
+    AddOptions("device", 'd', "<PCI DEVICE>", "Mellanox PCI device address");
+    AddOptions("mode", ' ', "<MODE>", "Set Mode, options are: [aggressive | dynamic]");
+    AddOptions("action", ' ', "<ACTION>", "Set Action, options are: [disabled | drop | mark]");
+    AddOptions("query", 'q', "", "Query congestion");
+    AddOptions("help", 'h', "", "Show help message and exit");
+    AddOptions("version", 'v', "", "Show version and exit");
+    AddDescription("mstcongestion is a tool to set Congestion mode and action.");
+    _cmdParser.AddRequester(this);
+}
+
+ParseStatus CongestionUI::HandleOption(string name, string value)
+{
+    if (name == "device") {
+        _devname = value;
+    } else if (name == "mode" ) {
+        _ops++;
+        if (value == "aggressive") {
+            _mode = MODE_AGGRESSIVE;
+        } else if (value == "dynamic") {
+            _mode = MODE_DYNAMIC;
+        } else {
+            _errorMsg = "Invalid mode, options are: [aggressive | dynamic]";
+            return PARSE_ERROR;
+        }
+    } else if (name == "action") {
+        _ops++;
+        if (value == "disabled") {
+            _action = ACTION_DISABLED;
+        } else if (value == "drop") {
+            _action = ACTION_DROP;
+        } else if (value == "mark") {
+            _action = ACTION_MARK;
+        } else {
+            _errorMsg = "Invalid action, options are: [disabled | drop | mark]";
+            return PARSE_ERROR;
+        }
+    } else if (name == "help") {
+        cout << _cmdParser.GetUsage() << endl;
+        return PARSE_OK_WITH_EXIT;
+    } else if (name == "version") {
+        print_version_string("mstcongestion", NULL);
+        return PARSE_OK_WITH_EXIT;
+    } else if (name == "query") {
+        _ops++;
+        _query = true;
+    } else {
+        _errorMsg = "Invalid option: " + name;
+        return PARSE_ERROR;
+    }
+    return PARSE_OK;
+}
+
+bool CongestionUI::run(int argc, char** argv)
+{
+    ParseStatus rc = _cmdParser.ParseOptions(argc, argv);
+    if (rc == PARSE_OK_WITH_EXIT) {
+        return true;
+    } else if (rc == PARSE_ERROR) {
+        if (_errorMsg == "") {
+            _errorMsg = "Failed while parsing the arguments.";
+        }
+        return false;
+    }
+
+    if (_devname == "") {
+        _errorMsg = "Missing device.";
+        return false;
+    }
+    _mf = mopen(_devname.c_str());
+    if (!_mf) {
+        _errorMsg = "Failed to open device: " + _devname;
+        return false;
+    }
+    struct tools_open_mcam mcam;
+    memset(&mcam, 0, sizeof(mcam));
+    reg_access_status_t status = reg_access_mcam(_mf, REG_ACCESS_METHOD_GET, &mcam);
+    if (status) {
+        _errorMsg = "Failed to get device capabilities!";
+        return false;
+    }
+    u_int8_t caps = mcam.mng_feature_cap_mask[14];
+    _dynamicSupp = caps & 0x2;
+    _markCqeSupp = caps & 0x4;
+    _markCnpSupp = caps & 0x8;
+    if (_ops != 1) {
+        _errorMsg = "Please choose one operation.";
+        return false;
+    }
+    if (_mode != MODE_NA) {
+        return setMode(_mode);
+    } else if (_action != ACTION_NA) {
+        return setAction(_action);
+    } else if (_query) {
+        return query();
+    }
+    return true;
+}
+
+
+bool CongestionUI::setMode(cong_mode_t mode)
+{
+    if (!_dynamicSupp) {
+        _errorMsg = "Dynamic overflow is not supported.";
+        return false;
+    }
+    _successMsg = "Mode was set successfully.";
+    struct reg_access_hca_mpegc_reg mpegc;
+    memset(&mpegc, 0, sizeof (mpegc));
+    mpegc.tx_overflow_sense = (int)mode;
+    mpegc.field_select |= BIT_TX_SENSE;
+    reg_access_status_t status = reg_access_mpegc(_mf, REG_ACCESS_METHOD_SET, &mpegc);
+    if (status) {
+        _errorMsg = string(reg_access_err2str(status));
+        return false;
+    }
+    return true;
+}
+
+bool CongestionUI::setAction(cong_action_t action)
+{
+    _successMsg = "Action was set successfully.";
+    struct reg_access_hca_mpegc_reg mpegc;
+    memset(&mpegc, 0, sizeof (mpegc));
+    mpegc.tx_lossy_overflow_oper = (int)action;
+    mpegc.field_select |= BIT_TX_LOSSY_OPER;
+    if (action == ACTION_MARK) {
+        if (_markCqeSupp) {
+            mpegc.field_select |= BIT_MARK_TX_CQE;
+            mpegc.mark_cqe = 1;
+        }
+        if (_markCnpSupp) {
+            mpegc.field_select |= BIT_MARK_TX_CNP;
+            mpegc.mark_cnp = 1;
+        }
+    }
+    reg_access_status_t status = reg_access_mpegc(_mf, REG_ACCESS_METHOD_SET, &mpegc);
+    if (status) {
+        _errorMsg = string(reg_access_err2str(status));
+        return false;
+    }
+    return true;
+}
+
+bool CongestionUI::query()
+{
+    struct reg_access_hca_mpegc_reg mpegc;
+    memset(&mpegc, 0, sizeof (mpegc));
+    reg_access_status_t status = reg_access_mpegc(_mf, REG_ACCESS_METHOD_GET, &mpegc);
+    if (status) {
+        _errorMsg = string(reg_access_err2str(status));
+        return false;
+    }
+    printf("Action: %s\nMode: %s\n", getActionString((cong_action_t)mpegc.tx_lossy_overflow_oper).c_str(),
+           getModeString((cong_mode_t)mpegc.tx_overflow_sense).c_str());
+    return true;
+}
+
+
+string CongestionUI::getModeString(cong_mode_t mode)
+{
+    switch (mode) {
+    case MODE_AGGRESSIVE:
+        return "Aggressive";
+    case MODE_DYNAMIC:
+        return "Dynamic";
+    default:
+        return "N/A";
+    }
+}
+
+string CongestionUI::getActionString(cong_action_t action)
+{
+    switch (action) {
+    case ACTION_DISABLED:
+        return "Disabled";
+    case ACTION_DROP:
+        return "Drop";
+    case ACTION_MARK:
+        return "Mark";
+    default:
+        return "N/A";
+    }
+}