?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HAMMER 60I/Many: Mirroring
[dragonfly.git] / sys / kern / kern_syslink.c
blobba8c5ff898dc2a01f9a6343b2cc261555c0054f3
1 /*
2 * Copyright (c) 2006-2007 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * $DragonFly: src/sys/kern/kern_syslink.c,v 1.15 2007/08/13 17:47:19 dillon Exp $
35 */
36 /*
37 * This module implements the core syslink() system call and provides
38 * glue for kernel syslink frontends and backends, creating a intra-host
39 * communications infrastructure and DMA transport abstraction.
40 */
41
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/endian.h>
46 #include <sys/malloc.h>
47 #include <sys/alist.h>
48 #include <sys/file.h>
49 #include <sys/proc.h>
50 #include <sys/lock.h>
51 #include <sys/uio.h>
52 #include <sys/objcache.h>
53 #include <sys/queue.h>
54 #include <sys/thread.h>
55 #include <sys/tree.h>
56 #include <sys/sysctl.h>
57 #include <sys/sysproto.h>
58 #include <sys/mbuf.h>
59 #include <sys/socket.h>
60 #include <sys/socketvar.h>
61 #include <sys/socketops.h>
62 #include <sys/sysref.h>
63 #include <sys/syslink.h>
64 #include <sys/syslink_msg.h>
65 #include <netinet/in.h>
66
67 #include <sys/thread2.h>
68 #include <sys/spinlock2.h>
69 #include <sys/buf2.h>
70
71 #include "opt_syslink.h"
72
73 /*
74 * Syslink Connection abstraction
75 */
76 struct slcommon {
77 struct spinlock spin;
78 int refs;
79 };
80
81 struct sldesc {
82 struct slmsgq inq;
83 struct slmsg_rb_tree reply_rb_root; /* replies to requests */
84 struct spinlock spin;
85 struct sldesc *peer; /* peer syslink, if any */
86 struct file *xfp; /* external file pointer */
87 struct slcommon *common;
88 int flags;
89 int rwaiters; /* number of threads waiting */
90 int wblocked; /* blocked waiting for us to drain */
91 size_t cmdbytes; /* unreplied commands pending */
92 size_t repbytes; /* undrained replies pending */
93 int (*backend_wblocked)(struct sldesc *, int, sl_proto_t);
94 int (*backend_write)(struct sldesc *, struct slmsg *);
95 void (*backend_reply)(struct sldesc *,struct slmsg *,struct slmsg *);
96 void (*backend_dispose)(struct sldesc *, struct slmsg *);
97 };
98
99 #define SLF_RSHUTDOWN 0x0001
100 #define SLF_WSHUTDOWN 0x0002
101
102 static int syslink_cmd_new(struct syslink_info_new *info, int *result);
103 static struct sldesc *allocsldesc(struct slcommon *common);
104 static void setsldescfp(struct sldesc *sl, struct file *fp);
105 static void shutdownsldesc(struct sldesc *sl, int how);
106 static void shutdownsldesc2(struct sldesc *sl, int how);
107 static void sldrop(struct sldesc *sl);
108 static int syslink_validate_msg(struct syslink_msg *msg, int bytes);
109 static int syslink_validate_elm(struct syslink_elm *elm, sl_reclen_t bytes,
110 int swapit, int depth);
111
112 static int sl_local_mmap(struct slmsg *slmsg, char *base, size_t len);
113 static void sl_local_munmap(struct slmsg *slmsg);
114
115 static int backend_wblocked_user(struct sldesc *sl, int nbio, sl_proto_t proto);
116 static int backend_write_user(struct sldesc *sl, struct slmsg *slmsg);
117 static void backend_reply_user(struct sldesc *sl, struct slmsg *slcmd,
118 struct slmsg *slrep);
119 static void backend_dispose_user(struct sldesc *sl, struct slmsg *slmsg);
120
121 static int backend_wblocked_kern(struct sldesc *sl, int nbio, sl_proto_t proto);
122 static int backend_write_kern(struct sldesc *sl, struct slmsg *slmsg);
123 static void backend_reply_kern(struct sldesc *sl, struct slmsg *slcmd,
124 struct slmsg *slrep);
125 static void backend_dispose_kern(struct sldesc *sl, struct slmsg *slmsg);
126 static void slmsg_put(struct slmsg *slmsg);
127
128 /*
129 * Objcache memory backend
130 *
131 * All three object caches return slmsg structures but each is optimized
132 * for syslink message buffers of varying sizes. We use the slightly
133 * more complex ctor/dtor API in order to provide ready-to-go slmsg's.
134 */
135
136 static struct objcache *sl_objcache_big;
137 static struct objcache *sl_objcache_small;
138 static struct objcache *sl_objcache_none;
139
140 MALLOC_DEFINE(M_SYSLINK, "syslink", "syslink manager");
141
142 static boolean_t slmsg_ctor(void *data, void *private, int ocflags);
143 static void slmsg_dtor(void *data, void *private);
144
145 static
146 void
147 syslinkinit(void *dummy __unused)
148 {
149 size_t n = sizeof(struct slmsg);
150
151 sl_objcache_none = objcache_create_mbacked(M_SYSLINK, n, 0, 64,
152 slmsg_ctor, slmsg_dtor,
153 &sl_objcache_none);
154 sl_objcache_small= objcache_create_mbacked(M_SYSLINK, n, 0, 64,
155 slmsg_ctor, slmsg_dtor,
156 &sl_objcache_small);
157 sl_objcache_big = objcache_create_mbacked(M_SYSLINK, n, 0, 16,
158 slmsg_ctor, slmsg_dtor,
159 &sl_objcache_big);
160 }
161
162 static
163 boolean_t
164 slmsg_ctor(void *data, void *private, int ocflags)
165 {
166 struct slmsg *slmsg = data;
167
168 bzero(slmsg, sizeof(*slmsg));
169
170 slmsg->oc = *(struct objcache **)private;
171 if (slmsg->oc == sl_objcache_none) {
172 slmsg->maxsize = 0;
173 } else if (slmsg->oc == sl_objcache_small) {
174 slmsg->maxsize = SLMSG_SMALL;
175 } else if (slmsg->oc == sl_objcache_big) {
176 slmsg->maxsize = SLMSG_BIG;
177 } else {
178 panic("slmsg_ctor: bad objcache?\n");
179 }
180 if (slmsg->maxsize) {
181 slmsg->msg = kmalloc(slmsg->maxsize,
182 M_SYSLINK, M_WAITOK|M_ZERO);
183 }
184 xio_init(&slmsg->xio);
185 return(TRUE);
186 }
187
188 static
189 void
190 slmsg_dtor(void *data, void *private)
191 {
192 struct slmsg *slmsg = data;
193
194 if (slmsg->maxsize && slmsg->msg) {
195 kfree(slmsg->msg, M_SYSLINK);
196 slmsg->msg = NULL;
197 }
198 slmsg->oc = NULL;
199 }
200
201 SYSINIT(syslink, SI_BOOT2_MACHDEP, SI_ORDER_ANY, syslinkinit, NULL)
202
203 static int rb_slmsg_compare(struct slmsg *msg1, struct slmsg *msg2);
204 RB_GENERATE2(slmsg_rb_tree, slmsg, rbnode, rb_slmsg_compare,
205 sysid_t, msg->sm_msgid);
206
207 /*
208 * Sysctl elements
209 */
210 static int syslink_enabled;
211 SYSCTL_NODE(_kern, OID_AUTO, syslink, CTLFLAG_RW, 0, "Pipe operation");
212 SYSCTL_INT(_kern_syslink, OID_AUTO, enabled,
213 CTLFLAG_RW, &syslink_enabled, 0, "Enable SYSLINK");
214 static size_t syslink_bufsize = 65536;
215 SYSCTL_UINT(_kern_syslink, OID_AUTO, bufsize,
216 CTLFLAG_RW, &syslink_bufsize, 0, "Maximum buffer size");
217
218 /*
219 * Fileops API - typically used to glue a userland frontend with a
220 * kernel backend.
221 */
222
223 static int slfileop_read(struct file *fp, struct uio *uio,
224 struct ucred *cred, int flags);
225 static int slfileop_write(struct file *fp, struct uio *uio,
226 struct ucred *cred, int flags);
227 static int slfileop_close(struct file *fp);
228 static int slfileop_stat(struct file *fp, struct stat *sb, struct ucred *cred);
229 static int slfileop_shutdown(struct file *fp, int how);
230 static int slfileop_ioctl(struct file *fp, u_long cmd, caddr_t data,
231 struct ucred *cred);
232 static int slfileop_poll(struct file *fp, int events, struct ucred *cred);
233 static int slfileop_kqfilter(struct file *fp, struct knote *kn);
234
235 static struct fileops syslinkops = {
236 .fo_read = slfileop_read,
237 .fo_write = slfileop_write,
238 .fo_ioctl = slfileop_ioctl,
239 .fo_poll = slfileop_poll,
240 .fo_kqfilter = slfileop_kqfilter,
241 .fo_stat = slfileop_stat,
242 .fo_close = slfileop_close,
243 .fo_shutdown = slfileop_shutdown
244 };
245
246 /************************************************************************
247 * PRIMARY SYSTEM CALL INTERFACE *
248 ************************************************************************
249 *
250 * syslink(int cmd, struct syslink_info *info, size_t bytes)
251 */
252 int
253 sys_syslink(struct syslink_args *uap)
254 {
255 union syslink_info_all info;
256 int error;
257
258 /*
259 * System call is under construction and disabled by default.
260 * Superuser access is also required for now, but eventually
261 * will not be needed.
262 */
263 if (syslink_enabled == 0)
264 return (EAUTH);
265 error = suser(curthread);
266 if (error)
267 return (error);
268
269 /*
270 * Load and validate the info structure. Unloaded bytes are zerod
271 * out. The label field must always be 0-filled, even if not used
272 * for a command.
273 */
274 bzero(&info, sizeof(info));
275 if ((unsigned)uap->bytes <= sizeof(info)) {
276 if (uap->bytes)
277 error = copyin(uap->info, &info, uap->bytes);
278 } else {
279 error = EINVAL;
280 }
281 if (error)
282 return (error);
283
284 /*
285 * Process the command
286 */
287 switch(uap->cmd) {
288 case SYSLINK_CMD_NEW:
289 error = syslink_cmd_new(&info.cmd_new, &uap->sysmsg_result);
290 break;
291 default:
292 error = EINVAL;
293 break;
294 }
295 if (error == 0 && info.head.wbflag)
296 copyout(&info, uap->info, uap->bytes);
297 return (error);
298 }
299
300 /*
301 * Create a linked pair of descriptors, like a pipe.
302 */
303 static
304 int
305 syslink_cmd_new(struct syslink_info_new *info, int *result)
306 {
307 struct proc *p = curproc;
308 struct file *fp1;
309 struct file *fp2;
310 struct sldesc *sl;
311 struct sldesc *slpeer;
312 int error;
313 int fd1, fd2;
314
315 error = falloc(p, &fp1, &fd1);
316 if (error)
317 return(error);
318 error = falloc(p, &fp2, &fd2);
319 if (error) {
320 fsetfd(p, NULL, fd1);
321 fdrop(fp1);
322 return(error);
323 }
324 slpeer = allocsldesc(NULL);
325 slpeer->backend_wblocked = backend_wblocked_user;
326 slpeer->backend_write = backend_write_user;
327 slpeer->backend_reply = backend_reply_user;
328 slpeer->backend_dispose = backend_dispose_user;
329 sl = allocsldesc(slpeer->common);
330 sl->peer = slpeer;
331 sl->backend_wblocked = backend_wblocked_user;
332 sl->backend_write = backend_write_user;
333 sl->backend_reply = backend_reply_user;
334 sl->backend_dispose = backend_dispose_user;
335 slpeer->peer = sl;
336
337 setsldescfp(sl, fp1);
338 setsldescfp(slpeer, fp2);
339
340 fsetfd(p, fp1, fd1);
341 fdrop(fp1);
342 fsetfd(p, fp2, fd2);
343 fdrop(fp2);
344
345 info->head.wbflag = 1; /* write back */
346 info->fds[0] = fd1;
347 info->fds[1] = fd2;
348
349 return(0);
350 }
351
352 /************************************************************************
353 * LOW LEVEL SLDESC SUPPORT *
354 ************************************************************************
355 *
356 */
357
358 static
359 struct sldesc *
360 allocsldesc(struct slcommon *common)
361 {
362 struct sldesc *sl;
363
364 sl = kmalloc(sizeof(struct sldesc), M_SYSLINK, M_WAITOK|M_ZERO);
365 if (common == NULL)
366 common = kmalloc(sizeof(*common), M_SYSLINK, M_WAITOK|M_ZERO);
367 TAILQ_INIT(&sl->inq); /* incoming requests */
368 RB_INIT(&sl->reply_rb_root); /* match incoming replies */
369 spin_init(&sl->spin);
370 sl->common = common;
371 ++common->refs;
372 return(sl);
373 }
374
375 static
376 void
377 setsldescfp(struct sldesc *sl, struct file *fp)
378 {
379 sl->xfp = fp;
380 fp->f_type = DTYPE_SYSLINK;
381 fp->f_flag = FREAD | FWRITE;
382 fp->f_ops = &syslinkops;
383 fp->f_data = sl;
384 }
385
386 /*
387 * Red-black tree compare function
388 */
389 static
390 int
391 rb_slmsg_compare(struct slmsg *msg1, struct slmsg *msg2)
392 {
393 if (msg1->msg->sm_msgid < msg2->msg->sm_msgid)
394 return(-1);
395 if (msg1->msg->sm_msgid == msg2->msg->sm_msgid)
396 return(0);
397 return(1);
398 }
399
400 static
401 void
402 shutdownsldesc(struct sldesc *sl, int how)
403 {
404 struct slmsg *slmsg;
405 int rhow;
406
407 shutdownsldesc2(sl, how);
408
409 /*
410 * Return unread and unreplied messages
411 */
412 spin_lock_wr(&sl->spin);
413 while ((slmsg = TAILQ_FIRST(&sl->inq)) != NULL) {
414 TAILQ_REMOVE(&sl->inq, slmsg, tqnode);
415 spin_unlock_wr(&sl->spin);
416 if (slmsg->msg->sm_proto & SM_PROTO_REPLY) {
417 sl->repbytes -= slmsg->maxsize;
418 slmsg->flags &= ~SLMSGF_ONINQ;
419 sl->peer->backend_dispose(sl->peer, slmsg);
420 }
421 /* leave ONINQ set for commands, it will cleared below */
422 spin_lock_wr(&sl->spin);
423 }
424 while ((slmsg = RB_ROOT(&sl->reply_rb_root)) != NULL) {
425 RB_REMOVE(slmsg_rb_tree, &sl->reply_rb_root, slmsg);
426 sl->cmdbytes -= slmsg->maxsize;
427 spin_unlock_wr(&sl->spin);
428 slmsg->flags &= ~SLMSGF_ONINQ;
429 sl->peer->backend_reply(sl->peer, slmsg, NULL);
430 spin_lock_wr(&sl->spin);
431 }
432 spin_unlock_wr(&sl->spin);
433
434 /*
435 * Call shutdown on the peer with the opposite flags
436 */
437 rhow = 0;
438 switch(how) {
439 case SHUT_RD:
440 rhow = SHUT_WR;
441 break;
442 case SHUT_WR:
443 rhow = SHUT_WR;
444 break;
445 case SHUT_RDWR:
446 rhow = SHUT_RDWR;
447 break;
448 }
449 shutdownsldesc2(sl->peer, rhow);
450 }
451
452 static
453 void
454 shutdownsldesc2(struct sldesc *sl, int how)
455 {
456 spin_lock_wr(&sl->spin);
457 switch(how) {
458 case SHUT_RD:
459 sl->flags |= SLF_RSHUTDOWN;
460 break;
461 case SHUT_WR:
462 sl->flags |= SLF_WSHUTDOWN;
463 break;
464 case SHUT_RDWR:
465 sl->flags |= SLF_RSHUTDOWN | SLF_WSHUTDOWN;
466 break;
467 }
468 spin_unlock_wr(&sl->spin);
469
470 /*
471 * Handle signaling on the user side
472 */
473 if (how & SHUT_RD) {
474 if (sl->rwaiters)
475 wakeup(&sl->rwaiters);
476 }
477 if (how & SHUT_WR) {
478 if (sl->wblocked) {
479 sl->wblocked = 0; /* race ok */
480 wakeup(&sl->wblocked);
481 }
482 }
483 }
484
485 static
486 void
487 sldrop(struct sldesc *sl)
488 {
489 struct sldesc *slpeer;
490
491 spin_lock_wr(&sl->common->spin);
492 if (--sl->common->refs == 0) {
493 spin_unlock_wr(&sl->common->spin);
494 if ((slpeer = sl->peer) != NULL) {
495 sl->peer = NULL;
496 slpeer->peer = NULL;
497 slpeer->common = NULL;
498 KKASSERT(slpeer->xfp == NULL);
499 KKASSERT(TAILQ_EMPTY(&slpeer->inq));
500 KKASSERT(RB_EMPTY(&slpeer->reply_rb_root));
501 kfree(slpeer, M_SYSLINK);
502 }
503 KKASSERT(sl->xfp == NULL);
504 KKASSERT(TAILQ_EMPTY(&sl->inq));
505 KKASSERT(RB_EMPTY(&sl->reply_rb_root));
506 kfree(sl->common, M_SYSLINK);
507 sl->common = NULL;
508 kfree(sl, M_SYSLINK);
509 } else {
510 spin_unlock_wr(&sl->common->spin);
511 }
512 }
513
514 static
515 void
516 slmsg_put(struct slmsg *slmsg)
517 {
518 if (slmsg->flags & SLMSGF_HASXIO) {
519 slmsg->flags &= ~SLMSGF_HASXIO;
520 get_mplock();
521 xio_release(&slmsg->xio);
522 rel_mplock();
523 }
524 slmsg->flags &= ~SLMSGF_LINMAP;
525 objcache_put(slmsg->oc, slmsg);
526 }
527
528 /************************************************************************
529 * FILEOPS API *
530 ************************************************************************
531 *
532 * Implement userland fileops.
533 *
534 * MPSAFE ops
535 */
536 static
537 int
538 slfileop_read(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
539 {
540 struct sldesc *sl = fp->f_data; /* fp refed on call */
541 struct slmsg *slmsg;
542 struct iovec *iov0;
543 struct iovec *iov1;
544 struct syslink_msg *wmsg;
545 int error;
546 int nbio;
547
548 /*
549 * Kinda messy. Figure out the non-blocking state
550 */
551 if (flags & O_FBLOCKING)
552 nbio = 0;
553 else if (flags & O_FNONBLOCKING)
554 nbio = 1;
555 else if (fp->f_flag & O_NONBLOCK)
556 nbio = 1;
557 else
558 nbio = 0;
559
560 /*
561 * Validate the uio.
562 *
563 * iov0 - message buffer
564 * iov1 - DMA buffer or backup buffer
565 */
566 if (uio->uio_iovcnt < 1) {
567 error = 0;
568 goto done2;
569 }
570 iov0 = &uio->uio_iov[0];
571 if (uio->uio_iovcnt > 2) {
572 error = EINVAL;
573 goto done2;
574 }
575
576 /*
577 * Get a message, blocking if necessary.
578 */
579 spin_lock_wr(&sl->spin);
580 while ((slmsg = TAILQ_FIRST(&sl->inq)) == NULL) {
581 if (sl->flags & SLF_RSHUTDOWN) {
582 error = 0;
583 goto done1;
584 }
585 if (nbio) {
586 error = EAGAIN;
587 goto done1;
588 }
589 ++sl->rwaiters;
590 error = msleep(&sl->rwaiters, &sl->spin, PCATCH, "slrmsg", 0);
591 --sl->rwaiters;
592 if (error)
593 goto done1;
594 }
595 wmsg = slmsg->msg;
596
597 /*
598 * We have a message and still hold the spinlock. Make sure the
599 * uio has enough room to hold the message.
600 *
601 * Note that replies do not have XIOs.
602 */
603 if (slmsg->msgsize > iov0->iov_len) {
604 error = ENOSPC;
605 goto done1;
606 }
607 if (slmsg->xio.xio_bytes) {
608 if (uio->uio_iovcnt != 2) {
609 error = ENOSPC;
610 goto done1;
611 }
612 iov1 = &uio->uio_iov[1];
613 if (slmsg->xio.xio_bytes > iov1->iov_len) {
614 error = ENOSPC;
615 goto done1;
616 }
617 } else {
618 iov1 = NULL;
619 }
620
621 /*
622 * Dequeue the message. Adjust repbytes immediately. cmdbytes
623 * are adjusted when the command is replied to, not here.
624 */
625 TAILQ_REMOVE(&sl->inq, slmsg, tqnode);
626 if (slmsg->msg->sm_proto & SM_PROTO_REPLY)
627 sl->repbytes -= slmsg->maxsize;
628 spin_unlock_wr(&sl->spin);
629
630 /*
631 * Load the message data into the user buffer.
632 *
633 * If receiving a command an XIO may exist specifying a DMA buffer.
634 * For commands, if DMAW is set we have to copy or map the buffer
635 * so the caller can access the data being written. If DMAR is set
636 * we do not have to copy but we still must map the buffer so the
637 * caller can directly fill in the data being requested.
638 */
639 error = uiomove((void *)slmsg->msg, slmsg->msgsize, uio);
640 if (error == 0 && slmsg->xio.xio_bytes &&
641 (wmsg->sm_head.se_cmd & SE_CMDF_REPLY) == 0) {
642 if (wmsg->sm_head.se_cmd & SE_CMDF_DMAW) {
643 /*
644 * Data being passed to caller or being passed in both
645 * directions, copy or map.
646 */
647 get_mplock();
648 if ((flags & O_MAPONREAD) &&
649 (slmsg->xio.xio_flags & XIOF_VMLINEAR)) {
650 error = sl_local_mmap(slmsg,
651 iov1->iov_base,
652 iov1->iov_len);
653 if (error)
654 error = xio_copy_xtou(&slmsg->xio, 0,
655 iov1->iov_base,
656 slmsg->xio.xio_bytes);
657 } else {
658 error = xio_copy_xtou(&slmsg->xio, 0,
659 iov1->iov_base,
660 slmsg->xio.xio_bytes);
661 }
662 rel_mplock();
663 } else if (wmsg->sm_head.se_cmd & SE_CMDF_DMAR) {
664 /*
665 * Data will be passed back to originator, map
666 * the buffer if we can, else use the backup
667 * buffer at the same VA supplied by the caller.
668 */
669 get_mplock();
670 if ((flags & O_MAPONREAD) &&
671 (slmsg->xio.xio_flags & XIOF_VMLINEAR)) {
672 error = sl_local_mmap(slmsg,
673 iov1->iov_base,
674 iov1->iov_len);
675 error = 0; /* ignore errors */
676 }
677 rel_mplock();
678 }
679 }
680
681 /*
682 * Clean up.
683 */
684 if (error) {
685 /*
686 * Requeue the message if we could not read it successfully
687 */
688 spin_lock_wr(&sl->spin);
689 TAILQ_INSERT_HEAD(&sl->inq, slmsg, tqnode);
690 slmsg->flags |= SLMSGF_ONINQ;
691 spin_unlock_wr(&sl->spin);
692 } else if (slmsg->msg->sm_proto & SM_PROTO_REPLY) {
693 /*
694 * Dispose of any received reply after we've copied it
695 * to userland. We don't need the slmsg any more.
696 */
697 slmsg->flags &= ~SLMSGF_ONINQ;
698 sl->peer->backend_dispose(sl->peer, slmsg);
699 if (sl->wblocked && sl->repbytes < syslink_bufsize) {
700 sl->wblocked = 0; /* MP race ok here */
701 wakeup(&sl->wblocked);
702 }
703 } else {
704 /*
705 * Leave the command in the RB tree but clear ONINQ now
706 * that we have returned it to userland so userland can
707 * reply to it.
708 */
709 slmsg->flags &= ~SLMSGF_ONINQ;
710 }
711 return(error);
712 done1:
713 spin_unlock_wr(&sl->spin);
714 done2:
715 return(error);
716 }
717
718 /*
719 * Userland writes syslink message (optionally with DMA buffer in iov[1]).
720 */
721 static
722 int
723 slfileop_write(struct file *fp, struct uio *uio, struct ucred *cred, int flags)
724 {
725 struct sldesc *sl = fp->f_data;
726 struct slmsg *slmsg;
727 struct slmsg *slcmd;
728 struct syslink_msg sltmp;
729 struct syslink_msg *wmsg; /* wire message */
730 struct iovec *iov0;
731 struct iovec *iov1;
732 sl_proto_t proto;
733 int nbio;
734 int error;
735 int xflags;
736
737 /*
738 * Kinda messy. Figure out the non-blocking state
739 */
740 if (flags & O_FBLOCKING)
741 nbio = 0;
742 else if (flags & O_FNONBLOCKING)
743 nbio = 1;
744 else if (fp->f_flag & O_NONBLOCK)
745 nbio = 1;
746 else
747 nbio = 0;
748
749 /*
750 * Validate the uio
751 */
752 if (uio->uio_iovcnt < 1) {
753 error = 0;
754 goto done2;
755 }
756 iov0 = &uio->uio_iov[0];
757 if (iov0->iov_len > SLMSG_BIG) {
758 error = EFBIG;
759 goto done2;
760 }
761 if (uio->uio_iovcnt > 2) {
762 error = EFBIG;
763 goto done2;
764 }
765 if (uio->uio_iovcnt > 1) {
766 iov1 = &uio->uio_iov[1];
767 if (iov1->iov_len > XIO_INTERNAL_SIZE) {
768 error = EFBIG;
769 goto done2;
770 }
771 if ((intptr_t)iov1->iov_base & PAGE_MASK) {
772 error = EINVAL;
773 goto done2;
774 }
775 } else {
776 iov1 = NULL;
777 }
778
779 /*
780 * Handle the buffer-full case. slpeer cmdbytes is managed
781 * by the backend function, not us so if the callback just
782 * directly implements the message and never adjusts cmdbytes,
783 * we will never sleep here.
784 */
785 if (sl->flags & SLF_WSHUTDOWN) {
786 error = EPIPE;
787 goto done2;
788 }
789
790 /*
791 * Only commands can block the pipe, not replies. Otherwise a
792 * deadlock is possible.
793 */
794 error = copyin(iov0->iov_base, &sltmp, sizeof(sltmp));
795 if (error)
796 goto done2;
797 if ((proto = sltmp.sm_proto) & SM_PROTO_ENDIAN_REV)
798 proto = bswap16(proto);
799 error = sl->peer->backend_wblocked(sl->peer, nbio, proto);
800 if (error)
801 goto done2;
802
803 /*
804 * Allocate a slmsg and load the message. Note that the bytes
805 * returned to userland only reflects the primary syslink message
806 * and does not include any DMA buffers.
807 */
808 if (iov0->iov_len <= SLMSG_SMALL)
809 slmsg = objcache_get(sl_objcache_small, M_WAITOK);
810 else
811 slmsg = objcache_get(sl_objcache_big, M_WAITOK);
812 slmsg->msgsize = iov0->iov_len;
813 wmsg = slmsg->msg;
814
815 error = uiomove((void *)wmsg, iov0->iov_len, uio);
816 if (error)
817 goto done1;
818 error = syslink_validate_msg(wmsg, slmsg->msgsize);
819 if (error)
820 goto done1;
821
822 if ((wmsg->sm_head.se_cmd & SE_CMDF_REPLY) == 0) {
823 /*
824 * Install the XIO for commands if any DMA flags are set.
825 *
826 * XIOF_VMLINEAR requires that the XIO represent a
827 * contiguous set of pages associated with a single VM
828 * object (so the reader side can mmap it easily).
829 *
830 * XIOF_VMLINEAR might not be set when the kernel sends
831 * commands to userland so the reader side backs off to
832 * a backup buffer if it isn't set, but we require it
833 * for userland writes.
834 */
835 xflags = XIOF_VMLINEAR;
836 if (wmsg->sm_head.se_cmd & SE_CMDF_DMAR)
837 xflags |= XIOF_READ | XIOF_WRITE;
838 else if (wmsg->sm_head.se_cmd & SE_CMDF_DMAW)
839 xflags |= XIOF_READ;
840 if (xflags && iov1) {
841 get_mplock();
842 error = xio_init_ubuf(&slmsg->xio, iov1->iov_base,
843 iov1->iov_len, xflags);
844 rel_mplock();
845 if (error)
846 goto done1;
847 slmsg->flags |= SLMSGF_HASXIO;
848 }
849 error = sl->peer->backend_write(sl->peer, slmsg);
850 } else {
851 /*
852 * Replies have to be matched up against received commands.
853 */
854 spin_lock_wr(&sl->spin);
855 slcmd = slmsg_rb_tree_RB_LOOKUP(&sl->reply_rb_root,
856 slmsg->msg->sm_msgid);
857 if (slcmd == NULL || (slcmd->flags & SLMSGF_ONINQ)) {
858 error = ENOENT;
859 spin_unlock_wr(&sl->spin);
860 goto done1;
861 }
862 RB_REMOVE(slmsg_rb_tree, &sl->reply_rb_root, slcmd);
863 sl->cmdbytes -= slcmd->maxsize;
864 spin_unlock_wr(&sl->spin);
865
866 /*
867 * If the original command specified DMAR, has an xio, and
868 * our write specifies a DMA buffer, then we can do a
869 * copyback. But if we are linearly mapped and the caller
870 * is using the map base address, then the caller filled in
871 * the data via the direct memory map and no copyback is
872 * needed.
873 */
874 if ((slcmd->msg->sm_head.se_cmd & SE_CMDF_DMAR) && iov1 &&
875 (slcmd->flags & SLMSGF_HASXIO) &&
876 ((slcmd->flags & SLMSGF_LINMAP) == 0 ||
877 iov1->iov_base != slcmd->vmbase)
878 ) {
879 size_t count;
880 if (iov1->iov_len > slcmd->xio.xio_bytes)
881 count = slcmd->xio.xio_bytes;
882 else
883 count = iov1->iov_len;
884 get_mplock();
885 error = xio_copy_utox(&slcmd->xio, 0, iov1->iov_base,
886 count);
887 rel_mplock();
888 }
889
890 /*
891 * If we had mapped a DMA buffer, remove it
892 */
893 if (slcmd->flags & SLMSGF_LINMAP) {
894 get_mplock();
895 sl_local_munmap(slcmd);
896 rel_mplock();
897 }
898
899 /*
900 * Reply and handle unblocking
901 */
902 sl->peer->backend_reply(sl->peer, slcmd, slmsg);
903 if (sl->wblocked && sl->cmdbytes < syslink_bufsize) {
904 sl->wblocked = 0; /* MP race ok here */
905 wakeup(&sl->wblocked);
906 }
907
908 /*
909 * slmsg has already been dealt with, make sure error is
910 * 0 so we do not double-free it.
911 */
912 error = 0;
913 }
914 /* fall through */
915 done1:
916 if (error)
917 slmsg_put(slmsg);
918 /* fall through */
919 done2:
920 return(error);
921 }
922
923 /*
924 * Close a syslink descriptor.
925 *
926 * Disassociate the syslink from the file descriptor and disconnect from
927 * any peer.
928 */
929 static
930 int
931 slfileop_close(struct file *fp)
932 {
933 struct sldesc *sl;
934
935 /*
936 * Disassociate the file pointer. Take ownership of the ref on the
937 * sldesc.
938 */
939 sl = fp->f_data;
940 fp->f_data = NULL;
941 fp->f_ops = &badfileops;
942 sl->xfp = NULL;
943
944 /*
945 * Shutdown both directions. The other side will not issue API
946 * calls to us after we've shutdown both directions.
947 */
948 shutdownsldesc(sl, SHUT_RDWR);
949
950 /*
951 * Cleanup
952 */
953 KKASSERT(sl->cmdbytes == 0);
954 KKASSERT(sl->repbytes == 0);
955 sldrop(sl);
956 return(0);
957 }
958
959 static
960 int
961 slfileop_stat (struct file *fp, struct stat *sb, struct ucred *cred)
962 {
963 return(EINVAL);
964 }
965
966 static
967 int
968 slfileop_shutdown (struct file *fp, int how)
969 {
970 shutdownsldesc((struct sldesc *)fp->f_data, how);
971 return(0);
972 }
973
974 static
975 int
976 slfileop_ioctl (struct file *fp, u_long cmd, caddr_t data, struct ucred *cred)
977 {
978 return(EINVAL);
979 }
980
981 static
982 int
983 slfileop_poll (struct file *fp, int events, struct ucred *cred)
984 {
985 return(0);
986 }
987
988 static
989 int
990 slfileop_kqfilter(struct file *fp, struct knote *kn)
991 {
992 return(0);
993 }
994
995 /************************************************************************
996 * LOCAL MEMORY MAPPING *
997 ************************************************************************
998 *
999 * This feature is currently not implemented
1000 *
1001 */
1002
1003 static
1004 int
1005 sl_local_mmap(struct slmsg *slmsg, char *base, size_t len)
1006 {
1007 return (EOPNOTSUPP);
1008 }
1009
1010 static
1011 void
1012 sl_local_munmap(struct slmsg *slmsg)
1013 {
1014 /* empty */
1015 }
1016
1017 #if 0
1018
1019 static
1020 int
1021 sl_local_mmap(struct slmsg *slmsg, char *base, size_t len)
1022 {
1023 struct vmspace *vms = curproc->p_vmspace;
1024 vm_offset_t addr = (vm_offset_t)base;
1025
1026 /* XXX check user address range */
1027 error = vm_map_replace(
1028 &vma->vm_map,
1029 (vm_offset_t)base, (vm_offset_t)base + len,
1030 slmsg->xio.xio_pages[0]->object,
1031 slmsg->xio.xio_pages[0]->pindex << PAGE_SHIFT,
1032 VM_PROT_READ|VM_PROT_WRITE,
1033 VM_PROT_READ|VM_PROT_WRITE,
1034 MAP_DISABLE_SYNCER);
1035 }
1036 if (error == 0) {
1037 slmsg->flags |= SLMSGF_LINMAP;
1038 slmsg->vmbase = base;
1039 slmsg->vmsize = len;
1040 }
1041 return (error);
1042 }
1043
1044 static
1045 void
1046 sl_local_munmap(struct slmsg *slmsg)
1047 {
1048 if (slmsg->flags & SLMSGF_LINMAP) {
1049 vm_map_remove(&curproc->p_vmspace->vm_map,
1050 slmsg->vmbase,
1051 slmsg->vmbase + slcmd->vmsize);
1052 slmsg->flags &= ~SLMSGF_LINMAP;
1053 }
1054 }
1055
1056 #endif
1057
1058 /************************************************************************
1059 * MESSAGE VALIDATION *
1060 ************************************************************************
1061 *
1062 * Validate that the syslink message. Check that all headers and elements
1063 * conform. Correct the endian if necessary.
1064 *
1065 * NOTE: If reverse endian needs to be corrected, SE_CMDF_UNTRANSLATED
1066 * is recursively flipped on all syslink_elm's in the message. As the
1067 * message traverses the mesh, multiple flips may occur. It is
1068 * up to the RPC protocol layer to correct opaque data payloads and
1069 * SE_CMDF_UNTRANSLATED prevents the protocol layer from misinterpreting
1070 * a command or reply element which has not been endian-corrected.
1071 */
1072 static
1073 int
1074 syslink_validate_msg(struct syslink_msg *msg, int bytes)
1075 {
1076 int aligned_reclen;
1077 int swapit;
1078 int error;
1079
1080 /*
1081 * The raw message must be properly-aligned.
1082 */
1083 if (bytes & SL_ALIGNMASK)
1084 return (EINVAL);
1085
1086 while (bytes) {
1087 /*
1088 * The message must at least contain the msgid, bytes, and
1089 * protoid.
1090 */
1091 if (bytes < SL_MIN_PAD_SIZE)
1092 return (EINVAL);
1093
1094 /*
1095 * Fix the endian if it is reversed.
1096 */
1097 if (msg->sm_proto & SM_PROTO_ENDIAN_REV) {
1098 msg->sm_msgid = bswap64(msg->sm_msgid);
1099 msg->sm_sessid = bswap64(msg->sm_sessid);
1100 msg->sm_bytes = bswap16(msg->sm_bytes);
1101 msg->sm_proto = bswap16(msg->sm_proto);
1102 msg->sm_rlabel = bswap32(msg->sm_rlabel);
1103 if (msg->sm_proto & SM_PROTO_ENDIAN_REV)
1104 return (EINVAL);
1105 swapit = 1;
1106 } else {
1107 swapit = 0;
1108 }
1109
1110 /*
1111 * Validate the contents. For PADs, the entire payload is
1112 * ignored and the minimum message size can be as small as
1113 * 8 bytes.
1114 */
1115 if (msg->sm_proto == SMPROTO_PAD) {
1116 if (msg->sm_bytes < SL_MIN_PAD_SIZE ||
1117 msg->sm_bytes > bytes) {
1118 return (EINVAL);
1119 }
1120 /* ignore the entire payload, it can be garbage */
1121 } else {
1122 if (msg->sm_bytes < SL_MIN_MSG_SIZE ||
1123 msg->sm_bytes > bytes) {
1124 return (EINVAL);
1125 }
1126 error = syslink_validate_elm(
1127 &msg->sm_head,
1128 msg->sm_bytes -
1129 offsetof(struct syslink_msg,
1130 sm_head),
1131 swapit, SL_MAXDEPTH);
1132 if (error)
1133 return (error);
1134 }
1135
1136 /*
1137 * The aligned payload size must be used to locate the
1138 * next syslink_msg in the buffer.
1139 */
1140 aligned_reclen = SL_MSG_ALIGN(msg->sm_bytes);
1141 bytes -= aligned_reclen;
1142 msg = (void *)((char *)msg + aligned_reclen);
1143 }
1144 return(0);
1145 }
1146
1147 static
1148 int
1149 syslink_validate_elm(struct syslink_elm *elm, sl_reclen_t bytes,
1150 int swapit, int depth)
1151 {
1152 int aligned_reclen;
1153
1154 /*
1155 * If the buffer isn't big enough to fit the header, stop now!
1156 */
1157 if (bytes < SL_MIN_ELM_SIZE)
1158 return (EINVAL);
1159 /*
1160 * All syslink_elm headers are recursively endian-adjusted. Opaque
1161 * data payloads are not.
1162 */
1163 if (swapit) {
1164 elm->se_cmd = bswap16(elm->se_cmd) ^ SE_CMDF_UNTRANSLATED;
1165 elm->se_bytes = bswap16(elm->se_bytes);
1166 elm->se_aux = bswap32(elm->se_aux);
1167 }
1168
1169 /*
1170 * Check element size requirements.
1171 */
1172 if (elm->se_bytes < SL_MIN_ELM_SIZE || elm->se_bytes > bytes)
1173 return (EINVAL);
1174
1175 /*
1176 * Recursively check structured payloads. A structured payload may
1177 * contain as few as 0 recursive elements.
1178 */
1179 if (elm->se_cmd & SE_CMDF_STRUCTURED) {
1180 if (depth == 0)
1181 return (EINVAL);
1182 bytes -= SL_MIN_ELM_SIZE;
1183 ++elm;
1184 while (bytes > 0) {
1185 if (syslink_validate_elm(elm, bytes, swapit, depth - 1))
1186 return (EINVAL);
1187 aligned_reclen = SL_MSG_ALIGN(elm->se_bytes);
1188 elm = (void *)((char *)elm + aligned_reclen);
1189 bytes -= aligned_reclen;
1190 }
1191 }
1192 return(0);
1193 }
1194
1195 /************************************************************************
1196 * BACKEND FUNCTIONS - USER DESCRIPTOR *
1197 ************************************************************************
1198 *
1199 * Peer backend links are primarily used when userland creates a pair
1200 * of linked descriptors.
1201 */
1202
1203 /*
1204 * Do any required blocking / nbio handling for attempts to write to
1205 * a sldesc associated with a user descriptor.
1206 */
1207 static
1208 int
1209 backend_wblocked_user(struct sldesc *sl, int nbio, sl_proto_t proto)
1210 {
1211 int error = 0;
1212 int *bytesp = (proto & SM_PROTO_REPLY) ? &sl->repbytes : &sl->cmdbytes;
1213
1214 /*
1215 * Block until sufficient data is drained by the target. It is
1216 * ok to have a MP race against cmdbytes.
1217 */
1218 if (*bytesp >= syslink_bufsize) {
1219 spin_lock_wr(&sl->spin);
1220 while (*bytesp >= syslink_bufsize) {
1221 if (sl->flags & SLF_WSHUTDOWN) {
1222 error = EPIPE;
1223 break;
1224 }
1225 if (nbio) {
1226 error = EAGAIN;
1227 break;
1228 }
1229 ++sl->wblocked;
1230 error = msleep(&sl->wblocked, &sl->spin,
1231 PCATCH, "slwmsg", 0);
1232 if (error)
1233 break;
1234 }
1235 spin_unlock_wr(&sl->spin);
1236 }
1237 return (error);
1238 }
1239
1240 /*
1241 * Unconditionally write a syslink message to the sldesc associated with
1242 * a user descriptor. Command messages are also placed in a red-black
1243 * tree so their DMA tag (if any) can be accessed and so they can be
1244 * linked to any reply message.
1245 */
1246 static
1247 int
1248 backend_write_user(struct sldesc *sl, struct slmsg *slmsg)
1249 {
1250 int error;
1251
1252 spin_lock_wr(&sl->spin);
1253 if (sl->flags & SLF_RSHUTDOWN) {
1254 /*
1255 * Not accepting new messages
1256 */
1257 error = EPIPE;
1258 } else if (slmsg->msg->sm_proto & SM_PROTO_REPLY) {
1259 /*
1260 * Write a reply
1261 */
1262 TAILQ_INSERT_TAIL(&sl->inq, slmsg, tqnode);
1263 sl->repbytes += slmsg->maxsize;
1264 slmsg->flags |= SLMSGF_ONINQ;
1265 error = 0;
1266 } else if (RB_INSERT(slmsg_rb_tree, &sl->reply_rb_root, slmsg)) {
1267 /*
1268 * Write a command, but there was a msgid collision when
1269 * we tried to insert it into the RB tree.
1270 */
1271 error = EEXIST;
1272 } else {
1273 /*
1274 * Write a command, successful insertion into the RB tree.
1275 */
1276 TAILQ_INSERT_TAIL(&sl->inq, slmsg, tqnode);
1277 sl->cmdbytes += slmsg->maxsize;
1278 slmsg->flags |= SLMSGF_ONINQ;
1279 error = 0;
1280 }
1281 spin_unlock_wr(&sl->spin);
1282 if (sl->rwaiters)
1283 wakeup(&sl->rwaiters);
1284 return(error);
1285 }
1286
1287 /*
1288 * Our peer is replying a command we previously sent it back to us, along
1289 * with the reply message (if not NULL). We just queue the reply to
1290 * userland and free of the command.
1291 */
1292 static
1293 void
1294 backend_reply_user(struct sldesc *sl, struct slmsg *slcmd, struct slmsg *slrep)
1295 {
1296 int error;
1297
1298 slmsg_put(slcmd);
1299 if (slrep) {
1300 spin_lock_wr(&sl->spin);
1301 if ((sl->flags & SLF_RSHUTDOWN) == 0) {
1302 TAILQ_INSERT_TAIL(&sl->inq, slrep, tqnode);
1303 sl->repbytes += slrep->maxsize;
1304 error = 0;
1305 } else {
1306 error = EPIPE;
1307 }
1308 spin_unlock_wr(&sl->spin);
1309 if (error)
1310 sl->peer->backend_dispose(sl->peer, slrep);
1311 else if (sl->rwaiters)
1312 wakeup(&sl->rwaiters);
1313 }
1314 }
1315
1316 static
1317 void
1318 backend_dispose_user(struct sldesc *sl, struct slmsg *slmsg)
1319 {
1320 slmsg_put(slmsg);
1321 }
1322
1323 /************************************************************************
1324 * KERNEL DRIVER OR FILESYSTEM API *
1325 ************************************************************************
1326 *
1327 */
1328
1329 /*
1330 * Create a user<->kernel link, returning the user descriptor in *fdp
1331 * and the kernel descriptor in *kslp. 0 is returned on success, and an
1332 * error code is returned on failure.
1333 */
1334 int
1335 syslink_ukbackend(int *fdp, struct sldesc **kslp)
1336 {
1337 struct proc *p = curproc;
1338 struct file *fp;
1339 struct sldesc *usl;
1340 struct sldesc *ksl;
1341 int error;
1342 int fd;
1343
1344 *fdp = -1;
1345 *kslp = NULL;
1346
1347 error = falloc(p, &fp, &fd);
1348 if (error)
1349 return(error);
1350 usl = allocsldesc(NULL);
1351 usl->backend_wblocked = backend_wblocked_user;
1352 usl->backend_write = backend_write_user;
1353 usl->backend_reply = backend_reply_user;
1354 usl->backend_dispose = backend_dispose_user;
1355
1356 ksl = allocsldesc(usl->common);
1357 ksl->peer = usl;
1358 ksl->backend_wblocked = backend_wblocked_kern;
1359 ksl->backend_write = backend_write_kern;
1360 ksl->backend_reply = backend_reply_kern;
1361 ksl->backend_dispose = backend_dispose_kern;
1362
1363 usl->peer = ksl;
1364
1365 setsldescfp(usl, fp);
1366 fsetfd(p, fp, fd);
1367 fdrop(fp);
1368
1369 *fdp = fd;
1370 *kslp = ksl;
1371 return(0);
1372 }
1373
1374 /*
1375 * Assign a unique message id, issue a syslink message to userland,
1376 * and wait for a reply.
1377 */
1378 int
1379 syslink_kdomsg(struct sldesc *ksl, struct slmsg *slmsg)
1380 {
1381 struct syslink_msg *msg;
1382 int error;
1383
1384 /*
1385 * Finish initializing slmsg and post it to the red-black tree for
1386 * reply matching. If the message id is already in use we return
1387 * EEXIST, giving the originator the chance to roll a new msgid.
1388 */
1389 msg = slmsg->msg;
1390 slmsg->msgsize = msg->sm_bytes;
1391 if ((error = syslink_validate_msg(msg, msg->sm_bytes)) != 0)
1392 return (error);
1393 msg->sm_msgid = allocsysid();
1394
1395 /*
1396 * Issue the request and wait for a matching reply or failure,
1397 * then remove the message from the matching tree and return.
1398 */
1399 error = ksl->peer->backend_write(ksl->peer, slmsg);
1400 spin_lock_wr(&ksl->spin);
1401 if (error == 0) {
1402 while (slmsg->rep == NULL) {
1403 error = msleep(slmsg, &ksl->spin, 0, "kwtmsg", 0);
1404 /* XXX ignore error for now */
1405 }
1406 if (slmsg->rep == (struct slmsg *)-1) {
1407 error = EIO;
1408 slmsg->rep = NULL;
1409 } else {
1410 error = slmsg->rep->msg->sm_head.se_aux;
1411 }
1412 }
1413 spin_unlock_wr(&ksl->spin);
1414 return(error);
1415 }
1416
1417 /*
1418 * Similar to syslink_kdomsg but return immediately instead of
1419 * waiting for a reply. The kernel must supply a callback function
1420 * which will be made in the context of the user process replying
1421 * to the message.
1422 */
1423 int
1424 syslink_ksendmsg(struct sldesc *ksl, struct slmsg *slmsg,
1425 void (*func)(struct slmsg *, void *, int), void *arg)
1426 {
1427 struct syslink_msg *msg;
1428 int error;
1429
1430 /*
1431 * Finish initializing slmsg and post it to the red-black tree for
1432 * reply matching. If the message id is already in use we return
1433 * EEXIST, giving the originator the chance to roll a new msgid.
1434 */
1435 msg = slmsg->msg;
1436 slmsg->msgsize = msg->sm_bytes;
1437 slmsg->callback_func = func;
1438 slmsg->callback_data = arg;
1439 if ((error = syslink_validate_msg(msg, msg->sm_bytes)) != 0)
1440 return (error);
1441 msg->sm_msgid = allocsysid();
1442
1443 /*
1444 * Issue the request. If no error occured the operation will be
1445 * in progress, otherwise the operation is considered to have failed
1446 * and the caller can deallocate the slmsg.
1447 */
1448 error = ksl->peer->backend_write(ksl->peer, slmsg);
1449 return (error);
1450 }
1451
1452 int
1453 syslink_kwaitmsg(struct sldesc *ksl, struct slmsg *slmsg)
1454 {
1455 int error;
1456
1457 spin_lock_wr(&ksl->spin);
1458 while (slmsg->rep == NULL) {
1459 error = msleep(slmsg, &ksl->spin, 0, "kwtmsg", 0);
1460 /* XXX ignore error for now */
1461 }
1462 if (slmsg->rep == (struct slmsg *)-1) {
1463 error = EIO;
1464 slmsg->rep = NULL;
1465 } else {
1466 error = slmsg->rep->msg->sm_head.se_aux;
1467 }
1468 spin_unlock_wr(&ksl->spin);
1469 return(error);
1470 }
1471
1472 struct slmsg *
1473 syslink_kallocmsg(void)
1474 {
1475 return(objcache_get(sl_objcache_small, M_WAITOK));
1476 }
1477
1478 void
1479 syslink_kfreemsg(struct sldesc *ksl, struct slmsg *slmsg)
1480 {
1481 struct slmsg *rep;
1482
1483 if ((rep = slmsg->rep) != NULL) {
1484 slmsg->rep = NULL;
1485 ksl->peer->backend_dispose(ksl->peer, rep);
1486 }
1487 slmsg->callback_func = NULL;
1488 slmsg_put(slmsg);
1489 }
1490
1491 void
1492 syslink_kshutdown(struct sldesc *ksl, int how)
1493 {
1494 shutdownsldesc(ksl, how);
1495 }
1496
1497 void
1498 syslink_kclose(struct sldesc *ksl)
1499 {
1500 shutdownsldesc(ksl, SHUT_RDWR);
1501 sldrop(ksl);
1502 }
1503
1504 /*
1505 * Associate a DMA buffer with a kernel syslink message prior to it
1506 * being sent to userland. The DMA buffer is set up from the point
1507 * of view of the target.
1508 */
1509 int
1510 syslink_kdmabuf_pages(struct slmsg *slmsg, struct vm_page **mbase, int npages)
1511 {
1512 int xflags;
1513 int error;
1514
1515 xflags = XIOF_VMLINEAR;
1516 if (slmsg->msg->sm_head.se_cmd & SE_CMDF_DMAR)
1517 xflags |= XIOF_READ | XIOF_WRITE;
1518 else if (slmsg->msg->sm_head.se_cmd & SE_CMDF_DMAW)
1519 xflags |= XIOF_READ;
1520 error = xio_init_pages(&slmsg->xio, mbase, npages, xflags);
1521 slmsg->flags |= SLMSGF_HASXIO;
1522 return (error);
1523 }
1524
1525 /*
1526 * Associate a DMA buffer with a kernel syslink message prior to it
1527 * being sent to userland. The DMA buffer is set up from the point
1528 * of view of the target.
1529 */
1530 int
1531 syslink_kdmabuf_data(struct slmsg *slmsg, char *base, int bytes)
1532 {
1533 int xflags;
1534
1535 xflags = XIOF_VMLINEAR;
1536 if (slmsg->msg->sm_head.se_cmd & SE_CMDF_DMAR)
1537 xflags |= XIOF_READ | XIOF_WRITE;
1538 else if (slmsg->msg->sm_head.se_cmd & SE_CMDF_DMAW)
1539 xflags |= XIOF_READ;
1540 xio_init_kbuf(&slmsg->xio, base, bytes);
1541 slmsg->xio.xio_flags |= xflags;
1542 slmsg->flags |= SLMSGF_HASXIO;
1543 return(0);
1544 }
1545
1546 /************************************************************************
1547 * BACKEND FUNCTIONS FOR KERNEL API *
1548 ************************************************************************
1549 *
1550 * These are the backend functions for a sldesc associated with a kernel
1551 * API.
1552 */
1553
1554 /*
1555 * Our peer wants to write a syslink message to us and is asking us to
1556 * block if our input queue is full. We don't implement command reception
1557 * so don't block right now.
1558 */
1559 static
1560 int
1561 backend_wblocked_kern(struct sldesc *ksl, int nbio, sl_proto_t proto)
1562 {
1563 /* never blocks */
1564 return(0);
1565 }
1566
1567 /*
1568 * Our peer is writing a request to the kernel. At the moment we do not
1569 * accept commands.
1570 */
1571 static
1572 int
1573 backend_write_kern(struct sldesc *ksl, struct slmsg *slmsg)
1574 {
1575 return(EOPNOTSUPP);
1576 }
1577
1578 /*
1579 * Our peer wants to reply to a syslink message we sent it earlier. The
1580 * original command (that we passed to our peer), and the peer's reply
1581 * is specified. If the peer has failed slrep will be NULL.
1582 */
1583 static
1584 void
1585 backend_reply_kern(struct sldesc *ksl, struct slmsg *slcmd, struct slmsg *slrep)
1586 {
1587 int error;
1588
1589 spin_lock_wr(&ksl->spin);
1590 if (slrep == NULL) {
1591 slcmd->rep = (struct slmsg *)-1;
1592 error = EIO;
1593 } else {
1594 slcmd->rep = slrep;
1595 error = slrep->msg->sm_head.se_aux;
1596 }
1597 spin_unlock_wr(&ksl->spin);
1598
1599 /*
1600 * Issue callback or wakeup a synchronous waiter.
1601 */
1602 if (slcmd->callback_func) {
1603 slcmd->callback_func(slcmd, slcmd->callback_data, error);
1604 } else {
1605 wakeup(slcmd);
1606 }
1607 }
1608
1609 /*
1610 * Any reply messages we sent to our peer are returned to us for disposal.
1611 * Since we do not currently accept commands from our peer, there will not
1612 * be any replies returned to the peer to dispose of.
1613 */
1614 static
1615 void
1616 backend_dispose_kern(struct sldesc *ksl, struct slmsg *slmsg)
1617 {
1618 panic("backend_dispose_kern: kernel can't accept commands so it "
1619 "certainly did not reply to one!");
1620 }
1621
DragonFly BSD