Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Intel MIC Platform Software Stack (MPSS)
4 *
5 * Copyright(c) 2014 Intel Corporation.
6 *
7 * Intel SCIF driver.
8 */
9#include "scif_main.h"
10
11static int scif_fdopen(struct inode *inode, struct file *f)
12{
13 struct scif_endpt *priv = scif_open();
14
15 if (!priv)
16 return -ENOMEM;
17 f->private_data = priv;
18 return 0;
19}
20
21static int scif_fdclose(struct inode *inode, struct file *f)
22{
23 struct scif_endpt *priv = f->private_data;
24
25 return scif_close(priv);
26}
27
28static int scif_fdmmap(struct file *f, struct vm_area_struct *vma)
29{
30 struct scif_endpt *priv = f->private_data;
31
32 return scif_mmap(vma, priv);
33}
34
35static __poll_t scif_fdpoll(struct file *f, poll_table *wait)
36{
37 struct scif_endpt *priv = f->private_data;
38
39 return __scif_pollfd(f, wait, priv);
40}
41
42static int scif_fdflush(struct file *f, fl_owner_t id)
43{
44 struct scif_endpt *ep = f->private_data;
45
46 spin_lock(&ep->lock);
47 /*
48 * The listening endpoint stashes the open file information before
49 * waiting for incoming connections. The release callback would never be
50 * called if the application closed the endpoint, while waiting for
51 * incoming connections from a separate thread since the file descriptor
52 * reference count is bumped up in the accept IOCTL. Call the flush
53 * routine if the id matches the endpoint open file information so that
54 * the listening endpoint can be woken up and the fd released.
55 */
56 if (ep->files == id)
57 __scif_flush(ep);
58 spin_unlock(&ep->lock);
59 return 0;
60}
61
62static __always_inline void scif_err_debug(int err, const char *str)
63{
64 /*
65 * ENOTCONN is a common uninteresting error which is
66 * flooding debug messages to the console unnecessarily.
67 */
68 if (err < 0 && err != -ENOTCONN)
69 dev_dbg(scif_info.mdev.this_device, "%s err %d\n", str, err);
70}
71
72static long scif_fdioctl(struct file *f, unsigned int cmd, unsigned long arg)
73{
74 struct scif_endpt *priv = f->private_data;
75 void __user *argp = (void __user *)arg;
76 int err = 0;
77 struct scifioctl_msg request;
78 bool non_block = false;
79
80 non_block = !!(f->f_flags & O_NONBLOCK);
81
82 switch (cmd) {
83 case SCIF_BIND:
84 {
85 int pn;
86
87 if (copy_from_user(&pn, argp, sizeof(pn)))
88 return -EFAULT;
89
90 pn = scif_bind(priv, pn);
91 if (pn < 0)
92 return pn;
93
94 if (copy_to_user(argp, &pn, sizeof(pn)))
95 return -EFAULT;
96
97 return 0;
98 }
99 case SCIF_LISTEN:
100 return scif_listen(priv, arg);
101 case SCIF_CONNECT:
102 {
103 struct scifioctl_connect req;
104 struct scif_endpt *ep = (struct scif_endpt *)priv;
105
106 if (copy_from_user(&req, argp, sizeof(req)))
107 return -EFAULT;
108
109 err = __scif_connect(priv, &req.peer, non_block);
110 if (err < 0)
111 return err;
112
113 req.self.node = ep->port.node;
114 req.self.port = ep->port.port;
115
116 if (copy_to_user(argp, &req, sizeof(req)))
117 return -EFAULT;
118
119 return 0;
120 }
121 /*
122 * Accept is done in two halves. The request ioctl does the basic
123 * functionality of accepting the request and returning the information
124 * about it including the internal ID of the end point. The register
125 * is done with the internal ID on a new file descriptor opened by the
126 * requesting process.
127 */
128 case SCIF_ACCEPTREQ:
129 {
130 struct scifioctl_accept request;
131 scif_epd_t *ep = (scif_epd_t *)&request.endpt;
132
133 if (copy_from_user(&request, argp, sizeof(request)))
134 return -EFAULT;
135
136 err = scif_accept(priv, &request.peer, ep, request.flags);
137 if (err < 0)
138 return err;
139
140 if (copy_to_user(argp, &request, sizeof(request))) {
141 scif_close(*ep);
142 return -EFAULT;
143 }
144 /*
145 * Add to the list of user mode eps where the second half
146 * of the accept is not yet completed.
147 */
148 mutex_lock(&scif_info.eplock);
149 list_add_tail(&((*ep)->miacceptlist), &scif_info.uaccept);
150 list_add_tail(&((*ep)->liacceptlist), &priv->li_accept);
151 (*ep)->listenep = priv;
152 priv->acceptcnt++;
153 mutex_unlock(&scif_info.eplock);
154
155 return 0;
156 }
157 case SCIF_ACCEPTREG:
158 {
159 struct scif_endpt *priv = f->private_data;
160 struct scif_endpt *newep;
161 struct scif_endpt *lisep;
162 struct scif_endpt *fep = NULL;
163 struct scif_endpt *tmpep;
164 struct list_head *pos, *tmpq;
165
166 /* Finally replace the pointer to the accepted endpoint */
167 if (copy_from_user(&newep, argp, sizeof(void *)))
168 return -EFAULT;
169
170 /* Remove form the user accept queue */
171 mutex_lock(&scif_info.eplock);
172 list_for_each_safe(pos, tmpq, &scif_info.uaccept) {
173 tmpep = list_entry(pos,
174 struct scif_endpt, miacceptlist);
175 if (tmpep == newep) {
176 list_del(pos);
177 fep = tmpep;
178 break;
179 }
180 }
181
182 if (!fep) {
183 mutex_unlock(&scif_info.eplock);
184 return -ENOENT;
185 }
186
187 lisep = newep->listenep;
188 list_for_each_safe(pos, tmpq, &lisep->li_accept) {
189 tmpep = list_entry(pos,
190 struct scif_endpt, liacceptlist);
191 if (tmpep == newep) {
192 list_del(pos);
193 lisep->acceptcnt--;
194 break;
195 }
196 }
197
198 mutex_unlock(&scif_info.eplock);
199
200 /* Free the resources automatically created from the open. */
201 scif_anon_inode_fput(priv);
202 scif_teardown_ep(priv);
203 scif_add_epd_to_zombie_list(priv, !SCIF_EPLOCK_HELD);
204 f->private_data = newep;
205 return 0;
206 }
207 case SCIF_SEND:
208 {
209 struct scif_endpt *priv = f->private_data;
210
211 if (copy_from_user(&request, argp,
212 sizeof(struct scifioctl_msg))) {
213 err = -EFAULT;
214 goto send_err;
215 }
216 err = scif_user_send(priv, (void __user *)request.msg,
217 request.len, request.flags);
218 if (err < 0)
219 goto send_err;
220 if (copy_to_user(&
221 ((struct scifioctl_msg __user *)argp)->out_len,
222 &err, sizeof(err))) {
223 err = -EFAULT;
224 goto send_err;
225 }
226 err = 0;
227send_err:
228 scif_err_debug(err, "scif_send");
229 return err;
230 }
231 case SCIF_RECV:
232 {
233 struct scif_endpt *priv = f->private_data;
234
235 if (copy_from_user(&request, argp,
236 sizeof(struct scifioctl_msg))) {
237 err = -EFAULT;
238 goto recv_err;
239 }
240
241 err = scif_user_recv(priv, (void __user *)request.msg,
242 request.len, request.flags);
243 if (err < 0)
244 goto recv_err;
245
246 if (copy_to_user(&
247 ((struct scifioctl_msg __user *)argp)->out_len,
248 &err, sizeof(err))) {
249 err = -EFAULT;
250 goto recv_err;
251 }
252 err = 0;
253recv_err:
254 scif_err_debug(err, "scif_recv");
255 return err;
256 }
257 case SCIF_GET_NODEIDS:
258 {
259 struct scifioctl_node_ids node_ids;
260 int entries;
261 u16 *nodes;
262 void __user *unodes, *uself;
263 u16 self;
264
265 if (copy_from_user(&node_ids, argp, sizeof(node_ids))) {
266 err = -EFAULT;
267 goto getnodes_err2;
268 }
269
270 entries = min_t(int, scif_info.maxid, node_ids.len);
271 nodes = kmalloc_array(entries, sizeof(u16), GFP_KERNEL);
272 if (entries && !nodes) {
273 err = -ENOMEM;
274 goto getnodes_err2;
275 }
276 node_ids.len = scif_get_node_ids(nodes, entries, &self);
277
278 unodes = (void __user *)node_ids.nodes;
279 if (copy_to_user(unodes, nodes, sizeof(u16) * entries)) {
280 err = -EFAULT;
281 goto getnodes_err1;
282 }
283
284 uself = (void __user *)node_ids.self;
285 if (copy_to_user(uself, &self, sizeof(u16))) {
286 err = -EFAULT;
287 goto getnodes_err1;
288 }
289
290 if (copy_to_user(argp, &node_ids, sizeof(node_ids))) {
291 err = -EFAULT;
292 goto getnodes_err1;
293 }
294getnodes_err1:
295 kfree(nodes);
296getnodes_err2:
297 return err;
298 }
299 case SCIF_REG:
300 {
301 struct scif_endpt *priv = f->private_data;
302 struct scifioctl_reg reg;
303 off_t ret;
304
305 if (copy_from_user(®, argp, sizeof(reg))) {
306 err = -EFAULT;
307 goto reg_err;
308 }
309 if (reg.flags & SCIF_MAP_KERNEL) {
310 err = -EINVAL;
311 goto reg_err;
312 }
313 ret = scif_register(priv, (void *)reg.addr, reg.len,
314 reg.offset, reg.prot, reg.flags);
315 if (ret < 0) {
316 err = (int)ret;
317 goto reg_err;
318 }
319
320 if (copy_to_user(&((struct scifioctl_reg __user *)argp)
321 ->out_offset, &ret, sizeof(reg.out_offset))) {
322 err = -EFAULT;
323 goto reg_err;
324 }
325 err = 0;
326reg_err:
327 scif_err_debug(err, "scif_register");
328 return err;
329 }
330 case SCIF_UNREG:
331 {
332 struct scif_endpt *priv = f->private_data;
333 struct scifioctl_unreg unreg;
334
335 if (copy_from_user(&unreg, argp, sizeof(unreg))) {
336 err = -EFAULT;
337 goto unreg_err;
338 }
339 err = scif_unregister(priv, unreg.offset, unreg.len);
340unreg_err:
341 scif_err_debug(err, "scif_unregister");
342 return err;
343 }
344 case SCIF_READFROM:
345 {
346 struct scif_endpt *priv = f->private_data;
347 struct scifioctl_copy copy;
348
349 if (copy_from_user(©, argp, sizeof(copy))) {
350 err = -EFAULT;
351 goto readfrom_err;
352 }
353 err = scif_readfrom(priv, copy.loffset, copy.len, copy.roffset,
354 copy.flags);
355readfrom_err:
356 scif_err_debug(err, "scif_readfrom");
357 return err;
358 }
359 case SCIF_WRITETO:
360 {
361 struct scif_endpt *priv = f->private_data;
362 struct scifioctl_copy copy;
363
364 if (copy_from_user(©, argp, sizeof(copy))) {
365 err = -EFAULT;
366 goto writeto_err;
367 }
368 err = scif_writeto(priv, copy.loffset, copy.len, copy.roffset,
369 copy.flags);
370writeto_err:
371 scif_err_debug(err, "scif_writeto");
372 return err;
373 }
374 case SCIF_VREADFROM:
375 {
376 struct scif_endpt *priv = f->private_data;
377 struct scifioctl_copy copy;
378
379 if (copy_from_user(©, argp, sizeof(copy))) {
380 err = -EFAULT;
381 goto vreadfrom_err;
382 }
383 err = scif_vreadfrom(priv, (void __force *)copy.addr, copy.len,
384 copy.roffset, copy.flags);
385vreadfrom_err:
386 scif_err_debug(err, "scif_vreadfrom");
387 return err;
388 }
389 case SCIF_VWRITETO:
390 {
391 struct scif_endpt *priv = f->private_data;
392 struct scifioctl_copy copy;
393
394 if (copy_from_user(©, argp, sizeof(copy))) {
395 err = -EFAULT;
396 goto vwriteto_err;
397 }
398 err = scif_vwriteto(priv, (void __force *)copy.addr, copy.len,
399 copy.roffset, copy.flags);
400vwriteto_err:
401 scif_err_debug(err, "scif_vwriteto");
402 return err;
403 }
404 case SCIF_FENCE_MARK:
405 {
406 struct scif_endpt *priv = f->private_data;
407 struct scifioctl_fence_mark mark;
408 int tmp_mark = 0;
409
410 if (copy_from_user(&mark, argp, sizeof(mark))) {
411 err = -EFAULT;
412 goto fence_mark_err;
413 }
414 err = scif_fence_mark(priv, mark.flags, &tmp_mark);
415 if (err)
416 goto fence_mark_err;
417 if (copy_to_user((void __user *)mark.mark, &tmp_mark,
418 sizeof(tmp_mark))) {
419 err = -EFAULT;
420 goto fence_mark_err;
421 }
422fence_mark_err:
423 scif_err_debug(err, "scif_fence_mark");
424 return err;
425 }
426 case SCIF_FENCE_WAIT:
427 {
428 struct scif_endpt *priv = f->private_data;
429
430 err = scif_fence_wait(priv, arg);
431 scif_err_debug(err, "scif_fence_wait");
432 return err;
433 }
434 case SCIF_FENCE_SIGNAL:
435 {
436 struct scif_endpt *priv = f->private_data;
437 struct scifioctl_fence_signal signal;
438
439 if (copy_from_user(&signal, argp, sizeof(signal))) {
440 err = -EFAULT;
441 goto fence_signal_err;
442 }
443
444 err = scif_fence_signal(priv, signal.loff, signal.lval,
445 signal.roff, signal.rval, signal.flags);
446fence_signal_err:
447 scif_err_debug(err, "scif_fence_signal");
448 return err;
449 }
450 }
451 return -EINVAL;
452}
453
454const struct file_operations scif_fops = {
455 .open = scif_fdopen,
456 .release = scif_fdclose,
457 .unlocked_ioctl = scif_fdioctl,
458 .mmap = scif_fdmmap,
459 .poll = scif_fdpoll,
460 .flush = scif_fdflush,
461 .owner = THIS_MODULE,
462};