*inlen = MLX5_ST_SZ_BYTES(create_cq_in) +
                 MLX5_FLD_SZ_BYTES(create_cq_in, pas[0]) * ncont;
-       *cqb = mlx5_vzalloc(*inlen);
+       *cqb = kvzalloc(*inlen, GFP_KERNEL);
        if (!*cqb) {
                err = -ENOMEM;
                goto err_db;
 
        *inlen = MLX5_ST_SZ_BYTES(create_cq_in) +
                 MLX5_FLD_SZ_BYTES(create_cq_in, pas[0]) * cq->buf.buf.npages;
-       *cqb = mlx5_vzalloc(*inlen);
+       *cqb = kvzalloc(*inlen, GFP_KERNEL);
        if (!*cqb) {
                err = -ENOMEM;
                goto err_buf;
        inlen = MLX5_ST_SZ_BYTES(modify_cq_in) +
                MLX5_FLD_SZ_BYTES(modify_cq_in, pas[0]) * npas;
 
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in) {
                err = -ENOMEM;
                goto ex_resize;
 
                        (struct ib_pma_portcounters_ext *)(out_mad->data + 40);
                int sz = MLX5_ST_SZ_BYTES(query_vport_counter_out);
 
-               out_cnt = mlx5_vzalloc(sz);
+               out_cnt = kvzalloc(sz, GFP_KERNEL);
                if (!out_cnt)
                        return IB_MAD_RESULT_FAILURE;
 
                        (struct ib_pma_portcounters *)(out_mad->data + 40);
                int sz = MLX5_ST_SZ_BYTES(ppcnt_reg);
 
-               out_cnt = mlx5_vzalloc(sz);
+               out_cnt = kvzalloc(sz, GFP_KERNEL);
                if (!out_cnt)
                        return IB_MAD_RESULT_FAILURE;
 
 
        if (!is_valid_attr(dev->mdev, flow_attr))
                return ERR_PTR(-EINVAL);
 
-       spec = mlx5_vzalloc(sizeof(*spec));
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
        handler = kzalloc(sizeof(*handler), GFP_KERNEL);
        if (!handler || !spec) {
                err = -ENOMEM;
        __be32 val;
        int ret, i;
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
        int ret, i;
        int offset = port->cnts.num_q_counters;
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
 
 
        inlen = MLX5_ST_SZ_BYTES(create_mkey_in) +
                sizeof(*pas) * ((npages + 1) / 2) * 2;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in) {
                err = -ENOMEM;
                goto err_1;
 
 
        *inlen = MLX5_ST_SZ_BYTES(create_qp_in) +
                 MLX5_FLD_SZ_BYTES(create_qp_in, pas[0]) * ncont;
-       *in = mlx5_vzalloc(*inlen);
+       *in = kvzalloc(*inlen, GFP_KERNEL);
        if (!*in) {
                err = -ENOMEM;
                goto err_umem;
        qp->sq.qend = mlx5_get_send_wqe(qp, qp->sq.wqe_cnt);
        *inlen = MLX5_ST_SZ_BYTES(create_qp_in) +
                 MLX5_FLD_SZ_BYTES(create_qp_in, pas[0]) * qp->buf.npages;
-       *in = mlx5_vzalloc(*inlen);
+       *in = kvzalloc(*inlen, GFP_KERNEL);
        if (!*in) {
                err = -ENOMEM;
                goto err_buf;
                return err;
 
        inlen = MLX5_ST_SZ_BYTES(create_sq_in) + sizeof(u64) * ncont;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in) {
                err = -ENOMEM;
                goto err_umem;
        u32 rq_pas_size = get_rq_pas_size(qpc);
 
        inlen = MLX5_ST_SZ_BYTES(create_rq_in) + rq_pas_size;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(create_tir_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        }
 
        inlen = MLX5_ST_SZ_BYTES(create_tir_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
                if (err)
                        return err;
        } else {
-               in = mlx5_vzalloc(inlen);
+               in = kvzalloc(inlen, GFP_KERNEL);
                if (!in)
                        return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(modify_tis_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(modify_tis_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(modify_rq_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(modify_sq_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(query_sq_out);
-       out = mlx5_vzalloc(inlen);
+       out = kvzalloc(inlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(query_rq_out);
-       out = mlx5_vzalloc(inlen);
+       out = kvzalloc(inlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
        dev = to_mdev(pd->device);
 
        inlen = MLX5_ST_SZ_BYTES(create_rq_in) + sizeof(u64) * rwq->rq_num_pas;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
                return ERR_PTR(-ENOMEM);
 
        inlen = MLX5_ST_SZ_BYTES(create_rqt_in) + sizeof(u32) * sz;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in) {
                err = -ENOMEM;
                goto err;
                return -EOPNOTSUPP;
 
        inlen = MLX5_ST_SZ_BYTES(modify_rq_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
                goto err_umem;
        }
 
-       in->pas = mlx5_vzalloc(sizeof(*in->pas) * ncont);
+       in->pas = kvzalloc(sizeof(*in->pas) * ncont, GFP_KERNEL);
        if (!in->pas) {
                err = -ENOMEM;
                goto err_umem;
        }
 
        mlx5_ib_dbg(dev, "srq->buf.page_shift = %d\n", srq->buf.page_shift);
-       in->pas = mlx5_vzalloc(sizeof(*in->pas) * srq->buf.npages);
+       in->pas = kvzalloc(sizeof(*in->pas) * srq->buf.npages, GFP_KERNEL);
        if (!in->pas) {
                err = -ENOMEM;
                goto err_buf;
 
        u32 *out;
        int err;
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return param;
 
 
        struct mlx5_flow_spec *spec;
        int err = 0;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
        if (!spec) {
-               netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
                err = -ENOMEM;
                goto out;
        }
 
        ft->g = kcalloc(MLX5E_ARFS_NUM_GROUPS,
                        sizeof(*ft->g), GFP_KERNEL);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if  (!in || !ft->g) {
                kvfree(ft->g);
                kvfree(in);
        struct mlx5_flow_table *ft;
        int err = 0;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
        if (!spec) {
-               netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
                err = -ENOMEM;
                goto out;
        }
 
        u32 *in;
        int err;
 
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
 
        inlen = MLX5_ST_SZ_BYTES(modify_tir_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                goto out;
 
 
            (hfunc != ETH_RSS_HASH_TOP))
                return -EINVAL;
 
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
        struct mlx5_flow_spec *spec;
        int err = 0;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
-       if (!spec) {
-               netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
+       if (!spec)
                return -ENOMEM;
-       }
 
        if (rule_type == MLX5E_VLAN_RULE_TYPE_MATCH_VID)
                mlx5e_vport_context_update_vlans(priv);
        struct mlx5_flow_spec *spec;
        int err = 0;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
-       if (!spec) {
-               netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
+       if (!spec)
                return ERR_PTR(-ENOMEM);
-       }
 
        if (proto) {
                spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
                        sizeof(*ft->g), GFP_KERNEL);
        if (!ft->g)
                return -ENOMEM;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in) {
                kfree(ft->g);
                return -ENOMEM;
        u8 *mc_dmac;
        u8 *mv_dmac;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
-       if (!spec) {
-               netdev_err(priv->netdev, "%s: alloc failed\n", __func__);
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
+       if (!spec)
                return -ENOMEM;
-       }
 
        mc_dmac = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
                               outer_headers.dmac_47_16);
        ft->g = kcalloc(MLX5E_NUM_L2_GROUPS, sizeof(*ft->g), GFP_KERNEL);
        if (!ft->g)
                return -ENOMEM;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in) {
                kfree(ft->g);
                return -ENOMEM;
        int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
        int err;
 
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
        struct mlx5_flow_handle *rule;
        int err = 0;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
        if (!spec)
                return ERR_PTR(-ENOMEM);
        err = set_flow_attrs(spec->match_criteria, spec->match_value,
 
        void *out;
        u32 *in;
 
-       in = mlx5_vzalloc(sz);
+       in = kvzalloc(sz, GFP_KERNEL);
        if (!in)
-               goto free_out;
+               return;
 
        MLX5_SET(ppcnt_reg, in, local_port, 1);
 
                                     MLX5_REG_PPCNT, 0, 0);
        }
 
-free_out:
        kvfree(in);
 }
 
        if (!MLX5_CAP_MCAM_FEATURE(mdev, pcie_performance_group))
                return;
 
-       in = mlx5_vzalloc(sz);
+       in = kvzalloc(sz, GFP_KERNEL);
        if (!in)
                return;
 
        if (!MLX5E_VALID_NUM_MTTS(npages))
                return -EINVAL;
 
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
        inlen = MLX5_ST_SZ_BYTES(create_rq_in) +
                sizeof(u64) * rq->wq_ctrl.buf.npages;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(modify_rq_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(modify_rq_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(modify_rq_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
        inlen = MLX5_ST_SZ_BYTES(create_sq_in) +
                sizeof(u64) * csp->wq_ctrl->buf.npages;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(modify_sq_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
        inlen = MLX5_ST_SZ_BYTES(create_cq_in) +
                sizeof(u64) * cq->wq_ctrl.frag_buf.npages;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int i;
 
        inlen = MLX5_ST_SZ_BYTES(create_rqt_in) + sizeof(u32) * sz;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int err;
 
        inlen = MLX5_ST_SZ_BYTES(modify_rqt_in) + sizeof(u32) * sz;
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int ix;
 
        inlen = MLX5_ST_SZ_BYTES(modify_tir_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int tt;
 
        inlen = MLX5_ST_SZ_BYTES(create_tir_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        int ix;
 
        inlen = MLX5_ST_SZ_BYTES(create_tir_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
        }
 
        flow = kzalloc(sizeof(*flow) + attr_size, GFP_KERNEL);
-       parse_attr = mlx5_vzalloc(sizeof(*parse_attr));
+       parse_attr = kvzalloc(sizeof(*parse_attr), GFP_KERNEL);
        if (!parse_attr || !flow) {
                err = -ENOMEM;
                goto err_free;
 
        inlen = MLX5_ST_SZ_BYTES(create_eq_in) +
                MLX5_FLD_SZ_BYTES(create_eq_in, pas[0]) * eq->buf.npages;
 
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in) {
                err = -ENOMEM;
                goto err_buf;
 
        if (rx_rule)
                match_header |= MLX5_MATCH_MISC_PARAMETERS;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
-       if (!spec) {
-               esw_warn(esw->dev, "FDB: Failed to alloc match parameters\n");
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
+       if (!spec)
                return NULL;
-       }
+
        dmac_v = MLX5_ADDR_OF(fte_match_param, spec->match_value,
                              outer_headers.dmac_47_16);
        dmac_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
                return -EOPNOTSUPP;
        }
 
-       flow_group_in = mlx5_vzalloc(inlen);
+       flow_group_in = kvzalloc(inlen, GFP_KERNEL);
        if (!flow_group_in)
                return -ENOMEM;
-       memset(flow_group_in, 0, inlen);
 
        table_size = BIT(MLX5_CAP_ESW_FLOWTABLE_FDB(dev, log_max_ft_size));
 
                return -EOPNOTSUPP;
        }
 
-       flow_group_in = mlx5_vzalloc(inlen);
+       flow_group_in = kvzalloc(inlen, GFP_KERNEL);
        if (!flow_group_in)
                return -ENOMEM;
 
                return -EOPNOTSUPP;
        }
 
-       flow_group_in = mlx5_vzalloc(inlen);
+       flow_group_in = kvzalloc(inlen, GFP_KERNEL);
        if (!flow_group_in)
                return -ENOMEM;
 
                  "vport[%d] configure ingress rules, vlan(%d) qos(%d)\n",
                  vport->vport, vport->info.vlan, vport->info.qos);
 
-       spec = mlx5_vzalloc(sizeof(*spec));
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
        if (!spec) {
                err = -ENOMEM;
-               esw_warn(esw->dev, "vport[%d] configure ingress rules failed, err(%d)\n",
-                        vport->vport, err);
                goto out;
        }
 
                  "vport[%d] configure egress rules, vlan(%d) qos(%d)\n",
                  vport->vport, vport->info.vlan, vport->info.qos);
 
-       spec = mlx5_vzalloc(sizeof(*spec));
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
        if (!spec) {
                err = -ENOMEM;
-               esw_warn(esw->dev, "vport[%d] configure egress rules failed, err(%d)\n",
-                        vport->vport, err);
                goto out;
        }
 
        if (!LEGAL_VPORT(esw, vport))
                return -EINVAL;
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
 
        struct mlx5_flow_spec *spec;
        void *misc;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
        if (!spec) {
-               esw_warn(esw->dev, "FDB: Failed to alloc match parameters\n");
                flow_rule = ERR_PTR(-ENOMEM);
                goto out;
        }
        struct mlx5_flow_spec *spec;
        int err = 0;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
        if (!spec) {
-               esw_warn(esw->dev, "FDB: Failed to alloc match parameters\n");
                err = -ENOMEM;
                goto out;
        }
        u32 *flow_group_in;
 
        esw_debug(esw->dev, "Create offloads FDB Tables\n");
-       flow_group_in = mlx5_vzalloc(inlen);
+       flow_group_in = kvzalloc(inlen, GFP_KERNEL);
        if (!flow_group_in)
                return -ENOMEM;
 
        int err = 0;
        int nvports = priv->sriov.num_vfs + 2;
 
-       flow_group_in = mlx5_vzalloc(inlen);
+       flow_group_in = kvzalloc(inlen, GFP_KERNEL);
        if (!flow_group_in)
                return -ENOMEM;
 
        struct mlx5_flow_spec *spec;
        void *misc;
 
-       spec = mlx5_vzalloc(sizeof(*spec));
+       spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
        if (!spec) {
-               esw_warn(esw->dev, "Failed to alloc match parameters\n");
                flow_rule = ERR_PTR(-ENOMEM);
                goto out;
        }
 
        u32 *in;
        int err;
 
-       in = mlx5_vzalloc(inlen);
-       if (!in) {
-               mlx5_core_warn(dev, "failed to allocate inbox\n");
+       in = kvzalloc(inlen, GFP_KERNEL);
+       if (!in)
                return -ENOMEM;
-       }
 
        MLX5_SET(set_fte_in, in, opcode, MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY);
        MLX5_SET(set_fte_in, in, op_mod, opmod);
 
        int err;
        bool update_fte = false;
 
-       match_value = mlx5_vzalloc(match_len);
-       if (!match_value) {
-               mlx5_core_warn(dev, "failed to allocate inbox\n");
+       match_value = kvzalloc(match_len, GFP_KERNEL);
+       if (!match_value)
                return;
-       }
 
        fs_get_obj(rule, node);
        fs_get_obj(fte, rule->node.parent);
        if (!ft->autogroup.active)
                return ERR_PTR(-ENOENT);
 
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return ERR_PTR(-ENOMEM);
 
        struct mlx5_flow_namespace *ns;
 
        /* Create the root namespace */
-       root_ns = mlx5_vzalloc(sizeof(*root_ns));
+       root_ns = kvzalloc(sizeof(*root_ns), GFP_KERNEL);
        if (!root_ns)
                return NULL;
 
 
        void *qpc;
 
        inlen = MLX5_ST_SZ_BYTES(create_qp_in);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
        int i;
 
        inlen += npages * MLX5_FLD_SZ_BYTES(manage_pages_in, pas[0]);
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in) {
                err = -ENOMEM;
                mlx5_core_warn(dev, "vzalloc failed %d\n", inlen);
                *nclaimed = 0;
 
        outlen += npages * MLX5_FLD_SZ_BYTES(manage_pages_out, pas[0]);
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
 
        u32 *in = NULL;
        void *data;
 
-       in = mlx5_vzalloc(inlen);
-       out = mlx5_vzalloc(outlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!in || !out)
                goto out;
 
        u32 *in;
        int err;
 
-       in  = mlx5_vzalloc(sz);
+       in  = kvzalloc(sz, GFP_KERNEL);
        if (!in) {
                err = -ENOMEM;
                return err;
 
        void *out;
        int err;
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
 
 
        pas_size  = get_pas_size(in);
        inlen     = MLX5_ST_SZ_BYTES(create_srq_in) + pas_size;
-       create_in = mlx5_vzalloc(inlen);
+       create_in = kvzalloc(inlen, GFP_KERNEL);
        if (!create_in)
                return -ENOMEM;
 
        void *srqc;
        int err;
 
-       srq_out = mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_srq_out));
+       srq_out = kvzalloc(MLX5_ST_SZ_BYTES(query_srq_out), GFP_KERNEL);
        if (!srq_out)
                return -ENOMEM;
 
 
        pas_size  = get_pas_size(in);
        inlen     = MLX5_ST_SZ_BYTES(create_xrc_srq_in) + pas_size;
-       create_in = mlx5_vzalloc(inlen);
+       create_in = kvzalloc(inlen, GFP_KERNEL);
        if (!create_in)
                return -ENOMEM;
 
        void *xrc_srqc;
        int err;
 
-       xrcsrq_out = mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_xrc_srq_out));
+       xrcsrq_out = kvzalloc(MLX5_ST_SZ_BYTES(query_xrc_srq_out), GFP_KERNEL);
        if (!xrcsrq_out)
                return -ENOMEM;
        memset(xrcsrq_in, 0, sizeof(xrcsrq_in));
 
        pas_size = get_pas_size(in);
        inlen = MLX5_ST_SZ_BYTES(create_rmp_in) + pas_size;
-       create_in = mlx5_vzalloc(inlen);
+       create_in = kvzalloc(inlen, GFP_KERNEL);
        if (!create_in)
                return -ENOMEM;
 
        void *bitmask;
        int err;
 
-       in = mlx5_vzalloc(MLX5_ST_SZ_BYTES(modify_rmp_in));
+       in = kvzalloc(MLX5_ST_SZ_BYTES(modify_rmp_in), GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        void *rmpc;
        int err;
 
-       rmp_out =  mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_rmp_out));
+       rmp_out =  kvzalloc(MLX5_ST_SZ_BYTES(query_rmp_out), GFP_KERNEL);
        if (!rmp_out)
                return -ENOMEM;
 
 
        void *bitmask;
        int  err;
 
-       in = mlx5_vzalloc(MLX5_ST_SZ_BYTES(modify_rmp_in));
+       in = kvzalloc(MLX5_ST_SZ_BYTES(modify_rmp_in), GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
 
        u8 *out_addr;
        int err;
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
        void *nic_vport_ctx;
        u8 *perm_mac;
 
-       in = mlx5_vzalloc(inlen);
-       if (!in) {
-               mlx5_core_warn(mdev, "failed to allocate inbox\n");
+       in = kvzalloc(inlen, GFP_KERNEL);
+       if (!in)
                return -ENOMEM;
-       }
 
        MLX5_SET(modify_nic_vport_context_in, in,
                 field_select.permanent_address, 1);
        u32 *out;
        int err;
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
        void *in;
        int err;
 
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        u32 *out;
        int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
        u32 *out;
        int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
        if (!MLX5_CAP_ESW(mdev, nic_vport_node_guid_modify))
                return -EOPNOTSUPP;
 
-       in = mlx5_vzalloc(inlen);
+       in = kvzalloc(inlen, GFP_KERNEL);
        if (!in)
                return -ENOMEM;
 
        u32 *out;
        int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
 
-       out = mlx5_vzalloc(outlen);
+       out = kvzalloc(outlen, GFP_KERNEL);
        if (!out)
                return -ENOMEM;
 
        int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
        int err;
 
-       in = mlx5_vzalloc(inlen);
-       if (!in) {
-               mlx5_core_err(mdev, "failed to allocate inbox\n");
+       in = kvzalloc(inlen, GFP_KERNEL);
+       if (!in)
                return -ENOMEM;
-       }
 
        MLX5_SET(modify_nic_vport_context_in, in, field_select.promisc, 1);
        MLX5_SET(modify_nic_vport_context_in, in,
        int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
        int err;
 
-       in = mlx5_vzalloc(inlen);
-       if (!in) {
-               mlx5_core_warn(mdev, "failed to allocate inbox\n");
+       in = kvzalloc(inlen, GFP_KERNEL);
+       if (!in)
                return -ENOMEM;
-       }
 
        MLX5_SET(modify_nic_vport_context_in, in, field_select.roce_en, 1);
        MLX5_SET(modify_nic_vport_context_in, in, nic_vport_context.roce_en,
        int     err;
 
        is_group_manager = MLX5_CAP_GEN(dev, vport_group_manager);
-       in = mlx5_vzalloc(in_sz);
+       in = kvzalloc(in_sz, GFP_KERNEL);
        if (!in) {
                err = -ENOMEM;
                return err;
 
        return ioread32be(&dev->iseg->cmdif_rev_fw_sub) >> 16;
 }
 
-static inline void *mlx5_vzalloc(unsigned long size)
-{
-       return kvzalloc(size, GFP_KERNEL);
-}
-
 static inline u32 mlx5_base_mkey(const u32 key)
 {
        return key & 0xffffff00u;