#include <rdma/ib_addr.h>
 #include <rdma/ib_mad.h>
 #include <rdma/ib_cache.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include "bnxt_ulp.h"
 
 
        /* Write AVID to shared page. */
        if (udata) {
-               struct ib_ucontext *ib_uctx = ib_pd->uobject->context;
-               struct bnxt_re_ucontext *uctx;
+               struct bnxt_re_ucontext *uctx = rdma_udata_to_drv_context(
+                       udata, struct bnxt_re_ucontext, ib_uctx);
                unsigned long flag;
                u32 *wrptr;
 
-               uctx = container_of(ib_uctx, struct bnxt_re_ucontext, ib_uctx);
                spin_lock_irqsave(&uctx->sh_lock, flag);
                wrptr = (u32 *)(uctx->shpg + BNXT_RE_AVID_OFFT);
                *wrptr = ah->qplib_ah.id;
        struct bnxt_qplib_qp *qplib_qp = &qp->qplib_qp;
        struct ib_umem *umem;
        int bytes = 0, psn_sz;
-       struct ib_ucontext *context = pd->ib_pd.uobject->context;
-       struct bnxt_re_ucontext *cntx = container_of(context,
-                                                    struct bnxt_re_ucontext,
-                                                    ib_uctx);
+       struct bnxt_re_ucontext *cntx = rdma_udata_to_drv_context(
+               udata, struct bnxt_re_ucontext, ib_uctx);
+
        if (ib_copy_from_udata(&ureq, udata, sizeof(ureq)))
                return -EFAULT;
 
        struct bnxt_qplib_srq *qplib_srq = &srq->qplib_srq;
        struct ib_umem *umem;
        int bytes = 0;
-       struct ib_ucontext *context = pd->ib_pd.uobject->context;
-       struct bnxt_re_ucontext *cntx = container_of(context,
-                                                    struct bnxt_re_ucontext,
-                                                    ib_uctx);
+       struct bnxt_re_ucontext *cntx = rdma_udata_to_drv_context(
+               udata, struct bnxt_re_ucontext, ib_uctx);
+
        if (ib_copy_from_udata(&ureq, udata, sizeof(ureq)))
                return -EFAULT;
 
 
 #include <rdma/ib_smi.h>
 #include <rdma/ib_umem.h>
 #include <rdma/ib_user_verbs.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include "cxio_hal.h"
 #include "iwch.h"
         * Kernel users need more wq space for fastreg WRs which can take
         * 2 WR fragments.
         */
-       ucontext = udata ? to_iwch_ucontext(pd->uobject->context) : NULL;
+       ucontext = rdma_udata_to_drv_context(udata, struct iwch_ucontext,
+                                            ibucontext);
        if (!ucontext && wqsize < (rqsize + (2 * sqsize)))
                wqsize = roundup_pow_of_two(rqsize +
                                roundup_pow_of_two(attrs->cap.max_send_wr * 2));
 
  */
 
 #include <linux/module.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include "iw_cxgb4.h"
 
        struct c4iw_cq *rchp;
        struct c4iw_create_qp_resp uresp;
        unsigned int sqsize, rqsize = 0;
-       struct c4iw_ucontext *ucontext;
+       struct c4iw_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct c4iw_ucontext, ibucontext);
        int ret;
        struct c4iw_mm_entry *sq_key_mm, *rq_key_mm = NULL, *sq_db_key_mm;
        struct c4iw_mm_entry *rq_db_key_mm = NULL, *ma_sync_key_mm = NULL;
        if (sqsize < 8)
                sqsize = 8;
 
-       ucontext = udata ? to_c4iw_ucontext(pd->uobject->context) : NULL;
-
        qhp = kzalloc(sizeof(*qhp), GFP_KERNEL);
        if (!qhp)
                return ERR_PTR(-ENOMEM);
        rqsize = attrs->attr.max_wr + 1;
        rqsize = roundup_pow_of_two(max_t(u16, rqsize, 16));
 
-       ucontext = udata ? to_c4iw_ucontext(pd->uobject->context) : NULL;
+       ucontext = rdma_udata_to_drv_context(udata, struct c4iw_ucontext,
+                                            ibucontext);
 
        srq = kzalloc(sizeof(*srq), GFP_KERNEL);
        if (!srq)
 
 #include <linux/platform_device.h>
 #include <rdma/ib_addr.h>
 #include <rdma/ib_umem.h>
+#include <rdma/uverbs_ioctl.h>
 #include "hns_roce_common.h"
 #include "hns_roce_device.h"
 #include "hns_roce_hem.h"
        struct device *dev = hr_dev->dev;
        struct hns_roce_ib_create_qp ucmd;
        struct hns_roce_ib_create_qp_resp resp = {};
+       struct hns_roce_ucontext *uctx = rdma_udata_to_drv_context(
+               udata, struct hns_roce_ucontext, ibucontext);
        unsigned long qpn = 0;
        int ret = 0;
        u32 page_shift;
                    (udata->inlen >= sizeof(ucmd)) &&
                    (udata->outlen >= sizeof(resp)) &&
                    hns_roce_qp_has_sq(init_attr)) {
-                       ret = hns_roce_db_map_user(
-                               to_hr_ucontext(ib_pd->uobject->context), udata,
-                               ucmd.sdb_addr, &hr_qp->sdb);
+                       ret = hns_roce_db_map_user(uctx, udata, ucmd.sdb_addr,
+                                                  &hr_qp->sdb);
                        if (ret) {
                                dev_err(dev, "sq record doorbell map failed!\n");
                                goto err_mtt;
                if ((hr_dev->caps.flags & HNS_ROCE_CAP_FLAG_RECORD_DB) &&
                    (udata->outlen >= sizeof(resp)) &&
                    hns_roce_qp_has_rq(init_attr)) {
-                       ret = hns_roce_db_map_user(
-                               to_hr_ucontext(ib_pd->uobject->context), udata,
-                               ucmd.db_addr, &hr_qp->rdb);
+                       ret = hns_roce_db_map_user(uctx, udata, ucmd.db_addr,
+                                                  &hr_qp->rdb);
                        if (ret) {
                                dev_err(dev, "rq record doorbell map failed!\n");
                                goto err_sq_dbmap;
                if ((hr_dev->caps.flags & HNS_ROCE_CAP_FLAG_RECORD_DB) &&
                    (udata->outlen >= sizeof(resp)) &&
                    hns_roce_qp_has_rq(init_attr))
-                       hns_roce_db_unmap_user(
-                                       to_hr_ucontext(ib_pd->uobject->context),
-                                       &hr_qp->rdb);
+                       hns_roce_db_unmap_user(uctx, &hr_qp->rdb);
        } else {
                kfree(hr_qp->sq.wrid);
                kfree(hr_qp->rq.wrid);
                    (udata->inlen >= sizeof(ucmd)) &&
                    (udata->outlen >= sizeof(resp)) &&
                    hns_roce_qp_has_sq(init_attr))
-                       hns_roce_db_unmap_user(
-                                       to_hr_ucontext(ib_pd->uobject->context),
-                                       &hr_qp->sdb);
+                       hns_roce_db_unmap_user(uctx, &hr_qp->sdb);
 
 err_mtt:
        hns_roce_mtt_cleanup(hr_dev, &hr_qp->mtt);
 
 #include <rdma/iw_cm.h>
 #include <rdma/ib_user_verbs.h>
 #include <rdma/ib_umem.h>
+#include <rdma/uverbs_ioctl.h>
 #include "i40iw.h"
 
 /**
        struct i40iw_device *iwdev = to_iwdev(ibpd->device);
        struct i40iw_cqp *iwcqp = &iwdev->cqp;
        struct i40iw_qp *iwqp;
-       struct i40iw_ucontext *ucontext;
+       struct i40iw_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct i40iw_ucontext, ibucontext);
        struct i40iw_create_qp_req req;
        struct i40iw_create_qp_resp uresp;
        u32 qp_num = 0;
                }
                iwqp->ctx_info.qp_compl_ctx = req.user_compl_ctx;
                iwqp->user_mode = 1;
-               ucontext = to_ucontext(ibpd->uobject->context);
 
                if (req.user_wqe_buffers) {
                        struct i40iw_pbl *iwpbl;
 {
        struct i40iw_pd *iwpd = to_iwpd(pd);
        struct i40iw_device *iwdev = to_iwdev(pd->device);
-       struct i40iw_ucontext *ucontext;
+       struct i40iw_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct i40iw_ucontext, ibucontext);
        struct i40iw_pble_alloc *palloc;
        struct i40iw_pbl *iwpbl;
        struct i40iw_mr *iwmr;
        iwmr->region = region;
        iwmr->ibmr.pd = pd;
        iwmr->ibmr.device = pd->device;
-       ucontext = to_ucontext(pd->uobject->context);
 
        iwmr->page_size = PAGE_SIZE;
        iwmr->page_msk = PAGE_MASK;
 
        return block_shift;
 }
 
-static struct ib_umem *mlx4_get_umem_mr(struct ib_ucontext *context,
-                                       struct ib_udata *udata, u64 start,
+static struct ib_umem *mlx4_get_umem_mr(struct ib_udata *udata, u64 start,
                                        u64 length, u64 virt_addr,
                                        int access_flags)
 {
        if (!mr)
                return ERR_PTR(-ENOMEM);
 
-       mr->umem = mlx4_get_umem_mr(pd->uobject->context, udata, start, length,
-                                   virt_addr, access_flags);
+       mr->umem =
+               mlx4_get_umem_mr(udata, start, length, virt_addr, access_flags);
        if (IS_ERR(mr->umem)) {
                err = PTR_ERR(mr->umem);
                goto err_free;
 
                mlx4_mr_rereg_mem_cleanup(dev->dev, &mmr->mmr);
                ib_umem_release(mmr->umem);
-               mmr->umem =
-                       mlx4_get_umem_mr(mr->uobject->context, udata, start,
-                                        length, virt_addr, mr_access_flags);
+               mmr->umem = mlx4_get_umem_mr(udata, start, length, virt_addr,
+                                            mr_access_flags);
                if (IS_ERR(mmr->umem)) {
                        err = PTR_ERR(mmr->umem);
                        /* Prevent mlx4_ib_dereg_mr from free'ing invalid pointer */
 
 #include <rdma/ib_pack.h>
 #include <rdma/ib_addr.h>
 #include <rdma/ib_mad.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include <linux/mlx4/driver.h>
 #include <linux/mlx4/qp.h>
                             struct mlx4_ib_cq *recv_cq);
 static void mlx4_ib_unlock_cqs(struct mlx4_ib_cq *send_cq,
                               struct mlx4_ib_cq *recv_cq);
-static int _mlx4_ib_modify_wq(struct ib_wq *ibwq, enum ib_wq_state new_state);
+static int _mlx4_ib_modify_wq(struct ib_wq *ibwq, enum ib_wq_state new_state,
+                             struct ib_udata *udata);
 
 enum {
        MLX4_IB_ACK_REQ_FREQ    = 8,
        int err;
        struct mlx4_ib_sqp *sqp = NULL;
        struct mlx4_ib_qp *qp;
+       struct mlx4_ib_ucontext *context = rdma_udata_to_drv_context(
+               udata, struct mlx4_ib_ucontext, ibucontext);
        enum mlx4_ib_qp_type qp_type = (enum mlx4_ib_qp_type) init_attr->qp_type;
        struct mlx4_ib_cq *mcq;
        unsigned long flags;
 
                if (qp_has_rq(init_attr)) {
                        err = mlx4_ib_db_map_user(
-                               to_mucontext(pd->uobject->context), udata,
+                               context, udata,
                                (src == MLX4_IB_QP_SRC) ? ucmd.qp.db_addr :
                                                          ucmd.wq.db_addr,
                                &qp->db);
                        }
                }
        } else if (src == MLX4_IB_RWQ_SRC) {
-               err = mlx4_ib_alloc_wqn(to_mucontext(pd->uobject->context), qp,
-                                       range_size, &qpn);
+               err = mlx4_ib_alloc_wqn(context, qp, range_size, &qpn);
                if (err)
                        goto err_wrid;
        } else {
                if (qp->flags & MLX4_IB_QP_NETIF)
                        mlx4_ib_steer_qp_free(dev, qpn, 1);
                else if (src == MLX4_IB_RWQ_SRC)
-                       mlx4_ib_release_wqn(to_mucontext(pd->uobject->context),
-                                           qp, 0);
+                       mlx4_ib_release_wqn(context, qp, 0);
                else
                        mlx4_qp_release_range(dev->dev, qpn, 1);
        }
 err_wrid:
        if (udata) {
                if (qp_has_rq(init_attr))
-                       mlx4_ib_db_unmap_user(to_mucontext(pd->uobject->context), &qp->db);
+                       mlx4_ib_db_unmap_user(context, &qp->db);
        } else {
                kvfree(qp->sq.wrid);
                kvfree(qp->rq.wrid);
  * Go over all RSS QP's childes (WQs) and apply their HW state according to
  * their logic state if the RSS QP is the first RSS QP associated for the WQ.
  */
-static int bringup_rss_rwqs(struct ib_rwq_ind_table *ind_tbl, u8 port_num)
+static int bringup_rss_rwqs(struct ib_rwq_ind_table *ind_tbl, u8 port_num,
+                           struct ib_udata *udata)
 {
        int err = 0;
        int i;
                }
                wq->port = port_num;
                if ((wq->rss_usecnt == 0) && (ibwq->state == IB_WQS_RDY)) {
-                       err = _mlx4_ib_modify_wq(ibwq, IB_WQS_RDY);
+                       err = _mlx4_ib_modify_wq(ibwq, IB_WQS_RDY, udata);
                        if (err) {
                                mutex_unlock(&wq->mutex);
                                break;
 
                        if ((wq->rss_usecnt == 1) &&
                            (ibwq->state == IB_WQS_RDY))
-                               if (_mlx4_ib_modify_wq(ibwq, IB_WQS_RESET))
+                               if (_mlx4_ib_modify_wq(ibwq, IB_WQS_RESET,
+                                                      udata))
                                        pr_warn("failed to reverse WQN=0x%06x\n",
                                                ibwq->wq_num);
                        wq->rss_usecnt--;
        return err;
 }
 
-static void bring_down_rss_rwqs(struct ib_rwq_ind_table *ind_tbl)
+static void bring_down_rss_rwqs(struct ib_rwq_ind_table *ind_tbl,
+                               struct ib_udata *udata)
 {
        int i;
 
                mutex_lock(&wq->mutex);
 
                if ((wq->rss_usecnt == 1) && (ibwq->state == IB_WQS_RDY))
-                       if (_mlx4_ib_modify_wq(ibwq, IB_WQS_RESET))
+                       if (_mlx4_ib_modify_wq(ibwq, IB_WQS_RESET, udata))
                                pr_warn("failed to reverse WQN=%x\n",
                                        ibwq->wq_num);
                wq->rss_usecnt--;
 
 static int __mlx4_ib_modify_qp(void *src, enum mlx4_ib_source_type src_type,
                               const struct ib_qp_attr *attr, int attr_mask,
-                              enum ib_qp_state cur_state, enum ib_qp_state new_state)
+                              enum ib_qp_state cur_state,
+                              enum ib_qp_state new_state,
+                              struct ib_udata *udata)
 {
-       struct ib_uobject *ibuobject;
        struct ib_srq  *ibsrq;
        const struct ib_gid_attr *gid_attr = NULL;
        struct ib_rwq_ind_table *rwq_ind_tbl;
        struct mlx4_ib_qp *qp;
        struct mlx4_ib_pd *pd;
        struct mlx4_ib_cq *send_cq, *recv_cq;
+       struct mlx4_ib_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mlx4_ib_ucontext, ibucontext);
        struct mlx4_qp_context *context;
        enum mlx4_qp_optpar optpar = 0;
        int sqd_event;
                struct ib_wq *ibwq;
 
                ibwq        = (struct ib_wq *)src;
-               ibuobject   = ibwq->uobject;
                ibsrq       = NULL;
                rwq_ind_tbl = NULL;
                qp_type     = IB_QPT_RAW_PACKET;
                struct ib_qp *ibqp;
 
                ibqp        = (struct ib_qp *)src;
-               ibuobject   = ibqp->uobject;
                ibsrq       = ibqp->srq;
                rwq_ind_tbl = ibqp->rwq_ind_tbl;
                qp_type     = ibqp->qp_type;
                        context->param3 |= cpu_to_be32(1 << 30);
        }
 
-       if (ibuobject)
+       if (ucontext)
                context->usr_page = cpu_to_be32(
-                       mlx4_to_hw_uar_index(dev->dev,
-                                            to_mucontext(ibuobject->context)
-                                            ->uar.index));
+                       mlx4_to_hw_uar_index(dev->dev, ucontext->uar.index));
        else
                context->usr_page = cpu_to_be32(
                        mlx4_to_hw_uar_index(dev->dev, dev->priv_uar.index));
        context->cqn_recv = cpu_to_be32(recv_cq->mcq.cqn);
 
        /* Set "fast registration enabled" for all kernel QPs */
-       if (!ibuobject)
+       if (!ucontext)
                context->params1 |= cpu_to_be32(1 << 11);
 
        if (attr_mask & IB_QP_RNR_RETRY) {
        else
                sqd_event = 0;
 
-       if (!ibuobject &&
+       if (!ucontext &&
            cur_state == IB_QPS_RESET &&
            new_state == IB_QPS_INIT)
                context->rlkey_roce_mode |= (1 << 4);
         * headroom is stamped so that the hardware doesn't start
         * processing stale work requests.
         */
-       if (!ibuobject &&
+       if (!ucontext &&
            cur_state == IB_QPS_RESET &&
            new_state == IB_QPS_INIT) {
                struct mlx4_wqe_ctrl_seg *ctrl;
         * entries and reinitialize the QP.
         */
        if (new_state == IB_QPS_RESET) {
-               if (!ibuobject) {
+               if (!ucontext) {
                        mlx4_ib_cq_clean(recv_cq, qp->mqp.qpn,
                                         ibsrq ? to_msrq(ibsrq) : NULL);
                        if (send_cq != recv_cq)
        }
 
        if (ibqp->rwq_ind_tbl && (new_state == IB_QPS_INIT)) {
-               err = bringup_rss_rwqs(ibqp->rwq_ind_tbl, attr->port_num);
+               err = bringup_rss_rwqs(ibqp->rwq_ind_tbl, attr->port_num,
+                                      udata);
                if (err)
                        goto out;
        }
 
        err = __mlx4_ib_modify_qp(ibqp, MLX4_IB_QP_SRC, attr, attr_mask,
-                                 cur_state, new_state);
+                                 cur_state, new_state, udata);
 
        if (ibqp->rwq_ind_tbl && err)
-               bring_down_rss_rwqs(ibqp->rwq_ind_tbl);
+               bring_down_rss_rwqs(ibqp->rwq_ind_tbl, udata);
 
        if (mlx4_is_bonded(dev->dev) && (attr_mask & IB_QP_PORT))
                attr->port_num = 1;
        }
 }
 
-static int _mlx4_ib_modify_wq(struct ib_wq *ibwq, enum ib_wq_state new_state)
+static int _mlx4_ib_modify_wq(struct ib_wq *ibwq, enum ib_wq_state new_state,
+                             struct ib_udata *udata)
 {
        struct mlx4_ib_qp *qp = to_mqp((struct ib_qp *)ibwq);
        enum ib_qp_state qp_cur_state;
                attr_mask = IB_QP_PORT;
 
                err = __mlx4_ib_modify_qp(ibwq, MLX4_IB_RWQ_SRC, &attr,
-                                         attr_mask, IB_QPS_RESET, IB_QPS_INIT);
+                                         attr_mask, IB_QPS_RESET, IB_QPS_INIT,
+                                         udata);
                if (err) {
                        pr_debug("WQN=0x%06x failed to apply RST->INIT on the HW QP\n",
                                 ibwq->wq_num);
 
        attr_mask = 0;
        err = __mlx4_ib_modify_qp(ibwq, MLX4_IB_RWQ_SRC, NULL, attr_mask,
-                                 qp_cur_state,  qp_new_state);
+                                 qp_cur_state,  qp_new_state, udata);
 
        if (err && (qp_cur_state == IB_QPS_INIT)) {
                qp_new_state = IB_QPS_RESET;
                if (__mlx4_ib_modify_qp(ibwq, MLX4_IB_RWQ_SRC, NULL,
-                                       attr_mask, IB_QPS_INIT, IB_QPS_RESET)) {
+                                       attr_mask, IB_QPS_INIT, IB_QPS_RESET,
+                                       udata)) {
                        pr_warn("WQN=0x%06x failed with reverting HW's resources failure\n",
                                ibwq->wq_num);
                        qp_new_state = IB_QPS_INIT;
         * WQ, so we can apply its port on the WQ.
         */
        if (qp->rss_usecnt)
-               err = _mlx4_ib_modify_wq(ibwq, new_state);
+               err = _mlx4_ib_modify_wq(ibwq, new_state, udata);
 
        if (!err)
                ibwq->state = new_state;
 
 
 #include "mlx4_ib.h"
 #include <rdma/mlx4-abi.h>
+#include <rdma/uverbs_ioctl.h>
 
 static void *get_wqe(struct mlx4_ib_srq *srq, int n)
 {
                                  struct ib_udata *udata)
 {
        struct mlx4_ib_dev *dev = to_mdev(pd->device);
+       struct mlx4_ib_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mlx4_ib_ucontext, ibucontext);
        struct mlx4_ib_srq *srq;
        struct mlx4_wqe_srq_next_seg *next;
        struct mlx4_wqe_data_seg *scatter;
                if (err)
                        goto err_mtt;
 
-               err = mlx4_ib_db_map_user(to_mucontext(pd->uobject->context),
-                                         udata, ucmd.db_addr, &srq->db);
+               err = mlx4_ib_db_map_user(ucontext, udata, ucmd.db_addr,
+                                         &srq->db);
                if (err)
                        goto err_mtt;
        } else {
 
 err_wrid:
        if (udata)
-               mlx4_ib_db_unmap_user(to_mucontext(pd->uobject->context), &srq->db);
+               mlx4_ib_db_unmap_user(ucontext, &srq->db);
        else
                kvfree(srq->wrid);
 
 
        void *cmd_out;
        struct ib_uobject *uobj = uverbs_attr_get_uobject(
                attrs, MLX5_IB_ATTR_DEVX_OBJ_CREATE_HANDLE);
-       struct mlx5_ib_ucontext *c = to_mucontext(uobj->context);
+       struct mlx5_ib_ucontext *c = rdma_udata_to_drv_context(
+               &attrs->driver_udata, struct mlx5_ib_ucontext, ibucontext);
        struct mlx5_ib_dev *dev = to_mdev(c->ibucontext.device);
        u32 out[MLX5_ST_SZ_DW(general_obj_out_cmd_hdr)];
        struct devx_obj *obj;
                                        MLX5_IB_ATTR_DEVX_OBJ_MODIFY_CMD_OUT);
        struct ib_uobject *uobj = uverbs_attr_get_uobject(attrs,
                                                          MLX5_IB_ATTR_DEVX_OBJ_MODIFY_HANDLE);
-       struct mlx5_ib_ucontext *c = to_mucontext(uobj->context);
-       struct mlx5_ib_dev *mdev = to_mdev(uobj->context->device);
+       struct mlx5_ib_ucontext *c = rdma_udata_to_drv_context(
+               &attrs->driver_udata, struct mlx5_ib_ucontext, ibucontext);
+       struct mlx5_ib_dev *mdev = to_mdev(c->ibucontext.device);
        void *cmd_out;
        int err;
        int uid;
                                              MLX5_IB_ATTR_DEVX_OBJ_QUERY_CMD_OUT);
        struct ib_uobject *uobj = uverbs_attr_get_uobject(attrs,
                                                          MLX5_IB_ATTR_DEVX_OBJ_QUERY_HANDLE);
-       struct mlx5_ib_ucontext *c = to_mucontext(uobj->context);
+       struct mlx5_ib_ucontext *c = rdma_udata_to_drv_context(
+               &attrs->driver_udata, struct mlx5_ib_ucontext, ibucontext);
        void *cmd_out;
        int err;
        int uid;
-       struct mlx5_ib_dev *mdev = to_mdev(uobj->context->device);
+       struct mlx5_ib_dev *mdev = to_mdev(c->ibucontext.device);
 
        uid = devx_get_uid(c, cmd_in);
        if (uid < 0)
                                attrs,
                                MLX5_IB_ATTR_DEVX_OBJ_QUERY_ASYNC_HANDLE);
        u16 cmd_out_len;
-       struct mlx5_ib_ucontext *c = to_mucontext(uobj->context);
+       struct mlx5_ib_ucontext *c = rdma_udata_to_drv_context(
+               &attrs->driver_udata, struct mlx5_ib_ucontext, ibucontext);
        struct ib_uobject *fd_uobj;
        int err;
        int uid;
-       struct mlx5_ib_dev *mdev = to_mdev(uobj->context->device);
+       struct mlx5_ib_dev *mdev = to_mdev(c->ibucontext.device);
        struct devx_async_cmd_event_file *ev_file;
        struct devx_async_data *async_data;
 
        struct ib_uobject *uobj = uverbs_attr_get_uobject(
                attrs, MLX5_IB_ATTR_DEVX_UMEM_REG_HANDLE);
        u32 obj_id;
-       struct mlx5_ib_ucontext *c = to_mucontext(uobj->context);
+       struct mlx5_ib_ucontext *c = rdma_udata_to_drv_context(
+               &attrs->driver_udata, struct mlx5_ib_ucontext, ibucontext);
        struct mlx5_ib_dev *dev = to_mdev(c->ibucontext.device);
        int err;
 
 
                          struct ib_udata *udata, struct mlx5_ib_rwq *rwq,
                          struct mlx5_ib_create_wq *ucmd)
 {
+       struct mlx5_ib_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mlx5_ib_ucontext, ibucontext);
        int page_shift = 0;
        int npages;
        u32 offset = 0;
                    (unsigned long long)ucmd->buf_addr, rwq->buf_size,
                    npages, page_shift, ncont, offset);
 
-       err = mlx5_ib_db_map_user(to_mucontext(pd->uobject->context), udata,
-                                 ucmd->db_addr, &rwq->db);
+       err = mlx5_ib_db_map_user(ucontext, udata, ucmd->db_addr, &rwq->db);
        if (err) {
                mlx5_ib_dbg(dev, "map failed\n");
                goto err_umem;
                return err;
        }
 
-       context = to_mucontext(pd->uobject->context);
+       context = rdma_udata_to_drv_context(udata, struct mlx5_ib_ucontext,
+                                           ibucontext);
        if (ucmd.flags & MLX5_QP_FLAG_BFREG_INDEX) {
                uar_index = bfregn_to_uar_index(dev, &context->bfregi,
                                                ucmd.bfreg_index, true);
        struct mlx5_ib_raw_packet_qp *raw_packet_qp = &qp->raw_packet_qp;
        struct mlx5_ib_sq *sq = &raw_packet_qp->sq;
        struct mlx5_ib_rq *rq = &raw_packet_qp->rq;
-       struct ib_uobject *uobj = pd->uobject;
-       struct ib_ucontext *ucontext = uobj->context;
-       struct mlx5_ib_ucontext *mucontext = to_mucontext(ucontext);
+       struct mlx5_ib_ucontext *mucontext = rdma_udata_to_drv_context(
+               udata, struct mlx5_ib_ucontext, ibucontext);
        int err;
        u32 tdn = mucontext->tdn;
        u16 uid = to_mpd(pd)->uid;
                                 struct ib_qp_init_attr *init_attr,
                                 struct ib_udata *udata)
 {
-       struct ib_uobject *uobj = pd->uobject;
-       struct ib_ucontext *ucontext = uobj->context;
-       struct mlx5_ib_ucontext *mucontext = to_mucontext(ucontext);
+       struct mlx5_ib_ucontext *mucontext = rdma_udata_to_drv_context(
+               udata, struct mlx5_ib_ucontext, ibucontext);
        struct mlx5_ib_create_qp_resp resp = {};
        int inlen;
        int err;
        int inlen = MLX5_ST_SZ_BYTES(create_qp_in);
        struct mlx5_core_dev *mdev = dev->mdev;
        struct mlx5_ib_create_qp_resp resp = {};
+       struct mlx5_ib_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mlx5_ib_ucontext, ibucontext);
        struct mlx5_ib_cq *send_cq;
        struct mlx5_ib_cq *recv_cq;
        unsigned long flags;
                                      MLX5_QP_FLAG_TYPE_DCT))
                        return -EINVAL;
 
-               err = get_qp_user_index(to_mucontext(pd->uobject->context),
-                                       &ucmd, udata->inlen, &uidx);
+               err = get_qp_user_index(ucontext, &ucmd, udata->inlen, &uidx);
                if (err)
                        return err;
 
 
 static struct ib_qp *mlx5_ib_create_dct(struct ib_pd *pd,
                                        struct ib_qp_init_attr *attr,
-                                       struct mlx5_ib_create_qp *ucmd)
+                                       struct mlx5_ib_create_qp *ucmd,
+                                       struct ib_udata *udata)
 {
+       struct mlx5_ib_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mlx5_ib_ucontext, ibucontext);
        struct mlx5_ib_qp *qp;
        int err = 0;
        u32 uidx = MLX5_IB_DEFAULT_UIDX;
        if (!attr->srq || !attr->recv_cq)
                return ERR_PTR(-EINVAL);
 
-       err = get_qp_user_index(to_mucontext(pd->uobject->context),
-                               ucmd, sizeof(*ucmd), &uidx);
+       err = get_qp_user_index(ucontext, ucmd, sizeof(*ucmd), &uidx);
        if (err)
                return ERR_PTR(err);
 
        int err;
        struct ib_qp_init_attr mlx_init_attr;
        struct ib_qp_init_attr *init_attr = verbs_init_attr;
+       struct mlx5_ib_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mlx5_ib_ucontext, ibucontext);
 
        if (pd) {
                dev = to_mdev(pd->device);
 
                if (init_attr->qp_type == IB_QPT_RAW_PACKET) {
-                       if (!udata) {
+                       if (!ucontext) {
                                mlx5_ib_dbg(dev, "Raw Packet QP is not supported for kernel consumers\n");
                                return ERR_PTR(-EINVAL);
-                       } else if (!to_mucontext(pd->uobject->context)->cqe_version) {
+                       } else if (!ucontext->cqe_version) {
                                mlx5_ib_dbg(dev, "Raw Packet QP is only supported for CQE version > 0\n");
                                return ERR_PTR(-EINVAL);
                        }
                                return ERR_PTR(-EINVAL);
                        }
                } else {
-                       return mlx5_ib_create_dct(pd, init_attr, &ucmd);
+                       return mlx5_ib_create_dct(pd, init_attr, &ucmd, udata);
                }
        }
 
 static unsigned int get_tx_affinity(struct mlx5_ib_dev *dev,
                                    struct mlx5_ib_pd *pd,
                                    struct mlx5_ib_qp_base *qp_base,
-                                   u8 port_num)
+                                   u8 port_num, struct ib_udata *udata)
 {
-       struct mlx5_ib_ucontext *ucontext = NULL;
+       struct mlx5_ib_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mlx5_ib_ucontext, ibucontext);
        unsigned int tx_port_affinity;
 
-       if (pd && pd->ibpd.uobject && pd->ibpd.uobject->context)
-               ucontext = to_mucontext(pd->ibpd.uobject->context);
-
        if (ucontext) {
                tx_port_affinity = (unsigned int)atomic_add_return(
                                           1, &ucontext->tx_port_affinity) %
 
 static int __mlx5_ib_modify_qp(struct ib_qp *ibqp,
                               const struct ib_qp_attr *attr, int attr_mask,
-                              enum ib_qp_state cur_state, enum ib_qp_state new_state,
-                              const struct mlx5_ib_modify_qp *ucmd)
+                              enum ib_qp_state cur_state,
+                              enum ib_qp_state new_state,
+                              const struct mlx5_ib_modify_qp *ucmd,
+                              struct ib_udata *udata)
 {
        static const u16 optab[MLX5_QP_NUM_STATE][MLX5_QP_NUM_STATE] = {
                [MLX5_QP_STATE_RST] = {
                    (ibqp->qp_type == IB_QPT_XRC_TGT)) {
                        if (dev->lag_active) {
                                u8 p = mlx5_core_native_port_num(dev->mdev);
-                               tx_affinity = get_tx_affinity(dev, pd, base, p);
+                               tx_affinity = get_tx_affinity(dev, pd, base, p,
+                                                             udata);
                                context->flags |= cpu_to_be32(tx_affinity << 24);
                        }
                }
        }
 
        err = __mlx5_ib_modify_qp(ibqp, attr, attr_mask, cur_state,
-                                 new_state, &ucmd);
+                                 new_state, &ucmd, udata);
 
 out:
        mutex_unlock(&qp->mutex);
 
 {
        struct mlx5_ib_dev *dev = to_mdev(pd->device);
        struct mlx5_ib_create_srq ucmd = {};
+       struct mlx5_ib_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mlx5_ib_ucontext, ibucontext);
        size_t ucmdlen;
        int err;
        int npages;
                return -EINVAL;
 
        if (in->type != IB_SRQT_BASIC) {
-               err = get_srq_user_index(to_mucontext(pd->uobject->context),
-                                        &ucmd, udata->inlen, &uidx);
+               err = get_srq_user_index(ucontext, &ucmd, udata->inlen, &uidx);
                if (err)
                        return err;
        }
 
        mlx5_ib_populate_pas(dev, srq->umem, page_shift, in->pas, 0);
 
-       err = mlx5_ib_db_map_user(to_mucontext(pd->uobject->context), udata,
-                                 ucmd.db_addr, &srq->db);
+       err = mlx5_ib_db_map_user(ucontext, udata, ucmd.db_addr, &srq->db);
        if (err) {
                mlx5_ib_dbg(dev, "map doorbell failed\n");
                goto err_in;
 
 #include <rdma/ib_smi.h>
 #include <rdma/ib_umem.h>
 #include <rdma/ib_user_verbs.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include <linux/sched.h>
 #include <linux/slab.h>
                                       struct ib_udata *udata)
 {
        struct mthca_create_srq ucmd;
-       struct mthca_ucontext *context = NULL;
+       struct mthca_ucontext *context = rdma_udata_to_drv_context(
+               udata, struct mthca_ucontext, ibucontext);
        struct mthca_srq *srq;
        int err;
 
                return ERR_PTR(-ENOMEM);
 
        if (udata) {
-               context = to_mucontext(pd->uobject->context);
-
                if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd)) {
                        err = -EFAULT;
                        goto err_free;
                                     struct ib_qp_init_attr *init_attr,
                                     struct ib_udata *udata)
 {
+       struct mthca_ucontext *context = rdma_udata_to_drv_context(
+               udata, struct mthca_ucontext, ibucontext);
        struct mthca_create_qp ucmd;
        struct mthca_qp *qp;
        int err;
        case IB_QPT_UC:
        case IB_QPT_UD:
        {
-               struct mthca_ucontext *context;
-
                qp = kzalloc(sizeof(*qp), GFP_KERNEL);
                if (!qp)
                        return ERR_PTR(-ENOMEM);
 
                if (udata) {
-                       context = to_mucontext(pd->uobject->context);
-
                        if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd)) {
                                kfree(qp);
                                return ERR_PTR(-EFAULT);
                                     &init_attr->cap, qp, udata);
 
                if (err && udata) {
-                       context = to_mucontext(pd->uobject->context);
-
                        mthca_unmap_user_db(to_mdev(pd->device),
                                            &context->uar,
                                            context->db_tab,
 {
        struct mthca_dev *dev = to_mdev(pd->device);
        struct sg_dma_page_iter sg_iter;
+       struct mthca_ucontext *context = rdma_udata_to_drv_context(
+               udata, struct mthca_ucontext, ibucontext);
        struct mthca_mr *mr;
        struct mthca_reg_mr ucmd;
        u64 *pages;
        int write_mtt_size;
 
        if (udata->inlen < sizeof ucmd) {
-               if (!to_mucontext(pd->uobject->context)->reg_mr_warned) {
+               if (!context->reg_mr_warned) {
                        mthca_warn(dev, "Process '%s' did not pass in MR attrs.\n",
                                   current->comm);
                        mthca_warn(dev, "  Update libmthca to fix this.\n");
                }
-               ++to_mucontext(pd->uobject->context)->reg_mr_warned;
+               ++context->reg_mr_warned;
                ucmd.mr_attrs = 0;
        } else if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd))
                return ERR_PTR(-EFAULT);
 
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_cache.h>
 #include <rdma/ib_pack.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include "mthca_dev.h"
 #include "mthca_cmd.h"
 
 static int __mthca_modify_qp(struct ib_qp *ibqp,
                             const struct ib_qp_attr *attr, int attr_mask,
-                            enum ib_qp_state cur_state, enum ib_qp_state new_state)
+                            enum ib_qp_state cur_state,
+                            enum ib_qp_state new_state,
+                            struct ib_udata *udata)
 {
        struct mthca_dev *dev = to_mdev(ibqp->device);
        struct mthca_qp *qp = to_mqp(ibqp);
+       struct mthca_ucontext *context = rdma_udata_to_drv_context(
+               udata, struct mthca_ucontext, ibucontext);
        struct mthca_mailbox *mailbox;
        struct mthca_qp_param *qp_param;
        struct mthca_qp_context *qp_context;
        /* leave arbel_sched_queue as 0 */
 
        if (qp->ibqp.uobject)
-               qp_context->usr_page =
-                       cpu_to_be32(to_mucontext(qp->ibqp.uobject->context)->uar.index);
+               qp_context->usr_page = cpu_to_be32(context->uar.index);
        else
                qp_context->usr_page = cpu_to_be32(dev->driver_uar.index);
        qp_context->local_qpn  = cpu_to_be32(qp->qpn);
                goto out;
        }
 
-       err = __mthca_modify_qp(ibqp, attr, attr_mask, cur_state, new_state);
+       err = __mthca_modify_qp(ibqp, attr, attr_mask, cur_state, new_state,
+                               udata);
 
 out:
        mutex_unlock(&qp->mutex);
 
 
 #include <asm/io.h>
 
+#include <rdma/uverbs_ioctl.h>
+
 #include "mthca_dev.h"
 #include "mthca_cmd.h"
 #include "mthca_memfree.h"
                                         struct mthca_pd *pd,
                                         struct mthca_srq *srq,
                                         struct mthca_tavor_srq_context *context,
-                                        bool is_user)
+                                        struct ib_udata *udata)
 {
+       struct mthca_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mthca_ucontext, ibucontext);
+
        memset(context, 0, sizeof *context);
 
        context->wqe_base_ds = cpu_to_be64(1 << (srq->wqe_shift - 4));
        context->state_pd    = cpu_to_be32(pd->pd_num);
        context->lkey        = cpu_to_be32(srq->mr.ibmr.lkey);
 
-       if (is_user)
-               context->uar =
-                       cpu_to_be32(to_mucontext(pd->ibpd.uobject->context)->uar.index);
+       if (udata)
+               context->uar = cpu_to_be32(ucontext->uar.index);
        else
                context->uar = cpu_to_be32(dev->driver_uar.index);
 }
                                         struct mthca_pd *pd,
                                         struct mthca_srq *srq,
                                         struct mthca_arbel_srq_context *context,
-                                        bool is_user)
+                                        struct ib_udata *udata)
 {
+       struct mthca_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct mthca_ucontext, ibucontext);
        int logsize, max;
 
        memset(context, 0, sizeof *context);
        context->lkey = cpu_to_be32(srq->mr.ibmr.lkey);
        context->db_index = cpu_to_be32(srq->db_index);
        context->logstride_usrpage = cpu_to_be32((srq->wqe_shift - 4) << 29);
-       if (is_user)
-               context->logstride_usrpage |=
-                       cpu_to_be32(to_mucontext(pd->ibpd.uobject->context)->uar.index);
+       if (udata)
+               context->logstride_usrpage |= cpu_to_be32(ucontext->uar.index);
        else
                context->logstride_usrpage |= cpu_to_be32(dev->driver_uar.index);
        context->eq_pd = cpu_to_be32(MTHCA_EQ_ASYNC << 24 | pd->pd_num);
 
 #include <rdma/ib_verbs.h>
 #include <rdma/iw_cm.h>
 #include <rdma/ib_user_verbs.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include "nes.h"
 
        struct nes_adapter *nesadapter = nesdev->nesadapter;
        struct nes_qp *nesqp;
        struct nes_cq *nescq;
-       struct nes_ucontext *nes_ucontext;
+       struct nes_ucontext *nes_ucontext = rdma_udata_to_drv_context(
+               udata, struct nes_ucontext, ibucontext);
        struct nes_hw_cqp_wqe *cqp_wqe;
        struct nes_cqp_request *cqp_request;
        struct nes_create_qp_req req;
                                }
                                if (req.user_qp_buffer)
                                        nesqp->nesuqp_addr = req.user_qp_buffer;
-                               if (udata && (ibpd->uobject->context)) {
+                               if (udata) {
                                        nesqp->user_mode = 1;
-                                       nes_ucontext = to_nesucontext(ibpd->uobject->context);
                                        if (virt_wqs) {
                                                err = 1;
                                                list_for_each_entry(nespbl, &nes_ucontext->qp_reg_mem_list, list) {
                                                }
                                        }
 
-                                       nes_ucontext = to_nesucontext(ibpd->uobject->context);
                                        nesqp->mmap_sq_db_index =
                                                find_next_zero_bit(nes_ucontext->allocated_wqs,
                                                                   NES_MAX_USER_WQ_REGIONS, nes_ucontext->first_free_wq);
        struct nes_adapter *nesadapter = nesdev->nesadapter;
        struct ib_mr *ibmr = ERR_PTR(-EINVAL);
        struct sg_dma_page_iter dma_iter;
-       struct nes_ucontext *nes_ucontext;
+       struct nes_ucontext *nes_ucontext = rdma_udata_to_drv_context(
+               udata, struct nes_ucontext, ibucontext);
        struct nes_pbl *nespbl;
        struct nes_mr *nesmr;
        struct ib_umem *region;
                                return ERR_PTR(-ENOMEM);
                        }
                        nesmr->region = region;
-                       nes_ucontext = to_nesucontext(pd->uobject->context);
                        pbl_depth = region->length >> 12;
                        pbl_depth += (region->length & (4096-1)) ? 1 : 0;
                        nespbl->pbl_size = pbl_depth*sizeof(u64);
 
        hw_srq->max_wr = init_attr->attr.max_wr;
        hw_srq->max_sges = init_attr->attr.max_sge;
 
-       if (udata && ibpd->uobject && ibpd->uobject->context) {
+       if (udata) {
                if (ib_copy_from_udata(&ureq, udata, sizeof(ureq))) {
                        DP_ERR(dev,
                               "create srq: problem copying data from user space\n");
 
 
 #include <rdma/ib_user_verbs.h>
 #include <rdma/ib_addr.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include "usnic_abi.h"
 #include "usnic_ib.h"
        int err;
        struct usnic_ib_dev *us_ibdev;
        struct usnic_ib_qp_grp *qp_grp;
-       struct usnic_ib_ucontext *ucontext;
+       struct usnic_ib_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct usnic_ib_ucontext, ibucontext);
        int cq_cnt;
        struct usnic_vnic_res_spec res_spec;
        struct usnic_ib_create_qp_cmd cmd;
 
        usnic_dbg("\n");
 
-       ucontext = to_uucontext(pd->uobject->context);
        us_ibdev = to_usdev(pd->device);
 
        if (init_attr->create_flags)
 
 #include <rdma/ib_verbs.h>
 #include <rdma/ib_hdrs.h>
 #include <rdma/opa_addr.h>
+#include <rdma/uverbs_ioctl.h>
 #include "qp.h"
 #include "vt.h"
 #include "trace.h"
        size_t sg_list_sz;
        struct ib_qp *ret = ERR_PTR(-ENOMEM);
        struct rvt_dev_info *rdi = ib_to_rvt(ibpd->device);
+       struct rvt_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct rvt_ucontext, ibucontext);
        void *priv = NULL;
        size_t sqsize;
 
                        u32 s = sizeof(struct rvt_rwq) + qp->r_rq.size * sz;
 
                        qp->ip = rvt_create_mmap_info(rdi, s,
-                                                     ibpd->uobject->context,
+                                                     &ucontext->ibucontext,
                                                      qp->r_rq.wq);
                        if (!qp->ip) {
                                ret = ERR_PTR(-ENOMEM);
 
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include "srq.h"
 #include "vt.h"
                              struct ib_udata *udata)
 {
        struct rvt_dev_info *dev = ib_to_rvt(ibpd->device);
+       struct rvt_ucontext *ucontext = rdma_udata_to_drv_context(
+               udata, struct rvt_ucontext, ibucontext);
        struct rvt_srq *srq;
        u32 sz;
        struct ib_srq *ret;
                u32 s = sizeof(struct rvt_rwq) + srq->rq.size * sz;
 
                srq->ip =
-                   rvt_create_mmap_info(dev, s, ibpd->uobject->context,
+                   rvt_create_mmap_info(dev, s, &ucontext->ibucontext,
                                         srq->rq.wq);
                if (!srq->ip) {
                        ret = ERR_PTR(-ENOMEM);
 
                                         &gid->global.interface_id);
 }
 
-struct rvt_ucontext {
-       struct ib_ucontext ibucontext;
-};
-
 static inline struct rvt_ucontext *to_iucontext(struct ib_ucontext
                                                *ibucontext)
 {
 
 #include <linux/delay.h>
 #include <linux/sched.h>
 #include <linux/vmalloc.h>
+#include <rdma/uverbs_ioctl.h>
 
 #include "rxe.h"
 #include "rxe_loc.h"
        struct rxe_cq *rcq = to_rcq(init->recv_cq);
        struct rxe_cq *scq = to_rcq(init->send_cq);
        struct rxe_srq *srq = init->srq ? to_rsrq(init->srq) : NULL;
-       struct ib_ucontext *context = udata ? ibpd->uobject->context : NULL;
+       struct rxe_ucontext *ucontext =
+               rdma_udata_to_drv_context(udata, struct rxe_ucontext, ibuc);
 
        rxe_add_ref(pd);
        rxe_add_ref(rcq);
 
        rxe_qp_init_misc(rxe, qp, init);
 
-       err = rxe_qp_init_req(rxe, qp, init, context, uresp);
+       err = rxe_qp_init_req(rxe, qp, init, &ucontext->ibuc, uresp);
        if (err)
                goto err1;
 
-       err = rxe_qp_init_resp(rxe, qp, init, context, uresp);
+       err = rxe_qp_init_resp(rxe, qp, init, &ucontext->ibuc, uresp);
        if (err)
                goto err2;
 
 
 
 #include <linux/dma-mapping.h>
 #include <net/addrconf.h>
+#include <rdma/uverbs_ioctl.h>
 #include "rxe.h"
 #include "rxe_loc.h"
 #include "rxe_queue.h"
        int err;
        struct rxe_dev *rxe = to_rdev(ibpd->device);
        struct rxe_pd *pd = to_rpd(ibpd);
+       struct rxe_ucontext *ucontext =
+               rdma_udata_to_drv_context(udata, struct rxe_ucontext, ibuc);
        struct rxe_srq *srq;
-       struct ib_ucontext *context = udata ? ibpd->uobject->context : NULL;
        struct rxe_create_srq_resp __user *uresp = NULL;
 
        if (udata) {
        rxe_add_ref(pd);
        srq->pd = pd;
 
-       err = rxe_srq_from_init(rxe, srq, init, context, uresp);
+       err = rxe_srq_from_init(rxe, srq, init, &ucontext->ibuc, uresp);
        if (err)
                goto err2;
 
 
        u8 reserved_operations;
 };
 
+/* User context */
+struct rvt_ucontext {
+       struct ib_ucontext ibucontext;
+};
+
 /* Protection domain */
 struct rvt_pd {
        struct ib_pd ibpd;