Merge tag 'scsi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

Pull first round of SCSI updates from James Bottomley:
 "This patch set is driver updates for qla4xxx, scsi_debug, pm80xx,
  fcoe/libfc, eas2r, lpfc, be2iscsi and megaraid_sas plus some assorted
  bug fixes and cleanups"

* tag 'scsi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (106 commits)
  [SCSI] scsi_error: Escalate to LUN reset if abort fails
  [SCSI] Add 'eh_deadline' to limit SCSI EH runtime
  [SCSI] remove check for 'resetting'
  [SCSI] dc395: Move 'last_reset' into internal host structure
  [SCSI] tmscsim: Move 'last_reset' into host structure
  [SCSI] advansys: Remove 'last_reset' references
  [SCSI] dpt_i2o: return SCSI_MLQUEUE_HOST_BUSY when in reset
  [SCSI] dpt_i2o: Remove DPTI_STATE_IOCTL
  [SCSI] megaraid_sas: Fix synchronization problem between sysPD IO path and AEN path
  [SCSI] lpfc: Fix typo on NULL assignment
  [SCSI] scsi_dh_alua: ALUA handler attach should succeed while TPG is transitioning
  [SCSI] scsi_dh_alua: ALUA check sense should retry device internal reset unit attention
  [SCSI] esas2r: Cleanup snprinf formatting of firmware version
  [SCSI] esas2r: Remove superfluous mask of pcie_cap_reg
  [SCSI] esas2r: Fixes for big-endian platforms
  [SCSI] esas2r: Directly call kernel functions for atomic bit operations
  [SCSI] lpfc 8.3.43: Update lpfc version to driver version 8.3.43
  [SCSI] lpfc 8.3.43: Fixed not processing task management IOCB response status
  [SCSI] lpfc 8.3.43: Fixed spinlock hang.
  [SCSI] lpfc 8.3.43: Fixed invalid Total_Data_Placed value received for els and ct command responses
  ...

3 files changed, 118 insertions, 69 deletions

diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index 07453bbf05e7..f3170008ae71 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -408,6 +408,7 @@ static struct fcoe_interface *fcoe_interface_create(struct net_device *netdev,
         }
 
         ctlr = fcoe_ctlr_device_priv(ctlr_dev);
+        ctlr->cdev = ctlr_dev;
         fcoe = fcoe_ctlr_priv(ctlr);
 
         dev_hold(netdev);
@@ -1440,22 +1441,28 @@ static int fcoe_rcv(struct sk_buff *skb, struct net_device *netdev,
         ctlr = fcoe_to_ctlr(fcoe);
         lport = ctlr->lp;
         if (unlikely(!lport)) {
-                FCOE_NETDEV_DBG(netdev, "Cannot find hba structure");
+                FCOE_NETDEV_DBG(netdev, "Cannot find hba structure\n");
                 goto err2;
         }
         if (!lport->link_up)
                 goto err2;
 
-        FCOE_NETDEV_DBG(netdev, "skb_info: len:%d data_len:%d head:%p "
-                        "data:%p tail:%p end:%p sum:%d dev:%s",
+        FCOE_NETDEV_DBG(netdev,
+                        "skb_info: len:%d data_len:%d head:%p data:%p tail:%p end:%p sum:%d dev:%s\n",
                         skb->len, skb->data_len, skb->head, skb->data,
                         skb_tail_pointer(skb), skb_end_pointer(skb),
                         skb->csum, skb->dev ? skb->dev->name : "<NULL>");
 
+
+        skb = skb_share_check(skb, GFP_ATOMIC);
+
+        if (skb == NULL)
+                return NET_RX_DROP;
+
         eh = eth_hdr(skb);
 
         if (is_fip_mode(ctlr) &&
-            compare_ether_addr(eh->h_source, ctlr->dest_addr)) {
+            !ether_addr_equal(eh->h_source, ctlr->dest_addr)) {
                 FCOE_NETDEV_DBG(netdev, "wrong source mac address:%pM\n",
                                 eh->h_source);
                 goto err;
@@ -1540,13 +1547,13 @@ static int fcoe_rcv(struct sk_buff *skb, struct net_device *netdev,
                 wake_up_process(fps->thread);
         spin_unlock(&fps->fcoe_rx_list.lock);
 
-        return 0;
+        return NET_RX_SUCCESS;
 err:
         per_cpu_ptr(lport->stats, get_cpu())->ErrorFrames++;
         put_cpu();
 err2:
         kfree_skb(skb);
-        return -1;
+        return NET_RX_DROP;
 }
 
 /**
@@ -1788,13 +1795,13 @@ static void fcoe_recv_frame(struct sk_buff *skb)
         lport = fr->fr_dev;
         if (unlikely(!lport)) {
                 if (skb->destructor != fcoe_percpu_flush_done)
-                        FCOE_NETDEV_DBG(skb->dev, "NULL lport in skb");
+                        FCOE_NETDEV_DBG(skb->dev, "NULL lport in skb\n");
                 kfree_skb(skb);
                 return;
         }
 
-        FCOE_NETDEV_DBG(skb->dev, "skb_info: len:%d data_len:%d "
-                        "head:%p data:%p tail:%p end:%p sum:%d dev:%s",
+        FCOE_NETDEV_DBG(skb->dev,
+                        "skb_info: len:%d data_len:%d head:%p data:%p tail:%p end:%p sum:%d dev:%s\n",
                         skb->len, skb->data_len,
                         skb->head, skb->data, skb_tail_pointer(skb),
                         skb_end_pointer(skb), skb->csum,
diff --git a/drivers/scsi/fcoe/fcoe_ctlr.c b/drivers/scsi/fcoe/fcoe_ctlr.c
index 203415e02518..34a1b1f333b4 100644
--- a/drivers/scsi/fcoe/fcoe_ctlr.c
+++ b/drivers/scsi/fcoe/fcoe_ctlr.c
@@ -160,74 +160,113 @@ void fcoe_ctlr_init(struct fcoe_ctlr *fip, enum fip_state mode)
 }
 EXPORT_SYMBOL(fcoe_ctlr_init);
 
+/**
+ * fcoe_sysfs_fcf_add() - Add a fcoe_fcf{,_device} to a fcoe_ctlr{,_device}
+ * @new: The newly discovered FCF
+ *
+ * Called with fip->ctlr_mutex held
+ */
 static int fcoe_sysfs_fcf_add(struct fcoe_fcf *new)
 {
         struct fcoe_ctlr *fip = new->fip;
-        struct fcoe_ctlr_device *ctlr_dev = fcoe_ctlr_to_ctlr_dev(fip);
-        struct fcoe_fcf_device temp, *fcf_dev;
-        int rc = 0;
+        struct fcoe_ctlr_device *ctlr_dev;
+        struct fcoe_fcf_device *temp, *fcf_dev;
+        int rc = -ENOMEM;
 
         LIBFCOE_FIP_DBG(fip, "New FCF fab %16.16llx mac %pM\n",
                         new->fabric_name, new->fcf_mac);
 
-        mutex_lock(&ctlr_dev->lock);
-
-        temp.fabric_name = new->fabric_name;
-        temp.switch_name = new->switch_name;
-        temp.fc_map = new->fc_map;
-        temp.vfid = new->vfid;
-        memcpy(temp.mac, new->fcf_mac, ETH_ALEN);
-        temp.priority = new->pri;
-        temp.fka_period = new->fka_period;
-        temp.selected = 0; /* default to unselected */
-
-        fcf_dev = fcoe_fcf_device_add(ctlr_dev, &temp);
-        if (unlikely(!fcf_dev)) {
-                rc = -ENOMEM;
+        temp = kzalloc(sizeof(*temp), GFP_KERNEL);
+        if (!temp)
                 goto out;
-        }
+
+        temp->fabric_name = new->fabric_name;
+        temp->switch_name = new->switch_name;
+        temp->fc_map = new->fc_map;
+        temp->vfid = new->vfid;
+        memcpy(temp->mac, new->fcf_mac, ETH_ALEN);
+        temp->priority = new->pri;
+        temp->fka_period = new->fka_period;
+        temp->selected = 0; /* default to unselected */
 
         /*
-         * The fcoe_sysfs layer can return a CONNECTED fcf that
-         * has a priv (fcf was never deleted) or a CONNECTED fcf
-         * that doesn't have a priv (fcf was deleted). However,
-         * libfcoe will always delete FCFs before trying to add
-         * them. This is ensured because both recv_adv and
-         * age_fcfs are protected by the the fcoe_ctlr's mutex.
-         * This means that we should never get a FCF with a
-         * non-NULL priv pointer.
+         * If ctlr_dev doesn't exist then it means we're a libfcoe user
+         * who doesn't use fcoe_syfs and didn't allocate a fcoe_ctlr_device.
+         * fnic would be an example of a driver with this behavior. In this
+         * case we want to add the fcoe_fcf to the fcoe_ctlr list, but we
+         * don't want to make sysfs changes.
          */
-        BUG_ON(fcf_dev->priv);
 
-        fcf_dev->priv = new;
-        new->fcf_dev = fcf_dev;
+        ctlr_dev = fcoe_ctlr_to_ctlr_dev(fip);
+        if (ctlr_dev) {
+                mutex_lock(&ctlr_dev->lock);
+                fcf_dev = fcoe_fcf_device_add(ctlr_dev, temp);
+                if (unlikely(!fcf_dev)) {
+                        rc = -ENOMEM;
+                        mutex_unlock(&ctlr_dev->lock);
+                        goto out;
+                }
+
+                /*
+                 * The fcoe_sysfs layer can return a CONNECTED fcf that
+                 * has a priv (fcf was never deleted) or a CONNECTED fcf
+                 * that doesn't have a priv (fcf was deleted). However,
+                 * libfcoe will always delete FCFs before trying to add
+                 * them. This is ensured because both recv_adv and
+                 * age_fcfs are protected by the the fcoe_ctlr's mutex.
+                 * This means that we should never get a FCF with a
+                 * non-NULL priv pointer.
+                 */
+                BUG_ON(fcf_dev->priv);
+
+                fcf_dev->priv = new;
+                new->fcf_dev = fcf_dev;
+                mutex_unlock(&ctlr_dev->lock);
+        }
 
         list_add(&new->list, &fip->fcfs);
         fip->fcf_count++;
+        rc = 0;
 
 out:
-        mutex_unlock(&ctlr_dev->lock);
+        kfree(temp);
         return rc;
 }
 
+/**
+ * fcoe_sysfs_fcf_del() - Remove a fcoe_fcf{,_device} to a fcoe_ctlr{,_device}
+ * @new: The FCF to be removed
+ *
+ * Called with fip->ctlr_mutex held
+ */
 static void fcoe_sysfs_fcf_del(struct fcoe_fcf *new)
 {
         struct fcoe_ctlr *fip = new->fip;
-        struct fcoe_ctlr_device *ctlr_dev = fcoe_ctlr_to_ctlr_dev(fip);
+        struct fcoe_ctlr_device *cdev;
         struct fcoe_fcf_device *fcf_dev;
 
         list_del(&new->list);
         fip->fcf_count--;
 
-        mutex_lock(&ctlr_dev->lock);
-
-        fcf_dev = fcoe_fcf_to_fcf_dev(new);
-        WARN_ON(!fcf_dev);
-        new->fcf_dev = NULL;
-        fcoe_fcf_device_delete(fcf_dev);
-        kfree(new);
-
-        mutex_unlock(&ctlr_dev->lock);
+        /*
+         * If ctlr_dev doesn't exist then it means we're a libfcoe user
+         * who doesn't use fcoe_syfs and didn't allocate a fcoe_ctlr_device
+         * or a fcoe_fcf_device.
+         *
+         * fnic would be an example of a driver with this behavior. In this
+         * case we want to remove the fcoe_fcf from the fcoe_ctlr list (above),
+         * but we don't want to make sysfs changes.
+         */
+        cdev = fcoe_ctlr_to_ctlr_dev(fip);
+        if (cdev) {
+                mutex_lock(&cdev->lock);
+                fcf_dev = fcoe_fcf_to_fcf_dev(new);
+                WARN_ON(!fcf_dev);
+                new->fcf_dev = NULL;
+                fcoe_fcf_device_delete(fcf_dev);
+                kfree(new);
+                mutex_unlock(&cdev->lock);
+        }
 }
 
 /**
@@ -300,7 +339,7 @@ static void fcoe_ctlr_announce(struct fcoe_ctlr *fip)
         spin_unlock_bh(&fip->ctlr_lock);
         sel = fip->sel_fcf;
 
-        if (sel && !compare_ether_addr(sel->fcf_mac, fip->dest_addr))
+        if (sel && ether_addr_equal(sel->fcf_mac, fip->dest_addr))
                 goto unlock;
         if (!is_zero_ether_addr(fip->dest_addr)) {
                 printk(KERN_NOTICE "libfcoe: host%d: "
@@ -1000,7 +1039,7 @@ static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
                 if (fcf->switch_name == new.switch_name &&
                     fcf->fabric_name == new.fabric_name &&
                     fcf->fc_map == new.fc_map &&
-                    compare_ether_addr(fcf->fcf_mac, new.fcf_mac) == 0) {
+                    ether_addr_equal(fcf->fcf_mac, new.fcf_mac)) {
                         found = 1;
                         break;
                 }
@@ -1340,7 +1379,7 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
                         mp = (struct fip_mac_desc *)desc;
                         if (dlen < sizeof(*mp))
                                 goto err;
-                        if (compare_ether_addr(mp->fd_mac, fcf->fcf_mac))
+                        if (!ether_addr_equal(mp->fd_mac, fcf->fcf_mac))
                                 goto err;
                         desc_mask &= ~BIT(FIP_DT_MAC);
                         break;
@@ -1418,8 +1457,8 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
                          * 'port_id' is already validated, check MAC address and
                          * wwpn
                          */
-                        if (compare_ether_addr(fip->get_src_addr(vn_port),
-                                                vp->fd_mac) != 0 ||
+                        if (!ether_addr_equal(fip->get_src_addr(vn_port),
+                                              vp->fd_mac) ||
                                 get_unaligned_be64(&vp->fd_wwpn) !=
                                                         vn_port->wwpn)
                                 continue;
@@ -1453,6 +1492,9 @@ err:
  */
 void fcoe_ctlr_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)
 {
+        skb = skb_share_check(skb, GFP_ATOMIC);
+        if (!skb)
+                return;
         skb_queue_tail(&fip->fip_recv_list, skb);
         schedule_work(&fip->recv_work);
 }
@@ -1479,12 +1521,12 @@ static int fcoe_ctlr_recv_handler(struct fcoe_ctlr *fip, struct sk_buff *skb)
                 goto drop;
         eh = eth_hdr(skb);
         if (fip->mode == FIP_MODE_VN2VN) {
-                if (compare_ether_addr(eh->h_dest, fip->ctl_src_addr) &&
-                    compare_ether_addr(eh->h_dest, fcoe_all_vn2vn) &&
-                    compare_ether_addr(eh->h_dest, fcoe_all_p2p))
+                if (!ether_addr_equal(eh->h_dest, fip->ctl_src_addr) &&
+                    !ether_addr_equal(eh->h_dest, fcoe_all_vn2vn) &&
+                    !ether_addr_equal(eh->h_dest, fcoe_all_p2p))
                         goto drop;
-        } else if (compare_ether_addr(eh->h_dest, fip->ctl_src_addr) &&
-                   compare_ether_addr(eh->h_dest, fcoe_all_enode))
+        } else if (!ether_addr_equal(eh->h_dest, fip->ctl_src_addr) &&
+                   !ether_addr_equal(eh->h_dest, fcoe_all_enode))
                 goto drop;
         fiph = (struct fip_header *)skb->data;
         op = ntohs(fiph->fip_op);
@@ -1856,7 +1898,7 @@ int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_lport *lport,
                  * address_mode flag to use FC_OUI-based Ethernet DA.
                  * Otherwise we use the FCoE gateway addr
                  */
-                if (!compare_ether_addr(sa, (u8[6])FC_FCOE_FLOGI_MAC)) {
+                if (ether_addr_equal(sa, (u8[6])FC_FCOE_FLOGI_MAC)) {
                         fcoe_ctlr_map_dest(fip);
                 } else {
                         memcpy(fip->dest_addr, sa, ETH_ALEN);
@@ -2825,8 +2867,8 @@ unlock:
  * disabled, so that should ensure that this routine is only called
  * when nothing is happening.
  */
-void fcoe_ctlr_mode_set(struct fc_lport *lport, struct fcoe_ctlr *fip,
-                        enum fip_state fip_mode)
+static void fcoe_ctlr_mode_set(struct fc_lport *lport, struct fcoe_ctlr *fip,
+                               enum fip_state fip_mode)
 {
         void *priv;
 
diff --git a/drivers/scsi/fcoe/fcoe_sysfs.c b/drivers/scsi/fcoe/fcoe_sysfs.c
index 1f4f22fe8281..045c4e11ee54 100644
--- a/drivers/scsi/fcoe/fcoe_sysfs.c
+++ b/drivers/scsi/fcoe/fcoe_sysfs.c
@@ -300,29 +300,29 @@ static ssize_t store_ctlr_mode(struct device *dev,
 
         switch (ctlr->enabled) {
         case FCOE_CTLR_ENABLED:
-                LIBFCOE_SYSFS_DBG(ctlr, "Cannot change mode when enabled.");
+                LIBFCOE_SYSFS_DBG(ctlr, "Cannot change mode when enabled.\n");
                 return -EBUSY;
         case FCOE_CTLR_DISABLED:
                 if (!ctlr->f->set_fcoe_ctlr_mode) {
                         LIBFCOE_SYSFS_DBG(ctlr,
-                                          "Mode change not supported by LLD.");
+                                          "Mode change not supported by LLD.\n");
                         return -ENOTSUPP;
                 }
 
                 ctlr->mode = fcoe_parse_mode(mode);
                 if (ctlr->mode == FIP_CONN_TYPE_UNKNOWN) {
-                        LIBFCOE_SYSFS_DBG(ctlr,
-                                          "Unknown mode %s provided.", buf);
+                        LIBFCOE_SYSFS_DBG(ctlr, "Unknown mode %s provided.\n",
+                                          buf);
                         return -EINVAL;
                 }
 
                 ctlr->f->set_fcoe_ctlr_mode(ctlr);
-                LIBFCOE_SYSFS_DBG(ctlr, "Mode changed to %s.", buf);
+                LIBFCOE_SYSFS_DBG(ctlr, "Mode changed to %s.\n", buf);
 
                 return count;
         case FCOE_CTLR_UNUSED:
         default:
-                LIBFCOE_SYSFS_DBG(ctlr, "Mode change not supported.");
+                LIBFCOE_SYSFS_DBG(ctlr, "Mode change not supported.\n");
                 return -ENOTSUPP;
         };
 }
@@ -657,7 +657,7 @@ static int fcoe_fcf_device_match(struct fcoe_fcf_device *new,
         if (new->switch_name == old->switch_name &&
             new->fabric_name == old->fabric_name &&
             new->fc_map == old->fc_map &&
-            compare_ether_addr(new->mac, old->mac) == 0)
+            ether_addr_equal(new->mac, old->mac))
                 return 1;
         return 0;
 }