/* * Copyright ( c ) 2004 , 2005 Topspin Communications . All rights reserved . * Copyright ( c ) 2005 , 2006 , 2007 , 2008 Mellanox Technologies . * All rights reserved . * Copyright ( c ) 2005 , 2006 , 2007 Cisco Systems , Inc . All rights reserved . * * This software is available to you under a choice of one of two * licenses . You may choose to be licensed under the terms of the GNU * General Public License ( GPL ) Version 2 , available from the file * COPYING in the main directory of this source tree , or the * OpenIB . org BSD license below : * * Redistribution and use in source and binary forms , with or * without modification , are permitted provided that the following * conditions are met : * * - Redistributions of source code must retain the above * copyright notice , this list of conditions and the following * disclaimer . * * - Redistributions in binary form must reproduce the above * copyright notice , this list of conditions and the following * disclaimer in the documentation and / or other materials * provided with the distribution . * * THE SOFTWARE IS PROVIDED " AS IS " , WITHOUT WARRANTY OF ANY KIND , * EXPRESS OR IMPLIED , INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY , FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT . IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS * BE LIABLE FOR ANY CLAIM , DAMAGES OR OTHER LIABILITY , WHETHER IN AN * ACTION OF CONTRACT , TORT OR OTHERWISE , ARISING FROM , OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE . #include <linux/sched.h>#include <linux/pci.h>#include <linux/errno.h>#include <linux/kernel.h>#include <linux/io.h>#include <linux/slab.h>#include <linux/mlx4/cmd.h>#include <linux/mlx4/qp.h>#include <linux/if_ether.h>#include <linux/etherdevice.h>#include "mlx4.h" #include "fw.h" #include "mlx4_stats.h" #define MLX4_MAC_VALID (1 ull << 63 )#define MLX4_PF_COUNTERS_PER_PORT 2 #define MLX4_VF_COUNTERS_PER_PORT 1 struct mac_res {struct list_head list;int ref_count;struct vlan_res {struct list_head list;int ref_count;int vlan_index;struct res_common {struct list_head list;struct rb_node node;int owner;int state;int from_state;int to_state;int removing;const char *func_name;enum {1 struct res_gid {struct list_head list;16 ];enum mlx4_protocol prot;enum mlx4_steer_type steer;enum res_qp_states {/* QP number was allocated */ /* ICM memory for QP context was mapped */ /* QP is in hw ownership */ struct res_qp {struct res_common com;struct res_mtt *mtt;struct res_cq *rcq;struct res_cq *scq;struct res_srq *srq;struct list_head mcg_list;int local_qpn;/* saved qp params before VST enforcement in order to restore on VGT */ enum res_mtt_states {static inline const char *mtt_states_str(enum res_mtt_states state)switch (state) {case RES_MTT_BUSY: return "RES_MTT_BUSY" ;case RES_MTT_ALLOCATED: return "RES_MTT_ALLOCATED" ;default : return "Unknown" ;struct res_mtt {struct res_common com;int order;enum res_mpt_states {struct res_mpt {struct res_common com;struct res_mtt *mtt;int key;enum res_eq_states {struct res_eq {struct res_common com;struct res_mtt *mtt;enum res_cq_states {struct res_cq {struct res_common com;struct res_mtt *mtt;enum res_srq_states {struct res_srq {struct res_common com;struct res_mtt *mtt;struct res_cq *cq;enum res_counter_states {struct res_counter {struct res_common com;int port;enum res_xrcdn_states {struct res_xrcdn {struct res_common com;int port;enum res_fs_rule_states {struct res_fs_rule {struct res_common com;int qpn;/* VF DMFS mbox with port flipped */ void *mirr_mbox;/* > 0 --> apply mirror when getting into HA mode */ /* = 0 --> un-apply mirror when getting out of HA mode */ struct list_head mirr_list;static void *res_tracker_lookup(struct rb_root *root, u64 res_id)struct rb_node *node = root->rb_node;while (node) {struct res_common *res = rb_entry(node, struct res_common,if (res_id < res->res_id)else if (res_id > res->res_id)else return res;return NULL;static int res_tracker_insert(struct rb_root *root, struct res_common *res)struct rb_node **new = &(root->rb_node), *parent = NULL;/* Figure out where to put new node */ while (*new ) {struct res_common *this = rb_entry(*new , struct res_common,new ;if (res->res_id < this ->res_id)new = &((*new )->rb_left);else if (res->res_id > this ->res_id)new = &((*new )->rb_right);else return -EEXIST;/* Add new node and rebalance tree. */ new );return 0 ;enum qp_transition {/* For Debug uses */ static const char *resource_str(enum mlx4_resource rt)switch (rt) {case RES_QP: return "RES_QP" ;case RES_CQ: return "RES_CQ" ;case RES_SRQ: return "RES_SRQ" ;case RES_MPT: return "RES_MPT" ;case RES_MTT: return "RES_MTT" ;case RES_MAC: return "RES_MAC" ;case RES_VLAN: return "RES_VLAN" ;case RES_EQ: return "RES_EQ" ;case RES_COUNTER: return "RES_COUNTER" ;case RES_FS_RULE: return "RES_FS_RULE" ;case RES_XRCD: return "RES_XRCD" ;default : return "Unknown resource type !!!" ;static void rem_slave_vlans(struct mlx4_dev *dev, int slave);static inline int mlx4_grant_resource(struct mlx4_dev *dev, int slave,enum mlx4_resource res_type, int count,int port)struct mlx4_priv *priv = mlx4_priv(dev);struct resource_allocator *res_alloc =int err = -EDQUOT;int allocated, free, reserved, guaranteed, from_free;int from_rsvd;if (slave > dev->persist->num_vfs)return -EINVAL;0 ) ?1 ) *1 ) + slave] :0 ) ? res_alloc->res_port_free[port - 1 ] :0 ) ? res_alloc->res_port_rsvd[port - 1 ] :if (allocated + count > res_alloc->quota[slave]) {"VF %d port %d res %s: quota exceeded, count %d alloc %d quota %d\n" ,goto out;if (allocated + count <= guaranteed) {0 ;else {/* portion may need to be obtained from free area */ if (guaranteed - allocated > 0 )else if (free - from_free >= reserved)0 ;else "VF %d port %d res %s: free pool empty, free %d from_free %d rsvd %d\n" ,if (!err) {/* grant the request */ if (port > 0 ) {1 ) *1 ) + slave] += count;1 ] -= count;1 ] -= from_rsvd;else {return err;static inline void mlx4_release_resource(struct mlx4_dev *dev, int slave,enum mlx4_resource res_type, int count,int port)struct mlx4_priv *priv = mlx4_priv(dev);struct resource_allocator *res_alloc =int allocated, guaranteed, from_rsvd;if (slave > dev->persist->num_vfs)return ;0 ) ?1 ) *1 ) + slave] :if (allocated - count >= guaranteed) {0 ;else {/* portion may need to be returned to reserved area */ if (allocated - guaranteed > 0 )else if (port > 0 ) {1 ) *1 ) + slave] -= count;1 ] += count;1 ] += from_rsvd;else {return ;static inline void initialize_res_quotas(struct mlx4_dev *dev,struct resource_allocator *res_alloc,enum mlx4_resource res_type,int vf, int num_instances)2 * (dev->persist->num_vfs + 1 ));2 ) + res_alloc->guaranteed[vf];if (vf == mlx4_master_func_num(dev)) {if (res_type == RES_MTT) {/* reserved mtts will be taken out of the PF allocation */ void mlx4_init_quotas(struct mlx4_dev *dev)struct mlx4_priv *priv = mlx4_priv(dev);int pf;/* quotas for VFs are initialized in mlx4_slave_cap */ if (mlx4_is_slave(dev))return ;if (!mlx4_is_mfunc(dev)) {return ;static int struct mlx4_dev *dev,struct resource_allocator *res_alloc,int vf)struct mlx4_active_ports actv_ports;int ports, counters_guaranteed;/* For master, only allocate according to the number of phys ports */ if (vf == mlx4_master_func_num(dev))return MLX4_PF_COUNTERS_PER_PORT * dev->caps.num_ports;/* calculate real number of ports for the VF */ /* If we do not have enough counters for this VF, do not * allocate any for it . ' - 1 ' to reduce the sink counter . if ((res_alloc->res_reserved + counters_guaranteed) >1 ))return 0 ;return counters_guaranteed;int mlx4_init_resource_tracker(struct mlx4_dev *dev)struct mlx4_priv *priv = mlx4_priv(dev);int i, j;int t;sizeof (struct slave_list),if (!priv->mfunc.master.res_tracker.slave_list)return -ENOMEM;for (i = 0 ; i < dev->num_slaves; i++) {for (t = 0 ; t < MLX4_NUM_OF_RESOURCE_TYPE; ++t)"Started init_resource_tracker: %ld slaves\n" ,for (i = 0 ; i < MLX4_NUM_OF_RESOURCE_TYPE; i++)for (i = 0 ; i < MLX4_NUM_OF_RESOURCE_TYPE; i++) {struct resource_allocator *res_alloc =1 ,sizeof (int ),1 ,sizeof (int ),if (i == RES_MAC || i == RES_VLAN)1 ),sizeof (int ), GFP_KERNEL);else 1 ,sizeof (int ), GFP_KERNEL);/* Reduce the sink counter */ if (i == RES_COUNTER)1 ;if (!res_alloc->quota || !res_alloc->guaranteed ||goto no_mem_err;for (t = 0 ; t < dev->persist->num_vfs + 1 ; t++) {struct mlx4_active_ports actv_ports =switch (i) {case RES_QP:break ;case RES_CQ:break ;case RES_SRQ:break ;case RES_MPT:break ;case RES_MTT:break ;case RES_MAC:if (t == mlx4_master_func_num(dev)) {int max_vfs_pport = 0 ;/* Calculate the max vfs per port for */ /* both ports. */ for (j = 0 ; j < dev->caps.num_ports;struct mlx4_slaves_pport slaves_pport =1 );unsigned current_slaves =1 ;if (max_vfs_pport < current_slaves)2 * max_vfs_pport;2 ;for (j = 0 ; j < MLX4_MAX_PORTS; j++)else {2 ;break ;case RES_VLAN:if (t == mlx4_master_func_num(dev)) {2 ;for (j = 0 ; j < MLX4_MAX_PORTS; j++)else {2 ;0 ;break ;case RES_COUNTER:break ;default :break ;if (i == RES_MAC || i == RES_VLAN) {for (j = 0 ; j < dev->caps.num_ports; j++)if (test_bit(j, actv_ports.ports))else {return 0 ;for (i = 0 ; i < MLX4_NUM_OF_RESOURCE_TYPE; i++) {return -ENOMEM;void mlx4_free_resource_tracker(struct mlx4_dev *dev,enum mlx4_res_tracker_free_type type)struct mlx4_priv *priv = mlx4_priv(dev);int i;if (priv->mfunc.master.res_tracker.slave_list) {if (type != RES_TR_FREE_STRUCTS_ONLY) {for (i = 0 ; i < dev->num_slaves; i++) {if (type == RES_TR_FREE_ALL ||/* free master's vlans */ if (type != RES_TR_FREE_SLAVES_ONLY) {for (i = 0 ; i < MLX4_NUM_OF_RESOURCE_TYPE; i++) {static void update_pkey_index(struct mlx4_dev *dev, int slave,struct mlx4_cmd_mailbox *inbox)64 );35 );struct mlx4_priv *priv = mlx4_priv(dev);int port;6 & 1 ) + 1 ;1 ][orig_index];35 ) = new_index;static void update_gid(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *inbox,struct mlx4_qp_context *qp_ctx = inbox->buf + 8 ;enum mlx4_qp_optpar optpar = be32_to_cpu(*(__be32 *) inbox->buf);16 ) & 0 xff;int port;if (MLX4_QP_ST_UD == ts) {6 & 1 ) + 1 ;if (mlx4_is_eth(dev, port))0 x80;else 0 x80;else if (MLX4_QP_ST_RC == ts || MLX4_QP_ST_XRC == ts || MLX4_QP_ST_UC == ts) {if (optpar & MLX4_QP_OPTPAR_PRIMARY_ADDR_PATH) {6 & 1 ) + 1 ;if (mlx4_is_eth(dev, port)) {0 x7f;else {0 x7F;if (optpar & MLX4_QP_OPTPAR_ALT_ADDR_PATH) {6 & 1 ) + 1 ;if (mlx4_is_eth(dev, port)) {0 x7f;else {0 x7F;static int handle_counter(struct mlx4_dev *dev, struct mlx4_qp_context *qpc,int port);static int update_vport_qp_param(struct mlx4_dev *dev,struct mlx4_cmd_mailbox *inbox,struct mlx4_qp_context *qpc = inbox->buf + 8 ;struct mlx4_vport_oper_state *vp_oper;struct mlx4_priv *priv;int port, err = 0 ;0 x40) ? 2 : 1 ;16 ) & 0 xff;if (err)goto out;if (MLX4_VGT != vp_oper->state.default_vlan) {/* the reserved QPs (special, proxy, tunnel) * do not operate over vlans if (mlx4_is_qp_reserved(dev, qpn))return 0 ;/* force strip vlan by clear vsd, MLX QP refers to Raw Ethernet */ if (qp_type == MLX4_QP_ST_UD ||if (dev->caps.bmme_flags & MLX4_BMME_FLAG_VSD_INIT2RTR) {else {struct mlx4_update_qp_params params = {.flags = 0 };if (err)goto out;/* preserve IF_COUNTER flag */ if (vp_oper->state.link_state == IFLA_VF_LINK_STATE_DISABLE &&else if (0 != vp_oper->state.default_vlan) {if (vp_oper->state.vlan_proto == htons(ETH_P_8021AD)) {/* vst QinQ should block untagged on TX, * but cvlan is in payload and phv is set so * hw see it as untagged . Block tagged instead . else { /* vst 802.1Q */ else { /* priority tagged */ if (vp_oper->state.vlan_proto == htons(ETH_P_8021AD))else 0 xC7;3 ;if (vp_oper->state.spoofchk) {0 x80 & qpc->pri_path.grh_mylmc) + vp_oper->mac_idx;return err;static int mpt_mask(struct mlx4_dev *dev)return dev->caps.num_mpts - 1 ;static const char *mlx4_resource_type_to_str(enum mlx4_resource t)switch (t) {case RES_QP:return "QP" ;case RES_CQ:return "CQ" ;case RES_SRQ:return "SRQ" ;case RES_XRCD:return "XRCD" ;case RES_MPT:return "MPT" ;case RES_MTT:return "MTT" ;case RES_MAC:return "MAC" ;case RES_VLAN:return "VLAN" ;case RES_COUNTER:return "COUNTER" ;case RES_FS_RULE:return "FS_RULE" ;case RES_EQ:return "EQ" ;default :return "INVALID RESOURCE" ;static void *find_res(struct mlx4_dev *dev, u64 res_id,enum mlx4_resource type)struct mlx4_priv *priv = mlx4_priv(dev);return res_tracker_lookup(&priv->mfunc.master.res_tracker.res_tree[type],static int _get_res(struct mlx4_dev *dev, int slave, u64 res_id,enum mlx4_resource type,void *res, const char *func_name)struct res_common *r;int err = 0 ;if (!r) {goto exit ;if (r->state == RES_ANY_BUSY) {"%s(%d) trying to get resource %llx of type %s, but it's already taken by %s\n" ,goto exit ;if (r->owner != slave) {goto exit ;if (res)struct res_common **)res) = r;exit :return err;#define get_res(dev, slave, res_id, type, res) \int mlx4_get_slave_from_resource_id(struct mlx4_dev *dev,enum mlx4_resource type,int *slave)struct res_common *r;int err = -ENOENT;int id = res_id;if (type == RES_QP)0 x7fffff;if (r) {0 ;return err;static void put_res(struct mlx4_dev *dev, int slave, u64 res_id,enum mlx4_resource type)struct res_common *r;if (r) {"" ;static int counter_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int port);static int handle_existing_counter(struct mlx4_dev *dev, u8 slave, int port,int counter_index)struct res_common *r;struct res_counter *counter;int ret = 0 ;if (counter_index == MLX4_SINK_COUNTER_INDEX(dev))return ret;if (!r || r->owner != slave) {else {struct res_counter, com);if (!counter->port)return ret;static int handle_unexisting_counter(struct mlx4_dev *dev,struct mlx4_qp_context *qpc, u8 slave,int port)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_common *tmp;struct res_counter *counter;int err = 0 ;struct res_counter, com);if (port == counter->port) {return 0 ;/* No existing counter, need to allocate a new counter */ 0 , 0 , &counter_idx,if (err == -ENOENT) {0 ;else if (err && err != -ENOSPC) {"%s: failed to create new counter for slave %d err %d\n" ,else {"%s: alloc new counter for slave %d index %d\n" ,0 ;return err;static int handle_counter(struct mlx4_dev *dev, struct mlx4_qp_context *qpc,int port)if (qpc->pri_path.counter_index != MLX4_SINK_COUNTER_INDEX(dev))return handle_existing_counter(dev, slave, port,return handle_unexisting_counter(dev, qpc, slave, port);static struct res_common *alloc_qp_tr(int id)struct res_qp *ret;sizeof (*ret), GFP_KERNEL);if (!ret)return NULL;0 );return &ret->com;static struct res_common *alloc_mtt_tr(int id, int order)struct res_mtt *ret;sizeof (*ret), GFP_KERNEL);if (!ret)return NULL;0 );return &ret->com;static struct res_common *alloc_mpt_tr(int id, int key)struct res_mpt *ret;sizeof (*ret), GFP_KERNEL);if (!ret)return NULL;return &ret->com;static struct res_common *alloc_eq_tr(int id)struct res_eq *ret;sizeof (*ret), GFP_KERNEL);if (!ret)return NULL;return &ret->com;static struct res_common *alloc_cq_tr(int id)struct res_cq *ret;sizeof (*ret), GFP_KERNEL);if (!ret)return NULL;0 );return &ret->com;static struct res_common *alloc_srq_tr(int id)struct res_srq *ret;sizeof (*ret), GFP_KERNEL);if (!ret)return NULL;0 );return &ret->com;static struct res_common *alloc_counter_tr(int id, int port)struct res_counter *ret;sizeof (*ret), GFP_KERNEL);if (!ret)return NULL;return &ret->com;static struct res_common *alloc_xrcdn_tr(int id)struct res_xrcdn *ret;sizeof (*ret), GFP_KERNEL);if (!ret)return NULL;return &ret->com;static struct res_common *alloc_fs_rule_tr(u64 id, int qpn)struct res_fs_rule *ret;sizeof (*ret), GFP_KERNEL);if (!ret)return NULL;return &ret->com;static struct res_common *alloc_tr(u64 id, enum mlx4_resource type, int slave,int extra)struct res_common *ret;switch (type) {case RES_QP:break ;case RES_MPT:break ;case RES_MTT:break ;case RES_EQ:break ;case RES_CQ:break ;case RES_SRQ:break ;case RES_MAC:"implementation missing\n" );return NULL;case RES_COUNTER:break ;case RES_XRCD:break ;case RES_FS_RULE:break ;default :return NULL;if (ret)return ret;int mlx4_calc_vf_counters(struct mlx4_dev *dev, int slave, int port,struct mlx4_counter *data)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_common *tmp;struct res_counter *counter;int *counters_arr;int i = 0 , err = 0 ;0 , sizeof (*data));sizeof (*counters_arr), GFP_KERNEL);if (!counters_arr)return -ENOMEM;struct res_counter, com);if (counter->port == port) {int )tmp->res_id;1 ;0 ;while (counters_arr[i] != -1 ) {0 );if (err) {0 , sizeof (*data));goto table_changed;return 0 ;static int add_res_range(struct mlx4_dev *dev, int slave, u64 base, int count,enum mlx4_resource type, int extra)int i;int err;struct mlx4_priv *priv = mlx4_priv(dev);struct res_common **res_arr;struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct rb_root *root = &tracker->res_tree[type];sizeof (*res_arr), GFP_KERNEL);if (!res_arr)return -ENOMEM;for (i = 0 ; i < count; ++i) {if (!res_arr[i]) {for (--i; i >= 0 ; --i)return -ENOMEM;for (i = 0 ; i < count; ++i) {if (find_res(dev, base + i, type)) {goto undo;if (err)goto undo;return 0 ;for (--i; i >= 0 ; --i) {for (i = 0 ; i < count; ++i)return err;static int remove_qp_ok(struct res_qp *res)if (res->com.state == RES_QP_BUSY || atomic_read(&res->ref_count) ||"resource tracker: fail to remove qp, state %d, ref_count %d\n" ,return -EBUSY;else if (res->com.state != RES_QP_RESERVED) {return -EPERM;return 0 ;static int remove_mtt_ok(struct res_mtt *res, int order)if (res->com.state == RES_MTT_BUSY ||"%s-%d: state %s, ref_count %d\n" ,return -EBUSY;else if (res->com.state != RES_MTT_ALLOCATED)return -EPERM;else if (res->order != order)return -EINVAL;return 0 ;static int remove_mpt_ok(struct res_mpt *res)if (res->com.state == RES_MPT_BUSY)return -EBUSY;else if (res->com.state != RES_MPT_RESERVED)return -EPERM;return 0 ;static int remove_eq_ok(struct res_eq *res)if (res->com.state == RES_MPT_BUSY)return -EBUSY;else if (res->com.state != RES_MPT_RESERVED)return -EPERM;return 0 ;static int remove_counter_ok(struct res_counter *res)if (res->com.state == RES_COUNTER_BUSY)return -EBUSY;else if (res->com.state != RES_COUNTER_ALLOCATED)return -EPERM;return 0 ;static int remove_xrcdn_ok(struct res_xrcdn *res)if (res->com.state == RES_XRCD_BUSY)return -EBUSY;else if (res->com.state != RES_XRCD_ALLOCATED)return -EPERM;return 0 ;static int remove_fs_rule_ok(struct res_fs_rule *res)if (res->com.state == RES_FS_RULE_BUSY)return -EBUSY;else if (res->com.state != RES_FS_RULE_ALLOCATED)return -EPERM;return 0 ;static int remove_cq_ok(struct res_cq *res)if (res->com.state == RES_CQ_BUSY)return -EBUSY;else if (res->com.state != RES_CQ_ALLOCATED)return -EPERM;return 0 ;static int remove_srq_ok(struct res_srq *res)if (res->com.state == RES_SRQ_BUSY)return -EBUSY;else if (res->com.state != RES_SRQ_ALLOCATED)return -EPERM;return 0 ;static int remove_ok(struct res_common *res, enum mlx4_resource type, int extra)switch (type) {case RES_QP:return remove_qp_ok((struct res_qp *)res);case RES_CQ:return remove_cq_ok((struct res_cq *)res);case RES_SRQ:return remove_srq_ok((struct res_srq *)res);case RES_MPT:return remove_mpt_ok((struct res_mpt *)res);case RES_MTT:return remove_mtt_ok((struct res_mtt *)res, extra);case RES_MAC:return -EOPNOTSUPP;case RES_EQ:return remove_eq_ok((struct res_eq *)res);case RES_COUNTER:return remove_counter_ok((struct res_counter *)res);case RES_XRCD:return remove_xrcdn_ok((struct res_xrcdn *)res);case RES_FS_RULE:return remove_fs_rule_ok((struct res_fs_rule *)res);default :return -EINVAL;static int rem_res_range(struct mlx4_dev *dev, int slave, u64 base, int count,enum mlx4_resource type, int extra)int err;struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_common *r;for (i = base; i < base + count; ++i) {if (!r) {goto out;if (r->owner != slave) {goto out;if (err)goto out;for (i = base; i < base + count; ++i) {0 ;return err;static int qp_res_start_move_to(struct mlx4_dev *dev, int slave, int qpn,enum res_qp_states state, struct res_qp **qp,int alloc)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_qp *r;int err = 0 ;if (!r)else if (r->com.owner != slave)else {switch (state) {case RES_QP_BUSY:"%s: failed RES_QP, 0x%llx\n" ,break ;case RES_QP_RESERVED:if (r->com.state == RES_QP_MAPPED && !alloc)break ;"failed RES_QP, 0x%llx\n" , r->com.res_id);break ;case RES_QP_MAPPED:if ((r->com.state == RES_QP_RESERVED && alloc) ||break ;else {"failed RES_QP, 0x%llx\n" ,break ;case RES_QP_HW:if (r->com.state != RES_QP_MAPPED)break ;default :if (!err) {if (qp)return err;static int mr_res_start_move_to(struct mlx4_dev *dev, int slave, int index,enum res_mpt_states state, struct res_mpt **mpt)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_mpt *r;int err = 0 ;if (!r)else if (r->com.owner != slave)else {switch (state) {case RES_MPT_BUSY:break ;case RES_MPT_RESERVED:if (r->com.state != RES_MPT_MAPPED)break ;case RES_MPT_MAPPED:if (r->com.state != RES_MPT_RESERVED &&break ;case RES_MPT_HW:if (r->com.state != RES_MPT_MAPPED)break ;default :if (!err) {if (mpt)return err;static int eq_res_start_move_to(struct mlx4_dev *dev, int slave, int index,enum res_eq_states state, struct res_eq **eq)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_eq *r;int err = 0 ;if (!r)else if (r->com.owner != slave)else {switch (state) {case RES_EQ_BUSY:break ;case RES_EQ_RESERVED:if (r->com.state != RES_EQ_HW)break ;case RES_EQ_HW:if (r->com.state != RES_EQ_RESERVED)break ;default :if (!err) {if (!err && eq)return err;static int cq_res_start_move_to(struct mlx4_dev *dev, int slave, int cqn,enum res_cq_states state, struct res_cq **cq)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_cq *r;int err;if (!r) {else if (r->com.owner != slave) {else if (state == RES_CQ_ALLOCATED) {if (r->com.state != RES_CQ_HW)else if (atomic_read(&r->ref_count))else 0 ;else if (state != RES_CQ_HW || r->com.state != RES_CQ_ALLOCATED) {else {0 ;if (!err) {if (cq)return err;static int srq_res_start_move_to(struct mlx4_dev *dev, int slave, int index,enum res_srq_states state, struct res_srq **srq)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_srq *r;int err = 0 ;if (!r) {else if (r->com.owner != slave) {else if (state == RES_SRQ_ALLOCATED) {if (r->com.state != RES_SRQ_HW)else if (atomic_read(&r->ref_count))else if (state != RES_SRQ_HW || r->com.state != RES_SRQ_ALLOCATED) {if (!err) {if (srq)return err;static void res_abort_move(struct mlx4_dev *dev, int slave,enum mlx4_resource type, int id)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_common *r;if (r && (r->owner == slave))static void res_end_move(struct mlx4_dev *dev, int slave,enum mlx4_resource type, int id)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_common *r;if (r && (r->owner == slave))static int valid_reserved(struct mlx4_dev *dev, int slave, int qpn)return mlx4_is_qp_reserved(dev, qpn) &&static int fw_reserved(struct mlx4_dev *dev, int qpn)return qpn < dev->caps.reserved_qps_cnt[MLX4_QP_REGION_FW];static int qp_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int err;int count;int align;int base;int qpn;switch (op) {case RES_OP_RESERVE:0 xffffff;/* Turn off all unsupported QP allocation flags that the * slave tries to set . 24 ) & dev->caps.alloc_res_qp_mask;0 );if (err)return err;if (err) {0 );return err;0 );if (err) {0 );return err;break ;case RES_OP_MAP_ICM:0 x7fffff;if (valid_reserved(dev, slave, qpn)) {1 , RES_QP, 0 );if (err)return err;1 );if (err)return err;if (!fw_reserved(dev, qpn)) {if (err) {return err;break ;default :break ;return err;static int mtt_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int err = -EINVAL;int base;int order;if (op != RES_OP_RESERVE_AND_MAP)return err;1 << order, 0 );if (err)return err;if (base == -1 ) {1 << order, 0 );return -ENOMEM;1 , RES_MTT, order);if (err) {1 << order, 0 );else {return err;static int mpt_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int err = -EINVAL;int index;int id;struct res_mpt *mpt;switch (op) {case RES_OP_RESERVE:1 , 0 );if (err)break ;if (index == -1 ) {1 , 0 );break ;1 , RES_MPT, index);if (err) {1 , 0 );break ;break ;case RES_OP_MAP_ICM:if (err)return err;if (err) {return err;break ;return err;static int cq_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int cqn;int err;switch (op) {case RES_OP_RESERVE_AND_MAP:1 , 0 );if (err)break ;if (err) {1 , 0 );break ;1 , RES_CQ, 0 );if (err) {1 , 0 );break ;break ;default :return err;static int srq_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int srqn;int err;switch (op) {case RES_OP_RESERVE_AND_MAP:1 , 0 );if (err)break ;if (err) {1 , 0 );break ;1 , RES_SRQ, 0 );if (err) {1 , 0 );break ;break ;default :return err;static int mac_find_smac_ix_in_slave(struct mlx4_dev *dev, int slave, int port,struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct list_head *mac_list =struct mac_res *res, *tmp;if (res->smac_index == smac_index && res->port == (u8) port) {return 0 ;return -ENOENT;static int mac_add_to_slave(struct mlx4_dev *dev, int slave, u64 mac, int port, u8 smac_index)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct list_head *mac_list =struct mac_res *res, *tmp;if (res->mac == mac && res->port == (u8) port) {/* mac found. update ref count */ return 0 ;if (mlx4_grant_resource(dev, slave, RES_MAC, 1 , port))return -EINVAL;sizeof (*res), GFP_KERNEL);if (!res) {1 , port);return -ENOMEM;1 ;return 0 ;static void mac_del_from_slave(struct mlx4_dev *dev, int slave, u64 mac,int port)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct list_head *mac_list =struct mac_res *res, *tmp;if (res->mac == mac && res->port == (u8) port) {if (!--res->ref_count) {1 , port);break ;static void rem_slave_macs(struct mlx4_dev *dev, int slave)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct list_head *mac_list =struct mac_res *res, *tmp;int i;/* dereference the mac the num times the slave referenced it */ for (i = 0 ; i < res->ref_count; i++)1 , res->port);static int mac_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int in_port)int err = -EINVAL;int port;if (op != RES_OP_RESERVE_AND_MAP)return err;if (port < 0 )return -EINVAL;if (err >= 0 ) {0 ;if (!err) {if (err)return err;static int vlan_add_to_slave(struct mlx4_dev *dev, int slave, u16 vlan,int port, int vlan_index)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct list_head *vlan_list =struct vlan_res *res, *tmp;if (res->vlan == vlan && res->port == (u8) port) {/* vlan found. update ref count */ return 0 ;if (mlx4_grant_resource(dev, slave, RES_VLAN, 1 , port))return -EINVAL;sizeof (*res), GFP_KERNEL);if (!res) {1 , port);return -ENOMEM;1 ;return 0 ;static void vlan_del_from_slave(struct mlx4_dev *dev, int slave, u16 vlan,int port)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct list_head *vlan_list =struct vlan_res *res, *tmp;if (res->vlan == vlan && res->port == (u8) port) {if (!--res->ref_count) {1 , port);break ;static void rem_slave_vlans(struct mlx4_dev *dev, int slave)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct list_head *vlan_list =struct vlan_res *res, *tmp;int i;/* dereference the vlan the num times the slave referenced it */ for (i = 0 ; i < res->ref_count; i++)1 , res->port);static int vlan_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int in_port)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_slave_state *slave_state = priv->mfunc.master.slave_state;int err;int vlan_index;int port;if (!port || op != RES_OP_RESERVE_AND_MAP)return -EINVAL;if (port < 0 )return -EINVAL;/* upstream kernels had NOP for reg/unreg vlan. Continue this. */ if (!in_port && port > 0 && port <= dev->caps.num_ports) {true ;return 0 ;if (!err) {if (err)return err;static int counter_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int port)int err;if (op != RES_OP_RESERVE)return -EINVAL;1 , 0 );if (err)return err;if (err) {1 , 0 );return err;1 , RES_COUNTER, port);if (err) {1 , 0 );else {return err;static int xrcdn_alloc_res(struct mlx4_dev *dev, int slave, int op, int cmd,int err;if (op != RES_OP_RESERVE)return -EINVAL;if (err)return err;1 , RES_XRCD, 0 );if (err)else return err;int mlx4_ALLOC_RES_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int alop = vhcr->op_modifier;switch (vhcr->in_modifier & 0 xFF) {case RES_QP:break ;case RES_MTT:break ;case RES_MPT:break ;case RES_CQ:break ;case RES_SRQ:break ;case RES_MAC:8 ) & 0 xFF);break ;case RES_VLAN:8 ) & 0 xFF);break ;case RES_COUNTER:0 );break ;case RES_XRCD:break ;default :break ;return err;static int qp_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,int err;int count;int base;int qpn;switch (op) {case RES_OP_RESERVE:0 x7fffff;0 );if (err)break ;0 );break ;case RES_OP_MAP_ICM:0 x7fffff;0 );if (err)return err;if (!fw_reserved(dev, qpn))if (valid_reserved(dev, slave, qpn))1 , RES_QP, 0 );break ;default :break ;return err;static int mtt_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,int err = -EINVAL;int base;int order;if (op != RES_OP_RESERVE_AND_MAP)return err;1 , RES_MTT, order);if (!err) {1 << order, 0 );return err;static int mpt_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,int err = -EINVAL;int index;int id;struct res_mpt *mpt;switch (op) {case RES_OP_RESERVE:if (err)break ;1 , RES_MPT, 0 );if (err)break ;1 , 0 );break ;case RES_OP_MAP_ICM:if (err)return err;break ;default :break ;return err;static int cq_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,int cqn;int err;switch (op) {case RES_OP_RESERVE_AND_MAP:1 , RES_CQ, 0 );if (err)break ;1 , 0 );break ;default :break ;return err;static int srq_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,int srqn;int err;switch (op) {case RES_OP_RESERVE_AND_MAP:1 , RES_SRQ, 0 );if (err)break ;1 , 0 );break ;default :break ;return err;static int mac_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,int in_port)int port;int err = 0 ;switch (op) {case RES_OP_RESERVE_AND_MAP:if (port < 0 )return -EINVAL;break ;default :break ;return err;static int vlan_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,int port)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_slave_state *slave_state = priv->mfunc.master.slave_state;int err = 0 ;if (port < 0 )return -EINVAL;switch (op) {case RES_OP_RESERVE_AND_MAP:if (slave_state[slave].old_vlan_api)return 0 ;if (!port)return -EINVAL;break ;default :break ;return err;static int counter_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,int index;int err;if (op != RES_OP_RESERVE)return -EINVAL;if (index == MLX4_SINK_COUNTER_INDEX(dev))return 0 ;1 , RES_COUNTER, 0 );if (err)return err;1 , 0 );return err;static int xrcdn_free_res(struct mlx4_dev *dev, int slave, int op, int cmd,int xrcdn;int err;if (op != RES_OP_RESERVE)return -EINVAL;1 , RES_XRCD, 0 );if (err)return err;return err;int mlx4_FREE_RES_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err = -EINVAL;int alop = vhcr->op_modifier;switch (vhcr->in_modifier & 0 xFF) {case RES_QP:break ;case RES_MTT:break ;case RES_MPT:break ;case RES_CQ:break ;case RES_SRQ:break ;case RES_MAC:8 ) & 0 xFF);break ;case RES_VLAN:8 ) & 0 xFF);break ;case RES_COUNTER:break ;case RES_XRCD:break ;default :break ;return err;/* ugly but other choices are uglier */ static int mr_phys_mpt(struct mlx4_mpt_entry *mpt)return (be32_to_cpu(mpt->flags) >> 9 ) & 1 ;static int mr_get_mtt_addr(struct mlx4_mpt_entry *mpt)return (int )be64_to_cpu(mpt->mtt_addr) & 0 xfffffff8;static int mr_get_mtt_size(struct mlx4_mpt_entry *mpt)return be32_to_cpu(mpt->mtt_sz);static u32 mr_get_pd(struct mlx4_mpt_entry *mpt)return be32_to_cpu(mpt->pd_flags) & 0 x00ffffff;static int mr_is_fmr(struct mlx4_mpt_entry *mpt)return be32_to_cpu(mpt->pd_flags) & MLX4_MPT_PD_FLAG_FAST_REG;static int mr_is_bind_enabled(struct mlx4_mpt_entry *mpt)return be32_to_cpu(mpt->flags) & MLX4_MPT_FLAG_BIND_ENABLE;static int mr_is_region(struct mlx4_mpt_entry *mpt)return be32_to_cpu(mpt->flags) & MLX4_MPT_FLAG_REGION;static int qp_get_mtt_addr(struct mlx4_qp_context *qpc)return be32_to_cpu(qpc->mtt_base_addr_l) & 0 xfffffff8;static int srq_get_mtt_addr(struct mlx4_srq_context *srqc)return be32_to_cpu(srqc->mtt_base_addr_l) & 0 xfffffff8;static int qp_get_mtt_size(struct mlx4_qp_context *qpc)int page_shift = (qpc->log_page_size & 0 x3f) + 12 ;int log_sq_size = (qpc->sq_size_stride >> 3 ) & 0 xf;int log_sq_sride = qpc->sq_size_stride & 7 ;int log_rq_size = (qpc->rq_size_stride >> 3 ) & 0 xf;int log_rq_stride = qpc->rq_size_stride & 7 ;int srq = (be32_to_cpu(qpc->srqn) >> 24 ) & 1 ;int rss = (be32_to_cpu(qpc->flags) >> 13 ) & 1 ;16 ) & 0 xff;int xrc = (ts == MLX4_QP_ST_XRC) ? 1 : 0 ;int sq_size;int rq_size;int total_pages;int total_mem;int page_offset = (be32_to_cpu(qpc->params2) >> 6 ) & 0 x3f;int tot;1 << (log_sq_size + log_sq_sride + 4 );0 : (1 << (log_rq_size + log_rq_stride + 4 ));6 )) >> page_shift;1 : roundup_pow_of_two(tot);return total_pages;static int check_mtt_range(struct mlx4_dev *dev, int slave, int start,int size, struct res_mtt *mtt)int res_start = mtt->com.res_id;int res_size = (1 << mtt->order);if (start < res_start || start + size > res_start + res_size)return -EPERM;return 0 ;int mlx4_SW2HW_MPT_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int index = vhcr->in_modifier;struct res_mtt *mtt;struct res_mpt *mpt = NULL;int mtt_base = mr_get_mtt_addr(inbox->buf) / dev->caps.mtt_entry_sz;int phys;int id;int pd_slave;if (err)return err;/* Disable memory windows for VFs. */ if (!mr_is_region(inbox->buf)) {goto ex_abort;/* Make sure that the PD bits related to the slave id are zeros. */ 17 ) & 0 x7f;if (pd_slave != 0 && --pd_slave != slave) {goto ex_abort;if (mr_is_fmr(inbox->buf)) {/* FMR and Bind Enable are forbidden in slave devices. */ if (mr_is_bind_enabled(inbox->buf)) {goto ex_abort;/* FMR and Memory Windows are also forbidden. */ if (!mr_is_region(inbox->buf)) {goto ex_abort;if (!phys) {if (err)goto ex_abort;if (err)goto ex_put;if (err)goto ex_put;if (!phys) {return 0 ;if (!phys)return err;int mlx4_HW2SW_MPT_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int index = vhcr->in_modifier;struct res_mpt *mpt;int id;if (err)return err;if (err)goto ex_abort;if (mpt->mtt)return 0 ;return err;int mlx4_QUERY_MPT_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int index = vhcr->in_modifier;struct res_mpt *mpt;int id;if (err)return err;if (mpt->com.from_state == RES_MPT_MAPPED) {/* In order to allow rereg in SRIOV, we need to alter the MPT entry. To do * that , the VF must read the MPT . But since the MPT entry memory is not * in the VF ' s virtual memory space , it must use QUERY_MPT to obtain the * entry contents . To guarantee that the MPT cannot be changed , the driver * must perform HW2SW_MPT before this query and return the MPT entry to HW * ownership fofollowing the change . The change here allows the VF to * perform QUERY_MPT also when the entry is in SW ownership . struct mlx4_mpt_entry *mpt_entry = mlx4_table_find(if (NULL == mpt_entry || NULL == outbox->buf) {goto out;sizeof (*mpt_entry));0 ;else if (mpt->com.from_state == RES_MPT_HW) {else {goto out;return err;static int qp_get_rcqn(struct mlx4_qp_context *qpc)return be32_to_cpu(qpc->cqn_recv) & 0 xffffff;static int qp_get_scqn(struct mlx4_qp_context *qpc)return be32_to_cpu(qpc->cqn_send) & 0 xffffff;static u32 qp_get_srqn(struct mlx4_qp_context *qpc)return be32_to_cpu(qpc->srqn) & 0 x1ffffff;static void adjust_proxy_tun_qkey(struct mlx4_dev *dev, struct mlx4_vhcr *vhcr,struct mlx4_qp_context *context)0 xffffff;0 ;if (mlx4_get_parav_qkey(dev, qpn, &qkey))return ;/* adjust qkey in qp context */ static int adjust_qp_sched_queue(struct mlx4_dev *dev, int slave,struct mlx4_qp_context *qpc,struct mlx4_cmd_mailbox *inbox);int mlx4_RST2INIT_QP_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int qpn = vhcr->in_modifier & 0 x7fffff;struct res_mtt *mtt;struct res_qp *qp;struct mlx4_qp_context *qpc = inbox->buf + 8 ;int mtt_base = qp_get_mtt_addr(qpc) / dev->caps.mtt_entry_sz;int mtt_size = qp_get_mtt_size(qpc);struct res_cq *rcq;struct res_cq *scq;int rcqn = qp_get_rcqn(qpc);int scqn = qp_get_scqn(qpc);0 xffffff;int use_srq = (qp_get_srqn(qpc) >> 24 ) & 1 ;struct res_srq *srq;int local_qpn = vhcr->in_modifier & 0 xffffff;if (err)return err;0 );if (err)return err;0 ;0 ;0 ;0 ;0 ;0 ;0 ;if (err)goto ex_abort;if (err)goto ex_put_mtt;if (err)goto ex_put_mtt;if (scqn != rcqn) {if (err)goto ex_put_rcq;else if (use_srq) {if (err)goto ex_put_scq;if (err)goto ex_put_srq;if (scqn != rcqn)if (use_srq) {/* Save param3 for dynamic changes from VST back to VGT */ return 0 ;if (use_srq)if (scqn != rcqn)return err;static int eq_get_mtt_addr(struct mlx4_eq_context *eqc)return be32_to_cpu(eqc->mtt_base_addr_l) & 0 xfffffff8;static int eq_get_mtt_size(struct mlx4_eq_context *eqc)int log_eq_size = eqc->log_eq_size & 0 x1f;int page_shift = (eqc->log_page_size & 0 x3f) + 12 ;if (log_eq_size + 5 < page_shift)return 1 ;return 1 << (log_eq_size + 5 - page_shift);static int cq_get_mtt_addr(struct mlx4_cq_context *cqc)return be32_to_cpu(cqc->mtt_base_addr_l) & 0 xfffffff8;static int cq_get_mtt_size(struct mlx4_cq_context *cqc)int log_cq_size = (be32_to_cpu(cqc->logsize_usrpage) >> 24 ) & 0 x1f;int page_shift = (cqc->log_page_size & 0 x3f) + 12 ;if (log_cq_size + 5 < page_shift)return 1 ;return 1 << (log_cq_size + 5 - page_shift);int mlx4_SW2HW_EQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int eqn = vhcr->in_modifier;int res_id = (slave << 10 ) | eqn;struct mlx4_eq_context *eqc = inbox->buf;int mtt_base = eq_get_mtt_addr(eqc) / dev->caps.mtt_entry_sz;int mtt_size = eq_get_mtt_size(eqc);struct res_eq *eq;struct res_mtt *mtt;1 , RES_EQ, 0 );if (err)return err;if (err)goto out_add;if (err)goto out_move;if (err)goto out_put;if (err)goto out_put;return 0 ;1 , RES_EQ, 0 );return err;int mlx4_CONFIG_DEV_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;if (get != 1 )return -EPERM;return err;static int get_containing_mtt(struct mlx4_dev *dev, int slave, int start,int len, struct res_mtt **res)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_resource_tracker *tracker = &priv->mfunc.master.res_tracker;struct res_mtt *mtt;int err = -EINVAL;if (!check_mtt_range(dev, slave, start, len, mtt)) {0 ;break ;return err;static int verify_qp_parameters(struct mlx4_dev *dev,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,enum qp_transition transition, u8 slave)struct mlx4_qp_context *qp_ctx;enum mlx4_qp_optpar optpar;int port;int num_gids;8 ;16 ) & 0 xff;if (slave != mlx4_master_func_num(dev)) {/* setting QP rate-limit is disallowed for VFs */ if (qp_ctx->rate_limit_params)return -EPERM;switch (qp_type) {case MLX4_QP_ST_RC:case MLX4_QP_ST_XRC:case MLX4_QP_ST_UC:switch (transition) {case QP_TRANS_INIT2RTR:case QP_TRANS_RTR2RTS:case QP_TRANS_RTS2RTS:case QP_TRANS_SQD2SQD:case QP_TRANS_SQD2RTS:if (slave != mlx4_master_func_num(dev)) {if (optpar & MLX4_QP_OPTPAR_PRIMARY_ADDR_PATH) {6 & 1 ) + 1 ;if (dev->caps.port_mask[port] != MLX4_PORT_TYPE_IB)else 1 ;if (qp_ctx->pri_path.mgid_index >= num_gids)return -EINVAL;if (optpar & MLX4_QP_OPTPAR_ALT_ADDR_PATH) {6 & 1 ) + 1 ;if (dev->caps.port_mask[port] != MLX4_PORT_TYPE_IB)else 1 ;if (qp_ctx->alt_path.mgid_index >= num_gids)return -EINVAL;break ;default :break ;break ;case MLX4_QP_ST_MLX:0 x7fffff;6 & 1 ) + 1 ;if (transition == QP_TRANS_INIT2RTR &&/* only enabled VFs may create MLX proxy QPs */ "%s: unprivileged slave %d attempting to create an MLX proxy special QP on port %d\n" ,return -EPERM;break ;default :break ;return 0 ;int mlx4_WRITE_MTT_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)struct mlx4_mtt mtt;int i;struct res_mtt *rmtt = NULL;int start = be64_to_cpu(page_list[0 ]);int npages = vhcr->in_modifier;int err;if (err)return err;/* Call the SW implementation of write_mtt: * - Prepare a dummy mtt struct 0 ; /* TBD this is broken but I don't handle it since 0 ;0 ;for (i = 0 ; i < npages; ++i)2 ] = (be64_to_cpu(page_list[i + 2 ]) & ~1 ULL);0 ]), npages,2 ));if (rmtt)return err;int mlx4_HW2SW_EQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int eqn = vhcr->in_modifier;int res_id = eqn | (slave << 10 );struct res_eq *eq;int err;if (err)return err;if (err)goto ex_abort;if (err)goto ex_put;1 , RES_EQ, 0 );return 0 ;return err;int mlx4_GEN_EQE(struct mlx4_dev *dev, int slave, struct mlx4_eqe *eqe)struct mlx4_priv *priv = mlx4_priv(dev);struct mlx4_slave_event_eq_info *event_eq;struct mlx4_cmd_mailbox *mailbox;0 ;int err;int res_id;struct res_eq *req;if (!priv->mfunc.master.slave_state)return -EINVAL;/* check for slave valid, slave not PF, and slave active */ if (slave < 0 || slave > dev->persist->num_vfs ||return 0 ;/* Create the event only if the slave is registered */ if (event_eq->eqn < 0 )return 0 ;10 ) | event_eq->eqn;if (err)goto unlock;if (req->com.from_state != RES_EQ_HW) {goto put;if (IS_ERR(mailbox)) {goto put;if (eqe->type == MLX4_EVENT_TYPE_CMD) {28 );0 xff) | ((event_eq->eqn & 0 x3ff) << 16 );0 ,return err;return err;int mlx4_QUERY_EQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int eqn = vhcr->in_modifier;int res_id = eqn | (slave << 10 );struct res_eq *eq;int err;if (err)return err;if (eq->com.from_state != RES_EQ_HW) {goto ex_put;return err;int mlx4_SW2HW_CQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int cqn = vhcr->in_modifier;struct mlx4_cq_context *cqc = inbox->buf;int mtt_base = cq_get_mtt_addr(cqc) / dev->caps.mtt_entry_sz;struct res_cq *cq = NULL;struct res_mtt *mtt;if (err)return err;if (err)goto out_move;if (err)goto out_put;if (err)goto out_put;return 0 ;return err;int mlx4_HW2SW_CQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int cqn = vhcr->in_modifier;struct res_cq *cq = NULL;if (err)return err;if (err)goto out_move;return 0 ;return err;int mlx4_QUERY_CQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int cqn = vhcr->in_modifier;struct res_cq *cq;int err;if (err)return err;if (cq->com.from_state != RES_CQ_HW)goto ex_put;return err;static int handle_resize(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd,struct res_cq *cq)int err;struct res_mtt *orig_mtt;struct res_mtt *mtt;struct mlx4_cq_context *cqc = inbox->buf;int mtt_base = cq_get_mtt_addr(cqc) / dev->caps.mtt_entry_sz;if (err)return err;if (orig_mtt != cq->mtt) {goto ex_put;if (err)goto ex_put;if (err)goto ex_put1;if (err)goto ex_put1;return 0 ;return err;int mlx4_MODIFY_CQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int cqn = vhcr->in_modifier;struct res_cq *cq;int err;if (err)return err;if (cq->com.from_state != RES_CQ_HW)goto ex_put;if (vhcr->op_modifier == 0 ) {goto ex_put;return err;static int srq_get_mtt_size(struct mlx4_srq_context *srqc)int log_srq_size = (be32_to_cpu(srqc->state_logsize_srqn) >> 24 ) & 0 xf;int log_rq_stride = srqc->logstride & 7 ;int page_shift = (srqc->log_page_size & 0 x3f) + 12 ;if (log_srq_size + log_rq_stride + 4 < page_shift)return 1 ;return 1 << (log_srq_size + log_rq_stride + 4 - page_shift);int mlx4_SW2HW_SRQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int srqn = vhcr->in_modifier;struct res_mtt *mtt;struct res_srq *srq = NULL;struct mlx4_srq_context *srqc = inbox->buf;int mtt_base = srq_get_mtt_addr(srqc) / dev->caps.mtt_entry_sz;if (srqn != (be32_to_cpu(srqc->state_logsize_srqn) & 0 xffffff))return -EINVAL;if (err)return err;if (err)goto ex_abort;if (err)goto ex_put_mtt;if (err)goto ex_put_mtt;return 0 ;return err;int mlx4_HW2SW_SRQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int srqn = vhcr->in_modifier;struct res_srq *srq = NULL;if (err)return err;if (err)goto ex_abort;if (srq->cq)return 0 ;return err;int mlx4_QUERY_SRQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int srqn = vhcr->in_modifier;struct res_srq *srq;if (err)return err;if (srq->com.from_state != RES_SRQ_HW) {goto out;return err;int mlx4_ARM_SRQ_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int srqn = vhcr->in_modifier;struct res_srq *srq;if (err)return err;if (srq->com.from_state != RES_SRQ_HW) {goto out;return err;int mlx4_GEN_QP_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;int qpn = vhcr->in_modifier & 0 x7fffff;struct res_qp *qp;if (err)return err;if (qp->com.from_state != RES_QP_HW) {goto out;return err;int mlx4_INIT2INIT_QP_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)struct mlx4_qp_context *context = inbox->buf + 8 ;return mlx4_GEN_QP_wrapper(dev, slave, vhcr, inbox, outbox, cmd);static int adjust_qp_sched_queue(struct mlx4_dev *dev, int slave,struct mlx4_qp_context *qpc,struct mlx4_cmd_mailbox *inbox)enum mlx4_qp_optpar optpar = be32_to_cpu(*(__be32 *)inbox->buf);int port = mlx4_slave_convert_port(6 & 1 ) + 1 ) - 1 ;if (port < 0 )return -EINVAL;1 << 6 )) |1 ) << 6 );if (optpar & (MLX4_QP_OPTPAR_PRIMARY_ADDR_PATH | MLX4_QP_OPTPAR_SCHED_QUEUE) ||1 )) {if (optpar & MLX4_QP_OPTPAR_ALT_ADDR_PATH) {6 & 1 )1 ) - 1 ;if (port < 0 )return -EINVAL;1 << 6 )) |1 ) << 6 ;return 0 ;static int roce_verify_mac(struct mlx4_dev *dev, int slave,struct mlx4_qp_context *qpc,struct mlx4_cmd_mailbox *inbox)int port;16 ) & 0 xff;64 );6 & 1 ) + 1 ;if (mlx4_is_eth(dev, port) && (ts != MLX4_QP_ST_MLX)) {0 x7f;if (mac_find_smac_ix_in_slave(dev, slave, port, smac_ix, &mac))return -ENOENT;return 0 ;int mlx4_INIT2RTR_QP_wrapper(struct mlx4_dev *dev, int slave,struct mlx4_vhcr *vhcr,struct mlx4_cmd_mailbox *inbox,struct mlx4_cmd_mailbox *outbox,struct mlx4_cmd_info *cmd)int err;struct mlx4_qp_context *qpc = inbox->buf + 8 ;int qpn = vhcr->in_modifier & 0 x7fffff;struct res_qp *qp;if (err)return err;if (err)return err;if (roce_verify_mac(dev, slave, qpc, inbox))return -EINVAL;if (err)return err;if (qp->com.from_state != RES_QP_HW) {goto out;if (err)goto out;/* if no error, save sched queue value passed in by VF. This is * essentially the QOS value provided by the VF . This will be useful * if we allow dynamic changes from VST back to VGT * / if ( ! err ) { qp - > sched_queue = orig_sched_queue ; qp - > vlan_control = orig_vlan_control ; qp - > fvl_rx = orig_fvl_rx ; qp - > pri_path_fl = orig_pri_path_fl ; qp - > vlan_index = orig_vlan_index ; qp - > feup = orig_feup ; } put_res ( dev , slave , qpn , RES_QP ) ; return err ; } int mlx4_RTR2RTS_QP_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { int err ; struct mlx4_qp_context * context = inbox - > buf + 8 ; err = adjust_qp_sched_queue ( dev , slave , context , inbox ) ; if ( err ) return err ; err = verify_qp_parameters ( dev , vhcr , inbox , QP_TRANS_RTR2RTS , slave ) ; if ( err ) return err ; update_pkey_index ( dev , slave , inbox ) ; update_gid ( dev , inbox , ( u8 ) slave ) ; adjust_proxy_tun_qkey ( dev , vhcr , context ) ; return mlx4_GEN_QP_wrapper ( dev , slave , vhcr , inbox , outbox , cmd ) ; } int mlx4_RTS2RTS_QP_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { int err ; struct mlx4_qp_context * context = inbox - > buf + 8 ; err = adjust_qp_sched_queue ( dev , slave , context , inbox ) ; if ( err ) return err ; err = verify_qp_parameters ( dev , vhcr , inbox , QP_TRANS_RTS2RTS , slave ) ; if ( err ) return err ; update_pkey_index ( dev , slave , inbox ) ; update_gid ( dev , inbox , ( u8 ) slave ) ; adjust_proxy_tun_qkey ( dev , vhcr , context ) ; return mlx4_GEN_QP_wrapper ( dev , slave , vhcr , inbox , outbox , cmd ) ; } int mlx4_SQERR2RTS_QP_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { struct mlx4_qp_context * context = inbox - > buf + 8 ; int err = adjust_qp_sched_queue ( dev , slave , context , inbox ) ; if ( err ) return err ; adjust_proxy_tun_qkey ( dev , vhcr , context ) ; return mlx4_GEN_QP_wrapper ( dev , slave , vhcr , inbox , outbox , cmd ) ; } int mlx4_SQD2SQD_QP_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { int err ; struct mlx4_qp_context * context = inbox - > buf + 8 ; err = adjust_qp_sched_queue ( dev , slave , context , inbox ) ; if ( err ) return err ; err = verify_qp_parameters ( dev , vhcr , inbox , QP_TRANS_SQD2SQD , slave ) ; if ( err ) return err ; adjust_proxy_tun_qkey ( dev , vhcr , context ) ; update_gid ( dev , inbox , ( u8 ) slave ) ; update_pkey_index ( dev , slave , inbox ) ; return mlx4_GEN_QP_wrapper ( dev , slave , vhcr , inbox , outbox , cmd ) ; } int mlx4_SQD2RTS_QP_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { int err ; struct mlx4_qp_context * context = inbox - > buf + 8 ; err = adjust_qp_sched_queue ( dev , slave , context , inbox ) ; if ( err ) return err ; err = verify_qp_parameters ( dev , vhcr , inbox , QP_TRANS_SQD2RTS , slave ) ; if ( err ) return err ; adjust_proxy_tun_qkey ( dev , vhcr , context ) ; update_gid ( dev , inbox , ( u8 ) slave ) ; update_pkey_index ( dev , slave , inbox ) ; return mlx4_GEN_QP_wrapper ( dev , slave , vhcr , inbox , outbox , cmd ) ; } int mlx4_2RST_QP_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { int err ; int qpn = vhcr - > in_modifier & 0 x7fffff ; struct res_qp * qp ; err = qp_res_start_move_to ( dev , slave , qpn , RES_QP_MAPPED , & qp , 0 ) ; if ( err ) return err ; err = mlx4_DMA_wrapper ( dev , slave , vhcr , inbox , outbox , cmd ) ; if ( err ) goto ex_abort ; atomic_dec ( & qp - > mtt - > ref_count ) ; atomic_dec ( & qp - > rcq - > ref_count ) ; atomic_dec ( & qp - > scq - > ref_count ) ; if ( qp - > srq ) atomic_dec ( & qp - > srq - > ref_count ) ; res_end_move ( dev , slave , RES_QP , qpn ) ; return 0 ; ex_abort : res_abort_move ( dev , slave , RES_QP , qpn ) ; return err ; } static struct res_gid * find_gid ( struct mlx4_dev * dev , int slave , struct res_qp * rqp , u8 * gid ) { struct res_gid * res ; list_for_each_entry ( res , & rqp - > mcg_list , list ) { if ( ! memcmp ( res - > gid , gid , 16 ) ) return res ; } return NULL ; } static int add_mcg_res ( struct mlx4_dev * dev , int slave , struct res_qp * rqp , u8 * gid , enum mlx4_protocol prot , enum mlx4_steer_type steer , u64 reg_id ) { struct res_gid * res ; int err ; res = kzalloc ( sizeof ( * res ) , GFP_KERNEL ) ; if ( ! res ) return - ENOMEM ; spin_lock_irq ( & rqp - > mcg_spl ) ; if ( find_gid ( dev , slave , rqp , gid ) ) { kfree ( res ) ; err = - EEXIST ; } else { memcpy ( res - > gid , gid , 16 ) ; res - > prot = prot ; res - > steer = steer ; res - > reg_id = reg_id ; list_add_tail ( & res - > list , & rqp - > mcg_list ) ; err = 0 ; } spin_unlock_irq ( & rqp - > mcg_spl ) ; return err ; } static int rem_mcg_res ( struct mlx4_dev * dev , int slave , struct res_qp * rqp , u8 * gid , enum mlx4_protocol prot , enum mlx4_steer_type steer , u64 * reg_id ) { struct res_gid * res ; int err ; spin_lock_irq ( & rqp - > mcg_spl ) ; res = find_gid ( dev , slave , rqp , gid ) ; if ( ! res | | res - > prot ! = prot | | res - > steer ! = steer ) err = - EINVAL ; else { * reg_id = res - > reg_id ; list_del ( & res - > list ) ; kfree ( res ) ; err = 0 ; } spin_unlock_irq ( & rqp - > mcg_spl ) ; return err ; } static int qp_attach ( struct mlx4_dev * dev , int slave , struct mlx4_qp * qp , u8 gid [ 16 ] , int block_loopback , enum mlx4_protocol prot , enum mlx4_steer_type type , u64 * reg_id ) { switch ( dev - > caps . steering_mode ) { case MLX4_STEERING_MODE_DEVICE_MANAGED : { int port = mlx4_slave_convert_port ( dev , slave , gid [ 5 ] ) ; if ( port < 0 ) return port ; return mlx4_trans_to_dmfs_attach ( dev , qp , gid , port , block_loopback , prot , reg_id ) ; } case MLX4_STEERING_MODE_B0 : if ( prot = = MLX4_PROT_ETH ) { int port = mlx4_slave_convert_port ( dev , slave , gid [ 5 ] ) ; if ( port < 0 ) return port ; gid [ 5 ] = port ; } return mlx4_qp_attach_common ( dev , qp , gid , block_loopback , prot , type ) ; default : return - EINVAL ; } } static int qp_detach ( struct mlx4_dev * dev , struct mlx4_qp * qp , u8 gid [ 16 ] , enum mlx4_protocol prot , enum mlx4_steer_type type , u64 reg_id ) { switch ( dev - > caps . steering_mode ) { case MLX4_STEERING_MODE_DEVICE_MANAGED : return mlx4_flow_detach ( dev , reg_id ) ; case MLX4_STEERING_MODE_B0 : return mlx4_qp_detach_common ( dev , qp , gid , prot , type ) ; default : return - EINVAL ; } } static int mlx4_adjust_port ( struct mlx4_dev * dev , int slave , u8 * gid , enum mlx4_protocol prot ) { int real_port ; if ( prot ! = MLX4_PROT_ETH ) return 0 ; if ( dev - > caps . steering_mode = = MLX4_STEERING_MODE_B0 | | dev - > caps . steering_mode = = MLX4_STEERING_MODE_DEVICE_MANAGED ) { real_port = mlx4_slave_convert_port ( dev , slave , gid [ 5 ] ) ; if ( real_port < 0 ) return - EINVAL ; gid [ 5 ] = real_port ; } return 0 ; } int mlx4_QP_ATTACH_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { struct mlx4_qp qp ; / * dummy for calling attach / detach * / u8 * gid = inbox - > buf ; enum mlx4_protocol prot = ( vhcr - > in_modifier > > 28 ) & 0 x7 ; int err ; int qpn ; struct res_qp * rqp ; u64 reg_id = 0 ; int attach = vhcr - > op_modifier ; int block_loopback = vhcr - > in_modifier > > 31 ; u8 steer_type_mask = 2 ; enum mlx4_steer_type type = ( gid [ 7 ] & steer_type_mask ) > > 1 ; qpn = vhcr - > in_modifier & 0 xffffff ; err = get_res ( dev , slave , qpn , RES_QP , & rqp ) ; if ( err ) return err ; qp . qpn = qpn ; if ( attach ) { err = qp_attach ( dev , slave , & qp , gid , block_loopback , prot , type , & reg_id ) ; if ( err ) { pr_err ( " Fail to attach rule to qp 0 x % x \ n " , qpn ) ; goto ex_put ; } err = add_mcg_res ( dev , slave , rqp , gid , prot , type , reg_id ) ; if ( err ) goto ex_detach ; } else { err = mlx4_adjust_port ( dev , slave , gid , prot ) ; if ( err ) goto ex_put ; err = rem_mcg_res ( dev , slave , rqp , gid , prot , type , & reg_id ) ; if ( err ) goto ex_put ; err = qp_detach ( dev , & qp , gid , prot , type , reg_id ) ; if ( err ) pr_err ( " Fail to detach rule from qp 0 x % x reg_id = 0 x % llx \ n " , qpn , reg_id ) ; } put_res ( dev , slave , qpn , RES_QP ) ; return err ; ex_detach : qp_detach ( dev , & qp , gid , prot , type , reg_id ) ; ex_put : put_res ( dev , slave , qpn , RES_QP ) ; return err ; } / * * MAC validation for Flow Steering rules . * VF can attach rules only with a mac address which is assigned to it . * / static int validate_eth_header_mac ( int slave , struct _ rule_hw * eth_header , struct list_head * rlist ) { struct mac_res * res , * tmp ; _ _ be64 be_mac ; / * make sure it isn ' t multicast or broadcast mac * / if ( ! is_multicast_ether_addr ( eth_header - > eth . dst_mac ) & & ! is_broadcast_ether_addr ( eth_header - > eth . dst_mac ) ) { list_for_each_entry_safe ( res , tmp , rlist , list ) { be_mac = cpu_to_be64 ( res - > mac < < 16 ) ; if ( ether_addr_equal ( ( u8 * ) & be_mac , eth_header - > eth . dst_mac ) ) return 0 ; } pr_err ( " MAC % pM doesn ' t belong to VF % d , Steering rule rejected \ n " , eth_header - > eth . dst_mac , slave ) ; return - EINVAL ; } return 0 ; } / * * In case of missing eth header , append eth header with a MAC address * assigned to the VF . * / static int add_eth_header ( struct mlx4_dev * dev , int slave , struct mlx4_cmd_mailbox * inbox , struct list_head * rlist , int header_id ) { struct mac_res * res , * tmp ; u8 port ; struct mlx4_net_trans_rule_hw_ctrl * ctrl ; struct mlx4_net_trans_rule_hw_eth * eth_header ; struct mlx4_net_trans_rule_hw_ipv4 * ip_header ; struct mlx4_net_trans_rule_hw_tcp_udp * l4_header ; _ _ be64 be_mac = 0 ; _ _ be64 mac_msk = cpu_to_be64 ( MLX4_MAC_MASK < < 16 ) ; ctrl = ( struct mlx4_net_trans_rule_hw_ctrl * ) inbox - > buf ; port = ctrl - > port ; eth_header = ( struct mlx4_net_trans_rule_hw_eth * ) ( ctrl + 1 ) ; / * Clear a space in the inbox for eth header * / switch ( header_id ) { case MLX4_NET_TRANS_RULE_ID_IPV4 : ip_header = ( struct mlx4_net_trans_rule_hw_ipv4 * ) ( eth_header + 1 ) ; memmove ( ip_header , eth_header , sizeof ( * ip_header ) + sizeof ( * l4_header ) ) ; break ; case MLX4_NET_TRANS_RULE_ID_TCP : case MLX4_NET_TRANS_RULE_ID_UDP : l4_header = ( struct mlx4_net_trans_rule_hw_tcp_udp * ) ( eth_header + 1 ) ; memmove ( l4_header , eth_header , sizeof ( * l4_header ) ) ; break ; default : return - EINVAL ; } list_for_each_entry_safe ( res , tmp , rlist , list ) { if ( port = = res - > port ) { be_mac = cpu_to_be64 ( res - > mac < < 16 ) ; break ; } } if ( ! be_mac ) { pr_err ( " Failed adding eth header to FS rule , Can ' t find matching MAC for port % d \ n " , port ) ; return - EINVAL ; } memset ( eth_header , 0 , sizeof ( * eth_header ) ) ; eth_header - > size = sizeof ( * eth_header ) > > 2 ; eth_header - > id = cpu_to_be16 ( _ _ sw_id_hw [ MLX4_NET_TRANS_RULE_ID_ETH ] ) ; memcpy ( eth_header - > dst_mac , & be_mac , ETH_ALEN ) ; memcpy ( eth_header - > dst_mac_msk , & mac_msk , ETH_ALEN ) ; return 0 ; } # define MLX4_UPD_QP_PATH_MASK_SUPPORTED ( \ 1 ULL < < MLX4_UPD_QP_PATH_MASK_MAC_INDEX | \ 1 ULL < < MLX4_UPD_QP_PATH_MASK_ETH_SRC_CHECK_MC_LB ) int mlx4_UPDATE_QP_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd_info ) { int err ; u32 qpn = vhcr - > in_modifier & 0 xffffff ; struct res_qp * rqp ; u64 mac ; unsigned port ; u64 pri_addr_path_mask ; struct mlx4_update_qp_context * cmd ; int smac_index ; cmd = ( struct mlx4_update_qp_context * ) inbox - > buf ; pri_addr_path_mask = be64_to_cpu ( cmd - > primary_addr_path_mask ) ; if ( cmd - > qp_mask | | cmd - > secondary_addr_path_mask | | ( pri_addr_path_mask & ~ MLX4_UPD_QP_PATH_MASK_SUPPORTED ) ) return - EPERM ; if ( ( pri_addr_path_mask & ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_ETH_SRC_CHECK_MC_LB ) ) & & ! ( dev - > caps . flags2 & MLX4_DEV_CAP_FLAG2_UPDATE_QP_SRC_CHECK_LB ) ) { mlx4_warn ( dev , " Src check LB for slave % d isn ' t supported \ n " , slave ) ; return - EOPNOTSUPP ; } / * Just change the smac for the QP * / err = get_res ( dev , slave , qpn , RES_QP , & rqp ) ; if ( err ) { mlx4_err ( dev , " Updating qpn 0 x % x for slave % d rejected \ n " , qpn , slave ) ; return err ; } port = ( rqp - > sched_queue > > 6 & 1 ) + 1 ; if ( pri_addr_path_mask & ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_MAC_INDEX ) ) { smac_index = cmd - > qp_context . pri_path . grh_mylmc ; err = mac_find_smac_ix_in_slave ( dev , slave , port , smac_index , & mac ) ; if ( err ) { mlx4_err ( dev , " Failed to update qpn 0 x % x , MAC is invalid . smac_ix : % d \ n " , qpn , smac_index ) ; goto err_mac ; } } err = mlx4_cmd ( dev , inbox - > dma , vhcr - > in_modifier , 0 , MLX4_CMD_UPDATE_QP , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; if ( err ) { mlx4_err ( dev , " Failed to update qpn on qpn 0 x % x , command failed \ n " , qpn ) ; goto err_mac ; } err_mac : put_res ( dev , slave , qpn , RES_QP ) ; return err ; } static u32 qp_attach_mbox_size ( void * mbox ) { u32 size = sizeof ( struct mlx4_net_trans_rule_hw_ctrl ) ; struct _ rule_hw * rule_header ; rule_header = ( struct _ rule_hw * ) ( mbox + size ) ; while ( rule_header - > size ) { size + = rule_header - > size * sizeof ( u32 ) ; rule_header + = 1 ; } return size ; } static int mlx4_do_mirror_rule ( struct mlx4_dev * dev , struct res_fs_rule * fs_rule ) ; int mlx4_QP_FLOW_STEERING_ATTACH_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * rlist = & tracker - > slave_list [ slave ] . res_list [ RES_MAC ] ; int err ; int qpn ; struct res_qp * rqp ; struct mlx4_net_trans_rule_hw_ctrl * ctrl ; struct _ rule_hw * rule_header ; int header_id ; struct res_fs_rule * rrule ; u32 mbox_size ; if ( dev - > caps . steering_mode ! = MLX4_STEERING_MODE_DEVICE_MANAGED ) return - EOPNOTSUPP ; ctrl = ( struct mlx4_net_trans_rule_hw_ctrl * ) inbox - > buf ; err = mlx4_slave_convert_port ( dev , slave , ctrl - > port ) ; if ( err < = 0 ) return - EINVAL ; ctrl - > port = err ; qpn = be32_to_cpu ( ctrl - > qpn ) & 0 xffffff ; err = get_res ( dev , slave , qpn , RES_QP , & rqp ) ; if ( err ) { pr_err ( " Steering rule with qpn 0 x % x rejected \ n " , qpn ) ; return err ; } rule_header = ( struct _ rule_hw * ) ( ctrl + 1 ) ; header_id = map_hw_to_sw_id ( be16_to_cpu ( rule_header - > id ) ) ; if ( header_id = = MLX4_NET_TRANS_RULE_ID_ETH ) mlx4_handle_eth_header_mcast_prio ( ctrl , rule_header ) ; switch ( header_id ) { case MLX4_NET_TRANS_RULE_ID_ETH : if ( validate_eth_header_mac ( slave , rule_header , rlist ) ) { err = - EINVAL ; goto err_put_qp ; } break ; case MLX4_NET_TRANS_RULE_ID_IB : break ; case MLX4_NET_TRANS_RULE_ID_IPV4 : case MLX4_NET_TRANS_RULE_ID_TCP : case MLX4_NET_TRANS_RULE_ID_UDP : pr_warn ( " Can ' t attach FS rule without L2 headers , adding L2 header \ n " ) ; if ( add_eth_header ( dev , slave , inbox , rlist , header_id ) ) { err = - EINVAL ; goto err_put_qp ; } vhcr - > in_modifier + = sizeof ( struct mlx4_net_trans_rule_hw_eth ) > > 2 ; break ; default : pr_err ( " Corrupted mailbox \ n " ) ; err = - EINVAL ; goto err_put_qp ; } err = mlx4_cmd_imm ( dev , inbox - > dma , & vhcr - > out_param , vhcr - > in_modifier , 0 , MLX4_QP_FLOW_STEERING_ATTACH , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; if ( err ) goto err_put_qp ; err = add_res_range ( dev , slave , vhcr - > out_param , 1 , RES_FS_RULE , qpn ) ; if ( err ) { mlx4_err ( dev , " Fail to add flow steering resources \ n " ) ; goto err_detach ; } err = get_res ( dev , slave , vhcr - > out_param , RES_FS_RULE , & rrule ) ; if ( err ) goto err_detach ; mbox_size = qp_attach_mbox_size ( inbox - > buf ) ; rrule - > mirr_mbox = kmalloc ( mbox_size , GFP_KERNEL ) ; if ( ! rrule - > mirr_mbox ) { err = - ENOMEM ; goto err_put_rule ; } rrule - > mirr_mbox_size = mbox_size ; rrule - > mirr_rule_id = 0 ; memcpy ( rrule - > mirr_mbox , inbox - > buf , mbox_size ) ; / * set different port * / ctrl = ( struct mlx4_net_trans_rule_hw_ctrl * ) rrule - > mirr_mbox ; if ( ctrl - > port = = 1 ) ctrl - > port = 2 ; else ctrl - > port = 1 ; if ( mlx4_is_bonded ( dev ) ) mlx4_do_mirror_rule ( dev , rrule ) ; atomic_inc ( & rqp - > ref_count ) ; err_put_rule : put_res ( dev , slave , vhcr - > out_param , RES_FS_RULE ) ; err_detach : / * detach rule on error * / if ( err ) mlx4_cmd ( dev , vhcr - > out_param , 0 , 0 , MLX4_QP_FLOW_STEERING_DETACH , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; err_put_qp : put_res ( dev , slave , qpn , RES_QP ) ; return err ; } static int mlx4_undo_mirror_rule ( struct mlx4_dev * dev , struct res_fs_rule * fs_rule ) { int err ; err = rem_res_range ( dev , fs_rule - > com . owner , fs_rule - > com . res_id , 1 , RES_FS_RULE , 0 ) ; if ( err ) { mlx4_err ( dev , " Fail to remove flow steering resources \ n " ) ; return err ; } mlx4_cmd ( dev , fs_rule - > com . res_id , 0 , 0 , MLX4_QP_FLOW_STEERING_DETACH , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; return 0 ; } int mlx4_QP_FLOW_STEERING_DETACH_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { int err ; struct res_qp * rqp ; struct res_fs_rule * rrule ; u64 mirr_reg_id ; int qpn ; if ( dev - > caps . steering_mode ! = MLX4_STEERING_MODE_DEVICE_MANAGED ) return - EOPNOTSUPP ; err = get_res ( dev , slave , vhcr - > in_param , RES_FS_RULE , & rrule ) ; if ( err ) return err ; if ( ! rrule - > mirr_mbox ) { mlx4_err ( dev , " Mirror rules cannot be removed explicitly \ n " ) ; put_res ( dev , slave , vhcr - > in_param , RES_FS_RULE ) ; return - EINVAL ; } mirr_reg_id = rrule - > mirr_rule_id ; kfree ( rrule - > mirr_mbox ) ; qpn = rrule - > qpn ; / * Release the rule form busy state before removal * / put_res ( dev , slave , vhcr - > in_param , RES_FS_RULE ) ; err = get_res ( dev , slave , qpn , RES_QP , & rqp ) ; if ( err ) return err ; if ( mirr_reg_id & & mlx4_is_bonded ( dev ) ) { err = get_res ( dev , slave , mirr_reg_id , RES_FS_RULE , & rrule ) ; if ( err ) { mlx4_err ( dev , " Fail to get resource of mirror rule \ n " ) ; } else { put_res ( dev , slave , mirr_reg_id , RES_FS_RULE ) ; mlx4_undo_mirror_rule ( dev , rrule ) ; } } err = rem_res_range ( dev , slave , vhcr - > in_param , 1 , RES_FS_RULE , 0 ) ; if ( err ) { mlx4_err ( dev , " Fail to remove flow steering resources \ n " ) ; goto out ; } err = mlx4_cmd ( dev , vhcr - > in_param , 0 , 0 , MLX4_QP_FLOW_STEERING_DETACH , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; if ( ! err ) atomic_dec ( & rqp - > ref_count ) ; out : put_res ( dev , slave , qpn , RES_QP ) ; return err ; } enum { BUSY_MAX_RETRIES = 10 } ; int mlx4_QUERY_IF_STAT_wrapper ( struct mlx4_dev * dev , int slave , struct mlx4_vhcr * vhcr , struct mlx4_cmd_mailbox * inbox , struct mlx4_cmd_mailbox * outbox , struct mlx4_cmd_info * cmd ) { int err ; int index = vhcr - > in_modifier & 0 xffff ; err = get_res ( dev , slave , index , RES_COUNTER , NULL ) ; if ( err ) return err ; err = mlx4_DMA_wrapper ( dev , slave , vhcr , inbox , outbox , cmd ) ; put_res ( dev , slave , index , RES_COUNTER ) ; return err ; } static void detach_qp ( struct mlx4_dev * dev , int slave , struct res_qp * rqp ) { struct res_gid * rgid ; struct res_gid * tmp ; struct mlx4_qp qp ; / * dummy for calling attach / detach * / list_for_each_entry_safe ( rgid , tmp , & rqp - > mcg_list , list ) { switch ( dev - > caps . steering_mode ) { case MLX4_STEERING_MODE_DEVICE_MANAGED : mlx4_flow_detach ( dev , rgid - > reg_id ) ; break ; case MLX4_STEERING_MODE_B0 : qp . qpn = rqp - > local_qpn ; ( void ) mlx4_qp_detach_common ( dev , & qp , rgid - > gid , rgid - > prot , rgid - > steer ) ; break ; } list_del ( & rgid - > list ) ; kfree ( rgid ) ; } } static int _ move_all_busy ( struct mlx4_dev * dev , int slave , enum mlx4_resource type , int print ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * rlist = & tracker - > slave_list [ slave ] . res_list [ type ] ; struct res_common * r ; struct res_common * tmp ; int busy ; busy = 0 ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( r , tmp , rlist , list ) { if ( r - > owner = = slave ) { if ( ! r - > removing ) { if ( r - > state = = RES_ANY_BUSY ) { if ( print ) mlx4_dbg ( dev , " % s id 0 x % llx is busy \ n " , resource_str ( type ) , r - > res_id ) ; + + busy ; } else { r - > from_state = r - > state ; r - > state = RES_ANY_BUSY ; r - > removing = 1 ; } } } } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; return busy ; } static int move_all_busy ( struct mlx4_dev * dev , int slave , enum mlx4_resource type ) { unsigned long begin ; int busy ; begin = jiffies ; do { busy = _ move_all_busy ( dev , slave , type , 0 ) ; if ( time_after ( jiffies , begin + 5 * HZ ) ) break ; if ( busy ) cond_resched ( ) ; } while ( busy ) ; if ( busy ) busy = _ move_all_busy ( dev , slave , type , 1 ) ; return busy ; } static void rem_slave_qps ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * qp_list = & tracker - > slave_list [ slave ] . res_list [ RES_QP ] ; struct res_qp * qp ; struct res_qp * tmp ; int state ; u64 in_param ; int qpn ; int err ; err = move_all_busy ( dev , slave , RES_QP ) ; if ( err ) mlx4_warn ( dev , " rem_slave_qps : Could not move all qps to busy for slave % d \ n " , slave ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( qp , tmp , qp_list , com . list ) { spin_unlock_irq ( mlx4_tlock ( dev ) ) ; if ( qp - > com . owner = = slave ) { qpn = qp - > com . res_id ; detach_qp ( dev , slave , qp ) ; state = qp - > com . from_state ; while ( state ! = 0 ) { switch ( state ) { case RES_QP_RESERVED : spin_lock_irq ( mlx4_tlock ( dev ) ) ; rb_erase ( & qp - > com . node , & tracker - > res_tree [ RES_QP ] ) ; list_del ( & qp - > com . list ) ; spin_unlock_irq ( mlx4_tlock ( dev ) ) ; if ( ! valid_reserved ( dev , slave , qpn ) ) { _ _ mlx4_qp_release_range ( dev , qpn , 1 ) ; mlx4_release_resource ( dev , slave , RES_QP , 1 , 0 ) ; } kfree ( qp ) ; state = 0 ; break ; case RES_QP_MAPPED : if ( ! valid_reserved ( dev , slave , qpn ) ) _ _ mlx4_qp_free_icm ( dev , qpn ) ; state = RES_QP_RESERVED ; break ; case RES_QP_HW : in_param = slave ; err = mlx4_cmd ( dev , in_param , qp - > local_qpn , 2 , MLX4_CMD_2RST_QP , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; if ( err ) mlx4_dbg ( dev , " rem_slave_qps : failed to move slave % d qpn % d to reset \ n " , slave , qp - > local_qpn ) ; atomic_dec ( & qp - > rcq - > ref_count ) ; atomic_dec ( & qp - > scq - > ref_count ) ; atomic_dec ( & qp - > mtt - > ref_count ) ; if ( qp - > srq ) atomic_dec ( & qp - > srq - > ref_count ) ; state = RES_QP_MAPPED ; break ; default : state = 0 ; } } } spin_lock_irq ( mlx4_tlock ( dev ) ) ; } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; } static void rem_slave_srqs ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * srq_list = & tracker - > slave_list [ slave ] . res_list [ RES_SRQ ] ; struct res_srq * srq ; struct res_srq * tmp ; int state ; u64 in_param ; int srqn ; int err ; err = move_all_busy ( dev , slave , RES_SRQ ) ; if ( err ) mlx4_warn ( dev , " rem_slave_srqs : Could not move all srqs - too busy for slave % d \ n " , slave ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( srq , tmp , srq_list , com . list ) { spin_unlock_irq ( mlx4_tlock ( dev ) ) ; if ( srq - > com . owner = = slave ) { srqn = srq - > com . res_id ; state = srq - > com . from_state ; while ( state ! = 0 ) { switch ( state ) { case RES_SRQ_ALLOCATED : _ _ mlx4_srq_free_icm ( dev , srqn ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; rb_erase ( & srq - > com . node , & tracker - > res_tree [ RES_SRQ ] ) ; list_del ( & srq - > com . list ) ; spin_unlock_irq ( mlx4_tlock ( dev ) ) ; mlx4_release_resource ( dev , slave , RES_SRQ , 1 , 0 ) ; kfree ( srq ) ; state = 0 ; break ; case RES_SRQ_HW : in_param = slave ; err = mlx4_cmd ( dev , in_param , srqn , 1 , MLX4_CMD_HW2SW_SRQ , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; if ( err ) mlx4_dbg ( dev , " rem_slave_srqs : failed to move slave % d srq % d to SW ownership \ n " , slave , srqn ) ; atomic_dec ( & srq - > mtt - > ref_count ) ; if ( srq - > cq ) atomic_dec ( & srq - > cq - > ref_count ) ; state = RES_SRQ_ALLOCATED ; break ; default : state = 0 ; } } } spin_lock_irq ( mlx4_tlock ( dev ) ) ; } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; } static void rem_slave_cqs ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * cq_list = & tracker - > slave_list [ slave ] . res_list [ RES_CQ ] ; struct res_cq * cq ; struct res_cq * tmp ; int state ; u64 in_param ; int cqn ; int err ; err = move_all_busy ( dev , slave , RES_CQ ) ; if ( err ) mlx4_warn ( dev , " rem_slave_cqs : Could not move all cqs - too busy for slave % d \ n " , slave ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( cq , tmp , cq_list , com . list ) { spin_unlock_irq ( mlx4_tlock ( dev ) ) ; if ( cq - > com . owner = = slave & & ! atomic_read ( & cq - > ref_count ) ) { cqn = cq - > com . res_id ; state = cq - > com . from_state ; while ( state ! = 0 ) { switch ( state ) { case RES_CQ_ALLOCATED : _ _ mlx4_cq_free_icm ( dev , cqn ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; rb_erase ( & cq - > com . node , & tracker - > res_tree [ RES_CQ ] ) ; list_del ( & cq - > com . list ) ; spin_unlock_irq ( mlx4_tlock ( dev ) ) ; mlx4_release_resource ( dev , slave , RES_CQ , 1 , 0 ) ; kfree ( cq ) ; state = 0 ; break ; case RES_CQ_HW : in_param = slave ; err = mlx4_cmd ( dev , in_param , cqn , 1 , MLX4_CMD_HW2SW_CQ , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; if ( err ) mlx4_dbg ( dev , " rem_slave_cqs : failed to move slave % d cq % d to SW ownership \ n " , slave , cqn ) ; atomic_dec ( & cq - > mtt - > ref_count ) ; state = RES_CQ_ALLOCATED ; break ; default : state = 0 ; } } } spin_lock_irq ( mlx4_tlock ( dev ) ) ; } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; } static void rem_slave_mrs ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * mpt_list = & tracker - > slave_list [ slave ] . res_list [ RES_MPT ] ; struct res_mpt * mpt ; struct res_mpt * tmp ; int state ; u64 in_param ; int mptn ; int err ; err = move_all_busy ( dev , slave , RES_MPT ) ; if ( err ) mlx4_warn ( dev , " rem_slave_mrs : Could not move all mpts - too busy for slave % d \ n " , slave ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( mpt , tmp , mpt_list , com . list ) { spin_unlock_irq ( mlx4_tlock ( dev ) ) ; if ( mpt - > com . owner = = slave ) { mptn = mpt - > com . res_id ; state = mpt - > com . from_state ; while ( state ! = 0 ) { switch ( state ) { case RES_MPT_RESERVED : _ _ mlx4_mpt_release ( dev , mpt - > key ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; rb_erase ( & mpt - > com . node , & tracker - > res_tree [ RES_MPT ] ) ; list_del ( & mpt - > com . list ) ; spin_unlock_irq ( mlx4_tlock ( dev ) ) ; mlx4_release_resource ( dev , slave , RES_MPT , 1 , 0 ) ; kfree ( mpt ) ; state = 0 ; break ; case RES_MPT_MAPPED : _ _ mlx4_mpt_free_icm ( dev , mpt - > key ) ; state = RES_MPT_RESERVED ; break ; case RES_MPT_HW : in_param = slave ; err = mlx4_cmd ( dev , in_param , mptn , 0 , MLX4_CMD_HW2SW_MPT , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; if ( err ) mlx4_dbg ( dev , " rem_slave_mrs : failed to move slave % d mpt % d to SW ownership \ n " , slave , mptn ) ; if ( mpt - > mtt ) atomic_dec ( & mpt - > mtt - > ref_count ) ; state = RES_MPT_MAPPED ; break ; default : state = 0 ; } } } spin_lock_irq ( mlx4_tlock ( dev ) ) ; } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; } static void rem_slave_mtts ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * mtt_list = & tracker - > slave_list [ slave ] . res_list [ RES_MTT ] ; struct res_mtt * mtt ; struct res_mtt * tmp ; int state ; int base ; int err ; err = move_all_busy ( dev , slave , RES_MTT ) ; if ( err ) mlx4_warn ( dev , " rem_slave_mtts : Could not move all mtts - too busy for slave % d \ n " , slave ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( mtt , tmp , mtt_list , com . list ) { spin_unlock_irq ( mlx4_tlock ( dev ) ) ; if ( mtt - > com . owner = = slave ) { base = mtt - > com . res_id ; state = mtt - > com . from_state ; while ( state ! = 0 ) { switch ( state ) { case RES_MTT_ALLOCATED : _ _ mlx4_free_mtt_range ( dev , base , mtt - > order ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; rb_erase ( & mtt - > com . node , & tracker - > res_tree [ RES_MTT ] ) ; list_del ( & mtt - > com . list ) ; spin_unlock_irq ( mlx4_tlock ( dev ) ) ; mlx4_release_resource ( dev , slave , RES_MTT , 1 < < mtt - > order , 0 ) ; kfree ( mtt ) ; state = 0 ; break ; default : state = 0 ; } } } spin_lock_irq ( mlx4_tlock ( dev ) ) ; } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; } static int mlx4_do_mirror_rule ( struct mlx4_dev * dev , struct res_fs_rule * fs_rule ) { struct mlx4_cmd_mailbox * mailbox ; int err ; struct res_fs_rule * mirr_rule ; u64 reg_id ; mailbox = mlx4_alloc_cmd_mailbox ( dev ) ; if ( IS_ERR ( mailbox ) ) return PTR_ERR ( mailbox ) ; if ( ! fs_rule - > mirr_mbox ) { mlx4_err ( dev , " rule mirroring mailbox is null \ n " ) ; mlx4_free_cmd_mailbox ( dev , mailbox ) ; return - EINVAL ; } memcpy ( mailbox - > buf , fs_rule - > mirr_mbox , fs_rule - > mirr_mbox_size ) ; err = mlx4_cmd_imm ( dev , mailbox - > dma , & reg_id , fs_rule - > mirr_mbox_size > > 2 , 0 , MLX4_QP_FLOW_STEERING_ATTACH , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; mlx4_free_cmd_mailbox ( dev , mailbox ) ; if ( err ) goto err ; err = add_res_range ( dev , fs_rule - > com . owner , reg_id , 1 , RES_FS_RULE , fs_rule - > qpn ) ; if ( err ) goto err_detach ; err = get_res ( dev , fs_rule - > com . owner , reg_id , RES_FS_RULE , & mirr_rule ) ; if ( err ) goto err_rem ; fs_rule - > mirr_rule_id = reg_id ; mirr_rule - > mirr_rule_id = 0 ; mirr_rule - > mirr_mbox_size = 0 ; mirr_rule - > mirr_mbox = NULL ; put_res ( dev , fs_rule - > com . owner , reg_id , RES_FS_RULE ) ; return 0 ; err_rem : rem_res_range ( dev , fs_rule - > com . owner , reg_id , 1 , RES_FS_RULE , 0 ) ; err_detach : mlx4_cmd ( dev , reg_id , 0 , 0 , MLX4_QP_FLOW_STEERING_DETACH , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; err : return err ; } static int mlx4_mirror_fs_rules ( struct mlx4_dev * dev , bool bond ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct rb_root * root = & tracker - > res_tree [ RES_FS_RULE ] ; struct rb_node * p ; struct res_fs_rule * fs_rule ; int err = 0 ; LIST_HEAD ( mirr_list ) ; for ( p = rb_first ( root ) ; p ; p = rb_next ( p ) ) { fs_rule = rb_entry ( p , struct res_fs_rule , com . node ) ; if ( ( bond & & fs_rule - > mirr_mbox_size ) | | ( ! bond & & ! fs_rule - > mirr_mbox_size ) ) list_add_tail ( & fs_rule - > mirr_list , & mirr_list ) ; } list_for_each_entry ( fs_rule , & mirr_list , mirr_list ) { if ( bond ) err + = mlx4_do_mirror_rule ( dev , fs_rule ) ; else err + = mlx4_undo_mirror_rule ( dev , fs_rule ) ; } return err ; } int mlx4_bond_fs_rules ( struct mlx4_dev * dev ) { return mlx4_mirror_fs_rules ( dev , true ) ; } int mlx4_unbond_fs_rules ( struct mlx4_dev * dev ) { return mlx4_mirror_fs_rules ( dev , false ) ; } static void rem_slave_fs_rule ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * fs_rule_list = & tracker - > slave_list [ slave ] . res_list [ RES_FS_RULE ] ; struct res_fs_rule * fs_rule ; struct res_fs_rule * tmp ; int state ; u64 base ; int err ; err = move_all_busy ( dev , slave , RES_FS_RULE ) ; if ( err ) mlx4_warn ( dev , " rem_slave_fs_rule : Could not move all mtts to busy for slave % d \ n " , slave ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( fs_rule , tmp , fs_rule_list , com . list ) { spin_unlock_irq ( mlx4_tlock ( dev ) ) ; if ( fs_rule - > com . owner = = slave ) { base = fs_rule - > com . res_id ; state = fs_rule - > com . from_state ; while ( state ! = 0 ) { switch ( state ) { case RES_FS_RULE_ALLOCATED : / * detach rule * / err = mlx4_cmd ( dev , base , 0 , 0 , MLX4_QP_FLOW_STEERING_DETACH , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; rb_erase ( & fs_rule - > com . node , & tracker - > res_tree [ RES_FS_RULE ] ) ; list_del ( & fs_rule - > com . list ) ; spin_unlock_irq ( mlx4_tlock ( dev ) ) ; kfree ( fs_rule - > mirr_mbox ) ; kfree ( fs_rule ) ; state = 0 ; break ; default : state = 0 ; } } } spin_lock_irq ( mlx4_tlock ( dev ) ) ; } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; } static void rem_slave_eqs ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * eq_list = & tracker - > slave_list [ slave ] . res_list [ RES_EQ ] ; struct res_eq * eq ; struct res_eq * tmp ; int err ; int state ; int eqn ; err = move_all_busy ( dev , slave , RES_EQ ) ; if ( err ) mlx4_warn ( dev , " rem_slave_eqs : Could not move all eqs - too busy for slave % d \ n " , slave ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( eq , tmp , eq_list , com . list ) { spin_unlock_irq ( mlx4_tlock ( dev ) ) ; if ( eq - > com . owner = = slave ) { eqn = eq - > com . res_id ; state = eq - > com . from_state ; while ( state ! = 0 ) { switch ( state ) { case RES_EQ_RESERVED : spin_lock_irq ( mlx4_tlock ( dev ) ) ; rb_erase ( & eq - > com . node , & tracker - > res_tree [ RES_EQ ] ) ; list_del ( & eq - > com . list ) ; spin_unlock_irq ( mlx4_tlock ( dev ) ) ; kfree ( eq ) ; state = 0 ; break ; case RES_EQ_HW : err = mlx4_cmd ( dev , slave , eqn & 0 x3ff , 1 , MLX4_CMD_HW2SW_EQ , MLX4_CMD_TIME_CLASS_A , MLX4_CMD_NATIVE ) ; if ( err ) mlx4_dbg ( dev , " rem_slave_eqs : failed to move slave % d eqs % d to SW ownership \ n " , slave , eqn & 0 x3ff ) ; atomic_dec ( & eq - > mtt - > ref_count ) ; state = RES_EQ_RESERVED ; break ; default : state = 0 ; } } } spin_lock_irq ( mlx4_tlock ( dev ) ) ; } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; } static void rem_slave_counters ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * counter_list = & tracker - > slave_list [ slave ] . res_list [ RES_COUNTER ] ; struct res_counter * counter ; struct res_counter * tmp ; int err ; int * counters_arr = NULL ; int i , j ; err = move_all_busy ( dev , slave , RES_COUNTER ) ; if ( err ) mlx4_warn ( dev , " rem_slave_counters : Could not move all counters - too busy for slave % d \ n " , slave ) ; counters_arr = kmalloc_array ( dev - > caps . max_counters , sizeof ( * counters_arr ) , GFP_KERNEL ) ; if ( ! counters_arr ) return ; do { i = 0 ; j = 0 ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( counter , tmp , counter_list , com . list ) { if ( counter - > com . owner = = slave ) { counters_arr [ i + + ] = counter - > com . res_id ; rb_erase ( & counter - > com . node , & tracker - > res_tree [ RES_COUNTER ] ) ; list_del ( & counter - > com . list ) ; kfree ( counter ) ; } } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; while ( j < i ) { _ _ mlx4_counter_free ( dev , counters_arr [ j + + ] ) ; mlx4_release_resource ( dev , slave , RES_COUNTER , 1 , 0 ) ; } } while ( i ) ; kfree ( counters_arr ) ; } static void rem_slave_xrcdns ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; struct mlx4_resource_tracker * tracker = & priv - > mfunc . master . res_tracker ; struct list_head * xrcdn_list = & tracker - > slave_list [ slave ] . res_list [ RES_XRCD ] ; struct res_xrcdn * xrcd ; struct res_xrcdn * tmp ; int err ; int xrcdn ; err = move_all_busy ( dev , slave , RES_XRCD ) ; if ( err ) mlx4_warn ( dev , " rem_slave_xrcdns : Could not move all xrcdns - too busy for slave % d \ n " , slave ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( xrcd , tmp , xrcdn_list , com . list ) { if ( xrcd - > com . owner = = slave ) { xrcdn = xrcd - > com . res_id ; rb_erase ( & xrcd - > com . node , & tracker - > res_tree [ RES_XRCD ] ) ; list_del ( & xrcd - > com . list ) ; kfree ( xrcd ) ; _ _ mlx4_xrcd_free ( dev , xrcdn ) ; } } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; } void mlx4_delete_all_resources_for_slave ( struct mlx4_dev * dev , int slave ) { struct mlx4_priv * priv = mlx4_priv ( dev ) ; mlx4_reset_roce_gids ( dev , slave ) ; mutex_lock ( & priv - > mfunc . master . res_tracker . slave_list [ slave ] . mutex ) ; rem_slave_vlans ( dev , slave ) ; rem_slave_macs ( dev , slave ) ; rem_slave_fs_rule ( dev , slave ) ; rem_slave_qps ( dev , slave ) ; rem_slave_srqs ( dev , slave ) ; rem_slave_cqs ( dev , slave ) ; rem_slave_mrs ( dev , slave ) ; rem_slave_eqs ( dev , slave ) ; rem_slave_mtts ( dev , slave ) ; rem_slave_counters ( dev , slave ) ; rem_slave_xrcdns ( dev , slave ) ; mutex_unlock ( & priv - > mfunc . master . res_tracker . slave_list [ slave ] . mutex ) ; } static void update_qos_vpp ( struct mlx4_update_qp_context * ctx , struct mlx4_vf_immed_vlan_work * work ) { ctx - > qp_mask | = cpu_to_be64 ( 1 ULL < < MLX4_UPD_QP_MASK_QOS_VPP ) ; ctx - > qp_context . qos_vport = work - > qos_vport ; } void mlx4_vf_immed_vlan_work_handler ( struct work_struct * _ work ) { struct mlx4_vf_immed_vlan_work * work = container_of ( _ work , struct mlx4_vf_immed_vlan_work , work ) ; struct mlx4_cmd_mailbox * mailbox ; struct mlx4_update_qp_context * upd_context ; struct mlx4_dev * dev = & work - > priv - > dev ; struct mlx4_resource_tracker * tracker = & work - > priv - > mfunc . master . res_tracker ; struct list_head * qp_list = & tracker - > slave_list [ work - > slave ] . res_list [ RES_QP ] ; struct res_qp * qp ; struct res_qp * tmp ; u64 qp_path_mask_vlan_ctrl = ( ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_ETH_TX_BLOCK_UNTAGGED ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_ETH_TX_BLOCK_1P ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_ETH_TX_BLOCK_TAGGED ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_ETH_RX_BLOCK_UNTAGGED ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_ETH_RX_BLOCK_1P ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_ETH_RX_BLOCK_TAGGED ) ) ; u64 qp_path_mask = ( ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_VLAN_INDEX ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_FVL ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_CV ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_SV ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_ETH_HIDE_CQE_VLAN ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_FEUP ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_FVL_RX ) | ( 1 ULL < < MLX4_UPD_QP_PATH_MASK_SCHED_QUEUE ) ) ; int err ; int port , errors = 0 ; u8 vlan_control ; if ( mlx4_is_slave ( dev ) ) { mlx4_warn ( dev , " Trying to update - qp in slave % d \ n " , work - > slave ) ; goto out ; } mailbox = mlx4_alloc_cmd_mailbox ( dev ) ; if ( IS_ERR ( mailbox ) ) goto out ; if ( work - > flags & MLX4_VF_IMMED_VLAN_FLAG_LINK_DISABLE ) / * block all * / vlan_control = MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED | MLX4_VLAN_CTRL_ETH_TX_BLOCK_PRIO_TAGGED | MLX4_VLAN_CTRL_ETH_TX_BLOCK_UNTAGGED | MLX4_VLAN_CTRL_ETH_RX_BLOCK_PRIO_TAGGED | MLX4_VLAN_CTRL_ETH_RX_BLOCK_UNTAGGED | MLX4_VLAN_CTRL_ETH_RX_BLOCK_TAGGED ; else if ( ! work - > vlan_id ) vlan_control = MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED | MLX4_VLAN_CTRL_ETH_RX_BLOCK_TAGGED ; else if ( work - > vlan_proto = = htons ( ETH_P_8021AD ) ) vlan_control = MLX4_VLAN_CTRL_ETH_TX_BLOCK_PRIO_TAGGED | MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED | MLX4_VLAN_CTRL_ETH_RX_BLOCK_PRIO_TAGGED | MLX4_VLAN_CTRL_ETH_RX_BLOCK_UNTAGGED ; else / * vst 802 . 1 Q * / vlan_control = MLX4_VLAN_CTRL_ETH_TX_BLOCK_TAGGED | MLX4_VLAN_CTRL_ETH_RX_BLOCK_PRIO_TAGGED | MLX4_VLAN_CTRL_ETH_RX_BLOCK_UNTAGGED ; upd_context = mailbox - > buf ; upd_context - > qp_mask = cpu_to_be64 ( 1 ULL < < MLX4_UPD_QP_MASK_VSD ) ; spin_lock_irq ( mlx4_tlock ( dev ) ) ; list_for_each_entry_safe ( qp , tmp , qp_list , com . list ) { spin_unlock_irq ( mlx4_tlock ( dev ) ) ; if ( qp - > com . owner = = work - > slave ) { if ( qp - > com . from_state ! = RES_QP_HW | | ! qp - > sched_queue | | / * no INIT2RTR trans yet * / mlx4_is_qp_reserved ( dev , qp - > local_qpn ) | | qp - > qpc_flags & ( 1 < < MLX4_RSS_QPC_FLAG_OFFSET ) ) { spin_lock_irq ( mlx4_tlock ( dev ) ) ; continue ; } port = ( qp - > sched_queue > > 6 & 1 ) + 1 ; if ( port ! = work - > port ) { spin_lock_irq ( mlx4_tlock ( dev ) ) ; continue ; } if ( MLX4_QP_ST_RC = = ( ( qp - > qpc_flags > > 16 ) & 0 xff ) ) upd_context - > primary_addr_path_mask = cpu_to_be64 ( qp_path_mask ) ; else upd_context - > primary_addr_path_mask = cpu_to_be64 ( qp_path_mask | qp_path_mask_vlan_ctrl ) ; if ( work - > vlan_id = = MLX4_VGT ) { upd_context - > qp_context . param3 = qp - > param3 ; upd_context - > qp_context . pri_path . vlan_control = qp - > vlan_control ; upd_context - > qp_context . pri_path . fvl_rx = qp - > fvl_rx ; upd_context - > qp_context . pri_path . vlan_index = qp - > vlan_index ; upd_context - > qp_context . pri_path . fl = qp - > pri_path_fl ; upd_context - > qp_context . pri_path . feup = qp - > feup ; upd_context - > qp_context . pri_path . sched_queue = qp - > sched_queue ; } else { upd_context - > qp_context . param3 = qp - > param3 & ~ cpu_to_be32 ( MLX4_STRIP_VLAN ) ; upd_context - > qp_context . pri_path . vlan_control = vlan_control ; upd_context - > qp_context . pri_path . vlan_index = work - > vlan_ix ; upd_context - > qp_context . pri_path . fvl_rx = qp - > fvl_rx | MLX4_FVL_RX_FORCE_ETH_VLAN ; upd_context - > qp_context . pri_path . fl = qp - > pri_path_fl | MLX4_FL_ETH_HIDE_CQE_VLAN ; if ( work - > vlan_proto = = htons ( ETH_P_8021AD ) ) upd_context - > qp_context . pri_path . fl | = MLX4_FL_SV ; else upd_context - > qp_context . pri_path . fl | = MLX4_FL_CV ; upd_context - > qp_context . pri_path . feup = qp - > feup | MLX4_FEUP_FORCE_ETH_UP | MLX4_FVL_FORCE_ETH_VLAN ; upd_context - > qp_context . pri_path . sched_queue = qp - > sched_queue & 0 xC7 ; upd_context - > qp_context . pri_path . sched_queue | = ( ( work - > qos & 0 x7 ) < < 3 ) ; if ( dev - > caps . flags2 & MLX4_DEV_CAP_FLAG2_QOS_VPP ) update_qos_vpp ( upd_context , work ) ; } err = mlx4_cmd ( dev , mailbox - > dma , qp - > local_qpn & 0 xffffff , 0 , MLX4_CMD_UPDATE_QP , MLX4_CMD_TIME_CLASS_C , MLX4_CMD_NATIVE ) ; if ( err ) { mlx4_info ( dev , " UPDATE_QP failed for slave % d , port % d , qpn % d ( % d ) \ n " , work - > slave , port , qp - > local_qpn , err ) ; errors + + ; } } spin_lock_irq ( mlx4_tlock ( dev ) ) ; } spin_unlock_irq ( mlx4_tlock ( dev ) ) ; mlx4_free_cmd_mailbox ( dev , mailbox ) ; if ( errors ) mlx4_err ( dev , " % d UPDATE_QP failures for slave % d , port % d \ n " , errors , work - > slave , work - > port ) ; / * unregister previous vlan_id if needed and we had no errors * while updating the QPs * / if ( work - > flags & MLX4_VF_IMMED_VLAN_FLAG_VLAN & & ! errors & & NO_INDX ! = work - > orig_vlan_ix ) _ _ mlx4_unregister_vlan ( & work - > priv - > dev , work - > port , work - > orig_vlan_id ) ; out : kfree ( work ) ; return ; }
Messung V0.5 in Prozent C=95 H=95 G=94
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.161Angebot
¤ *Eine klare Vorstellung vom Zielzustand
