BNX2X: mutexes -> qlocks
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 4 Feb 2015 16:45:57 +0000 (11:45 -0500)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 2 Mar 2015 16:59:07 +0000 (11:59 -0500)
kern/drivers/net/bnx2x/bnx2x.h
kern/drivers/net/bnx2x/bnx2x_cmn.c
kern/drivers/net/bnx2x/bnx2x_main.c
kern/drivers/net/bnx2x/bnx2x_sp.c
kern/drivers/net/bnx2x/bnx2x_sp.h
kern/drivers/net/bnx2x/bnx2x_sriov.c
kern/drivers/net/bnx2x/bnx2x_sriov.h
kern/drivers/net/bnx2x/bnx2x_vfpf.c
scripts/spatch/linux/sync.cocci [new file with mode: 0644]

index 14d6b32..dea6dbe 100644 (file)
@@ -1139,7 +1139,7 @@ struct bnx2x_port {
        uint32_t                        phy_addr;
 
        /* used to synchronize phy accesses */
-       struct mutex            phy_mutex;
+       qlock_t         phy_mutex;
 
        uint32_t                        port_stx;
 
index 5020e60..072de1b 100644 (file)
@@ -1139,7 +1139,7 @@ static irqreturn_t bnx2x_msix_fp_int(int irq, void *fp_cookie)
 /* HW Lock for shared dual port PHYs */
 void bnx2x_acquire_phy_lock(struct bnx2x *bp)
 {
-       mutex_lock(&bp->port.phy_mutex);
+       qlock(&bp->port.phy_mutex);
 
        bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_MDIO);
 }
@@ -1148,7 +1148,7 @@ void bnx2x_release_phy_lock(struct bnx2x *bp)
 {
        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_MDIO);
 
-       mutex_unlock(&bp->port.phy_mutex);
+       qunlock(&bp->port.phy_mutex);
 }
 
 /* calculates MF speed according to current linespeed and MF configuration */
index 11da66b..d29d563 100644 (file)
@@ -2971,7 +2971,7 @@ uint32_t bnx2x_fw_command(struct bnx2x *bp, uint32_t command, uint32_t param)
        uint32_t cnt = 1;
        uint8_t delay = CHIP_REV_IS_SLOW(bp) ? 100 : 10;
 
-       mutex_lock(&bp->fw_mb_mutex);
+       qlock(&bp->fw_mb_mutex);
        seq = ++bp->fw_seq;
        SHMEM_WR(bp, func_mb[mb_idx].drv_mb_param, param);
        SHMEM_WR(bp, func_mb[mb_idx].drv_mb_header, (command | seq));
@@ -3000,7 +3000,7 @@ uint32_t bnx2x_fw_command(struct bnx2x *bp, uint32_t command, uint32_t param)
                bnx2x_fw_dump(bp);
                rc = 0;
        }
-       mutex_unlock(&bp->fw_mb_mutex);
+       qunlock(&bp->fw_mb_mutex);
 
        return rc;
 }
@@ -3540,7 +3540,7 @@ static void bnx2x_handle_drv_info_req(struct bnx2x *bp)
                  DRV_INFO_CONTROL_OP_CODE_SHIFT;
 
        /* Must prevent other flows from accessing drv_info_to_mcp */
-       mutex_lock(&bp->drv_info_mutex);
+       qlock(&bp->drv_info_mutex);
 
        memset(&bp->slowpath->drv_info_to_mcp, 0,
               sizeof(union drv_info_to_mcp));
@@ -3600,7 +3600,7 @@ static void bnx2x_handle_drv_info_req(struct bnx2x *bp)
        }
 
 out:
-       mutex_unlock(&bp->drv_info_mutex);
+       qunlock(&bp->drv_info_mutex);
 }
 
 static uint32_t bnx2x_update_mng_version_utility(uint8_t *version,
@@ -3636,7 +3636,7 @@ void bnx2x_update_mng_version(struct bnx2x *bp)
        if (!SHMEM2_HAS(bp, func_os_drv_ver))
                return;
 
-       mutex_lock(&bp->drv_info_mutex);
+       qlock(&bp->drv_info_mutex);
        /* Must not proceed when `bnx2x_handle_drv_info_req' is feasible */
        if (bp->drv_info_mng_owner)
                goto out;
@@ -3667,7 +3667,7 @@ out:
        SHMEM2_WR(bp, func_os_drv_ver[idx].versions[DRV_PERS_ISCSI], iscsiver);
        SHMEM2_WR(bp, func_os_drv_ver[idx].versions[DRV_PERS_FCOE], fcoever);
 
-       mutex_unlock(&bp->drv_info_mutex);
+       qunlock(&bp->drv_info_mutex);
 
        DP(BNX2X_MSG_MCP, "Setting driver version: ETH [%08x] iSCSI [%08x] FCoE [%08x]\n",
           ethver, iscsiver, fcoever);
@@ -14059,12 +14059,12 @@ static int bnx2x_cnic_ctl_send(struct bnx2x *bp, struct cnic_ctl_info *ctl)
        struct cnic_ops *c_ops;
        int rc = 0;
 
-       mutex_lock(&bp->cnic_mutex);
+       qlock(&bp->cnic_mutex);
        c_ops = rcu_dereference_protected(bp->cnic_ops,
                                          lockdep_is_held(&bp->cnic_mutex));
        if (c_ops)
                rc = c_ops->cnic_ctl(bp->cnic_data, ctl);
-       mutex_unlock(&bp->cnic_mutex);
+       qunlock(&bp->cnic_mutex);
 
        return rc;
 }
@@ -14412,10 +14412,10 @@ static int bnx2x_unregister_cnic(struct net_device *dev)
        struct bnx2x *bp = netdev_priv(dev);
        struct cnic_eth_dev *cp = &bp->cnic_eth_dev;
 
-       mutex_lock(&bp->cnic_mutex);
+       qlock(&bp->cnic_mutex);
        cp->drv_state = 0;
        RCU_INIT_POINTER(bp->cnic_ops, NULL);
-       mutex_unlock(&bp->cnic_mutex);
+       qunlock(&bp->cnic_mutex);
        synchronize_rcu();
        bp->cnic_enabled = false;
        kfree(bp->cnic_kwq);
index 9c18b6d..24b61bb 100644 (file)
@@ -6013,25 +6013,25 @@ int bnx2x_func_state_change(struct bnx2x *bp,
        enum bnx2x_func_cmd cmd = params->cmd;
        unsigned long *pending = &o->pending;
 
-       mutex_lock(&o->one_pending_mutex);
+       qlock(&o->one_pending_mutex);
 
        /* Check that the requested transition is legal */
        rc = o->check_transition(bp, o, params);
        if ((rc == -EBUSY) &&
            (test_bit(RAMROD_RETRY, &params->ramrod_flags))) {
                while ((rc == -EBUSY) && (--cnt > 0)) {
-                       mutex_unlock(&o->one_pending_mutex);
+                       qunlock(&o->one_pending_mutex);
                        msleep(10);
-                       mutex_lock(&o->one_pending_mutex);
+                       qlock(&o->one_pending_mutex);
                        rc = o->check_transition(bp, o, params);
                }
                if (rc == -EBUSY) {
-                       mutex_unlock(&o->one_pending_mutex);
+                       qunlock(&o->one_pending_mutex);
                        BNX2X_ERR("timeout waiting for previous ramrod completion\n");
                        return rc;
                }
        } else if (rc) {
-               mutex_unlock(&o->one_pending_mutex);
+               qunlock(&o->one_pending_mutex);
                return rc;
        }
 
@@ -6041,12 +6041,12 @@ int bnx2x_func_state_change(struct bnx2x *bp,
        /* Don't send a command if only driver cleanup was requested */
        if (test_bit(RAMROD_DRV_CLR_ONLY, &params->ramrod_flags)) {
                bnx2x_func_state_change_comp(bp, o, cmd);
-               mutex_unlock(&o->one_pending_mutex);
+               qunlock(&o->one_pending_mutex);
        } else {
                /* Send a ramrod */
                rc = o->send_cmd(bp, params);
 
-               mutex_unlock(&o->one_pending_mutex);
+               qunlock(&o->one_pending_mutex);
 
                if (rc) {
                        o->next_state = BNX2X_F_STATE_MAX;
index 788f62f..5ea537d 100644 (file)
@@ -1322,7 +1322,7 @@ struct bnx2x_func_sp_obj {
        /* this mutex validates that when pending flag is taken, the next
         * ramrod to be sent will be the one set the pending bit
         */
-       struct mutex            one_pending_mutex;
+       qlock_t         one_pending_mutex;
 
        /* Driver interface */
        struct bnx2x_func_sp_drv_ops    *drv;
index 2243473..51a4e21 100644 (file)
@@ -1506,7 +1506,7 @@ int bnx2x_iov_link_update_vf(struct bnx2x *bp, int idx)
        if (rc)
                return rc;
 
-       mutex_lock(&bp->vfdb->bulletin_mutex);
+       qlock(&bp->vfdb->bulletin_mutex);
 
        if (vf->link_cfg == IFLA_VF_LINK_STATE_AUTO) {
                bulletin->valid_bitmap |= 1 << LINK_VALID;
@@ -1552,7 +1552,7 @@ int bnx2x_iov_link_update_vf(struct bnx2x *bp, int idx)
        }
 
 out:
-       mutex_unlock(&bp->vfdb->bulletin_mutex);
+       qunlock(&bp->vfdb->bulletin_mutex);
        return rc;
 }
 
@@ -2362,7 +2362,7 @@ void bnx2x_lock_vf_pf_channel(struct bnx2x *bp, struct bnx2x_virtf *vf,
        }
 
        /* lock the channel */
-       mutex_lock(&vf->op_mutex);
+       qlock(&vf->op_mutex);
 
        /* record the locking op */
        vf->op_current = tlv;
@@ -2396,7 +2396,7 @@ void bnx2x_unlock_vf_pf_channel(struct bnx2x *bp, struct bnx2x_virtf *vf,
        vf->op_current = CHANNEL_TLV_NONE;
 
        /* lock the channel */
-       mutex_unlock(&vf->op_mutex);
+       qunlock(&vf->op_mutex);
 
        /* log the unlock */
        DP(BNX2X_MSG_IOV, "VF[%d]: vf pf channel unlocked by %d\n",
@@ -2690,7 +2690,7 @@ int bnx2x_get_vf_config(struct net_device *dev, int vfidx,
                                                 VLAN_HLEN);
                }
        } else {
-               mutex_lock(&bp->vfdb->bulletin_mutex);
+               qlock(&bp->vfdb->bulletin_mutex);
                /* mac */
                if (bulletin->valid_bitmap & (1 << MAC_ADDR_VALID))
                        /* mac configured by ndo so its in bulletin board */
@@ -2707,7 +2707,7 @@ int bnx2x_get_vf_config(struct net_device *dev, int vfidx,
                        /* function has not been loaded yet. Show vlans as 0s */
                        memset(&ivi->vlan, 0, VLAN_HLEN);
 
-               mutex_unlock(&bp->vfdb->bulletin_mutex);
+               qunlock(&bp->vfdb->bulletin_mutex);
        }
 
        return 0;
@@ -2747,7 +2747,7 @@ int bnx2x_set_vf_mac(struct net_device *dev, int vfidx, uint8_t *mac)
        if (rc)
                return rc;
 
-       mutex_lock(&bp->vfdb->bulletin_mutex);
+       qlock(&bp->vfdb->bulletin_mutex);
 
        /* update PF's copy of the VF's bulletin. Will no longer accept mac
         * configuration requests from vf unless match this mac
@@ -2759,7 +2759,7 @@ int bnx2x_set_vf_mac(struct net_device *dev, int vfidx, uint8_t *mac)
        rc = bnx2x_post_vf_bulletin(bp, vfidx);
 
        /* release lock before checking return code */
-       mutex_unlock(&bp->vfdb->bulletin_mutex);
+       qunlock(&bp->vfdb->bulletin_mutex);
 
        if (rc) {
                BNX2X_ERR("failed to update VF[%d] bulletin\n", vfidx);
@@ -2846,7 +2846,7 @@ int bnx2x_set_vf_vlan(struct net_device *dev, int vfidx, uint16_t vlan,
         * configure the vlan later when it does. Treat vlan id 0 as remove the
         * Host tag.
         */
-       mutex_lock(&bp->vfdb->bulletin_mutex);
+       qlock(&bp->vfdb->bulletin_mutex);
 
        if (vlan > 0)
                bulletin->valid_bitmap |= 1 << VLAN_VALID;
@@ -2854,7 +2854,7 @@ int bnx2x_set_vf_vlan(struct net_device *dev, int vfidx, uint16_t vlan,
                bulletin->valid_bitmap &= ~(1 << VLAN_VALID);
        bulletin->vlan = vlan;
 
-       mutex_unlock(&bp->vfdb->bulletin_mutex);
+       qunlock(&bp->vfdb->bulletin_mutex);
 
        /* is vf initialized and queue set up? */
        if (vf->state != VF_ENABLED ||
index b372410..e4cbee2 100644 (file)
@@ -203,7 +203,7 @@ struct bnx2x_virtf {
        struct bnx2x_rss_config_obj     rss_conf_obj;
 
        /* slow-path operations */
-       struct mutex                    op_mutex; /* one vfop at a time mutex */
+       qlock_t                 op_mutex; /* one vfop at a time mutex */
        enum channel_tlvs               op_current;
 
        uint8_t fp_hsi;
@@ -341,11 +341,11 @@ struct bnx2x_vfdb {
        uint16_t first_vf_igu_entry;
 
        /* sp_rtnl synchronization */
-       struct mutex                    event_mutex;
+       qlock_t                 event_mutex;
        uint64_t                                event_occur;
 
        /* bulletin board update synchronization */
-       struct mutex                    bulletin_mutex;
+       qlock_t                 bulletin_mutex;
 };
 
 /* queue access */
index 879a850..c5fd309 100644 (file)
@@ -39,7 +39,7 @@ static void bnx2x_add_tlv(struct bnx2x *bp, void *tlvs_list,
 static void bnx2x_vfpf_prep(struct bnx2x *bp, struct vfpf_first_tlv *first_tlv,
                            uint16_t type, uint16_t length)
 {
-       mutex_lock(&bp->vf2pf_mutex);
+       qlock(&bp->vf2pf_mutex);
 
        DP(BNX2X_MSG_IOV, "preparing to send %d tlv over vf pf channel\n",
           type);
@@ -61,7 +61,7 @@ static void bnx2x_vfpf_finalize(struct bnx2x *bp,
        DP(BNX2X_MSG_IOV, "done sending [%d] tlv over vf pf channel\n",
           first_tlv->tl.type);
 
-       mutex_unlock(&bp->vf2pf_mutex);
+       qunlock(&bp->vf2pf_mutex);
 }
 
 /* Finds a TLV by type in a TLV buffer; If found, returns pointer to the TLV */
@@ -2070,11 +2070,11 @@ void bnx2x_vf_mbx_schedule(struct bnx2x *bp,
        vf_idx = bnx2x_vf_idx_by_abs_fid(bp, vfpf_event->vf_id);
 
        /* Update VFDB with current message and schedule its handling */
-       mutex_lock(&BP_VFDB(bp)->event_mutex);
+       qlock(&BP_VFDB(bp)->event_mutex);
        BP_VF_MBX(bp, vf_idx)->vf_addr_hi = vfpf_event->msg_addr_hi;
        BP_VF_MBX(bp, vf_idx)->vf_addr_lo = vfpf_event->msg_addr_lo;
        BP_VFDB(bp)->event_occur |= (1ULL << vf_idx);
-       mutex_unlock(&BP_VFDB(bp)->event_mutex);
+       qunlock(&BP_VFDB(bp)->event_mutex);
 
        bnx2x_schedule_iov_task(bp, BNX2X_IOV_HANDLE_VF_MSG);
 }
@@ -2090,10 +2090,10 @@ void bnx2x_vf_mbx(struct bnx2x *bp)
        if (!vfdb)
                return;
 
-       mutex_lock(&vfdb->event_mutex);
+       qlock(&vfdb->event_mutex);
        events = vfdb->event_occur;
        vfdb->event_occur = 0;
-       mutex_unlock(&vfdb->event_mutex);
+       qunlock(&vfdb->event_mutex);
 
        for_each_vf(bp, vf_idx) {
                struct bnx2x_vf_mbx *mbx = BP_VF_MBX(bp, vf_idx);
diff --git a/scripts/spatch/linux/sync.cocci b/scripts/spatch/linux/sync.cocci
new file mode 100644 (file)
index 0000000..eb77c77
--- /dev/null
@@ -0,0 +1,19 @@
+@@
+typedef qlock_t;
+@@
+-struct mutex
++qlock_t
+
+@@
+expression E;
+@@
+-mutex_lock(
++qlock(
+ E)
+
+@@
+expression E;
+@@
+-mutex_unlock(
++qunlock(
+ E)