Imported Upstream version 0.9.10.0 upstream/0.9.10.0

1 files changed, 426 insertions, 0 deletions

diff --git a/src/nm-dcb.c b/src/nm-dcb.c
new file mode 100644
index 00000000..3bdbf7d5
--- /dev/null
+++ b/src/nm-dcb.c
@@ -0,0 +1,426 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/* NetworkManager -- Network link manager
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2013 Red Hat, Inc.
+ */
+
+#include <config.h>
+#include <sys/wait.h>
+#include <string.h>
+
+#include <glib.h>
+#include "nm-dcb.h"
+#include "nm-platform.h"
+#include "NetworkManagerUtils.h"
+#include "nm-posix-signals.h"
+#include "nm-logging.h"
+
+GQuark
+nm_dcb_error_quark (void)
+{
+	static GQuark ret = 0;
+
+	if (ret == 0)
+		ret = g_quark_from_static_string ("nm-dcb-error");
+	return ret;
+}
+
+static const char *helper_names[] = { "dcbtool", "fcoeadm" };
+
+gboolean
+do_helper (const char *iface,
+           guint which,
+           DcbFunc run_func,
+           gpointer user_data,
+           GError **error,
+           const char *fmt,
+           ...)
+{
+	char **argv = NULL, **split = NULL, *cmdline, *errmsg = NULL;
+	gboolean success = FALSE;
+	guint i, u;
+	va_list args;
+
+	g_return_val_if_fail (fmt != NULL, FALSE);
+
+	va_start (args, fmt);
+	cmdline = g_strdup_vprintf (fmt, args);
+	va_end (args);
+
+	split = g_strsplit_set (cmdline, " ", 0);
+	if (!split) {
+		g_set_error (error, NM_DCB_ERROR, NM_DCB_ERROR_INTERNAL,
+		             "failure parsing %s command line", helper_names[which]);
+		goto out;
+	}
+
+	/* Allocate space for path, custom arg, interface name, arguments, and NULL */
+	i = u = 0;
+	argv = g_new0 (char *, g_strv_length (split) + 4);
+	argv[i++] = NULL;  /* Placeholder for dcbtool path */
+	if (which == DCBTOOL) {
+		argv[i++] = "sc";
+		argv[i++] = (char *) iface;
+	}
+	while (u < g_strv_length (split))
+		argv[i++] = split[u++];
+	argv[i++] = NULL;
+	success = run_func (argv, which, user_data, error);
+	if (!success && error)
+		g_assert (*error);
+
+out:
+	if (split)
+		g_strfreev (split);
+	g_free (argv);
+	g_free (cmdline);
+	g_free (errmsg);
+	return success;
+}
+
+gboolean
+_dcb_enable (const char *iface,
+             gboolean enable,
+             DcbFunc run_func,
+             gpointer user_data,
+             GError **error)
+{
+	if (enable)
+		return do_helper (iface, DCBTOOL, run_func, user_data, error, "dcb on");
+	else
+		return do_helper (iface, DCBTOOL, run_func, user_data, error, "dcb off");
+}
+
+#define SET_FLAGS(f, tag) \
+G_STMT_START { \
+	if (!do_helper (iface, DCBTOOL, run_func, user_data, error, tag " e:%c a:%c w:%c", \
+	                 f & NM_SETTING_DCB_FLAG_ENABLE ? '1' : '0', \
+	                 f & NM_SETTING_DCB_FLAG_ADVERTISE ? '1' : '0', \
+	                 f & NM_SETTING_DCB_FLAG_WILLING ? '1' : '0')) \
+		return FALSE; \
+} G_STMT_END
+
+#define SET_APP(f, s, tag) \
+G_STMT_START { \
+	gint prio = nm_setting_dcb_get_app_##tag##_priority (s); \
+ \
+	SET_FLAGS (f, "app:" #tag); \
+	if ((f & NM_SETTING_DCB_FLAG_ENABLE) && (prio >= 0)) { \
+		if (!do_helper (iface, DCBTOOL, run_func, user_data, error, "app:" #tag " appcfg:%02x", (1 << prio))) \
+			return FALSE; \
+	} \
+} G_STMT_END
+
+gboolean
+_dcb_setup (const char *iface,
+            NMSettingDcb *s_dcb,
+            DcbFunc run_func,
+            gpointer user_data,
+            GError **error)
+{
+	NMSettingDcbFlags flags;
+	guint i;
+
+	g_assert (s_dcb);
+
+	/* FCoE */
+	flags = nm_setting_dcb_get_app_fcoe_flags (s_dcb);
+	SET_APP (flags, s_dcb, fcoe);
+
+	/* iSCSI */
+	flags = nm_setting_dcb_get_app_iscsi_flags (s_dcb);
+	SET_APP (flags, s_dcb, iscsi);
+
+	/* FIP */
+	flags = nm_setting_dcb_get_app_fip_flags (s_dcb);
+	SET_APP (flags, s_dcb, fip);
+
+	/* Priority Flow Control */
+	flags = nm_setting_dcb_get_priority_flow_control_flags (s_dcb);
+	SET_FLAGS (flags, "pfc");
+	if (flags & NM_SETTING_DCB_FLAG_ENABLE) {
+		char buf[10];
+
+		for (i = 0; i < 8; i++)
+			buf[i] = nm_setting_dcb_get_priority_flow_control (s_dcb, i) ? '1' : '0';
+		buf[i] = 0;
+		if (!do_helper (iface, DCBTOOL, run_func, user_data, error, "pfc pfcup:%s", buf))
+			return FALSE;
+	}
+
+	/* Priority Groups */
+	flags = nm_setting_dcb_get_priority_group_flags (s_dcb);
+	if (flags & NM_SETTING_DCB_FLAG_ENABLE) {
+		GString *s;
+		gboolean success;
+		guint id;
+
+		s = g_string_sized_new (150);
+
+		g_string_append_printf (s, "pg e:1 a:%c w:%c",
+		                        flags & NM_SETTING_DCB_FLAG_ADVERTISE ? '1' : '0',
+		                        flags & NM_SETTING_DCB_FLAG_WILLING ? '1' : '0');
+
+		/* Priority Groups */
+		g_string_append (s, " pgid:");
+		for (i = 0; i < 8; i++) {
+			id = nm_setting_dcb_get_priority_group_id (s_dcb, i);
+			g_assert (id < 8 || id == 15);
+			g_string_append_c (s, (id < 8) ? ('0' + id) : 'f');
+		}
+
+		/* Priority Group Bandwidth */
+		g_string_append_printf (s, " pgpct:%u,%u,%u,%u,%u,%u,%u,%u",
+		                        nm_setting_dcb_get_priority_group_bandwidth (s_dcb, 0),
+		                        nm_setting_dcb_get_priority_group_bandwidth (s_dcb, 1),
+		                        nm_setting_dcb_get_priority_group_bandwidth (s_dcb, 2),
+		                        nm_setting_dcb_get_priority_group_bandwidth (s_dcb, 3),
+		                        nm_setting_dcb_get_priority_group_bandwidth (s_dcb, 4),
+		                        nm_setting_dcb_get_priority_group_bandwidth (s_dcb, 5),
+		                        nm_setting_dcb_get_priority_group_bandwidth (s_dcb, 6),
+		                        nm_setting_dcb_get_priority_group_bandwidth (s_dcb, 7));
+
+		/* Priority Bandwidth */
+		g_string_append_printf (s, " uppct:%u,%u,%u,%u,%u,%u,%u,%u",
+		                        nm_setting_dcb_get_priority_bandwidth (s_dcb, 0),
+		                        nm_setting_dcb_get_priority_bandwidth (s_dcb, 1),
+		                        nm_setting_dcb_get_priority_bandwidth (s_dcb, 2),
+		                        nm_setting_dcb_get_priority_bandwidth (s_dcb, 3),
+		                        nm_setting_dcb_get_priority_bandwidth (s_dcb, 4),
+		                        nm_setting_dcb_get_priority_bandwidth (s_dcb, 5),
+		                        nm_setting_dcb_get_priority_bandwidth (s_dcb, 6),
+		                        nm_setting_dcb_get_priority_bandwidth (s_dcb, 7));
+
+		/* Strict Bandwidth */
+		g_string_append (s, " strict:");
+		for (i = 0; i < 8; i++)
+			g_string_append_c (s, nm_setting_dcb_get_priority_strict_bandwidth (s_dcb, i) ? '1' : '0');
+
+		/* Priority Traffic Class */
+		g_string_append (s, " up2tc:");
+		for (i = 0; i < 8; i++) {
+			id = nm_setting_dcb_get_priority_traffic_class (s_dcb, i);
+			g_assert (id < 8);
+			g_string_append_c (s, '0' + id);
+		}
+
+		success = do_helper (iface, DCBTOOL, run_func, user_data, error, "%s", s->str);
+		g_string_free (s, TRUE);
+		if (!success)
+			return FALSE;
+	} else {
+		/* Ignore disable failure since lldpad <= 0.9.46 does not support disabling
+		 * priority groups without specifying an entire PG config.
+		 */
+		(void) do_helper (iface, DCBTOOL, run_func, user_data, error, "pg e:0");
+	}
+
+	return TRUE;
+}
+
+gboolean
+_dcb_cleanup (const char *iface,
+              DcbFunc run_func,
+              gpointer user_data,
+              GError **error)
+{
+	const char *cmds[] = {
+		"app:fcoe e:0",
+		"app:iscsi e:0",
+		"app:fip e:0",
+		"pfc e:0",
+		"pg e:0",
+		NULL
+	};
+	const char **iter = cmds;
+	gboolean success = TRUE;
+
+	/* Turn everything off and return first error we get (if any) */
+	while (iter && *iter) {
+		if (!do_helper (iface, DCBTOOL, run_func, user_data, success ? error : NULL, "%s", *iter))
+			success = FALSE;
+		iter++;
+	}
+
+	if (!_dcb_enable (iface, FALSE, run_func, user_data, success ? error : NULL))
+		success = FALSE;
+
+	return success;
+}
+
+gboolean
+_fcoe_setup (const char *iface,
+             NMSettingDcb *s_dcb,
+             DcbFunc run_func,
+             gpointer user_data,
+             GError **error)
+{
+	NMSettingDcbFlags flags;
+
+	g_assert (s_dcb);
+
+	flags = nm_setting_dcb_get_app_fcoe_flags (s_dcb);
+	if (flags & NM_SETTING_DCB_FLAG_ENABLE) {
+		const char *mode = nm_setting_dcb_get_app_fcoe_mode (s_dcb);
+
+		if (!do_helper (NULL, FCOEADM, run_func, user_data, error, "-m %s -c %s", mode, iface))
+			return FALSE;
+	} else {
+		if (!do_helper (NULL, FCOEADM, run_func, user_data, error, "-d %s", iface))
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+gboolean
+_fcoe_cleanup (const char *iface,
+               DcbFunc run_func,
+               gpointer user_data,
+               GError **error)
+{
+	return do_helper (NULL, FCOEADM, run_func, user_data, error, "-d %s", iface);
+}
+
+
+static const char *dcbpaths[] = {
+	"/sbin/dcbtool",
+	"/usr/sbin/dcbtool",
+	"/usr/local/sbin/dcbtool",
+	NULL
+};
+static const char *fcoepaths[] = {
+	"/sbin/fcoeadm",
+	"/usr/sbin/fcoeadm",
+	"/usr/local/sbin/fcoeadm",
+	NULL
+};
+
+
+static gboolean
+run_helper (char **argv, guint which, gpointer user_data, GError **error)
+{
+	static const char *helper_path[2] = { NULL, NULL };
+	int exit_status = 0;
+	gboolean success;
+	char *errmsg = NULL, *outmsg = NULL;
+	const char **iter;
+	char *cmdline;
+
+	if (G_UNLIKELY (helper_path[which] == NULL)) {
+		iter = (which == DCBTOOL) ? dcbpaths : fcoepaths;
+		while (*iter) {
+			if (g_file_test (*iter, G_FILE_TEST_EXISTS))
+				helper_path[which] = *iter;
+			iter++;
+		}
+		if (!helper_path[which]) {
+			g_set_error (error, NM_DCB_ERROR, NM_DCB_ERROR_HELPER_NOT_FOUND,
+			             "%s not found",
+			             which == DCBTOOL ? "dcbtool" : "fcoadm");
+			return FALSE;
+		}
+	}
+
+	argv[0] = (char *) helper_path[which];
+	cmdline = g_strjoinv (" ", argv);
+	nm_log_dbg (LOGD_DCB, "%s", cmdline);
+
+	success = g_spawn_sync ("/", argv, NULL, 0 /*G_SPAWN_DEFAULT*/,
+	                        nm_unblock_posix_signals, NULL,
+	                        &outmsg, &errmsg, &exit_status, error);
+	/* Log any stderr output */
+	if (success && WIFEXITED (exit_status) && WEXITSTATUS (exit_status) && (errmsg || outmsg)) {
+		gboolean ignore_error = FALSE;
+
+		/* Ignore fcoeadm "success" errors like when FCoE is already set up */
+		if (errmsg && strstr (errmsg, "Connection already created"))
+			ignore_error = TRUE;
+
+		if (ignore_error == FALSE) {
+			nm_log_warn (LOGD_DCB, "'%s' failed: '%s'",
+			             cmdline, (errmsg && strlen (errmsg)) ? errmsg : outmsg);
+			g_set_error (error, NM_DCB_ERROR, NM_DCB_ERROR_HELPER_FAILED,
+			             "Failed to run '%s'", cmdline);
+			success = FALSE;
+		}
+	}
+	g_free (outmsg);
+	g_free (errmsg);
+
+	g_free (cmdline);
+	return success;
+}
+
+gboolean
+nm_dcb_enable (const char *iface, gboolean enable, GError **error)
+{
+	return _dcb_enable (iface, enable, run_helper, GUINT_TO_POINTER (DCBTOOL), error);
+}
+
+gboolean
+nm_dcb_setup (const char *iface, NMSettingDcb *s_dcb, GError **error)
+{
+	gboolean success;
+
+	success = _dcb_setup (iface, s_dcb, run_helper, GUINT_TO_POINTER (DCBTOOL), error);
+	if (success)
+		success = _fcoe_setup (iface, s_dcb, run_helper, GUINT_TO_POINTER (FCOEADM), error);
+
+	return success;
+}
+
+static void
+carrier_wait (const char *iface, guint secs, gboolean up)
+{
+	int ifindex, count = secs * 10;
+
+	g_return_if_fail (iface != NULL);
+
+	ifindex = nm_platform_link_get_ifindex (iface);
+	if (ifindex > 0) {
+		/* To work around driver quirks and lldpad handling of carrier status,
+		 * we must wait a short period of time to see if the carrier goes
+		 * down, and then wait for the carrier to come back up again.  Otherwise
+		 * subsequent lldpad calls may fail with "Device not found, link down
+		 * or DCB not enabled" errors.
+		 */
+		nm_log_dbg (LOGD_DCB, "(%s): cleanup waiting for carrier %s",
+		            iface, up ? "up" : "down");
+		g_usleep (G_USEC_PER_SEC / 4);
+		while (nm_platform_link_is_connected (ifindex) != up && count-- > 0) {
+			g_usleep (G_USEC_PER_SEC / 10);
+			nm_platform_link_refresh (ifindex);
+		}
+	}
+}
+
+gboolean
+nm_dcb_cleanup (const char *iface, GError **error)
+{
+	/* Ignore FCoE cleanup errors */
+	_fcoe_cleanup (iface, run_helper, GUINT_TO_POINTER (FCOEADM), NULL);
+
+	/* Must pause a bit to wait for carrier-up since disabling FCoE may
+	 * cause the device to take the link down, making lldpad return errors.
+	 */
+	carrier_wait (iface, 2, FALSE);
+	carrier_wait (iface, 4, TRUE);
+
+	return _dcb_cleanup (iface, run_helper, GUINT_TO_POINTER (DCBTOOL), error);
+}
+