[SCSI] Merge tag 'fcoe-02-19-13' into for-linus (3e34c1fc) · Commits · e / devices / android_kernel_fairphone_FP5

Documentation/ABI/testing/sysfs-bus-fcoe

+42 −3

Original line number	Diff line number	Diff line
		What: /sys/bus/fcoe/ctlr_X
		What: /sys/bus/fcoe/
		Date: August 2012
		KernelVersion: TBD
		Contact: Robert Love <robert.w.love@intel.com>, devel@open-fcoe.org
		Description: The FCoE bus. Attributes in this directory are control interfaces.
		Attributes:

		ctlr_create: 'FCoE Controller' instance creation interface. Writing an
		<ifname> to this file will allocate and populate sysfs with a
		fcoe_ctlr_device (ctlr_X). The user can then configure any
		per-port settings and finally write to the fcoe_ctlr_device's
		'start' attribute to begin the kernel's discovery and login
		process.

		ctlr_destroy: 'FCoE Controller' instance removal interface. Writing a
		fcoe_ctlr_device's sysfs name to this file will log the
		fcoe_ctlr_device out of the fabric or otherwise connected
		FCoE devices. It will also free all kernel memory allocated
		for this fcoe_ctlr_device and any structures associated
		with it, this includes the scsi_host.

		What: /sys/bus/fcoe/devices/ctlr_X
		Date: March 2012
		KernelVersion: TBD
		Contact: Robert Love <robert.w.love@intel.com>, devel@open-fcoe.org
		Description: 'FCoE Controller' instances on the fcoe bus
		Description: 'FCoE Controller' instances on the fcoe bus.
		The FCoE Controller now has a three stage creation process.
		1) Write interface name to ctlr_create 2) Configure the FCoE
		Controller (ctlr_X) 3) Enable the FCoE Controller to begin
		discovery and login. The FCoE Controller is destroyed by
		writing it's name, i.e. ctlr_X to the ctlr_delete file.

		Attributes:

		fcf_dev_loss_tmo: Device loss timeout peroid (see below). Changing
		this value will change the dev_loss_tmo for all
		FCFs discovered by this controller.

		mode: Display or change the FCoE Controller's mode. Possible
		modes are 'Fabric' and 'VN2VN'. If a FCoE Controller
		is started in 'Fabric' mode then FIP FCF discovery is
		initiated and ultimately a fabric login is attempted.
		If a FCoE Controller is started in 'VN2VN' mode then
		FIP VN2VN discovery and login is performed. A FCoE
		Controller only supports one mode at a time.

		enabled: Whether an FCoE controller is enabled or disabled.
		0 if disabled, 1 if enabled. Writing either 0 or 1
		to this file will enable or disable the FCoE controller.

		lesb/link_fail: Link Error Status Block (LESB) link failure count.

		lesb/vlink_fail: Link Error Status Block (LESB) virtual link
		@@ -26,7 +65,7 @@ Attributes:

		Notes: ctlr_X (global increment starting at 0)

		What: /sys/bus/fcoe/fcf_X
		What: /sys/bus/fcoe/devices/fcf_X
		Date: March 2012
		KernelVersion: TBD
		Contact: Robert Love <robert.w.love@intel.com>, devel@open-fcoe.org

drivers/scsi/bnx2fc/bnx2fc_fcoe.c

+149 −107

Original line number	Diff line number	Diff line
		@@ -62,6 +62,10 @@ static int bnx2fc_destroy(struct net_device *net_device);
		static int bnx2fc_enable(struct net_device *netdev);
		static int bnx2fc_disable(struct net_device *netdev);

		/* fcoe_syfs control interface handlers */
		static int bnx2fc_ctlr_alloc(struct net_device *netdev);
		static int bnx2fc_ctlr_enabled(struct fcoe_ctlr_device *cdev);

		static void bnx2fc_recv_frame(struct sk_buff *skb);

		static void bnx2fc_start_disc(struct bnx2fc_interface *interface);
		@@ -89,7 +93,6 @@ static void bnx2fc_port_shutdown(struct fc_lport *lport);
		static void bnx2fc_stop(struct bnx2fc_interface *interface);
		static int __init bnx2fc_mod_init(void);
		static void __exit bnx2fc_mod_exit(void);
		static void bnx2fc_ctlr_get_lesb(struct fcoe_ctlr_device *ctlr_dev);

		unsigned int bnx2fc_debug_level;
		module_param_named(debug_logging, bnx2fc_debug_level, int, S_IRUGO\|S_IWUSR);
		@@ -107,44 +110,6 @@ static inline struct net_device bnx2fc_netdev(const struct fc_lport lport)
		((struct fcoe_port *)lport_priv(lport))->priv)->netdev;
		}

		/**
		* bnx2fc_get_lesb() - Fill the FCoE Link Error Status Block
		* @lport: the local port
		* @fc_lesb: the link error status block
		*/
		static void bnx2fc_get_lesb(struct fc_lport *lport,
		struct fc_els_lesb *fc_lesb)
		{
		struct net_device *netdev = bnx2fc_netdev(lport);

		__fcoe_get_lesb(lport, fc_lesb, netdev);
		}

		static void bnx2fc_ctlr_get_lesb(struct fcoe_ctlr_device *ctlr_dev)
		{
		struct fcoe_ctlr *fip = fcoe_ctlr_device_priv(ctlr_dev);
		struct net_device *netdev = bnx2fc_netdev(fip->lp);
		struct fcoe_fc_els_lesb *fcoe_lesb;
		struct fc_els_lesb fc_lesb;

		__fcoe_get_lesb(fip->lp, &fc_lesb, netdev);
		fcoe_lesb = (struct fcoe_fc_els_lesb *)(&fc_lesb);

		ctlr_dev->lesb.lesb_link_fail =
		ntohl(fcoe_lesb->lesb_link_fail);
		ctlr_dev->lesb.lesb_vlink_fail =
		ntohl(fcoe_lesb->lesb_vlink_fail);
		ctlr_dev->lesb.lesb_miss_fka =
		ntohl(fcoe_lesb->lesb_miss_fka);
		ctlr_dev->lesb.lesb_symb_err =
		ntohl(fcoe_lesb->lesb_symb_err);
		ctlr_dev->lesb.lesb_err_block =
		ntohl(fcoe_lesb->lesb_err_block);
		ctlr_dev->lesb.lesb_fcs_error =
		ntohl(fcoe_lesb->lesb_fcs_error);
		}
		EXPORT_SYMBOL(bnx2fc_ctlr_get_lesb);

		static void bnx2fc_fcf_get_vlan_id(struct fcoe_fcf_device *fcf_dev)
		{
		struct fcoe_ctlr_device *ctlr_dev =
		@@ -741,35 +706,6 @@ static int bnx2fc_shost_config(struct fc_lport lport, struct device dev)
		return 0;
		}

		static void bnx2fc_link_speed_update(struct fc_lport *lport)
		{
		struct fcoe_port *port = lport_priv(lport);
		struct bnx2fc_interface *interface = port->priv;
		struct net_device *netdev = interface->netdev;
		struct ethtool_cmd ecmd;

		if (!__ethtool_get_settings(netdev, &ecmd)) {
		lport->link_supported_speeds &=
		~(FC_PORTSPEED_1GBIT \| FC_PORTSPEED_10GBIT);
		if (ecmd.supported & (SUPPORTED_1000baseT_Half \|
		SUPPORTED_1000baseT_Full))
		lport->link_supported_speeds \|= FC_PORTSPEED_1GBIT;
		if (ecmd.supported & SUPPORTED_10000baseT_Full)
		lport->link_supported_speeds \|= FC_PORTSPEED_10GBIT;

		switch (ethtool_cmd_speed(&ecmd)) {
		case SPEED_1000:
		lport->link_speed = FC_PORTSPEED_1GBIT;
		break;
		case SPEED_2500:
		lport->link_speed = FC_PORTSPEED_2GBIT;
		break;
		case SPEED_10000:
		lport->link_speed = FC_PORTSPEED_10GBIT;
		break;
		}
		}
		}
		static int bnx2fc_link_ok(struct fc_lport *lport)
		{
		struct fcoe_port *port = lport_priv(lport);
		@@ -827,7 +763,7 @@ static int bnx2fc_net_config(struct fc_lport lport, struct net_device netdev)
		port->fcoe_pending_queue_active = 0;
		setup_timer(&port->timer, fcoe_queue_timer, (unsigned long) lport);

		bnx2fc_link_speed_update(lport);
		fcoe_link_speed_update(lport);

		if (!lport->vport) {
		if (fcoe_get_wwn(netdev, &wwnn, NETDEV_FCOE_WWNN))
		@@ -871,6 +807,7 @@ static void bnx2fc_indicate_netevent(void *context, unsigned long event,
		u16 vlan_id)
		{
		struct bnx2fc_hba hba = (struct bnx2fc_hba )context;
		struct fcoe_ctlr_device *cdev;
		struct fc_lport *lport;
		struct fc_lport *vport;
		struct bnx2fc_interface interface, tmp;
		@@ -930,30 +867,47 @@ static void bnx2fc_indicate_netevent(void *context, unsigned long event,
		BNX2FC_HBA_DBG(lport, "netevent handler - event=%s %ld\n",
		interface->netdev->name, event);

		bnx2fc_link_speed_update(lport);
		fcoe_link_speed_update(lport);

		cdev = fcoe_ctlr_to_ctlr_dev(ctlr);

		if (link_possible && !bnx2fc_link_ok(lport)) {
		switch (cdev->enabled) {
		case FCOE_CTLR_DISABLED:
		pr_info("Link up while interface is disabled.\n");
		break;
		case FCOE_CTLR_ENABLED:
		case FCOE_CTLR_UNUSED:
		/* Reset max recv frame size to default */
		fc_set_mfs(lport, BNX2FC_MFS);
		/*
		* ctlr link up will only be handled during
		* enable to avoid sending discovery solicitation
		* on a stale vlan
		* enable to avoid sending discovery
		* solicitation on a stale vlan
		*/
		if (interface->enabled)
		fcoe_ctlr_link_up(ctlr);
		};
		} else if (fcoe_ctlr_link_down(ctlr)) {
		switch (cdev->enabled) {
		case FCOE_CTLR_DISABLED:
		pr_info("Link down while interface is disabled.\n");
		break;
		case FCOE_CTLR_ENABLED:
		case FCOE_CTLR_UNUSED:
		mutex_lock(&lport->lp_mutex);
		list_for_each_entry(vport, &lport->vports, list)
		fc_host_port_type(vport->host) =
		FC_PORTTYPE_UNKNOWN;
		mutex_unlock(&lport->lp_mutex);
		fc_host_port_type(lport->host) = FC_PORTTYPE_UNKNOWN;
		fc_host_port_type(lport->host) =
		FC_PORTTYPE_UNKNOWN;
		per_cpu_ptr(lport->stats,
		get_cpu())->LinkFailureCount++;
		put_cpu();
		fcoe_clean_pending_queue(lport);
		wait_for_upload = 1;
		};
		}
		}
		mutex_unlock(&bnx2fc_dev_lock);
		@@ -1484,6 +1438,7 @@ static struct fc_lport bnx2fc_if_create(struct bnx2fc_interface interface,
		port = lport_priv(lport);
		port->lport = lport;
		port->priv = interface;
		port->get_netdev = bnx2fc_netdev;
		INIT_WORK(&port->destroy_work, bnx2fc_destroy_work);

		/* Configure fcoe_port */
		@@ -2003,7 +1958,9 @@ static void bnx2fc_ulp_init(struct cnic_dev *dev)
		set_bit(BNX2FC_CNIC_REGISTERED, &hba->reg_with_cnic);
		}


		/**
		* Deperecated: Use bnx2fc_enabled()
		*/
		static int bnx2fc_disable(struct net_device *netdev)
		{
		struct bnx2fc_interface *interface;
		@@ -2029,7 +1986,9 @@ static int bnx2fc_disable(struct net_device *netdev)
		return rc;
		}


		/**
		* Deprecated: Use bnx2fc_enabled()
		*/
		static int bnx2fc_enable(struct net_device *netdev)
		{
		struct bnx2fc_interface *interface;
		@@ -2055,17 +2014,57 @@ static int bnx2fc_enable(struct net_device *netdev)
		}

		/**
		* bnx2fc_create - Create bnx2fc FCoE interface
		* bnx2fc_ctlr_enabled() - Enable or disable an FCoE Controller
		* @cdev: The FCoE Controller that is being enabled or disabled
		*
		* @buffer: The name of Ethernet interface to create on
		* @kp: The associated kernel param
		* fcoe_sysfs will ensure that the state of 'enabled' has
		* changed, so no checking is necessary here. This routine simply
		* calls fcoe_enable or fcoe_disable, both of which are deprecated.
		* When those routines are removed the functionality can be merged
		* here.
		*/
		static int bnx2fc_ctlr_enabled(struct fcoe_ctlr_device *cdev)
		{
		struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(cdev);
		struct fc_lport *lport = ctlr->lp;
		struct net_device *netdev = bnx2fc_netdev(lport);

		switch (cdev->enabled) {
		case FCOE_CTLR_ENABLED:
		return bnx2fc_enable(netdev);
		case FCOE_CTLR_DISABLED:
		return bnx2fc_disable(netdev);
		case FCOE_CTLR_UNUSED:
		default:
		return -ENOTSUPP;
		};
		}

		enum bnx2fc_create_link_state {
		BNX2FC_CREATE_LINK_DOWN,
		BNX2FC_CREATE_LINK_UP,
		};

		/**
		* _bnx2fc_create() - Create bnx2fc FCoE interface
		* @netdev : The net_device object the Ethernet interface to create on
		* @fip_mode: The FIP mode for this creation
		* @link_state: The ctlr link state on creation
		*
		* Called from sysfs.
		* Called from either the libfcoe 'create' module parameter
		* via fcoe_create or from fcoe_syfs's ctlr_create file.
		*
		* libfcoe's 'create' module parameter is deprecated so some
		* consolidation of code can be done when that interface is
		* removed.
		*
		* Returns: 0 for success
		*/
		static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
		static int _bnx2fc_create(struct net_device *netdev,
		enum fip_state fip_mode,
		enum bnx2fc_create_link_state link_state)
		{
		struct fcoe_ctlr_device *cdev;
		struct fcoe_ctlr *ctlr;
		struct bnx2fc_interface *interface;
		struct bnx2fc_hba *hba;
		@@ -2160,7 +2159,15 @@ static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
		/* Make this master N_port */
		ctlr->lp = lport;

		if (!bnx2fc_link_ok(lport)) {
		cdev = fcoe_ctlr_to_ctlr_dev(ctlr);

		if (link_state == BNX2FC_CREATE_LINK_UP)
		cdev->enabled = FCOE_CTLR_ENABLED;
		else
		cdev->enabled = FCOE_CTLR_DISABLED;

		if (link_state == BNX2FC_CREATE_LINK_UP &&
		!bnx2fc_link_ok(lport)) {
		fcoe_ctlr_link_up(ctlr);
		fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
		set_bit(ADAPTER_STATE_READY, &interface->hba->adapter_state);
		@@ -2168,7 +2175,10 @@ static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)

		BNX2FC_HBA_DBG(lport, "create: START DISC\n");
		bnx2fc_start_disc(interface);

		if (link_state == BNX2FC_CREATE_LINK_UP)
		interface->enabled = true;

		/*
		* Release from kref_init in bnx2fc_interface_setup, on success
		* lport should be holding a reference taken in bnx2fc_if_create
		@@ -2193,6 +2203,37 @@ static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
		return rc;
		}

		/**
		* bnx2fc_create() - Create a bnx2fc interface
		* @netdev : The net_device object the Ethernet interface to create on
		* @fip_mode: The FIP mode for this creation
		*
		* Called from fcoe transport
		*
		* Returns: 0 for success
		*/
		static int bnx2fc_create(struct net_device *netdev, enum fip_state fip_mode)
		{
		return _bnx2fc_create(netdev, fip_mode, BNX2FC_CREATE_LINK_UP);
		}

		/**
		* bnx2fc_ctlr_alloc() - Allocate a bnx2fc interface from fcoe_sysfs
		* @netdev: The net_device to be used by the allocated FCoE Controller
		*
		* This routine is called from fcoe_sysfs. It will start the fcoe_ctlr
		* in a link_down state. The allows the user an opportunity to configure
		* the FCoE Controller from sysfs before enabling the FCoE Controller.
		*
		* Creating in with this routine starts the FCoE Controller in Fabric
		* mode. The user can change to VN2VN or another mode before enabling.
		*/
		static int bnx2fc_ctlr_alloc(struct net_device *netdev)
		{
		return _bnx2fc_create(netdev, FIP_MODE_FABRIC,
		BNX2FC_CREATE_LINK_DOWN);
		}

		/**
		* bnx2fc_find_hba_for_cnic - maps cnic instance to bnx2fc hba instance
		*
		@@ -2318,6 +2359,7 @@ static struct fcoe_transport bnx2fc_transport = {
		.name = {"bnx2fc"},
		.attached = false,
		.list = LIST_HEAD_INIT(bnx2fc_transport.list),
		.alloc = bnx2fc_ctlr_alloc,
		.match = bnx2fc_match,
		.create = bnx2fc_create,
		.destroy = bnx2fc_destroy,
		@@ -2562,13 +2604,13 @@ module_init(bnx2fc_mod_init);
		module_exit(bnx2fc_mod_exit);

		static struct fcoe_sysfs_function_template bnx2fc_fcoe_sysfs_templ = {
		.get_fcoe_ctlr_mode = fcoe_ctlr_get_fip_mode,
		.get_fcoe_ctlr_link_fail = bnx2fc_ctlr_get_lesb,
		.get_fcoe_ctlr_vlink_fail = bnx2fc_ctlr_get_lesb,
		.get_fcoe_ctlr_miss_fka = bnx2fc_ctlr_get_lesb,
		.get_fcoe_ctlr_symb_err = bnx2fc_ctlr_get_lesb,
		.get_fcoe_ctlr_err_block = bnx2fc_ctlr_get_lesb,
		.get_fcoe_ctlr_fcs_error = bnx2fc_ctlr_get_lesb,
		.set_fcoe_ctlr_enabled = bnx2fc_ctlr_enabled,
		.get_fcoe_ctlr_link_fail = fcoe_ctlr_get_lesb,
		.get_fcoe_ctlr_vlink_fail = fcoe_ctlr_get_lesb,
		.get_fcoe_ctlr_miss_fka = fcoe_ctlr_get_lesb,
		.get_fcoe_ctlr_symb_err = fcoe_ctlr_get_lesb,
		.get_fcoe_ctlr_err_block = fcoe_ctlr_get_lesb,
		.get_fcoe_ctlr_fcs_error = fcoe_ctlr_get_lesb,

		.get_fcoe_fcf_selected = fcoe_fcf_get_selected,
		.get_fcoe_fcf_vlan_id = bnx2fc_fcf_get_vlan_id,
		@@ -2675,7 +2717,7 @@ static struct libfc_function_template bnx2fc_libfc_fcn_templ = {
		.elsct_send = bnx2fc_elsct_send,
		.fcp_abort_io = bnx2fc_abort_io,
		.fcp_cleanup = bnx2fc_cleanup,
		.get_lesb = bnx2fc_get_lesb,
		.get_lesb = fcoe_get_lesb,
		.rport_event_callback = bnx2fc_rport_event_handler,
		};

drivers/scsi/fcoe/fcoe.c

+177 −89

File changed.

Preview size limit exceeded, changes collapsed.

drivers/scsi/fcoe/fcoe.h

+3 −3

Original line number	Diff line number	Diff line
		@@ -55,11 +55,11 @@ do { \

		#define FCOE_DBG(fmt, args...) \
		FCOE_CHECK_LOGGING(FCOE_LOGGING, \
		printk(KERN_INFO "fcoe: " fmt, ##args);)
		pr_info("fcoe: " fmt, ##args);)

		#define FCOE_NETDEV_DBG(netdev, fmt, args...) \
		FCOE_CHECK_LOGGING(FCOE_NETDEV_LOGGING, \
		printk(KERN_INFO "fcoe: %s: " fmt, \
		pr_info("fcoe: %s: " fmt, \
		netdev->name, ##args);)

		/**

drivers/scsi/fcoe/fcoe_ctlr.c

+26 −19

Original line number	Diff line number	Diff line
		@@ -1291,8 +1291,16 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,

		LIBFCOE_FIP_DBG(fip, "Clear Virtual Link received\n");

		if (!fcf \|\| !lport->port_id)
		if (!fcf \|\| !lport->port_id) {
		/*
		* We are yet to select best FCF, but we got CVL in the
		* meantime. reset the ctlr and let it rediscover the FCF
		*/
		mutex_lock(&fip->ctlr_mutex);
		fcoe_ctlr_reset(fip);
		mutex_unlock(&fip->ctlr_mutex);
		return;
		}

		/*
		* mask of required descriptors. Validating each one clears its bit.
		@@ -1551,15 +1559,6 @@ static struct fcoe_fcf fcoe_ctlr_select(struct fcoe_ctlr fip)
		fcf->fabric_name, fcf->vfid, fcf->fcf_mac,
		fcf->fc_map, fcoe_ctlr_mtu_valid(fcf),
		fcf->flogi_sent, fcf->pri);
		if (fcf->fabric_name != first->fabric_name \|\|
		fcf->vfid != first->vfid \|\|
		fcf->fc_map != first->fc_map) {
		LIBFCOE_FIP_DBG(fip, "Conflicting fabric, VFID, "
		"or FC-MAP\n");
		return NULL;
		}
		if (fcf->flogi_sent)
		continue;
		if (!fcoe_ctlr_fcf_usable(fcf)) {
		LIBFCOE_FIP_DBG(fip, "FCF for fab %16.16llx "
		"map %x %svalid %savailable\n",
		@@ -1569,6 +1568,15 @@ static struct fcoe_fcf fcoe_ctlr_select(struct fcoe_ctlr fip)
		"" : "un");
		continue;
		}
		if (fcf->fabric_name != first->fabric_name \|\|
		fcf->vfid != first->vfid \|\|
		fcf->fc_map != first->fc_map) {
		LIBFCOE_FIP_DBG(fip, "Conflicting fabric, VFID, "
		"or FC-MAP\n");
		return NULL;
		}
		if (fcf->flogi_sent)
		continue;
		if (!best \|\| fcf->pri < best->pri \|\| best->flogi_sent)
		best = fcf;
		}
		@@ -2864,22 +2872,21 @@ void fcoe_fcf_get_selected(struct fcoe_fcf_device *fcf_dev)
		}
		EXPORT_SYMBOL(fcoe_fcf_get_selected);

		void fcoe_ctlr_get_fip_mode(struct fcoe_ctlr_device *ctlr_dev)
		void fcoe_ctlr_set_fip_mode(struct fcoe_ctlr_device *ctlr_dev)
		{
		struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(ctlr_dev);

		mutex_lock(&ctlr->ctlr_mutex);
		switch (ctlr->mode) {
		case FIP_MODE_FABRIC:
		ctlr_dev->mode = FIP_CONN_TYPE_FABRIC;
		break;
		case FIP_MODE_VN2VN:
		ctlr_dev->mode = FIP_CONN_TYPE_VN2VN;
		switch (ctlr_dev->mode) {
		case FIP_CONN_TYPE_VN2VN:
		ctlr->mode = FIP_MODE_VN2VN;
		break;
		case FIP_CONN_TYPE_FABRIC:
		default:
		ctlr_dev->mode = FIP_CONN_TYPE_UNKNOWN;
		ctlr->mode = FIP_MODE_FABRIC;
		break;
		}

		mutex_unlock(&ctlr->ctlr_mutex);
		}
		EXPORT_SYMBOL(fcoe_ctlr_get_fip_mode);
		EXPORT_SYMBOL(fcoe_ctlr_set_fip_mode);