Quelle  rxe_cq.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
/*
 * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved.
 * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved.
 */
#include <linux/vmalloc.h>
#include "rxe.h"
#include "rxe_loc.h"
#include "rxe_queue.h"

int rxe_cq_chk_attr(struct rxe_dev *rxe, struct rxe_cq *cq,
      int cqe, int comp_vector)
{
 int count;

 if (cqe <= 0) {
  rxe_dbg_dev(rxe, "cqe(%d) <= 0\n", cqe);
  goto err1;
 }

 if (cqe > rxe->attr.max_cqe) {
  rxe_dbg_dev(rxe, "cqe(%d) > max_cqe(%d)\n",
    cqe, rxe->attr.max_cqe);
  goto err1;
 }

 if (cq) {
  count = queue_count(cq->queue, QUEUE_TYPE_TO_CLIENT);
  if (cqe < count) {
   rxe_dbg_cq(cq, "cqe(%d) < current # elements in queue (%d)\n",
     cqe, count);
   goto err1;
  }
 }

 return 0;

err1:
 return -EINVAL;
}

int rxe_cq_from_init(struct rxe_dev *rxe, struct rxe_cq *cq, int cqe,
       int comp_vector, struct ib_udata *udata,
       struct rxe_create_cq_resp __user *uresp)
{
 int err;
 enum queue_type type;

 type = QUEUE_TYPE_TO_CLIENT;
 cq->queue = rxe_queue_init(rxe, &cqe,
   sizeof(struct rxe_cqe), type);
 if (!cq->queue) {
  rxe_dbg_dev(rxe, "unable to create cq\n");
  return -ENOMEM;
 }

 err = do_mmap_info(rxe, uresp ? &uresp->mi : NULL, udata,
      cq->queue->buf, cq->queue->buf_size, &cq->queue->ip);
 if (err)
  return err;

 cq->is_user = uresp;

 spin_lock_init(&cq->cq_lock);
 cq->ibcq.cqe = cqe;
 return 0;
}

int rxe_cq_resize_queue(struct rxe_cq *cq, int cqe,
   struct rxe_resize_cq_resp __user *uresp,
   struct ib_udata *udata)
{
 int err;

 err = rxe_queue_resize(cq->queue, (unsigned int *)&cqe,
          sizeof(struct rxe_cqe), udata,
          uresp ? &uresp->mi : NULL, NULL, &cq->cq_lock);
 if (!err)
  cq->ibcq.cqe = cqe;

 return err;
}

/* caller holds reference to cq */
int rxe_cq_post(struct rxe_cq *cq, struct rxe_cqe *cqe, int solicited)
{
 struct ib_event ev;
 int full;
 void *addr;
 unsigned long flags;

 spin_lock_irqsave(&cq->cq_lock, flags);

 full = queue_full(cq->queue, QUEUE_TYPE_TO_CLIENT);
 if (unlikely(full)) {
  rxe_err_cq(cq, "queue full\n");
  spin_unlock_irqrestore(&cq->cq_lock, flags);
  if (cq->ibcq.event_handler) {
   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 -EBUSY;
 }

 addr = queue_producer_addr(cq->queue, QUEUE_TYPE_TO_CLIENT);
 memcpy(addr, cqe, sizeof(*cqe));

 queue_advance_producer(cq->queue, QUEUE_TYPE_TO_CLIENT);

 if ((cq->notify & IB_CQ_NEXT_COMP) ||
     (cq->notify & IB_CQ_SOLICITED && solicited)) {
  cq->notify = 0;
  cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context);
 }

 spin_unlock_irqrestore(&cq->cq_lock, flags);

 return 0;
}

void rxe_cq_cleanup(struct rxe_pool_elem *elem)
{
 struct rxe_cq *cq = container_of(elem, typeof(*cq), elem);

 if (cq->queue)
  rxe_queue_cleanup(cq->queue);
}