Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5474b132 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'sfc-next' 



Edward Cree says:

====================
sfc: add MCDI tracing

This patchset adds support for logging MCDI (Management-Controller-to-
 Driver Interface) interactions between the sfc driver and a bound device,
 to aid in debugging.
Solarflare has a tool to decode the resulting traces and will look to
 open-source this if there is any external interest, but the protocol is
 already detailed in drivers/net/ethernet/sfc/mcdi_pcol.h.
The logging buffer we allocate per MCDI context is a work area for
 constructing each individual message before logging it with netif_info.
The reason the buffer is long-lived is simply to avoid the overhead of
 allocating and freeing it every MCDI call, since MCDIs are already known
 to be serialised for other reasons.

--
v4: remove patch #4, which has already been applied via sshah
v3: add some explanations to cover letter and patch #4
v2: avoid long lines in cover letter; fix multiline comment style
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 14e1d0fa 42ca087f

drivers/net/ethernet/sfc/Kconfig

+9 −0
Original line number Diff line number Diff line
@@ -36,3 +36,12 @@ config SFC_SRIOV 
	  This enables support for the SFC9000 I/O Virtualization

	  features, allowing accelerated network performance in

	  virtualized environments.

config SFC_MCDI_LOGGING

	bool "Solarflare SFC9000/SFC9100-family MCDI logging support"

	depends on SFC

	default y

	---help---

	  This enables support for tracing of MCDI (Management-Controller-to-

	  Driver-Interface) commands and responses, allowing debugging of

	  driver/firmware interaction.  The tracing is actually enabled by

	  a sysfs file 'mcdi_logging' under the PCI device.

drivers/net/ethernet/sfc/ef10.c

+3 −0
Original line number Diff line number Diff line
@@ -267,6 +267,9 @@ static int efx_ef10_probe(struct efx_nic *efx) 
		return -ENOMEM;

	efx->nic_data = nic_data;



	/* we assume later that we can copy from this buffer in dwords */

	BUILD_BUG_ON(MCDI_CTL_SDU_LEN_MAX_V2 % 4);



	rc = efx_nic_alloc_buffer(efx, &nic_data->mcdi_buf,

				  8 + MCDI_CTL_SDU_LEN_MAX_V2, GFP_KERNEL);

	if (rc)

drivers/net/ethernet/sfc/efx.c

+42 −7
Original line number Diff line number Diff line
@@ -2326,6 +2326,28 @@ show_phy_type(struct device *dev, struct device_attribute *attr, char *buf) 
}

static DEVICE_ATTR(phy_type, 0444, show_phy_type, NULL);



#ifdef CONFIG_SFC_MCDI_LOGGING

static ssize_t show_mcdi_log(struct device *dev, struct device_attribute *attr,

			     char *buf)

{

	struct efx_nic *efx = pci_get_drvdata(to_pci_dev(dev));

	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);



	return scnprintf(buf, PAGE_SIZE, "%d\n", mcdi->logging_enabled);

}

static ssize_t set_mcdi_log(struct device *dev, struct device_attribute *attr,

			    const char *buf, size_t count)

{

	struct efx_nic *efx = pci_get_drvdata(to_pci_dev(dev));

	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);

	bool enable = count > 0 && *buf != '0';



	mcdi->logging_enabled = enable;

	return count;

}

static DEVICE_ATTR(mcdi_logging, 0644, show_mcdi_log, set_mcdi_log);

#endif



static int efx_register_netdev(struct efx_nic *efx)

{

	struct net_device *net_dev = efx->net_dev;
@@ -2383,9 +2405,21 @@ static int efx_register_netdev(struct efx_nic *efx) 
			  "failed to init net dev attributes\n");

		goto fail_registered;

	}

#ifdef CONFIG_SFC_MCDI_LOGGING

	rc = device_create_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);

	if (rc) {

		netif_err(efx, drv, efx->net_dev,

			  "failed to init net dev attributes\n");

		goto fail_attr_mcdi_logging;

	}

#endif



	return 0;



#ifdef CONFIG_SFC_MCDI_LOGGING

fail_attr_mcdi_logging:

	device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_type);

#endif

fail_registered:

	rtnl_lock();

	efx_dissociate(efx);
@@ -2404,13 +2438,14 @@ static void efx_unregister_netdev(struct efx_nic *efx) 


	BUG_ON(netdev_priv(efx->net_dev) != efx);



	if (efx_dev_registered(efx)) {

		strlcpy(efx->name, pci_name(efx->pci_dev), sizeof(efx->name));

#ifdef CONFIG_SFC_MCDI_LOGGING

		device_remove_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);

#endif

		device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_type);



	rtnl_lock();

	unregister_netdevice(efx->net_dev);

	efx->state = STATE_UNINIT;

	rtnl_unlock();

		unregister_netdev(efx->net_dev);

	}

}



/**************************************************************************

drivers/net/ethernet/sfc/mcdi.c

+96 −4
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 
 */



#include <linux/delay.h>

#include <linux/moduleparam.h>

#include <asm/cmpxchg.h>

#include "net_driver.h"

#include "nic.h"
@@ -54,18 +55,32 @@ static int efx_mcdi_drv_attach(struct efx_nic *efx, bool driver_operating, 
static bool efx_mcdi_poll_once(struct efx_nic *efx);

static void efx_mcdi_abandon(struct efx_nic *efx);



#ifdef CONFIG_SFC_MCDI_LOGGING

static bool mcdi_logging_default;

module_param(mcdi_logging_default, bool, 0644);

MODULE_PARM_DESC(mcdi_logging_default,

		 "Enable MCDI logging on newly-probed functions");

#endif



int efx_mcdi_init(struct efx_nic *efx)

{

	struct efx_mcdi_iface *mcdi;

	bool already_attached;

	int rc;

	int rc = -ENOMEM;



	efx->mcdi = kzalloc(sizeof(*efx->mcdi), GFP_KERNEL);

	if (!efx->mcdi)

		return -ENOMEM;

		goto fail;



	mcdi = efx_mcdi(efx);

	mcdi->efx = efx;

#ifdef CONFIG_SFC_MCDI_LOGGING

	/* consuming code assumes buffer is page-sized */

	mcdi->logging_buffer = (char *)__get_free_page(GFP_KERNEL);

	if (!mcdi->logging_buffer)

		goto fail1;

	mcdi->logging_enabled = mcdi_logging_default;

#endif

	init_waitqueue_head(&mcdi->wq);

	spin_lock_init(&mcdi->iface_lock);

	mcdi->state = MCDI_STATE_QUIESCENT;
@@ -81,7 +96,7 @@ int efx_mcdi_init(struct efx_nic *efx) 
	/* Recover from a failed assertion before probing */

	rc = efx_mcdi_handle_assertion(efx);

	if (rc)

		return rc;

		goto fail2;



	/* Let the MC (and BMC, if this is a LOM) know that the driver

	 * is loaded. We should do this before we reset the NIC.
@@ -90,7 +105,7 @@ int efx_mcdi_init(struct efx_nic *efx) 
	if (rc) {

		netif_err(efx, probe, efx->net_dev,

			  "Unable to register driver with MCPU\n");

		return rc;

		goto fail2;

	}

	if (already_attached)

		/* Not a fatal error */
@@ -102,6 +117,15 @@ int efx_mcdi_init(struct efx_nic *efx) 
		efx->primary = efx;



	return 0;

fail2:

#ifdef CONFIG_SFC_MCDI_LOGGING

	free_page((unsigned long)mcdi->logging_buffer);

fail1:

#endif

	kfree(efx->mcdi);

	efx->mcdi = NULL;

fail:

	return rc;

}



void efx_mcdi_fini(struct efx_nic *efx)
@@ -114,6 +138,10 @@ void efx_mcdi_fini(struct efx_nic *efx) 
	/* Relinquish the device (back to the BMC, if this is a LOM) */

	efx_mcdi_drv_attach(efx, false, NULL);



#ifdef CONFIG_SFC_MCDI_LOGGING

	free_page((unsigned long)efx->mcdi->iface.logging_buffer);

#endif



	kfree(efx->mcdi);

}
@@ -121,6 +149,9 @@ static void efx_mcdi_send_request(struct efx_nic *efx, unsigned cmd, 
				  const efx_dword_t *inbuf, size_t inlen)

{

	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);

#ifdef CONFIG_SFC_MCDI_LOGGING

	char *buf = mcdi->logging_buffer; /* page-sized */

#endif

	efx_dword_t hdr[2];

	size_t hdr_len;

	u32 xflags, seqno;
@@ -165,6 +196,31 @@ static void efx_mcdi_send_request(struct efx_nic *efx, unsigned cmd, 
		hdr_len = 8;

	}



#ifdef CONFIG_SFC_MCDI_LOGGING

	if (mcdi->logging_enabled && !WARN_ON_ONCE(!buf)) {

		int bytes = 0;

		int i;

		/* Lengths should always be a whole number of dwords, so scream

		 * if they're not.

		 */

		WARN_ON_ONCE(hdr_len % 4);

		WARN_ON_ONCE(inlen % 4);



		/* We own the logging buffer, as only one MCDI can be in

		 * progress on a NIC at any one time.  So no need for locking.

		 */

		for (i = 0; i < hdr_len / 4 && bytes < PAGE_SIZE; i++)

			bytes += snprintf(buf + bytes, PAGE_SIZE - bytes,

					  " %08x", le32_to_cpu(hdr[i].u32[0]));



		for (i = 0; i < inlen / 4 && bytes < PAGE_SIZE; i++)

			bytes += snprintf(buf + bytes, PAGE_SIZE - bytes,

					  " %08x", le32_to_cpu(inbuf[i].u32[0]));



		netif_info(efx, hw, efx->net_dev, "MCDI RPC REQ:%s\n", buf);

	}

#endif



	efx->type->mcdi_request(efx, hdr, hdr_len, inbuf, inlen);



	mcdi->new_epoch = false;
@@ -206,6 +262,9 @@ static void efx_mcdi_read_response_header(struct efx_nic *efx) 
{

	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);

	unsigned int respseq, respcmd, error;

#ifdef CONFIG_SFC_MCDI_LOGGING

	char *buf = mcdi->logging_buffer; /* page-sized */

#endif

	efx_dword_t hdr;



	efx->type->mcdi_read_response(efx, &hdr, 0, 4);
@@ -223,6 +282,39 @@ static void efx_mcdi_read_response_header(struct efx_nic *efx) 
			EFX_DWORD_FIELD(hdr, MC_CMD_V2_EXTN_IN_ACTUAL_LEN);

	}



#ifdef CONFIG_SFC_MCDI_LOGGING

	if (mcdi->logging_enabled && !WARN_ON_ONCE(!buf)) {

		size_t hdr_len, data_len;

		int bytes = 0;

		int i;



		WARN_ON_ONCE(mcdi->resp_hdr_len % 4);

		hdr_len = mcdi->resp_hdr_len / 4;

		/* MCDI_DECLARE_BUF ensures that underlying buffer is padded

		 * to dword size, and the MCDI buffer is always dword size

		 */

		data_len = DIV_ROUND_UP(mcdi->resp_data_len, 4);



		/* We own the logging buffer, as only one MCDI can be in

		 * progress on a NIC at any one time.  So no need for locking.

		 */

		for (i = 0; i < hdr_len && bytes < PAGE_SIZE; i++) {

			efx->type->mcdi_read_response(efx, &hdr, (i * 4), 4);

			bytes += snprintf(buf + bytes, PAGE_SIZE - bytes,

					  " %08x", le32_to_cpu(hdr.u32[0]));

		}



		for (i = 0; i < data_len && bytes < PAGE_SIZE; i++) {

			efx->type->mcdi_read_response(efx, &hdr,

					mcdi->resp_hdr_len + (i * 4), 4);

			bytes += snprintf(buf + bytes, PAGE_SIZE - bytes,

					  " %08x", le32_to_cpu(hdr.u32[0]));

		}



		netif_info(efx, hw, efx->net_dev, "MCDI RPC RESP:%s\n", buf);

	}

#endif



	if (error && mcdi->resp_data_len == 0) {

		netif_err(efx, hw, efx->net_dev, "MC rebooted\n");

		mcdi->resprc = -EIO;

drivers/net/ethernet/sfc/mcdi.h

+6 −0
Original line number Diff line number Diff line
@@ -58,6 +58,8 @@ enum efx_mcdi_mode { 
 *	enabled

 * @async_list: Queue of asynchronous requests

 * @async_timer: Timer for asynchronous request timeout

 * @logging_buffer: buffer that may be used to build MCDI tracing messages

 * @logging_enabled: whether to trace MCDI

 */

struct efx_mcdi_iface {

	struct efx_nic *efx;
@@ -74,6 +76,10 @@ struct efx_mcdi_iface { 
	spinlock_t async_lock;

	struct list_head async_list;

	struct timer_list async_timer;

#ifdef CONFIG_SFC_MCDI_LOGGING

	char *logging_buffer;

	bool logging_enabled;

#endif

};



struct efx_mcdi_mon {