1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB 2 /* 3 * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved. 4 * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved. 5 */ 6 #include <linux/vmalloc.h> 7 #include "rxe.h" 8 #include "rxe_loc.h" 9 #include "rxe_queue.h" 10 11 int rxe_cq_chk_attr(struct rxe_dev *rxe, struct rxe_cq *cq, 12 int cqe, int comp_vector) 13 { 14 int count; 15 16 if (cqe <= 0) { 17 rxe_dbg_dev(rxe, "cqe(%d) <= 0\n", cqe); 18 goto err1; 19 } 20 21 if (cqe > rxe->attr.max_cqe) { 22 rxe_dbg_dev(rxe, "cqe(%d) > max_cqe(%d)\n", 23 cqe, rxe->attr.max_cqe); 24 goto err1; 25 } 26 27 if (cq) { 28 count = queue_count(cq->queue, QUEUE_TYPE_TO_CLIENT); 29 if (cqe < count) { 30 rxe_dbg_cq(cq, "cqe(%d) < current # elements in queue (%d)\n", 31 cqe, count); 32 goto err1; 33 } 34 } 35 36 return 0; 37 38 err1: 39 return -EINVAL; 40 } 41 42 int rxe_cq_from_init(struct rxe_dev *rxe, struct rxe_cq *cq, int cqe, 43 int comp_vector, struct ib_udata *udata, 44 struct rxe_create_cq_resp __user *uresp) 45 { 46 int err; 47 enum queue_type type; 48 49 type = QUEUE_TYPE_TO_CLIENT; 50 cq->queue = rxe_queue_init(rxe, &cqe, 51 sizeof(struct rxe_cqe), type); 52 if (!cq->queue) { 53 rxe_dbg_dev(rxe, "unable to create cq\n"); 54 return -ENOMEM; 55 } 56 57 err = do_mmap_info(rxe, uresp ? &uresp->mi : NULL, udata, 58 cq->queue->buf, cq->queue->buf_size, &cq->queue->ip); 59 if (err) { 60 vfree(cq->queue->buf); 61 kfree(cq->queue); 62 return err; 63 } 64 65 cq->is_user = uresp; 66 67 spin_lock_init(&cq->cq_lock); 68 cq->ibcq.cqe = cqe; 69 return 0; 70 } 71 72 int rxe_cq_resize_queue(struct rxe_cq *cq, int cqe, 73 struct rxe_resize_cq_resp __user *uresp, 74 struct ib_udata *udata) 75 { 76 int err; 77 78 err = rxe_queue_resize(cq->queue, (unsigned int *)&cqe, 79 sizeof(struct rxe_cqe), udata, 80 uresp ? &uresp->mi : NULL, NULL, &cq->cq_lock); 81 if (!err) 82 cq->ibcq.cqe = cqe; 83 84 return err; 85 } 86 87 /* caller holds reference to cq */ 88 int rxe_cq_post(struct rxe_cq *cq, struct rxe_cqe *cqe, int solicited) 89 { 90 struct ib_event ev; 91 int full; 92 void *addr; 93 unsigned long flags; 94 95 spin_lock_irqsave(&cq->cq_lock, flags); 96 97 full = queue_full(cq->queue, QUEUE_TYPE_TO_CLIENT); 98 if (unlikely(full)) { 99 rxe_err_cq(cq, "queue full\n"); 100 spin_unlock_irqrestore(&cq->cq_lock, flags); 101 if (cq->ibcq.event_handler) { 102 ev.device = cq->ibcq.device; 103 ev.element.cq = &cq->ibcq; 104 ev.event = IB_EVENT_CQ_ERR; 105 cq->ibcq.event_handler(&ev, cq->ibcq.cq_context); 106 } 107 108 return -EBUSY; 109 } 110 111 addr = queue_producer_addr(cq->queue, QUEUE_TYPE_TO_CLIENT); 112 memcpy(addr, cqe, sizeof(*cqe)); 113 114 queue_advance_producer(cq->queue, QUEUE_TYPE_TO_CLIENT); 115 116 if ((cq->notify & IB_CQ_NEXT_COMP) || 117 (cq->notify & IB_CQ_SOLICITED && solicited)) { 118 cq->notify = 0; 119 cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context); 120 } 121 122 spin_unlock_irqrestore(&cq->cq_lock, flags); 123 124 return 0; 125 } 126 127 void rxe_cq_cleanup(struct rxe_pool_elem *elem) 128 { 129 struct rxe_cq *cq = container_of(elem, typeof(*cq), elem); 130 131 if (cq->queue) 132 rxe_queue_cleanup(cq->queue); 133 } 134