?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kernel/msdosfs: Add pathconf(3) support for FILESIZEBITS.
[dragonfly.git] / lib / libpuffs / framebuf.c
blob0d40ed7bc67b02ebb6fb41f97a7ce8d9b08e66d3
1 /* $NetBSD: framebuf.c,v 1.30 2010/01/12 18:42:38 pooka Exp $ */
2
3 /*
4 * Copyright (c) 2007 Antti Kantee. All Rights Reserved.
5 *
6 * Development of this software was supported by the
7 * Finnish Cultural Foundation.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
19 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 /*
32 * The event portion of this code is a twisty maze of pointers,
33 * flags, yields and continues. Sincere aplogies.
34 */
35
36 #include <sys/types.h>
37 #include <sys/event.h>
38 #include <sys/queue.h>
39
40 #include <assert.h>
41 #include <errno.h>
42 #include <poll.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <unistd.h>
46
47 #include "puffs.h"
48 #include "puffs_priv.h"
49
50 struct puffs_framebuf {
51 struct puffs_cc *pcc; /* pcc to continue with */
52 /* OR */
53 puffs_framev_cb fcb; /* non-blocking callback */
54 void *fcb_arg; /* argument for previous */
55
56 uint8_t *buf; /* buffer base */
57 size_t len; /* total length */
58
59 size_t offset; /* cursor, telloff() */
60 size_t maxoff; /* maximum offset for data, tellsize() */
61
62 volatile int rv; /* errno value */
63
64 int istat;
65
66 TAILQ_ENTRY(puffs_framebuf) pfb_entries;
67 };
68 #define ISTAT_NODESTROY 0x01 /* indestructible by framebuf_destroy() */
69 #define ISTAT_INTERNAL 0x02 /* never leaves library */
70 #define ISTAT_NOREPLY 0x04 /* nuke after sending */
71 #define ISTAT_DIRECT 0x08 /* receive directly, no moveinfo */
72
73 #define ISTAT_ONQUEUE ISTAT_NODESTROY /* alias */
74
75 #define PUFBUF_INCRALLOC 4096
76 #define PUFBUF_REMAIN(p) (p->len - p->offset)
77
78 /* for poll/kqueue */
79 struct puffs_fbevent {
80 struct puffs_cc *pcc;
81 int what;
82 volatile int rv;
83
84 LIST_ENTRY(puffs_fbevent) pfe_entries;
85 };
86
87 static struct puffs_fctrl_io *
88 getfiobyfd(struct puffs_usermount *pu, int fd)
89 {
90 struct puffs_fctrl_io *fio;
91
92 LIST_FOREACH(fio, &pu->pu_ios, fio_entries)
93 if (fio->io_fd == fd)
94 return fio;
95 return NULL;
96 }
97
98 struct puffs_framebuf *
99 puffs_framebuf_make(void)
100 {
101 struct puffs_framebuf *pufbuf;
102
103 pufbuf = malloc(sizeof(struct puffs_framebuf));
104 if (pufbuf == NULL)
105 return NULL;
106 memset(pufbuf, 0, sizeof(struct puffs_framebuf));
107
108 pufbuf->buf = malloc(PUFBUF_INCRALLOC);
109 if (pufbuf->buf == NULL) {
110 free(pufbuf);
111 return NULL;
112 }
113 pufbuf->len = PUFBUF_INCRALLOC;
114
115 puffs_framebuf_recycle(pufbuf);
116 return pufbuf;
117 }
118
119 void
120 puffs_framebuf_destroy(struct puffs_framebuf *pufbuf)
121 {
122
123 assert((pufbuf->istat & ISTAT_NODESTROY) == 0);
124
125 free(pufbuf->buf);
126 free(pufbuf);
127 }
128
129 void
130 puffs_framebuf_recycle(struct puffs_framebuf *pufbuf)
131 {
132
133 assert((pufbuf->istat & ISTAT_NODESTROY) == 0);
134
135 pufbuf->offset = 0;
136 pufbuf->maxoff = 0;
137 pufbuf->istat = 0;
138 }
139
140 static int
141 reservespace(struct puffs_framebuf *pufbuf, size_t off, size_t wantsize)
142 {
143 size_t incr;
144 void *nd;
145
146 if (off <= pufbuf->len && pufbuf->len - off >= wantsize)
147 return 0;
148
149 for (incr = PUFBUF_INCRALLOC;
150 pufbuf->len + incr < off + wantsize;
151 incr += PUFBUF_INCRALLOC)
152 continue;
153
154 nd = realloc(pufbuf->buf, pufbuf->len + incr);
155 if (nd == NULL)
156 return -1;
157
158 pufbuf->buf = nd;
159 pufbuf->len += incr;
160
161 return 0;
162 }
163
164 int
165 puffs_framebuf_dup(struct puffs_framebuf *pb, struct puffs_framebuf **pbp)
166 {
167 struct puffs_framebuf *newpb;
168
169 newpb = puffs_framebuf_make();
170 if (newpb == NULL) {
171 errno = ENOMEM;
172 return -1;
173 }
174 memcpy(newpb, pb, sizeof(struct puffs_framebuf));
175
176 newpb->buf = NULL;
177 newpb->len = 0;
178 if (reservespace(newpb, 0, pb->maxoff) == -1) {
179 puffs_framebuf_destroy(newpb);
180 return -1;
181 }
182
183 memcpy(newpb->buf, pb->buf, pb->maxoff);
184 newpb->istat = 0;
185 *pbp = newpb;
186
187 return 0;
188 }
189
190 int
191 puffs_framebuf_reserve_space(struct puffs_framebuf *pufbuf, size_t wantsize)
192 {
193
194 return reservespace(pufbuf, pufbuf->offset, wantsize);
195 }
196
197 int
198 puffs_framebuf_putdata(struct puffs_framebuf *pufbuf,
199 const void *data, size_t dlen)
200 {
201
202 if (PUFBUF_REMAIN(pufbuf) < dlen)
203 if (puffs_framebuf_reserve_space(pufbuf, dlen) == -1)
204 return -1;
205
206 memcpy(pufbuf->buf + pufbuf->offset, data, dlen);
207 pufbuf->offset += dlen;
208
209 if (pufbuf->offset > pufbuf->maxoff)
210 pufbuf->maxoff = pufbuf->offset;
211
212 return 0;
213 }
214
215 int
216 puffs_framebuf_putdata_atoff(struct puffs_framebuf *pufbuf, size_t offset,
217 const void *data, size_t dlen)
218 {
219
220 if (reservespace(pufbuf, offset, dlen) == -1)
221 return -1;
222
223 memcpy(pufbuf->buf + offset, data, dlen);
224
225 if (offset + dlen > pufbuf->maxoff)
226 pufbuf->maxoff = offset + dlen;
227
228 return 0;
229 }
230
231 int
232 puffs_framebuf_getdata(struct puffs_framebuf *pufbuf, void *data, size_t dlen)
233 {
234
235 if (pufbuf->maxoff < pufbuf->offset + dlen) {
236 errno = ENOBUFS;
237 return -1;
238 }
239
240 memcpy(data, pufbuf->buf + pufbuf->offset, dlen);
241 pufbuf->offset += dlen;
242
243 return 0;
244 }
245
246 int
247 puffs_framebuf_getdata_atoff(struct puffs_framebuf *pufbuf, size_t offset,
248 void *data, size_t dlen)
249 {
250
251 if (pufbuf->maxoff < offset + dlen) {
252 errno = ENOBUFS;
253 return -1;
254 }
255
256 memcpy(data, pufbuf->buf + offset, dlen);
257 return 0;
258 }
259
260 size_t
261 puffs_framebuf_telloff(struct puffs_framebuf *pufbuf)
262 {
263
264 return pufbuf->offset;
265 }
266
267 size_t
268 puffs_framebuf_tellsize(struct puffs_framebuf *pufbuf)
269 {
270
271 return pufbuf->maxoff;
272 }
273
274 size_t
275 puffs_framebuf_remaining(struct puffs_framebuf *pufbuf)
276 {
277
278 return puffs_framebuf_tellsize(pufbuf) - puffs_framebuf_telloff(pufbuf);
279 }
280
281 int
282 puffs_framebuf_seekset(struct puffs_framebuf *pufbuf, size_t newoff)
283 {
284
285 if (reservespace(pufbuf, newoff, 0) == -1)
286 return -1;
287
288 pufbuf->offset = newoff;
289 return 0;
290 }
291
292 int
293 puffs_framebuf_getwindow(struct puffs_framebuf *pufbuf, size_t winoff,
294 void **data, size_t *dlen)
295 {
296 size_t winlen;
297
298 #ifdef WINTESTING
299 winlen = MIN(*dlen, 32);
300 #else
301 winlen = *dlen;
302 #endif
303
304 if (reservespace(pufbuf, winoff, winlen) == -1)
305 return -1;
306
307 *data = pufbuf->buf + winoff;
308 if (pufbuf->maxoff < winoff + winlen)
309 pufbuf->maxoff = winoff + winlen;
310
311 return 0;
312 }
313
314 void *
315 puffs__framebuf_getdataptr(struct puffs_framebuf *pufbuf)
316 {
317
318 return pufbuf->buf;
319 }
320
321 static void
322 errnotify(struct puffs_usermount *pu, struct puffs_framebuf *pufbuf, int error)
323 {
324
325 pufbuf->rv = error;
326 if (pufbuf->pcc) {
327 puffs__goto(pufbuf->pcc);
328 } else if (pufbuf->fcb) {
329 pufbuf->istat &= ~ISTAT_NODESTROY;
330 pufbuf->fcb(pu, pufbuf, pufbuf->fcb_arg, error);
331 } else {
332 pufbuf->istat &= ~ISTAT_NODESTROY;
333 puffs_framebuf_destroy(pufbuf);
334 }
335 }
336
337 #define GETFIO(fd) \
338 do { \
339 fio = getfiobyfd(pu, fd); \
340 if (fio == NULL) { \
341 errno = EINVAL; \
342 return -1; \
343 } \
344 if (fio->stat & FIO_WRGONE) { \
345 errno = ESHUTDOWN; \
346 return -1; \
347 } \
348 } while (/*CONSTCOND*/0)
349
350 int
351 puffs_framev_enqueue_cc(struct puffs_cc *pcc, int fd,
352 struct puffs_framebuf *pufbuf, int flags)
353 {
354 struct puffs_usermount *pu = pcc->pcc_pu;
355 struct puffs_fctrl_io *fio;
356
357 /*
358 * Technically we shouldn't allow this if RDGONE, but it's
359 * difficult to trap write close without allowing writes.
360 * And besides, there's probably a disconnect sequence in
361 * the protocol, so unexpectedly getting a closed fd is
362 * most likely an error condition.
363 */
364 GETFIO(fd);
365
366 pufbuf->pcc = pcc;
367 pufbuf->fcb = NULL;
368 pufbuf->fcb_arg = NULL;
369
370 pufbuf->offset = 0;
371 pufbuf->istat |= ISTAT_NODESTROY;
372
373 if (flags & PUFFS_FBQUEUE_URGENT)
374 TAILQ_INSERT_HEAD(&fio->snd_qing, pufbuf, pfb_entries);
375 else
376 TAILQ_INSERT_TAIL(&fio->snd_qing, pufbuf, pfb_entries);
377
378 puffs_cc_yield(pcc);
379 if (pufbuf->rv) {
380 pufbuf->istat &= ~ISTAT_NODESTROY;
381 errno = pufbuf->rv;
382 return -1;
383 }
384
385 return 0;
386 }
387
388 int
389 puffs_framev_enqueue_cb(struct puffs_usermount *pu, int fd,
390 struct puffs_framebuf *pufbuf, puffs_framev_cb fcb, void *arg,
391 int flags)
392 {
393 struct puffs_fctrl_io *fio;
394
395 /* see enqueue_cc */
396 GETFIO(fd);
397
398 pufbuf->pcc = NULL;
399 pufbuf->fcb = fcb;
400 pufbuf->fcb_arg = arg;
401
402 pufbuf->offset = 0;
403 pufbuf->istat |= ISTAT_NODESTROY;
404
405 if (flags & PUFFS_FBQUEUE_URGENT)
406 TAILQ_INSERT_HEAD(&fio->snd_qing, pufbuf, pfb_entries);
407 else
408 TAILQ_INSERT_TAIL(&fio->snd_qing, pufbuf, pfb_entries);
409
410 return 0;
411 }
412
413 int
414 puffs_framev_enqueue_justsend(struct puffs_usermount *pu, int fd,
415 struct puffs_framebuf *pufbuf, int reply, int flags)
416 {
417 struct puffs_fctrl_io *fio;
418
419 assert((pufbuf->istat & ISTAT_INTERNAL) == 0);
420
421 GETFIO(fd);
422
423 pufbuf->pcc = NULL;
424 pufbuf->fcb = NULL;
425 pufbuf->fcb_arg = NULL;
426
427 pufbuf->offset = 0;
428 pufbuf->istat |= ISTAT_NODESTROY;
429 if (!reply)
430 pufbuf->istat |= ISTAT_NOREPLY;
431
432 if (flags & PUFFS_FBQUEUE_URGENT)
433 TAILQ_INSERT_HEAD(&fio->snd_qing, pufbuf, pfb_entries);
434 else
435 TAILQ_INSERT_TAIL(&fio->snd_qing, pufbuf, pfb_entries);
436
437 return 0;
438 }
439
440 /* ARGSUSED */
441 int
442 puffs_framev_enqueue_directreceive(struct puffs_cc *pcc, int fd,
443 struct puffs_framebuf *pufbuf, int flags /* used in the future */)
444 {
445 struct puffs_usermount *pu = pcc->pcc_pu;
446 struct puffs_fctrl_io *fio;
447
448 assert((pufbuf->istat & ISTAT_INTERNAL) == 0);
449
450 fio = getfiobyfd(pu, fd);
451 if (fio == NULL) {
452 errno = EINVAL;
453 return -1;
454 }
455
456 /* XXX: should have cur_in queue */
457 assert(fio->cur_in == NULL);
458 fio->cur_in = pufbuf;
459
460 pufbuf->pcc = pcc;
461 pufbuf->fcb = NULL;
462 pufbuf->fcb_arg = NULL;
463
464 pufbuf->offset = 0;
465 pufbuf->istat |= ISTAT_NODESTROY | ISTAT_DIRECT;
466
467 puffs_cc_yield(pcc);
468 pufbuf->istat &= ~ISTAT_NODESTROY; /* XXX: not the right place */
469 if (pufbuf->rv) {
470 errno = pufbuf->rv;
471 return -1;
472 }
473
474 return 0;
475 }
476
477 int
478 puffs_framev_enqueue_directsend(struct puffs_cc *pcc, int fd,
479 struct puffs_framebuf *pufbuf, int flags)
480 {
481 struct puffs_usermount *pu = pcc->pcc_pu;
482 struct puffs_fctrl_io *fio;
483
484 assert((pufbuf->istat & ISTAT_INTERNAL) == 0);
485
486 if (flags & PUFFS_FBQUEUE_URGENT)
487 abort(); /* EOPNOTSUPP for now */
488
489 GETFIO(fd);
490
491 pufbuf->pcc = pcc;
492 pufbuf->fcb = NULL;
493 pufbuf->fcb_arg = NULL;
494
495 pufbuf->offset = 0;
496 pufbuf->istat |= ISTAT_NODESTROY | ISTAT_DIRECT;
497
498 TAILQ_INSERT_TAIL(&fio->snd_qing, pufbuf, pfb_entries);
499
500 puffs_cc_yield(pcc);
501 if (pufbuf->rv) {
502 pufbuf->istat &= ~ISTAT_NODESTROY;
503 errno = pufbuf->rv;
504 return -1;
505 }
506
507 return 0;
508 }
509
510 int
511 puffs_framev_framebuf_ccpromote(struct puffs_framebuf *pufbuf,
512 struct puffs_cc *pcc)
513 {
514
515 if ((pufbuf->istat & ISTAT_ONQUEUE) == 0) {
516 errno = EBUSY;
517 return -1;
518 }
519
520 pufbuf->pcc = pcc;
521 pufbuf->fcb = NULL;
522 pufbuf->fcb_arg = NULL;
523 pufbuf->istat &= ~ISTAT_NOREPLY;
524
525 puffs_cc_yield(pcc);
526
527 return 0;
528 }
529
530 int
531 puffs_framev_enqueue_waitevent(struct puffs_cc *pcc, int fd, int *what)
532 {
533 struct puffs_usermount *pu = pcc->pcc_pu;
534 struct puffs_fctrl_io *fio;
535 struct puffs_fbevent feb;
536 struct kevent kev;
537 int rv, svwhat;
538
539 svwhat = *what;
540
541 if (*what == 0) {
542 errno = EINVAL;
543 return -1;
544 }
545
546 fio = getfiobyfd(pu, fd);
547 if (fio == NULL) {
548 errno = EINVAL;
549 return -1;
550 }
551
552 feb.pcc = pcc;
553 feb.what = *what & (PUFFS_FBIO_READ|PUFFS_FBIO_WRITE|PUFFS_FBIO_ERROR);
554
555 if (*what & PUFFS_FBIO_READ)
556 if ((fio->stat & FIO_ENABLE_R) == 0)
557 EV_SET(&kev, fd, EVFILT_READ, EV_ENABLE,
558 0, 0, fio);
559
560 rv = kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL);
561 if (rv != 0)
562 return errno;
563
564 if (*what & PUFFS_FBIO_READ)
565 fio->rwait++;
566 if (*what & PUFFS_FBIO_WRITE)
567 fio->wwait++;
568
569 LIST_INSERT_HEAD(&fio->ev_qing, &feb, pfe_entries);
570 puffs_cc_yield(pcc);
571
572 assert(svwhat == *what);
573
574 if (*what & PUFFS_FBIO_READ) {
575 fio->rwait--;
576 if (fio->rwait == 0 && (fio->stat & FIO_ENABLE_R) == 0) {
577 EV_SET(&kev, fd, EVFILT_READ, EV_DISABLE,
578 0, 0, fio);
579 rv = kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL);
580 #if 0
581 if (rv != 0)
582 /* XXXXX oh dear */;
583 #endif
584 }
585 }
586 if (*what & PUFFS_FBIO_WRITE)
587 fio->wwait--;
588
589 if (feb.rv == 0) {
590 *what = feb.what;
591 rv = 0;
592 } else {
593 *what = PUFFS_FBIO_ERROR;
594 errno = feb.rv;
595 rv = -1;
596 }
597
598 return rv;
599 }
600
601 void
602 puffs__framev_notify(struct puffs_fctrl_io *fio, int what)
603 {
604 struct puffs_fbevent *fbevp;
605
606 restart:
607 LIST_FOREACH(fbevp, &fio->ev_qing, pfe_entries) {
608 if (fbevp->what & what) {
609 fbevp->what = what;
610 fbevp->rv = 0;
611 LIST_REMOVE(fbevp, pfe_entries);
612 puffs_cc_continue(fbevp->pcc);
613 goto restart;
614 }
615 }
616 }
617
618 static struct puffs_framebuf *
619 findbuf(struct puffs_usermount *pu, struct puffs_framectrl *fctrl,
620 struct puffs_fctrl_io *fio, struct puffs_framebuf *findme)
621 {
622 struct puffs_framebuf *cand;
623 int notresp = 0;
624
625 TAILQ_FOREACH(cand, &fio->res_qing, pfb_entries)
626 if (fctrl->cmpfb(pu, findme, cand, &notresp) == 0 || notresp)
627 break;
628
629 assert(!(notresp && cand == NULL));
630 if (notresp || cand == NULL)
631 return NULL;
632
633 TAILQ_REMOVE(&fio->res_qing, cand, pfb_entries);
634 return cand;
635 }
636
637 void
638 puffs__framebuf_moveinfo(struct puffs_framebuf *from, struct puffs_framebuf *to)
639 {
640
641 assert(from->istat & ISTAT_INTERNAL);
642
643 /* migrate buffer */
644 free(to->buf);
645 to->buf = from->buf;
646
647 /* migrate buffer info */
648 to->len = from->len;
649 to->offset = from->offset;
650 to->maxoff = from->maxoff;
651
652 from->buf = NULL;
653 from->len = 0;
654 }
655
656 void
657 puffs__framev_input(struct puffs_usermount *pu, struct puffs_framectrl *fctrl,
658 struct puffs_fctrl_io *fio)
659 {
660 struct puffs_framebuf *pufbuf, *appbuf;
661 int rv, complete;
662
663 while ((fio->stat & FIO_DEAD) == 0 && (fio->stat & FIO_ENABLE_R)) {
664 if ((pufbuf = fio->cur_in) == NULL) {
665 pufbuf = puffs_framebuf_make();
666 if (pufbuf == NULL)
667 return;
668 pufbuf->istat |= ISTAT_INTERNAL;
669 fio->cur_in = pufbuf;
670 }
671
672 complete = 0;
673 rv = fctrl->rfb(pu, pufbuf, fio->io_fd, &complete);
674
675 /* error */
676 if (rv) {
677 puffs__framev_readclose(pu, fio, rv);
678 fio->cur_in = NULL;
679 return;
680 }
681
682 /* partial read, come back to fight another day */
683 if (complete == 0)
684 break;
685
686 /* else: full read, process */
687 fio->cur_in = NULL;
688 if ((pufbuf->istat & ISTAT_DIRECT) == 0) {
689 appbuf = findbuf(pu, fctrl, fio, pufbuf);
690
691 /*
692 * No request for this frame? If fs implements
693 * gotfb, give frame to that. Otherwise drop it.
694 */
695 if (appbuf == NULL) {
696 if (fctrl->gotfb) {
697 pufbuf->istat &= ~ISTAT_INTERNAL;
698 fctrl->gotfb(pu, pufbuf);
699 } else {
700 puffs_framebuf_destroy(pufbuf);
701 }
702 continue;
703 }
704
705 puffs__framebuf_moveinfo(pufbuf, appbuf);
706 puffs_framebuf_destroy(pufbuf);
707 } else {
708 appbuf = pufbuf;
709 }
710 appbuf->istat &= ~ISTAT_NODESTROY;
711
712 if (appbuf->pcc) {
713 puffs__cc_cont(appbuf->pcc);
714 } else if (appbuf->fcb) {
715 appbuf->fcb(pu, appbuf, appbuf->fcb_arg, 0);
716 } else {
717 puffs_framebuf_destroy(appbuf);
718 }
719
720 /* hopeless romantics, here we go again */
721 }
722 }
723
724 int
725 puffs__framev_output(struct puffs_usermount *pu, struct puffs_framectrl *fctrl,
726 struct puffs_fctrl_io *fio)
727 {
728 struct puffs_framebuf *pufbuf;
729 int rv, complete, done;
730
731 if (fio->stat & FIO_DEAD)
732 return 0;
733
734 for (pufbuf = TAILQ_FIRST(&fio->snd_qing), done = 0;
735 pufbuf && (fio->stat & FIO_DEAD) == 0 && fio->stat & FIO_ENABLE_W;
736 pufbuf = TAILQ_FIRST(&fio->snd_qing)) {
737 complete = 0;
738 rv = fctrl->wfb(pu, pufbuf, fio->io_fd, &complete);
739
740 if (rv) {
741 puffs__framev_writeclose(pu, fio, rv);
742 done = 1;
743 break;
744 }
745
746 /* partial write */
747 if (complete == 0)
748 return done;
749
750 /* else, complete write */
751 TAILQ_REMOVE(&fio->snd_qing, pufbuf, pfb_entries);
752
753 /* can't wait for result if we can't read */
754 if (fio->stat & FIO_RDGONE) {
755 errnotify(pu, pufbuf, ENXIO);
756 done = 1;
757 } else if ((pufbuf->istat & ISTAT_DIRECT)) {
758 pufbuf->istat &= ~ISTAT_NODESTROY;
759 done = 1;
760 puffs__cc_cont(pufbuf->pcc);
761 } else if ((pufbuf->istat & ISTAT_NOREPLY) == 0) {
762 TAILQ_INSERT_TAIL(&fio->res_qing, pufbuf,
763 pfb_entries);
764 } else {
765 pufbuf->istat &= ~ISTAT_NODESTROY;
766 puffs_framebuf_destroy(pufbuf);
767 }
768
769 /* omstart! */
770 }
771
772 return done;
773 }
774
775 int
776 puffs__framev_addfd_ctrl(struct puffs_usermount *pu, int fd, int what,
777 struct puffs_framectrl *pfctrl)
778 {
779 struct puffs_fctrl_io *fio;
780 struct kevent *newevs;
781 struct kevent kev[2];
782 size_t nevs;
783 int rv, readenable;
784
785 nevs = pu->pu_nevs+2;
786 newevs = realloc(pu->pu_evs, nevs*sizeof(struct kevent));
787 if (newevs == NULL)
788 return -1;
789 pu->pu_evs = newevs;
790
791 fio = malloc(sizeof(struct puffs_fctrl_io));
792 if (fio == NULL)
793 return -1;
794 memset(fio, 0, sizeof(struct puffs_fctrl_io));
795 fio->io_fd = fd;
796 fio->cur_in = NULL;
797 fio->fctrl = pfctrl;
798 TAILQ_INIT(&fio->snd_qing);
799 TAILQ_INIT(&fio->res_qing);
800 LIST_INIT(&fio->ev_qing);
801
802 readenable = 0;
803 if ((what & PUFFS_FBIO_READ) == 0)
804 readenable = EV_DISABLE;
805
806 if (pu->pu_state & PU_INLOOP) {
807 EV_SET(&kev[0], fd, EVFILT_READ,
808 EV_ADD|readenable, 0, 0, fio);
809 EV_SET(&kev[1], fd, EVFILT_WRITE,
810 EV_ADD|EV_DISABLE, 0, 0, fio);
811 rv = kevent(pu->pu_kq, kev, 2, NULL, 0, NULL);
812 if (rv == -1) {
813 free(fio);
814 return -1;
815 }
816 }
817 if (what & PUFFS_FBIO_READ)
818 fio->stat |= FIO_ENABLE_R;
819 if (what & PUFFS_FBIO_WRITE)
820 fio->stat |= FIO_ENABLE_W;
821
822 LIST_INSERT_HEAD(&pu->pu_ios, fio, fio_entries);
823 pu->pu_nevs = nevs;
824
825 return 0;
826 }
827
828 int
829 puffs_framev_addfd(struct puffs_usermount *pu, int fd, int what)
830 {
831
832 return puffs__framev_addfd_ctrl(pu, fd, what,
833 &pu->pu_framectrl[PU_FRAMECTRL_USER]);
834 }
835
836 /*
837 * XXX: the following en/disable should be coalesced and executed
838 * only during the actual kevent call. So feel free to fix if
839 * threatened by mindblowing boredom.
840 */
841
842 int
843 puffs_framev_enablefd(struct puffs_usermount *pu, int fd, int what)
844 {
845 struct kevent kev;
846 struct puffs_fctrl_io *fio;
847 int rv = 0;
848
849 assert((what & (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE)) != 0);
850
851 fio = getfiobyfd(pu, fd);
852 if (fio == NULL) {
853 errno = ENXIO;
854 return -1;
855 }
856
857 /* write is enabled in the event loop if there is output */
858 if (what & PUFFS_FBIO_READ && fio->rwait == 0) {
859 EV_SET(&kev, fd, EVFILT_READ, EV_ENABLE, 0, 0, fio);
860 rv = kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL);
861 }
862
863 if (rv == 0) {
864 if (what & PUFFS_FBIO_READ)
865 fio->stat |= FIO_ENABLE_R;
866 if (what & PUFFS_FBIO_WRITE)
867 fio->stat |= FIO_ENABLE_W;
868 }
869
870 return rv;
871 }
872
873 int
874 puffs_framev_disablefd(struct puffs_usermount *pu, int fd, int what)
875 {
876 struct kevent kev[2];
877 struct puffs_fctrl_io *fio;
878 size_t i;
879 int rv;
880
881 assert((what & (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE)) != 0);
882
883 fio = getfiobyfd(pu, fd);
884 if (fio == NULL) {
885 errno = ENXIO;
886 return -1;
887 }
888
889 i = 0;
890 if (what & PUFFS_FBIO_READ && fio->rwait == 0) {
891 EV_SET(&kev[0], fd,
892 EVFILT_READ, EV_DISABLE, 0, 0, fio);
893 i++;
894 }
895 if (what & PUFFS_FBIO_WRITE && fio->stat & FIO_WR && fio->wwait == 0) {
896 EV_SET(&kev[1], fd,
897 EVFILT_WRITE, EV_DISABLE, 0, 0, fio);
898 i++;
899 }
900 if (i)
901 rv = kevent(pu->pu_kq, kev, i, NULL, 0, NULL);
902 else
903 rv = 0;
904
905 if (rv == 0) {
906 if (what & PUFFS_FBIO_READ)
907 fio->stat &= ~FIO_ENABLE_R;
908 if (what & PUFFS_FBIO_WRITE)
909 fio->stat &= ~FIO_ENABLE_W;
910 }
911
912 return rv;
913 }
914
915 void
916 puffs__framev_readclose(struct puffs_usermount *pu,
917 struct puffs_fctrl_io *fio, int error)
918 {
919 struct puffs_framebuf *pufbuf;
920 struct kevent kev;
921 int notflag;
922
923 if (fio->stat & FIO_RDGONE || fio->stat & FIO_DEAD)
924 return;
925 fio->stat |= FIO_RDGONE;
926
927 if (fio->cur_in) {
928 if ((fio->cur_in->istat & ISTAT_DIRECT) == 0) {
929 puffs_framebuf_destroy(fio->cur_in);
930 fio->cur_in = NULL;
931 } else {
932 errnotify(pu, fio->cur_in, error);
933 }
934 }
935
936 while ((pufbuf = TAILQ_FIRST(&fio->res_qing)) != NULL) {
937 TAILQ_REMOVE(&fio->res_qing, pufbuf, pfb_entries);
938 errnotify(pu, pufbuf, error);
939 }
940
941 EV_SET(&kev, fio->io_fd, EVFILT_READ, EV_DELETE, 0, 0, 0);
942 (void) kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL);
943
944 notflag = PUFFS_FBIO_READ;
945 if (fio->stat & FIO_WRGONE)
946 notflag |= PUFFS_FBIO_WRITE;
947
948 if (fio->fctrl->fdnotfn)
949 fio->fctrl->fdnotfn(pu, fio->io_fd, notflag);
950 }
951
952 void
953 puffs__framev_writeclose(struct puffs_usermount *pu,
954 struct puffs_fctrl_io *fio, int error)
955 {
956 struct puffs_framebuf *pufbuf;
957 struct kevent kev;
958 int notflag;
959
960 if (fio->stat & FIO_WRGONE || fio->stat & FIO_DEAD)
961 return;
962 fio->stat |= FIO_WRGONE;
963
964 while ((pufbuf = TAILQ_FIRST(&fio->snd_qing)) != NULL) {
965 TAILQ_REMOVE(&fio->snd_qing, pufbuf, pfb_entries);
966 errnotify(pu, pufbuf, error);
967 }
968
969 EV_SET(&kev, fio->io_fd, EVFILT_WRITE, EV_DELETE, 0, 0, 0);
970 (void) kevent(pu->pu_kq, &kev, 1, NULL, 0, NULL);
971
972 notflag = PUFFS_FBIO_WRITE;
973 if (fio->stat & FIO_RDGONE)
974 notflag |= PUFFS_FBIO_READ;
975
976 if (fio->fctrl->fdnotfn)
977 fio->fctrl->fdnotfn(pu, fio->io_fd, notflag);
978 }
979
980 static int
981 removefio(struct puffs_usermount *pu, struct puffs_fctrl_io *fio, int error)
982 {
983 struct puffs_fbevent *fbevp;
984
985 LIST_REMOVE(fio, fio_entries);
986 if (pu->pu_state & PU_INLOOP) {
987 puffs__framev_readclose(pu, fio, error);
988 puffs__framev_writeclose(pu, fio, error);
989 }
990
991 while ((fbevp = LIST_FIRST(&fio->ev_qing)) != NULL) {
992 fbevp->rv = error;
993 LIST_REMOVE(fbevp, pfe_entries);
994 puffs__goto(fbevp->pcc);
995 }
996
997 /* don't bother with realloc */
998 pu->pu_nevs -= 2;
999
1000 /* don't free us yet, might have some references in event arrays */
1001 fio->stat |= FIO_DEAD;
1002 LIST_INSERT_HEAD(&pu->pu_ios_rmlist, fio, fio_entries);
1003
1004 return 0;
1005
1006 }
1007
1008 int
1009 puffs_framev_removefd(struct puffs_usermount *pu, int fd, int error)
1010 {
1011 struct puffs_fctrl_io *fio;
1012
1013 fio = getfiobyfd(pu, fd);
1014 if (fio == NULL) {
1015 errno = ENXIO;
1016 return -1;
1017 }
1018
1019 return removefio(pu, fio, error ? error : ECONNRESET);
1020 }
1021
1022 void
1023 puffs_framev_removeonclose(struct puffs_usermount *pu, int fd, int what)
1024 {
1025
1026 if (what == (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE))
1027 (void) puffs_framev_removefd(pu, fd, ECONNRESET);
1028 }
1029
1030 void
1031 puffs_framev_unmountonclose(struct puffs_usermount *pu, int fd, int what)
1032 {
1033
1034 /* XXX & X: unmount is non-sensible */
1035 puffs_framev_removeonclose(pu, fd, what);
1036 if (what == (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE))
1037 PU_SETSTATE(pu, PUFFS_STATE_UNMOUNTED);
1038 }
1039
1040 void
1041 puffs_framev_init(struct puffs_usermount *pu,
1042 puffs_framev_readframe_fn rfb, puffs_framev_writeframe_fn wfb,
1043 puffs_framev_cmpframe_fn cmpfb, puffs_framev_gotframe_fn gotfb,
1044 puffs_framev_fdnotify_fn fdnotfn)
1045 {
1046 struct puffs_framectrl *pfctrl;
1047
1048 pfctrl = &pu->pu_framectrl[PU_FRAMECTRL_USER];
1049 pfctrl->rfb = rfb;
1050 pfctrl->wfb = wfb;
1051 pfctrl->cmpfb = cmpfb;
1052 pfctrl->gotfb = gotfb;
1053 pfctrl->fdnotfn = fdnotfn;
1054 }
1055
1056 void
1057 puffs__framev_exit(struct puffs_usermount *pu)
1058 {
1059 struct puffs_fctrl_io *fio;
1060
1061 while ((fio = LIST_FIRST(&pu->pu_ios)) != NULL)
1062 removefio(pu, fio, ENXIO);
1063 free(pu->pu_evs);
1064
1065 /* closing pu->pu_kq takes care of puffsfd */
1066 }
DragonFly BSD