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 
rxe_cq_chk_attr(struct rxe_dev * rxe,struct rxe_cq * cq,int cqe,int comp_vector)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 		pr_warn("cqe(%d) <= 0\n", cqe);
18 		goto err1;
19 	}
20 
21 	if (cqe > rxe->attr.max_cqe) {
22 		pr_warn("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 			pr_warn("cqe(%d) < current # elements in queue (%d)",
31 				cqe, count);
32 			goto err1;
33 		}
34 	}
35 
36 	return 0;
37 
38 err1:
39 	return -EINVAL;
40 }
41 
rxe_send_complete(struct tasklet_struct * t)42 static void rxe_send_complete(struct tasklet_struct *t)
43 {
44 	struct rxe_cq *cq = from_tasklet(cq, t, comp_task);
45 	unsigned long flags;
46 
47 	spin_lock_irqsave(&cq->cq_lock, flags);
48 	if (cq->is_dying) {
49 		spin_unlock_irqrestore(&cq->cq_lock, flags);
50 		return;
51 	}
52 	spin_unlock_irqrestore(&cq->cq_lock, flags);
53 
54 	cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context);
55 }
56 
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)57 int rxe_cq_from_init(struct rxe_dev *rxe, struct rxe_cq *cq, int cqe,
58 		     int comp_vector, struct ib_udata *udata,
59 		     struct rxe_create_cq_resp __user *uresp)
60 {
61 	int err;
62 	enum queue_type type;
63 
64 	type = QUEUE_TYPE_TO_CLIENT;
65 	cq->queue = rxe_queue_init(rxe, &cqe,
66 			sizeof(struct rxe_cqe), type);
67 	if (!cq->queue) {
68 		pr_warn("unable to create cq\n");
69 		return -ENOMEM;
70 	}
71 
72 	err = do_mmap_info(rxe, uresp ? &uresp->mi : NULL, udata,
73 			   cq->queue->buf, cq->queue->buf_size, &cq->queue->ip);
74 	if (err) {
75 		vfree(cq->queue->buf);
76 		kfree(cq->queue);
77 		return err;
78 	}
79 
80 	cq->is_user = uresp;
81 
82 	cq->is_dying = false;
83 
84 	tasklet_setup(&cq->comp_task, rxe_send_complete);
85 
86 	spin_lock_init(&cq->cq_lock);
87 	cq->ibcq.cqe = cqe;
88 	return 0;
89 }
90 
rxe_cq_resize_queue(struct rxe_cq * cq,int cqe,struct rxe_resize_cq_resp __user * uresp,struct ib_udata * udata)91 int rxe_cq_resize_queue(struct rxe_cq *cq, int cqe,
92 			struct rxe_resize_cq_resp __user *uresp,
93 			struct ib_udata *udata)
94 {
95 	int err;
96 
97 	err = rxe_queue_resize(cq->queue, (unsigned int *)&cqe,
98 			       sizeof(struct rxe_cqe), udata,
99 			       uresp ? &uresp->mi : NULL, NULL, &cq->cq_lock);
100 	if (!err)
101 		cq->ibcq.cqe = cqe;
102 
103 	return err;
104 }
105 
rxe_cq_post(struct rxe_cq * cq,struct rxe_cqe * cqe,int solicited)106 int rxe_cq_post(struct rxe_cq *cq, struct rxe_cqe *cqe, int solicited)
107 {
108 	struct ib_event ev;
109 	int full;
110 	void *addr;
111 	unsigned long flags;
112 
113 	spin_lock_irqsave(&cq->cq_lock, flags);
114 
115 	full = queue_full(cq->queue, QUEUE_TYPE_TO_CLIENT);
116 	if (unlikely(full)) {
117 		spin_unlock_irqrestore(&cq->cq_lock, flags);
118 		if (cq->ibcq.event_handler) {
119 			ev.device = cq->ibcq.device;
120 			ev.element.cq = &cq->ibcq;
121 			ev.event = IB_EVENT_CQ_ERR;
122 			cq->ibcq.event_handler(&ev, cq->ibcq.cq_context);
123 		}
124 
125 		return -EBUSY;
126 	}
127 
128 	addr = queue_producer_addr(cq->queue, QUEUE_TYPE_TO_CLIENT);
129 	memcpy(addr, cqe, sizeof(*cqe));
130 
131 	queue_advance_producer(cq->queue, QUEUE_TYPE_TO_CLIENT);
132 
133 	spin_unlock_irqrestore(&cq->cq_lock, flags);
134 
135 	if ((cq->notify == IB_CQ_NEXT_COMP) ||
136 	    (cq->notify == IB_CQ_SOLICITED && solicited)) {
137 		cq->notify = 0;
138 		tasklet_schedule(&cq->comp_task);
139 	}
140 
141 	return 0;
142 }
143 
rxe_cq_disable(struct rxe_cq * cq)144 void rxe_cq_disable(struct rxe_cq *cq)
145 {
146 	unsigned long flags;
147 
148 	spin_lock_irqsave(&cq->cq_lock, flags);
149 	cq->is_dying = true;
150 	spin_unlock_irqrestore(&cq->cq_lock, flags);
151 }
152 
rxe_cq_cleanup(struct rxe_pool_elem * elem)153 void rxe_cq_cleanup(struct rxe_pool_elem *elem)
154 {
155 	struct rxe_cq *cq = container_of(elem, typeof(*cq), elem);
156 
157 	if (cq->queue)
158 		rxe_queue_cleanup(cq->queue);
159 }
160