IB/qib: Remove completion queue data structures and functions from qib
authorHarish Chegondi <harish.chegondi@intel.com>
Fri, 22 Jan 2016 21:07:36 +0000 (13:07 -0800)
committerDoug Ledford <dledford@redhat.com>
Fri, 11 Mar 2016 01:37:29 +0000 (20:37 -0500)
Use the completion queue functionality provided by rdmavt.

Reviewed-by: Dennis Dalessandro <dennis.dalessandro@intel.com>
Signed-off-by: Harish Chegondi <harish.chegondi@intel.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
drivers/infiniband/hw/qib/Makefile
drivers/infiniband/hw/qib/qib.h
drivers/infiniband/hw/qib/qib_cq.c [deleted file]
drivers/infiniband/hw/qib/qib_init.c
drivers/infiniband/hw/qib/qib_qp.c
drivers/infiniband/hw/qib/qib_rc.c
drivers/infiniband/hw/qib/qib_ruc.c
drivers/infiniband/hw/qib/qib_uc.c
drivers/infiniband/hw/qib/qib_ud.c
drivers/infiniband/hw/qib/qib_verbs.c
drivers/infiniband/hw/qib/qib_verbs.h

index 45db4fc21c936933c67cf8a4eefe699ce6b1beb6..d78f6889f82fd459c53f0154e7d96de883853cac 100644 (file)
@@ -1,6 +1,6 @@
 obj-$(CONFIG_INFINIBAND_QIB) += ib_qib.o
 
-ib_qib-y := qib_cq.o qib_diag.o qib_driver.o qib_eeprom.o \
+ib_qib-y := qib_diag.o qib_driver.o qib_eeprom.o \
        qib_file_ops.o qib_fs.o qib_init.o qib_intr.o \
        qib_mad.o qib_pcie.o qib_pio_copy.o \
        qib_qp.o qib_qsfp.o qib_rc.o qib_ruc.o qib_sdma.o qib_srq.o \
index 29cbe67f39d984d7b57f4aba4ade53c208d4be0d..ccadece9bb133d14a90eba413ee7f8aaf6f98ef9 100644 (file)
@@ -1097,8 +1097,6 @@ struct qib_devdata {
        u16 psxmitwait_check_rate;
        /* high volume overflow errors defered to tasklet */
        struct tasklet_struct error_tasklet;
-       /* per device cq worker */
-       struct kthread_worker *worker;
 
        int assigned_node_id; /* NUMA node closest to HCA */
 };
diff --git a/drivers/infiniband/hw/qib/qib_cq.c b/drivers/infiniband/hw/qib/qib_cq.c
deleted file mode 100644 (file)
index 094f694..0000000
+++ /dev/null
@@ -1,545 +0,0 @@
-/*
- * Copyright (c) 2013 Intel Corporation.  All rights reserved.
- * Copyright (c) 2006, 2007, 2008, 2010 QLogic Corporation. All rights reserved.
- * Copyright (c) 2005, 2006 PathScale, 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/err.h>
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-#include <linux/kthread.h>
-
-#include "qib_verbs.h"
-#include "qib.h"
-
-/**
- * qib_cq_enter - add a new entry to the completion queue
- * @cq: completion queue
- * @entry: work completion entry to add
- * @sig: true if @entry is a solicitated entry
- *
- * This may be called with qp->s_lock held.
- */
-void qib_cq_enter(struct qib_cq *cq, struct ib_wc *entry, int solicited)
-{
-       struct qib_cq_wc *wc;
-       unsigned long flags;
-       u32 head;
-       u32 next;
-
-       spin_lock_irqsave(&cq->lock, flags);
-
-       /*
-        * Note that the head pointer might be writable by user processes.
-        * Take care to verify it is a sane value.
-        */
-       wc = cq->queue;
-       head = wc->head;
-       if (head >= (unsigned) cq->ibcq.cqe) {
-               head = cq->ibcq.cqe;
-               next = 0;
-       } else
-               next = head + 1;
-       if (unlikely(next == wc->tail)) {
-               spin_unlock_irqrestore(&cq->lock, flags);
-               if (cq->ibcq.event_handler) {
-                       struct ib_event ev;
-
-                       ev.device = cq->ibcq.device;
-                       ev.element.cq = &cq->ibcq;
-                       ev.event = IB_EVENT_CQ_ERR;
-                       cq->ibcq.event_handler(&ev, cq->ibcq.cq_context);
-               }
-               return;
-       }
-       if (cq->ip) {
-               wc->uqueue[head].wr_id = entry->wr_id;
-               wc->uqueue[head].status = entry->status;
-               wc->uqueue[head].opcode = entry->opcode;
-               wc->uqueue[head].vendor_err = entry->vendor_err;
-               wc->uqueue[head].byte_len = entry->byte_len;
-               wc->uqueue[head].ex.imm_data =
-                       (__u32 __force)entry->ex.imm_data;
-               wc->uqueue[head].qp_num = entry->qp->qp_num;
-               wc->uqueue[head].src_qp = entry->src_qp;
-               wc->uqueue[head].wc_flags = entry->wc_flags;
-               wc->uqueue[head].pkey_index = entry->pkey_index;
-               wc->uqueue[head].slid = entry->slid;
-               wc->uqueue[head].sl = entry->sl;
-               wc->uqueue[head].dlid_path_bits = entry->dlid_path_bits;
-               wc->uqueue[head].port_num = entry->port_num;
-               /* Make sure entry is written before the head index. */
-               smp_wmb();
-       } else
-               wc->kqueue[head] = *entry;
-       wc->head = next;
-
-       if (cq->notify == IB_CQ_NEXT_COMP ||
-           (cq->notify == IB_CQ_SOLICITED &&
-            (solicited || entry->status != IB_WC_SUCCESS))) {
-               struct kthread_worker *worker;
-               /*
-                * This will cause send_complete() to be called in
-                * another thread.
-                */
-               smp_rmb();
-               worker = cq->dd->worker;
-               if (likely(worker)) {
-                       cq->notify = IB_CQ_NONE;
-                       cq->triggered++;
-                       queue_kthread_work(worker, &cq->comptask);
-               }
-       }
-
-       spin_unlock_irqrestore(&cq->lock, flags);
-}
-
-/**
- * qib_poll_cq - poll for work completion entries
- * @ibcq: the completion queue to poll
- * @num_entries: the maximum number of entries to return
- * @entry: pointer to array where work completions are placed
- *
- * Returns the number of completion entries polled.
- *
- * This may be called from interrupt context.  Also called by ib_poll_cq()
- * in the generic verbs code.
- */
-int qib_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry)
-{
-       struct qib_cq *cq = to_icq(ibcq);
-       struct qib_cq_wc *wc;
-       unsigned long flags;
-       int npolled;
-       u32 tail;
-
-       /* The kernel can only poll a kernel completion queue */
-       if (cq->ip) {
-               npolled = -EINVAL;
-               goto bail;
-       }
-
-       spin_lock_irqsave(&cq->lock, flags);
-
-       wc = cq->queue;
-       tail = wc->tail;
-       if (tail > (u32) cq->ibcq.cqe)
-               tail = (u32) cq->ibcq.cqe;
-       for (npolled = 0; npolled < num_entries; ++npolled, ++entry) {
-               if (tail == wc->head)
-                       break;
-               /* The kernel doesn't need a RMB since it has the lock. */
-               *entry = wc->kqueue[tail];
-               if (tail >= cq->ibcq.cqe)
-                       tail = 0;
-               else
-                       tail++;
-       }
-       wc->tail = tail;
-
-       spin_unlock_irqrestore(&cq->lock, flags);
-
-bail:
-       return npolled;
-}
-
-static void send_complete(struct kthread_work *work)
-{
-       struct qib_cq *cq = container_of(work, struct qib_cq, comptask);
-
-       /*
-        * The completion handler will most likely rearm the notification
-        * and poll for all pending entries.  If a new completion entry
-        * is added while we are in this routine, queue_work()
-        * won't call us again until we return so we check triggered to
-        * see if we need to call the handler again.
-        */
-       for (;;) {
-               u8 triggered = cq->triggered;
-
-               /*
-                * IPoIB connected mode assumes the callback is from a
-                * soft IRQ. We simulate this by blocking "bottom halves".
-                * See the implementation for ipoib_cm_handle_tx_wc(),
-                * netif_tx_lock_bh() and netif_tx_lock().
-                */
-               local_bh_disable();
-               cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context);
-               local_bh_enable();
-
-               if (cq->triggered == triggered)
-                       return;
-       }
-}
-
-/**
- * qib_create_cq - create a completion queue
- * @ibdev: the device this completion queue is attached to
- * @attr: creation attributes
- * @context: unused by the QLogic_IB driver
- * @udata: user data for libibverbs.so
- *
- * Returns a pointer to the completion queue or negative errno values
- * for failure.
- *
- * Called by ib_create_cq() in the generic verbs code.
- */
-struct ib_cq *qib_create_cq(struct ib_device *ibdev,
-                           const struct ib_cq_init_attr *attr,
-                           struct ib_ucontext *context,
-                           struct ib_udata *udata)
-{
-       int entries = attr->cqe;
-       struct qib_ibdev *dev = to_idev(ibdev);
-       struct qib_cq *cq;
-       struct qib_cq_wc *wc;
-       struct ib_cq *ret;
-       u32 sz;
-
-       if (attr->flags)
-               return ERR_PTR(-EINVAL);
-
-       if (entries < 1 || entries > ib_qib_max_cqes) {
-               ret = ERR_PTR(-EINVAL);
-               goto done;
-       }
-
-       /* Allocate the completion queue structure. */
-       cq = kmalloc(sizeof(*cq), GFP_KERNEL);
-       if (!cq) {
-               ret = ERR_PTR(-ENOMEM);
-               goto done;
-       }
-
-       /*
-        * Allocate the completion queue entries and head/tail pointers.
-        * This is allocated separately so that it can be resized and
-        * also mapped into user space.
-        * We need to use vmalloc() in order to support mmap and large
-        * numbers of entries.
-        */
-       sz = sizeof(*wc);
-       if (udata && udata->outlen >= sizeof(__u64))
-               sz += sizeof(struct ib_uverbs_wc) * (entries + 1);
-       else
-               sz += sizeof(struct ib_wc) * (entries + 1);
-       wc = vmalloc_user(sz);
-       if (!wc) {
-               ret = ERR_PTR(-ENOMEM);
-               goto bail_cq;
-       }
-
-       /*
-        * Return the address of the WC as the offset to mmap.
-        * See qib_mmap() for details.
-        */
-       if (udata && udata->outlen >= sizeof(__u64)) {
-               int err;
-
-               cq->ip = rvt_create_mmap_info(&dev->rdi, sz, context, wc);
-               if (!cq->ip) {
-                       ret = ERR_PTR(-ENOMEM);
-                       goto bail_wc;
-               }
-
-               err = ib_copy_to_udata(udata, &cq->ip->offset,
-                                      sizeof(cq->ip->offset));
-               if (err) {
-                       ret = ERR_PTR(err);
-                       goto bail_ip;
-               }
-       } else
-               cq->ip = NULL;
-
-       spin_lock(&dev->n_cqs_lock);
-       if (dev->n_cqs_allocated == ib_qib_max_cqs) {
-               spin_unlock(&dev->n_cqs_lock);
-               ret = ERR_PTR(-ENOMEM);
-               goto bail_ip;
-       }
-
-       dev->n_cqs_allocated++;
-       spin_unlock(&dev->n_cqs_lock);
-
-       if (cq->ip) {
-               spin_lock_irq(&dev->rdi.pending_lock);
-               list_add(&cq->ip->pending_mmaps, &dev->rdi.pending_mmaps);
-               spin_unlock_irq(&dev->rdi.pending_lock);
-       }
-
-       /*
-        * ib_create_cq() will initialize cq->ibcq except for cq->ibcq.cqe.
-        * The number of entries should be >= the number requested or return
-        * an error.
-        */
-       cq->dd = dd_from_dev(dev);
-       cq->ibcq.cqe = entries;
-       cq->notify = IB_CQ_NONE;
-       cq->triggered = 0;
-       spin_lock_init(&cq->lock);
-       init_kthread_work(&cq->comptask, send_complete);
-       wc->head = 0;
-       wc->tail = 0;
-       cq->queue = wc;
-
-       ret = &cq->ibcq;
-
-       goto done;
-
-bail_ip:
-       kfree(cq->ip);
-bail_wc:
-       vfree(wc);
-bail_cq:
-       kfree(cq);
-done:
-       return ret;
-}
-
-/**
- * qib_destroy_cq - destroy a completion queue
- * @ibcq: the completion queue to destroy.
- *
- * Returns 0 for success.
- *
- * Called by ib_destroy_cq() in the generic verbs code.
- */
-int qib_destroy_cq(struct ib_cq *ibcq)
-{
-       struct qib_ibdev *dev = to_idev(ibcq->device);
-       struct qib_cq *cq = to_icq(ibcq);
-
-       flush_kthread_work(&cq->comptask);
-       spin_lock(&dev->n_cqs_lock);
-       dev->n_cqs_allocated--;
-       spin_unlock(&dev->n_cqs_lock);
-       if (cq->ip)
-               kref_put(&cq->ip->ref, rvt_release_mmap_info);
-       else
-               vfree(cq->queue);
-       kfree(cq);
-
-       return 0;
-}
-
-/**
- * qib_req_notify_cq - change the notification type for a completion queue
- * @ibcq: the completion queue
- * @notify_flags: the type of notification to request
- *
- * Returns 0 for success.
- *
- * This may be called from interrupt context.  Also called by
- * ib_req_notify_cq() in the generic verbs code.
- */
-int qib_req_notify_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags notify_flags)
-{
-       struct qib_cq *cq = to_icq(ibcq);
-       unsigned long flags;
-       int ret = 0;
-
-       spin_lock_irqsave(&cq->lock, flags);
-       /*
-        * Don't change IB_CQ_NEXT_COMP to IB_CQ_SOLICITED but allow
-        * any other transitions (see C11-31 and C11-32 in ch. 11.4.2.2).
-        */
-       if (cq->notify != IB_CQ_NEXT_COMP)
-               cq->notify = notify_flags & IB_CQ_SOLICITED_MASK;
-
-       if ((notify_flags & IB_CQ_REPORT_MISSED_EVENTS) &&
-           cq->queue->head != cq->queue->tail)
-               ret = 1;
-
-       spin_unlock_irqrestore(&cq->lock, flags);
-
-       return ret;
-}
-
-/**
- * qib_resize_cq - change the size of the CQ
- * @ibcq: the completion queue
- *
- * Returns 0 for success.
- */
-int qib_resize_cq(struct ib_cq *ibcq, int cqe, struct ib_udata *udata)
-{
-       struct qib_cq *cq = to_icq(ibcq);
-       struct qib_cq_wc *old_wc;
-       struct qib_cq_wc *wc;
-       u32 head, tail, n;
-       int ret;
-       u32 sz;
-
-       if (cqe < 1 || cqe > ib_qib_max_cqes) {
-               ret = -EINVAL;
-               goto bail;
-       }
-
-       /*
-        * Need to use vmalloc() if we want to support large #s of entries.
-        */
-       sz = sizeof(*wc);
-       if (udata && udata->outlen >= sizeof(__u64))
-               sz += sizeof(struct ib_uverbs_wc) * (cqe + 1);
-       else
-               sz += sizeof(struct ib_wc) * (cqe + 1);
-       wc = vmalloc_user(sz);
-       if (!wc) {
-               ret = -ENOMEM;
-               goto bail;
-       }
-
-       /* Check that we can write the offset to mmap. */
-       if (udata && udata->outlen >= sizeof(__u64)) {
-               __u64 offset = 0;
-
-               ret = ib_copy_to_udata(udata, &offset, sizeof(offset));
-               if (ret)
-                       goto bail_free;
-       }
-
-       spin_lock_irq(&cq->lock);
-       /*
-        * Make sure head and tail are sane since they
-        * might be user writable.
-        */
-       old_wc = cq->queue;
-       head = old_wc->head;
-       if (head > (u32) cq->ibcq.cqe)
-               head = (u32) cq->ibcq.cqe;
-       tail = old_wc->tail;
-       if (tail > (u32) cq->ibcq.cqe)
-               tail = (u32) cq->ibcq.cqe;
-       if (head < tail)
-               n = cq->ibcq.cqe + 1 + head - tail;
-       else
-               n = head - tail;
-       if (unlikely((u32)cqe < n)) {
-               ret = -EINVAL;
-               goto bail_unlock;
-       }
-       for (n = 0; tail != head; n++) {
-               if (cq->ip)
-                       wc->uqueue[n] = old_wc->uqueue[tail];
-               else
-                       wc->kqueue[n] = old_wc->kqueue[tail];
-               if (tail == (u32) cq->ibcq.cqe)
-                       tail = 0;
-               else
-                       tail++;
-       }
-       cq->ibcq.cqe = cqe;
-       wc->head = n;
-       wc->tail = 0;
-       cq->queue = wc;
-       spin_unlock_irq(&cq->lock);
-
-       vfree(old_wc);
-
-       if (cq->ip) {
-               struct qib_ibdev *dev = to_idev(ibcq->device);
-               struct rvt_mmap_info *ip = cq->ip;
-
-               rvt_update_mmap_info(&dev->rdi, ip, sz, wc);
-
-               /*
-                * Return the offset to mmap.
-                * See qib_mmap() for details.
-                */
-               if (udata && udata->outlen >= sizeof(__u64)) {
-                       ret = ib_copy_to_udata(udata, &ip->offset,
-                                              sizeof(ip->offset));
-                       if (ret)
-                               goto bail;
-               }
-
-               spin_lock_irq(&dev->rdi.pending_lock);
-               if (list_empty(&ip->pending_mmaps))
-                       list_add(&ip->pending_mmaps, &dev->rdi.pending_mmaps);
-               spin_unlock_irq(&dev->rdi.pending_lock);
-       }
-
-       ret = 0;
-       goto bail;
-
-bail_unlock:
-       spin_unlock_irq(&cq->lock);
-bail_free:
-       vfree(wc);
-bail:
-       return ret;
-}
-
-int qib_cq_init(struct qib_devdata *dd)
-{
-       int ret = 0;
-       int cpu;
-       struct task_struct *task;
-
-       if (dd->worker)
-               return 0;
-       dd->worker = kzalloc(sizeof(*dd->worker), GFP_KERNEL);
-       if (!dd->worker)
-               return -ENOMEM;
-       init_kthread_worker(dd->worker);
-       task = kthread_create_on_node(
-               kthread_worker_fn,
-               dd->worker,
-               dd->assigned_node_id,
-               "qib_cq%d", dd->unit);
-       if (IS_ERR(task))
-               goto task_fail;
-       cpu = cpumask_first(cpumask_of_node(dd->assigned_node_id));
-       kthread_bind(task, cpu);
-       wake_up_process(task);
-out:
-       return ret;
-task_fail:
-       ret = PTR_ERR(task);
-       kfree(dd->worker);
-       dd->worker = NULL;
-       goto out;
-}
-
-void qib_cq_exit(struct qib_devdata *dd)
-{
-       struct kthread_worker *worker;
-
-       worker = dd->worker;
-       if (!worker)
-               return;
-       /* blocks future queuing from send_complete() */
-       dd->worker = NULL;
-       smp_wmb();
-       flush_kthread_worker(worker);
-       kthread_stop(worker->task);
-       kfree(worker);
-}
index a3c74bb4df62fbbccad141a4ab000b90925a8d5d..3f062f0dd9d8082f9fb2986ee13b61c4a867a362 100644 (file)
@@ -457,8 +457,6 @@ static int loadtime_init(struct qib_devdata *dd)
        init_timer(&dd->intrchk_timer);
        dd->intrchk_timer.function = verify_interrupt;
        dd->intrchk_timer.data = (unsigned long) dd;
-
-       ret = qib_cq_init(dd);
 done:
        return ret;
 }
@@ -1435,7 +1433,6 @@ static void cleanup_device_data(struct qib_devdata *dd)
        }
        kfree(tmp);
        kfree(dd->boardname);
-       qib_cq_exit(dd);
 }
 
 /*
index 83dec693845ede5306c01a7ce8aa218d9d302c4a..6e5a05e35fef7bd84fc80dd6b97f1b90ca4aff76 100644 (file)
@@ -473,7 +473,7 @@ int qib_error_qp(struct rvt_qp *qp, enum ib_wc_status err)
        if (test_and_clear_bit(RVT_R_WRID_VALID, &qp->r_aflags)) {
                wc.wr_id = qp->r_wr_id;
                wc.status = err;
-               qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc, 1);
+               rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.recv_cq), &wc, 1);
        }
        wc.status = IB_WC_WR_FLUSH_ERR;
 
@@ -496,7 +496,7 @@ int qib_error_qp(struct rvt_qp *qp, enum ib_wc_status err)
                        wc.wr_id = get_rwqe_ptr(&qp->r_rq, tail)->wr_id;
                        if (++tail >= qp->r_rq.size)
                                tail = 0;
-                       qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc, 1);
+                       rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.recv_cq), &wc, 1);
                }
                wq->tail = tail;
 
index e118004fab17621e51d7f3f3ae3fe8990b9e42a5..8be5d45107ab3f17b919236c42c8cd023e059696 100644 (file)
@@ -1026,7 +1026,7 @@ void qib_rc_send_complete(struct rvt_qp *qp, struct qib_ib_header *hdr)
                        wc.opcode = ib_qib_wc_opcode[wqe->wr.opcode];
                        wc.byte_len = wqe->length;
                        wc.qp = &qp->ibqp;
-                       qib_cq_enter(to_icq(qp->ibqp.send_cq), &wc, 0);
+                       rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.send_cq), &wc, 0);
                }
                if (++qp->s_last >= qp->s_size)
                        qp->s_last = 0;
@@ -1082,7 +1082,7 @@ static struct rvt_swqe *do_rc_completion(struct rvt_qp *qp,
                        wc.opcode = ib_qib_wc_opcode[wqe->wr.opcode];
                        wc.byte_len = wqe->length;
                        wc.qp = &qp->ibqp;
-                       qib_cq_enter(to_icq(qp->ibqp.send_cq), &wc, 0);
+                       rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.send_cq), &wc, 0);
                }
                if (++qp->s_last >= qp->s_size)
                        qp->s_last = 0;
@@ -2048,7 +2048,7 @@ send_last:
                wc.dlid_path_bits = 0;
                wc.port_num = 0;
                /* Signal completion event if the solicited bit is set. */
-               qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
+               rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.recv_cq), &wc,
                             (ohdr->bth[0] &
                              cpu_to_be32(IB_BTH_SOLICITED)) != 0);
                break;
index f7b3bb794d1b58090dcd9a2418257bed306f2f56..80f113078720d628b79657e22757caff0f0748b1 100644 (file)
@@ -120,7 +120,7 @@ bad_lkey:
        wc.opcode = IB_WC_RECV;
        wc.qp = &qp->ibqp;
        /* Signal solicited completion event. */
-       qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc, 1);
+       rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.recv_cq), &wc, 1);
        ret = 0;
 bail:
        return ret;
@@ -563,8 +563,8 @@ again:
        wc.sl = qp->remote_ah_attr.sl;
        wc.port_num = 1;
        /* Signal completion event if the solicited bit is set. */
-       qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
-                      wqe->wr.send_flags & IB_SEND_SOLICITED);
+       rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.recv_cq), &wc,
+                    wqe->wr.send_flags & IB_SEND_SOLICITED);
 
 send_comp:
        spin_lock_irqsave(&sqp->s_lock, flags);
@@ -806,7 +806,7 @@ void qib_send_complete(struct rvt_qp *qp, struct rvt_swqe *wqe,
                wc.qp = &qp->ibqp;
                if (status == IB_WC_SUCCESS)
                        wc.byte_len = wqe->length;
-               qib_cq_enter(to_icq(qp->ibqp.send_cq), &wc,
+               rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.send_cq), &wc,
                             status != IB_WC_SUCCESS);
        }
 
index deceb459e990b305551b5cfde587e95b75cab884..caf0191651a93cd7430d1348f32937b194eb808e 100644 (file)
@@ -415,7 +415,7 @@ last_imm:
                wc.dlid_path_bits = 0;
                wc.port_num = 0;
                /* Signal completion event if the solicited bit is set. */
-               qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
+               rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.recv_cq), &wc,
                             (ohdr->bth[0] &
                                cpu_to_be32(IB_BTH_SOLICITED)) != 0);
                break;
index 76f854e7aee852070c7a8b78edd8b40e85f4ac21..abca52782a4fb70f66419e50880501967db79f10 100644 (file)
@@ -217,7 +217,7 @@ static void qib_ud_loopback(struct rvt_qp *sqp, struct rvt_swqe *swqe)
        wc.dlid_path_bits = ah_attr->dlid & ((1 << ppd->lmc) - 1);
        wc.port_num = qp->port_num;
        /* Signal completion event if the solicited bit is set. */
-       qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
+       rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.recv_cq), &wc,
                     swqe->wr.send_flags & IB_SEND_SOLICITED);
        ibp->rvp.n_loop_pkts++;
 bail_unlock:
@@ -583,7 +583,7 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
                dlid & ((1 << ppd_from_ibp(ibp)->lmc) - 1);
        wc.port_num = qp->port_num;
        /* Signal completion event if the solicited bit is set. */
-       qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
+       rvt_cq_enter(ibcq_to_rvtcq(qp->ibqp.recv_cq), &wc,
                     (ohdr->bth[0] &
                        cpu_to_be32(IB_BTH_SOLICITED)) != 0);
        return;
index a1815028ef7237d8c2b6344fa269a930b3d18510..a27166b67a78e312a0d6d2e8aff5e6c569e1286f 100644 (file)
@@ -1909,7 +1909,6 @@ int qib_register_ib_device(struct qib_devdata *dd)
                init_ibport(ppd + i);
 
        /* Only need to initialize non-zero fields. */
-       spin_lock_init(&dev->n_cqs_lock);
        spin_lock_init(&dev->n_qps_lock);
        spin_lock_init(&dev->n_srqs_lock);
        spin_lock_init(&dev->n_mcast_grps_lock);
@@ -2021,11 +2020,11 @@ int qib_register_ib_device(struct qib_devdata *dd)
        ibdev->post_send = qib_post_send;
        ibdev->post_recv = qib_post_receive;
        ibdev->post_srq_recv = qib_post_srq_receive;
-       ibdev->create_cq = qib_create_cq;
-       ibdev->destroy_cq = qib_destroy_cq;
-       ibdev->resize_cq = qib_resize_cq;
-       ibdev->poll_cq = qib_poll_cq;
-       ibdev->req_notify_cq = qib_req_notify_cq;
+       ibdev->create_cq = NULL;
+       ibdev->destroy_cq = NULL;
+       ibdev->resize_cq = NULL;
+       ibdev->poll_cq = NULL;
+       ibdev->req_notify_cq = NULL;
        ibdev->get_dma_mr = NULL;
        ibdev->reg_user_mr = NULL;
        ibdev->dereg_mr = NULL;
@@ -2059,7 +2058,7 @@ int qib_register_ib_device(struct qib_devdata *dd)
        dd->verbs_dev.rdi.driver_f.free_all_qps = qib_free_all_qps;
        dd->verbs_dev.rdi.driver_f.notify_qp_reset = notify_qp_reset;
 
-       dd->verbs_dev.rdi.flags = RVT_FLAG_CQ_INIT_DRIVER;
+       dd->verbs_dev.rdi.flags = 0;
 
        dd->verbs_dev.rdi.dparms.lkey_table_size = qib_lkey_table_size;
        dd->verbs_dev.rdi.dparms.qp_table_size = ib_qib_qp_table_size;
@@ -2070,6 +2069,10 @@ int qib_register_ib_device(struct qib_devdata *dd)
        dd->verbs_dev.rdi.dparms.qos_shift = 1;
        dd->verbs_dev.rdi.dparms.nports = dd->num_pports;
        dd->verbs_dev.rdi.dparms.npkeys = qib_get_npkeys(dd);
+       dd->verbs_dev.rdi.dparms.node = dd->assigned_node_id;
+       snprintf(dd->verbs_dev.rdi.dparms.cq_name,
+                sizeof(dd->verbs_dev.rdi.dparms.cq_name),
+                "qib_cq%d", dd->unit);
 
        qib_fill_device_attr(dd);
 
index 3383d565b8db645accc029ef3cbadc214d0219c7..818ac871738667c6f9baf81c91a238a5621d28ef 100644 (file)
@@ -46,6 +46,7 @@
 #include <rdma/ib_pack.h>
 #include <rdma/ib_user_verbs.h>
 #include <rdma/rdma_vt.h>
+#include <rdma/rdmavt_cq.h>
 
 struct qib_ctxtdata;
 struct qib_pportdata;
@@ -61,12 +62,6 @@ struct qib_verbs_txreq;
  */
 #define QIB_UVERBS_ABI_VERSION       2
 
-/*
- * Define an ib_cq_notify value that is not valid so we know when CQ
- * notifications are armed.
- */
-#define IB_CQ_NONE      (IB_CQ_NEXT_COMP + 1)
-
 #define IB_SEQ_NAK     (3 << 29)
 
 /* AETH NAK opcode values */
@@ -219,35 +214,6 @@ struct qib_mcast {
        int n_attached;
 };
 
-/*
- * This structure is used to contain the head pointer, tail pointer,
- * and completion queue entries as a single memory allocation so
- * it can be mmap'ed into user space.
- */
-struct qib_cq_wc {
-       u32 head;               /* index of next entry to fill */
-       u32 tail;               /* index of next ib_poll_cq() entry */
-       union {
-               /* these are actually size ibcq.cqe + 1 */
-               struct ib_uverbs_wc uqueue[0];
-               struct ib_wc kqueue[0];
-       };
-};
-
-/*
- * The completion queue structure.
- */
-struct qib_cq {
-       struct ib_cq ibcq;
-       struct kthread_work comptask;
-       struct qib_devdata *dd;
-       spinlock_t lock; /* protect changes in this struct */
-       u8 notify;
-       u8 triggered;
-       struct qib_cq_wc *queue;
-       struct rvt_mmap_info *ip;
-};
-
 /*
  * qib specific data structure that will be hidden from rvt after the queue pair
  * is made common.
@@ -345,8 +311,6 @@ struct qib_ibdev {
        u32 n_piowait;
        u32 n_txwait;
 
-       u32 n_cqs_allocated;    /* number of CQs allocated for device */
-       spinlock_t n_cqs_lock;
        u32 n_qps_allocated;    /* number of QPs allocated for device */
        spinlock_t n_qps_lock;
        u32 n_srqs_allocated;   /* number of SRQs allocated for device */
@@ -375,11 +339,6 @@ struct qib_verbs_counters {
        u32 vl15_dropped;
 };
 
-static inline struct qib_cq *to_icq(struct ib_cq *ibcq)
-{
-       return container_of(ibcq, struct qib_cq, ibcq);
-}
-
 static inline struct rvt_qp *to_iqp(struct ib_qp *ibqp)
 {
        return container_of(ibqp, struct rvt_qp, ibqp);
@@ -545,25 +504,6 @@ int qib_query_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr);
 
 int qib_destroy_srq(struct ib_srq *ibsrq);
 
-int qib_cq_init(struct qib_devdata *dd);
-
-void qib_cq_exit(struct qib_devdata *dd);
-
-void qib_cq_enter(struct qib_cq *cq, struct ib_wc *entry, int sig);
-
-int qib_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *entry);
-
-struct ib_cq *qib_create_cq(struct ib_device *ibdev,
-                           const struct ib_cq_init_attr *attr,
-                           struct ib_ucontext *context,
-                           struct ib_udata *udata);
-
-int qib_destroy_cq(struct ib_cq *ibcq);
-
-int qib_req_notify_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags notify_flags);
-
-int qib_resize_cq(struct ib_cq *ibcq, int cqe, struct ib_udata *udata);
-
 void mr_rcu_callback(struct rcu_head *list);
 
 static inline void qib_put_ss(struct rvt_sge_state *ss)