ret = -ENODEV;
                goto out;
        }
-       ah = ib_create_ah(mad_agent->qp->pd, &av->ah_attr);
+       ah = rdma_create_ah(mad_agent->qp->pd, &av->ah_attr);
        if (IS_ERR(ah)) {
                ret = PTR_ERR(ah);
                goto out;
 
                        cpu_to_be64(IB_SA_WELL_KNOWN_GUID);
        }
 
-       new_ah->ah = ib_create_ah(port->agent->qp->pd, &ah_attr);
+       new_ah->ah = rdma_create_ah(port->agent->qp->pd, &ah_attr);
        if (IS_ERR(new_ah->ah)) {
                pr_warn("Couldn't create new SM AH\n");
                kfree(new_ah);
 
                ah_attr.grh.traffic_class  = packet->mad.hdr.traffic_class;
        }
 
-       ah = ib_create_ah(agent->qp->pd, &ah_attr);
+       ah = rdma_create_ah(agent->qp->pd, &ah_attr);
        if (IS_ERR(ah)) {
                ret = PTR_ERR(ah);
                goto err_up;
 
 
 /* Address handles */
 
-struct ib_ah *ib_create_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr)
+struct ib_ah *rdma_create_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr)
 {
        struct ib_ah *ah;
 
 
        return ah;
 }
-EXPORT_SYMBOL(ib_create_ah);
+EXPORT_SYMBOL(rdma_create_ah);
 
 int ib_get_rdma_header_version(const union rdma_network_hdr *hdr)
 {
        if (ret)
                return ERR_PTR(ret);
 
-       return ib_create_ah(pd, &ah_attr);
+       return rdma_create_ah(pd, &ah_attr);
 }
 EXPORT_SYMBOL(ib_create_ah_from_wc);
 
 
        rcu_read_lock();
        qp0 = rcu_dereference(ibp->rvp.qp[0]);
        if (qp0)
-               ah = ib_create_ah(qp0->ibqp.pd, &attr);
+               ah = rdma_create_ah(qp0->ibqp.pd, &attr);
        rcu_read_unlock();
        return ah;
 }
 
        ah_attr.sl       = sl;
        ah_attr.port_num = port_num;
 
-       new_ah = ib_create_ah(dev->send_agent[port_num - 1][0]->qp->pd,
-                             &ah_attr);
+       new_ah = rdma_create_ah(dev->send_agent[port_num - 1][0]->qp->pd,
+                               &ah_attr);
        if (IS_ERR(new_ah))
                return;
 
                        return -EINVAL;
                attr.ah_flags = IB_AH_GRH;
        }
-       ah = ib_create_ah(tun_ctx->pd, &attr);
+       ah = rdma_create_ah(tun_ctx->pd, &attr);
        if (IS_ERR(ah))
                return -ENOMEM;
 
        /* create ah */
        sgid_index = attr->grh.sgid_index;
        attr->grh.sgid_index = 0;
-       ah = ib_create_ah(sqp_ctx->pd, attr);
+       ah = rdma_create_ah(sqp_ctx->pd, attr);
        if (IS_ERR(ah))
                return -ENOMEM;
        attr->grh.sgid_index = sgid_index;
 
        ah_attr.sl       = sl;
        ah_attr.port_num = port_num;
 
-       new_ah = ib_create_ah(dev->send_agent[port_num - 1][0]->qp->pd,
-                             &ah_attr);
+       new_ah = rdma_create_ah(dev->send_agent[port_num - 1][0]->qp->pd,
+                               &ah_attr);
        if (IS_ERR(new_ah))
                return;
 
 
        rcu_read_lock();
        qp0 = rcu_dereference(ibp->rvp.qp[0]);
        if (qp0)
-               ah = ib_create_ah(qp0->ibqp.pd, &attr);
+               ah = rdma_create_ah(qp0->ibqp.pd, &attr);
        rcu_read_unlock();
        return ah;
 }
 
        ah->last_send = 0;
        kref_init(&ah->ref);
 
-       vah = ib_create_ah(pd, attr);
+       vah = rdma_create_ah(pd, attr);
        if (IS_ERR(vah)) {
                kfree(ah);
                ah = (struct ipoib_ah *)vah;
 
        }
 
        ah_attr.dlid = trap_lid;
-       ah = ib_create_ah(port->mad_agent->qp->pd, &ah_attr);
+       ah = rdma_create_ah(port->mad_agent->qp->pd, &ah_attr);
        if (IS_ERR(ah)) {
                c_err("%s:Couldn't create new AH = %p\n", __func__, ah);
                c_err("%s:dlid = %d, sl = %d, port = %d\n", __func__,
 
 void ib_dealloc_pd(struct ib_pd *pd);
 
 /**
- * ib_create_ah - Creates an address handle for the given address vector.
+ * rdma_create_ah - Creates an address handle for the given address vector.
  * @pd: The protection domain associated with the address handle.
  * @ah_attr: The attributes of the address vector.
  *
  * The address handle is used to reference a local or global destination
  * in all UD QP post sends.
  */
-struct ib_ah *ib_create_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr);
+struct ib_ah *rdma_create_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr);
 
 /**
  * ib_get_gids_from_rdma_hdr - Get sgid and dgid from GRH or IPv4 header