?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
diff(1): Commit our patches to contrib/ and get rid of -I-.
[dragonfly.git] / lib / libc_r / uthread / uthread_fd.c
blobcf06446d2e3f1e3d21a5a2ea3b3c7b8d8c4e3a4c
1 /*
2 * Copyright (c) 1995-1998 John Birrell <jb@cimlogic.com.au>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by John Birrell.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * $FreeBSD: src/lib/libc_r/uthread/uthread_fd.c,v 1.16.2.7 2002/10/22 14:44:03 fjoe Exp $
33 * $DragonFly: src/lib/libc_r/uthread/uthread_fd.c,v 1.3 2006/06/14 01:45:28 dillon Exp $
34 *
35 */
36 #include <errno.h>
37 #include <fcntl.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <pthread.h>
41 #include "pthread_private.h"
42
43 #define FDQ_INSERT(q,p) \
44 do { \
45 TAILQ_INSERT_TAIL(q,p,qe); \
46 p->flags |= PTHREAD_FLAGS_IN_FDQ; \
47 } while (0)
48
49 #define FDQ_REMOVE(q,p) \
50 do { \
51 if ((p->flags & PTHREAD_FLAGS_IN_FDQ) != 0) { \
52 TAILQ_REMOVE(q,p,qe); \
53 p->flags &= ~PTHREAD_FLAGS_IN_FDQ; \
54 } \
55 } while (0)
56
57
58 /* Static variables: */
59 static spinlock_t fd_table_lock = _SPINLOCK_INITIALIZER;
60
61 /* Prototypes: */
62 #ifdef _FDLOCKS_ENABLED
63 static inline pthread_t fd_next_reader(int fd);
64 static inline pthread_t fd_next_writer(int fd);
65 #endif
66
67
68 /*
69 * This function *must* return -1 and set the thread specific errno
70 * as a system call. This is because the error return from this
71 * function is propagated directly back from thread-wrapped system
72 * calls.
73 */
74
75 int
76 _thread_fd_table_init(int fd)
77 {
78 int ret = 0;
79 struct fd_table_entry *entry;
80 int saved_errno;
81
82 if (_thread_initial == NULL)
83 _thread_init();
84
85 /* Check if the file descriptor is out of range: */
86 if (fd < 0 || fd >= _thread_dtablesize) {
87 /* Return a bad file descriptor error: */
88 errno = EBADF;
89 ret = -1;
90 }
91
92 /*
93 * Check if memory has already been allocated for this file
94 * descriptor:
95 */
96 else if (_thread_fd_table[fd] != NULL) {
97 /* Memory has already been allocated. */
98
99 /* Allocate memory for the file descriptor table entry: */
100 } else if ((entry = (struct fd_table_entry *)
101 malloc(sizeof(struct fd_table_entry))) == NULL) {
102 /* Return an insufficient memory error: */
103 errno = ENOMEM;
104 ret = -1;
105 } else {
106 /* Initialise the file locks: */
107 memset(&entry->lock, 0, sizeof(entry->lock));
108 entry->r_owner = NULL;
109 entry->w_owner = NULL;
110 entry->r_fname = NULL;
111 entry->w_fname = NULL;
112 entry->r_lineno = 0;
113 entry->w_lineno = 0;
114 entry->r_lockcount = 0;
115 entry->w_lockcount = 0;
116
117 /* Initialise the read/write queues: */
118 TAILQ_INIT(&entry->r_queue);
119 TAILQ_INIT(&entry->w_queue);
120
121 /* Get the flags for the file: */
122 if (((fd >= 3) || (_pthread_stdio_flags[fd] == -1)) &&
123 (entry->flags = __sys_fcntl(fd, F_GETFL, 0)) == -1) {
124 ret = -1;
125 } else {
126 /* Check if a stdio descriptor: */
127 if ((fd < 3) && (_pthread_stdio_flags[fd] != -1)) {
128 /*
129 * Use the stdio flags read by
130 * _pthread_init() to avoid
131 * mistaking the non-blocking
132 * flag that, when set on one
133 * stdio fd, is set on all stdio
134 * fds.
135 */
136 entry->flags = _pthread_stdio_flags[fd];
137 }
138
139 /*
140 * NOTE: We now use new system calls which allow
141 * the non-blocking mode to be set on a per-I/O
142 * basis, we no longer have to mess with the
143 * file pointer (which can have unexpected side
144 * effects since it might be shared with parent
145 * processes such as, oh, gmake).
146 */
147
148 /* Lock the file descriptor table: */
149 _SPINLOCK(&fd_table_lock);
150
151 /*
152 * Check if another thread allocated the
153 * file descriptor entry while this thread
154 * was doing the same thing. The table wasn't
155 * kept locked during this operation because
156 * it has the potential to recurse.
157 */
158 if (_thread_fd_table[fd] == NULL) {
159 /* This thread wins: */
160 _thread_fd_table[fd] = entry;
161 entry = NULL;
162 }
163
164 /* Unlock the file descriptor table: */
165 _SPINUNLOCK(&fd_table_lock);
166 }
167
168 /*
169 * Check if another thread initialised the table entry
170 * before this one could:
171 */
172 if (entry != NULL)
173 /*
174 * Throw away the table entry that this thread
175 * prepared. The other thread wins.
176 */
177 free(entry);
178 }
179
180 /* Return the completion status: */
181 return (ret);
182 }
183
184 int
185 _thread_fd_getflags(int fd)
186 {
187 if (_thread_fd_table[fd] != NULL)
188 return (_thread_fd_table[fd]->flags);
189 else
190 return (0);
191 }
192
193 void
194 _thread_fd_setflags(int fd, int flags)
195 {
196 if (_thread_fd_table[fd] != NULL)
197 _thread_fd_table[fd]->flags = flags;
198 }
199
200 #ifdef _FDLOCKS_ENABLED
201 void
202 _thread_fd_unlock(int fd, int lock_type)
203 {
204 struct pthread *curthread = _get_curthread();
205 int ret;
206
207 /*
208 * Check that the file descriptor table is initialised for this
209 * entry:
210 */
211 if ((ret = _thread_fd_table_init(fd)) == 0) {
212 /*
213 * Defer signals to protect the scheduling queues from
214 * access by the signal handler:
215 */
216 _thread_kern_sig_defer();
217
218 /*
219 * Lock the file descriptor table entry to prevent
220 * other threads for clashing with the current
221 * thread's accesses:
222 */
223 _SPINLOCK(&_thread_fd_table[fd]->lock);
224
225 /* Check if the running thread owns the read lock: */
226 if (_thread_fd_table[fd]->r_owner == curthread) {
227 /* Check the file descriptor and lock types: */
228 if (lock_type == FD_READ || lock_type == FD_RDWR) {
229 /*
230 * Decrement the read lock count for the
231 * running thread:
232 */
233 _thread_fd_table[fd]->r_lockcount--;
234
235 /*
236 * Check if the running thread still has read
237 * locks on this file descriptor:
238 */
239 if (_thread_fd_table[fd]->r_lockcount != 0) {
240 }
241 /*
242 * Get the next thread in the queue for a
243 * read lock on this file descriptor:
244 */
245 else if ((_thread_fd_table[fd]->r_owner = fd_next_reader(fd)) == NULL) {
246 } else {
247 /* Remove this thread from the queue: */
248 FDQ_REMOVE(&_thread_fd_table[fd]->r_queue,
249 _thread_fd_table[fd]->r_owner);
250
251 /*
252 * Set the state of the new owner of
253 * the thread to running:
254 */
255 PTHREAD_NEW_STATE(_thread_fd_table[fd]->r_owner,PS_RUNNING);
256
257 /*
258 * Reset the number of read locks.
259 * This will be incremented by the
260 * new owner of the lock when it sees
261 * that it has the lock.
262 */
263 _thread_fd_table[fd]->r_lockcount = 0;
264 }
265 }
266 }
267 /* Check if the running thread owns the write lock: */
268 if (_thread_fd_table[fd]->w_owner == curthread) {
269 /* Check the file descriptor and lock types: */
270 if (lock_type == FD_WRITE || lock_type == FD_RDWR) {
271 /*
272 * Decrement the write lock count for the
273 * running thread:
274 */
275 _thread_fd_table[fd]->w_lockcount--;
276
277 /*
278 * Check if the running thread still has
279 * write locks on this file descriptor:
280 */
281 if (_thread_fd_table[fd]->w_lockcount != 0) {
282 }
283 /*
284 * Get the next thread in the queue for a
285 * write lock on this file descriptor:
286 */
287 else if ((_thread_fd_table[fd]->w_owner = fd_next_writer(fd)) == NULL) {
288 } else {
289 /* Remove this thread from the queue: */
290 FDQ_REMOVE(&_thread_fd_table[fd]->w_queue,
291 _thread_fd_table[fd]->w_owner);
292
293 /*
294 * Set the state of the new owner of
295 * the thread to running:
296 */
297 PTHREAD_NEW_STATE(_thread_fd_table[fd]->w_owner,PS_RUNNING);
298
299 /*
300 * Reset the number of write locks.
301 * This will be incremented by the
302 * new owner of the lock when it
303 * sees that it has the lock.
304 */
305 _thread_fd_table[fd]->w_lockcount = 0;
306 }
307 }
308 }
309
310 /* Unlock the file descriptor table entry: */
311 _SPINUNLOCK(&_thread_fd_table[fd]->lock);
312
313 /*
314 * Undefer and handle pending signals, yielding if
315 * necessary:
316 */
317 _thread_kern_sig_undefer();
318 }
319 }
320
321 int
322 _thread_fd_lock(int fd, int lock_type, struct timespec * timeout)
323 {
324 struct pthread *curthread = _get_curthread();
325 int ret;
326
327 /*
328 * Check that the file descriptor table is initialised for this
329 * entry:
330 */
331 if ((ret = _thread_fd_table_init(fd)) == 0) {
332 /* Clear the interrupted flag: */
333 curthread->interrupted = 0;
334
335 /*
336 * Lock the file descriptor table entry to prevent
337 * other threads for clashing with the current
338 * thread's accesses:
339 */
340 _SPINLOCK(&_thread_fd_table[fd]->lock);
341
342 /* Check the file descriptor and lock types: */
343 if (lock_type == FD_READ || lock_type == FD_RDWR) {
344 /*
345 * Wait for the file descriptor to be locked
346 * for read for the current thread:
347 */
348 while ((_thread_fd_table[fd]->r_owner != curthread) &&
349 (curthread->interrupted == 0)) {
350 /*
351 * Check if the file descriptor is locked by
352 * another thread:
353 */
354 if (_thread_fd_table[fd]->r_owner != NULL) {
355 /*
356 * Another thread has locked the file
357 * descriptor for read, so join the
358 * queue of threads waiting for a
359 * read lock on this file descriptor:
360 */
361 FDQ_INSERT(&_thread_fd_table[fd]->r_queue, curthread);
362
363 /*
364 * Save the file descriptor details
365 * in the thread structure for the
366 * running thread:
367 */
368 curthread->data.fd.fd = fd;
369
370 /* Set the timeout: */
371 _thread_kern_set_timeout(timeout);
372
373 /*
374 * Unlock the file descriptor
375 * table entry:
376 */
377 _SPINUNLOCK(&_thread_fd_table[fd]->lock);
378
379 /*
380 * Schedule this thread to wait on
381 * the read lock. It will only be
382 * woken when it becomes the next in
383 * the queue and is granted access
384 * to the lock by the thread
385 * that is unlocking the file
386 * descriptor.
387 */
388 _thread_kern_sched_state(PS_FDLR_WAIT, __FILE__, __LINE__);
389
390 /*
391 * Lock the file descriptor
392 * table entry again:
393 */
394 _SPINLOCK(&_thread_fd_table[fd]->lock);
395
396 if (curthread->interrupted != 0) {
397 FDQ_REMOVE(&_thread_fd_table[fd]->r_queue,
398 curthread);
399 }
400 } else {
401 /*
402 * The running thread now owns the
403 * read lock on this file descriptor:
404 */
405 _thread_fd_table[fd]->r_owner = curthread;
406
407 /*
408 * Reset the number of read locks for
409 * this file descriptor:
410 */
411 _thread_fd_table[fd]->r_lockcount = 0;
412 }
413 }
414
415 if (_thread_fd_table[fd]->r_owner == curthread)
416 /* Increment the read lock count: */
417 _thread_fd_table[fd]->r_lockcount++;
418 }
419
420 /* Check the file descriptor and lock types: */
421 if (curthread->interrupted == 0 &&
422 (lock_type == FD_WRITE || lock_type == FD_RDWR)) {
423 /*
424 * Wait for the file descriptor to be locked
425 * for write for the current thread:
426 */
427 while ((_thread_fd_table[fd]->w_owner != curthread) &&
428 (curthread->interrupted == 0)) {
429 /*
430 * Check if the file descriptor is locked by
431 * another thread:
432 */
433 if (_thread_fd_table[fd]->w_owner != NULL) {
434 /*
435 * Another thread has locked the file
436 * descriptor for write, so join the
437 * queue of threads waiting for a
438 * write lock on this file
439 * descriptor:
440 */
441 FDQ_INSERT(&_thread_fd_table[fd]->w_queue, curthread);
442
443 /*
444 * Save the file descriptor details
445 * in the thread structure for the
446 * running thread:
447 */
448 curthread->data.fd.fd = fd;
449
450 /* Set the timeout: */
451 _thread_kern_set_timeout(timeout);
452
453 /*
454 * Unlock the file descriptor
455 * table entry:
456 */
457 _SPINUNLOCK(&_thread_fd_table[fd]->lock);
458
459 /*
460 * Schedule this thread to wait on
461 * the write lock. It will only be
462 * woken when it becomes the next in
463 * the queue and is granted access to
464 * the lock by the thread that is
465 * unlocking the file descriptor.
466 */
467 _thread_kern_sched_state(PS_FDLW_WAIT, __FILE__, __LINE__);
468
469 /*
470 * Lock the file descriptor
471 * table entry again:
472 */
473 _SPINLOCK(&_thread_fd_table[fd]->lock);
474
475 if (curthread->interrupted != 0) {
476 FDQ_REMOVE(&_thread_fd_table[fd]->w_queue,
477 curthread);
478 }
479 } else {
480 /*
481 * The running thread now owns the
482 * write lock on this file
483 * descriptor:
484 */
485 _thread_fd_table[fd]->w_owner = curthread;
486
487 /*
488 * Reset the number of write locks
489 * for this file descriptor:
490 */
491 _thread_fd_table[fd]->w_lockcount = 0;
492 }
493 }
494
495 if (_thread_fd_table[fd]->w_owner == curthread)
496 /* Increment the write lock count: */
497 _thread_fd_table[fd]->w_lockcount++;
498 }
499
500 /* Unlock the file descriptor table entry: */
501 _SPINUNLOCK(&_thread_fd_table[fd]->lock);
502
503 if (curthread->interrupted != 0) {
504 ret = -1;
505 errno = EINTR;
506 if (curthread->continuation != NULL)
507 curthread->continuation((void *)curthread);
508 }
509 }
510
511 /* Return the completion status: */
512 return (ret);
513 }
514
515 void
516 _thread_fd_unlock_debug(int fd, int lock_type, char *fname, int lineno)
517 {
518 struct pthread *curthread = _get_curthread();
519 int ret;
520
521 /*
522 * Check that the file descriptor table is initialised for this
523 * entry:
524 */
525 if ((ret = _thread_fd_table_init(fd)) == 0) {
526 /*
527 * Defer signals to protect the scheduling queues from
528 * access by the signal handler:
529 */
530 _thread_kern_sig_defer();
531
532 /*
533 * Lock the file descriptor table entry to prevent
534 * other threads for clashing with the current
535 * thread's accesses:
536 */
537 _spinlock_debug(&_thread_fd_table[fd]->lock, fname, lineno);
538
539 /* Check if the running thread owns the read lock: */
540 if (_thread_fd_table[fd]->r_owner == curthread) {
541 /* Check the file descriptor and lock types: */
542 if (lock_type == FD_READ || lock_type == FD_RDWR) {
543 /*
544 * Decrement the read lock count for the
545 * running thread:
546 */
547 _thread_fd_table[fd]->r_lockcount--;
548
549 /*
550 * Check if the running thread still has read
551 * locks on this file descriptor:
552 */
553 if (_thread_fd_table[fd]->r_lockcount != 0) {
554 }
555 /*
556 * Get the next thread in the queue for a
557 * read lock on this file descriptor:
558 */
559 else if ((_thread_fd_table[fd]->r_owner = fd_next_reader(fd)) == NULL) {
560 } else {
561 /* Remove this thread from the queue: */
562 FDQ_REMOVE(&_thread_fd_table[fd]->r_queue,
563 _thread_fd_table[fd]->r_owner);
564
565 /*
566 * Set the state of the new owner of
567 * the thread to running:
568 */
569 PTHREAD_NEW_STATE(_thread_fd_table[fd]->r_owner,PS_RUNNING);
570
571 /*
572 * Reset the number of read locks.
573 * This will be incremented by the
574 * new owner of the lock when it sees
575 * that it has the lock.
576 */
577 _thread_fd_table[fd]->r_lockcount = 0;
578 }
579 }
580 }
581 /* Check if the running thread owns the write lock: */
582 if (_thread_fd_table[fd]->w_owner == curthread) {
583 /* Check the file descriptor and lock types: */
584 if (lock_type == FD_WRITE || lock_type == FD_RDWR) {
585 /*
586 * Decrement the write lock count for the
587 * running thread:
588 */
589 _thread_fd_table[fd]->w_lockcount--;
590
591 /*
592 * Check if the running thread still has
593 * write locks on this file descriptor:
594 */
595 if (_thread_fd_table[fd]->w_lockcount != 0) {
596 }
597 /*
598 * Get the next thread in the queue for a
599 * write lock on this file descriptor:
600 */
601 else if ((_thread_fd_table[fd]->w_owner = fd_next_writer(fd)) == NULL) {
602 } else {
603 /* Remove this thread from the queue: */
604 FDQ_REMOVE(&_thread_fd_table[fd]->w_queue,
605 _thread_fd_table[fd]->w_owner);
606
607 /*
608 * Set the state of the new owner of
609 * the thread to running:
610 */
611 PTHREAD_NEW_STATE(_thread_fd_table[fd]->w_owner,PS_RUNNING);
612
613 /*
614 * Reset the number of write locks.
615 * This will be incremented by the
616 * new owner of the lock when it
617 * sees that it has the lock.
618 */
619 _thread_fd_table[fd]->w_lockcount = 0;
620 }
621 }
622 }
623
624 /* Unlock the file descriptor table entry: */
625 _SPINUNLOCK(&_thread_fd_table[fd]->lock);
626
627 /*
628 * Undefer and handle pending signals, yielding if
629 * necessary.
630 */
631 _thread_kern_sig_undefer();
632 }
633 }
634
635 int
636 _thread_fd_lock_debug(int fd, int lock_type, struct timespec * timeout,
637 char *fname, int lineno)
638 {
639 struct pthread *curthread = _get_curthread();
640 int ret;
641
642 /*
643 * Check that the file descriptor table is initialised for this
644 * entry:
645 */
646 if ((ret = _thread_fd_table_init(fd)) == 0) {
647 /* Clear the interrupted flag: */
648 curthread->interrupted = 0;
649
650 /*
651 * Lock the file descriptor table entry to prevent
652 * other threads for clashing with the current
653 * thread's accesses:
654 */
655 _spinlock_debug(&_thread_fd_table[fd]->lock, fname, lineno);
656
657 /* Check the file descriptor and lock types: */
658 if (lock_type == FD_READ || lock_type == FD_RDWR) {
659 /*
660 * Wait for the file descriptor to be locked
661 * for read for the current thread:
662 */
663 while ((_thread_fd_table[fd]->r_owner != curthread) &&
664 (curthread->interrupted == 0)) {
665 /*
666 * Check if the file descriptor is locked by
667 * another thread:
668 */
669 if (_thread_fd_table[fd]->r_owner != NULL) {
670 /*
671 * Another thread has locked the file
672 * descriptor for read, so join the
673 * queue of threads waiting for a
674 * read lock on this file descriptor:
675 */
676 FDQ_INSERT(&_thread_fd_table[fd]->r_queue, curthread);
677
678 /*
679 * Save the file descriptor details
680 * in the thread structure for the
681 * running thread:
682 */
683 curthread->data.fd.fd = fd;
684 curthread->data.fd.branch = lineno;
685 curthread->data.fd.fname = fname;
686
687 /* Set the timeout: */
688 _thread_kern_set_timeout(timeout);
689
690 /*
691 * Unlock the file descriptor
692 * table entry:
693 */
694 _SPINUNLOCK(&_thread_fd_table[fd]->lock);
695
696 /*
697 * Schedule this thread to wait on
698 * the read lock. It will only be
699 * woken when it becomes the next in
700 * the queue and is granted access
701 * to the lock by the thread
702 * that is unlocking the file
703 * descriptor.
704 */
705 _thread_kern_sched_state(PS_FDLR_WAIT, __FILE__, __LINE__);
706
707 /*
708 * Lock the file descriptor
709 * table entry again:
710 */
711 _SPINLOCK(&_thread_fd_table[fd]->lock);
712
713 if (curthread->interrupted != 0) {
714 FDQ_REMOVE(&_thread_fd_table[fd]->r_queue,
715 curthread);
716 }
717 } else {
718 /*
719 * The running thread now owns the
720 * read lock on this file descriptor:
721 */
722 _thread_fd_table[fd]->r_owner = curthread;
723
724 /*
725 * Reset the number of read locks for
726 * this file descriptor:
727 */
728 _thread_fd_table[fd]->r_lockcount = 0;
729
730 /*
731 * Save the source file details for
732 * debugging:
733 */
734 _thread_fd_table[fd]->r_fname = fname;
735 _thread_fd_table[fd]->r_lineno = lineno;
736 }
737 }
738
739 if (_thread_fd_table[fd]->r_owner == curthread)
740 /* Increment the read lock count: */
741 _thread_fd_table[fd]->r_lockcount++;
742 }
743
744 /* Check the file descriptor and lock types: */
745 if (curthread->interrupted == 0 &&
746 (lock_type == FD_WRITE || lock_type == FD_RDWR)) {
747 /*
748 * Wait for the file descriptor to be locked
749 * for write for the current thread:
750 */
751 while ((_thread_fd_table[fd]->w_owner != curthread) &&
752 (curthread->interrupted == 0)) {
753 /*
754 * Check if the file descriptor is locked by
755 * another thread:
756 */
757 if (_thread_fd_table[fd]->w_owner != NULL) {
758 /*
759 * Another thread has locked the file
760 * descriptor for write, so join the
761 * queue of threads waiting for a
762 * write lock on this file
763 * descriptor:
764 */
765 FDQ_INSERT(&_thread_fd_table[fd]->w_queue, curthread);
766
767 /*
768 * Save the file descriptor details
769 * in the thread structure for the
770 * running thread:
771 */
772 curthread->data.fd.fd = fd;
773 curthread->data.fd.branch = lineno;
774 curthread->data.fd.fname = fname;
775
776 /* Set the timeout: */
777 _thread_kern_set_timeout(timeout);
778
779 /*
780 * Unlock the file descriptor
781 * table entry:
782 */
783 _SPINUNLOCK(&_thread_fd_table[fd]->lock);
784
785 /*
786 * Schedule this thread to wait on
787 * the write lock. It will only be
788 * woken when it becomes the next in
789 * the queue and is granted access to
790 * the lock by the thread that is
791 * unlocking the file descriptor.
792 */
793 _thread_kern_sched_state(PS_FDLW_WAIT, __FILE__, __LINE__);
794
795 /*
796 * Lock the file descriptor
797 * table entry again:
798 */
799 _SPINLOCK(&_thread_fd_table[fd]->lock);
800
801 if (curthread->interrupted != 0) {
802 FDQ_REMOVE(&_thread_fd_table[fd]->w_queue,
803 curthread);
804 }
805 } else {
806 /*
807 * The running thread now owns the
808 * write lock on this file
809 * descriptor:
810 */
811 _thread_fd_table[fd]->w_owner = curthread;
812
813 /*
814 * Reset the number of write locks
815 * for this file descriptor:
816 */
817 _thread_fd_table[fd]->w_lockcount = 0;
818
819 /*
820 * Save the source file details for
821 * debugging:
822 */
823 _thread_fd_table[fd]->w_fname = fname;
824 _thread_fd_table[fd]->w_lineno = lineno;
825 }
826 }
827
828 if (_thread_fd_table[fd]->w_owner == curthread)
829 /* Increment the write lock count: */
830 _thread_fd_table[fd]->w_lockcount++;
831 }
832
833 /* Unlock the file descriptor table entry: */
834 _SPINUNLOCK(&_thread_fd_table[fd]->lock);
835
836 if (curthread->interrupted != 0) {
837 ret = -1;
838 errno = EINTR;
839 if (curthread->continuation != NULL)
840 curthread->continuation((void *)curthread);
841 }
842 }
843
844 /* Return the completion status: */
845 return (ret);
846 }
847
848 void
849 _thread_fd_unlock_owned(pthread_t pthread)
850 {
851 int fd;
852
853 for (fd = 0; fd < _thread_dtablesize; fd++) {
854 if ((_thread_fd_table[fd] != NULL) &&
855 ((_thread_fd_table[fd]->r_owner == pthread) ||
856 (_thread_fd_table[fd]->w_owner == pthread))) {
857 /*
858 * Defer signals to protect the scheduling queues
859 * from access by the signal handler:
860 */
861 _thread_kern_sig_defer();
862
863 /*
864 * Lock the file descriptor table entry to prevent
865 * other threads for clashing with the current
866 * thread's accesses:
867 */
868 _SPINLOCK(&_thread_fd_table[fd]->lock);
869
870 /* Check if the thread owns the read lock: */
871 if (_thread_fd_table[fd]->r_owner == pthread) {
872 /* Clear the read lock count: */
873 _thread_fd_table[fd]->r_lockcount = 0;
874
875 /*
876 * Get the next thread in the queue for a
877 * read lock on this file descriptor:
878 */
879 if ((_thread_fd_table[fd]->r_owner = fd_next_reader(fd)) != NULL) {
880 /* Remove this thread from the queue: */
881 FDQ_REMOVE(&_thread_fd_table[fd]->r_queue,
882 _thread_fd_table[fd]->r_owner);
883
884 /*
885 * Set the state of the new owner of
886 * the thread to running:
887 */
888 PTHREAD_NEW_STATE(_thread_fd_table[fd]->r_owner,PS_RUNNING);
889 }
890 }
891
892 /* Check if the thread owns the write lock: */
893 if (_thread_fd_table[fd]->w_owner == pthread) {
894 /* Clear the write lock count: */
895 _thread_fd_table[fd]->w_lockcount = 0;
896
897 /*
898 * Get the next thread in the queue for a
899 * write lock on this file descriptor:
900 */
901 if ((_thread_fd_table[fd]->w_owner = fd_next_writer(fd)) != NULL) {
902 /* Remove this thread from the queue: */
903 FDQ_REMOVE(&_thread_fd_table[fd]->w_queue,
904 _thread_fd_table[fd]->w_owner);
905
906 /*
907 * Set the state of the new owner of
908 * the thread to running:
909 */
910 PTHREAD_NEW_STATE(_thread_fd_table[fd]->w_owner,PS_RUNNING);
911
912 }
913 }
914
915 /* Unlock the file descriptor table entry: */
916 _SPINUNLOCK(&_thread_fd_table[fd]->lock);
917
918 /*
919 * Undefer and handle pending signals, yielding if
920 * necessary.
921 */
922 _thread_kern_sig_undefer();
923 }
924 }
925 }
926
927 void
928 _fd_lock_backout(pthread_t pthread)
929 {
930 int fd;
931
932 /*
933 * Defer signals to protect the scheduling queues
934 * from access by the signal handler:
935 */
936 _thread_kern_sig_defer();
937
938 switch (pthread->state) {
939
940 case PS_FDLR_WAIT:
941 fd = pthread->data.fd.fd;
942
943 /*
944 * Lock the file descriptor table entry to prevent
945 * other threads for clashing with the current
946 * thread's accesses:
947 */
948 _SPINLOCK(&_thread_fd_table[fd]->lock);
949
950 /* Remove the thread from the waiting queue: */
951 FDQ_REMOVE(&_thread_fd_table[fd]->r_queue, pthread);
952 break;
953
954 case PS_FDLW_WAIT:
955 fd = pthread->data.fd.fd;
956
957 /*
958 * Lock the file descriptor table entry to prevent
959 * other threads from clashing with the current
960 * thread's accesses:
961 */
962 _SPINLOCK(&_thread_fd_table[fd]->lock);
963
964 /* Remove the thread from the waiting queue: */
965 FDQ_REMOVE(&_thread_fd_table[fd]->w_queue, pthread);
966 break;
967
968 default:
969 break;
970 }
971
972 /*
973 * Undefer and handle pending signals, yielding if
974 * necessary.
975 */
976 _thread_kern_sig_undefer();
977 }
978
979 static inline pthread_t
980 fd_next_reader(int fd)
981 {
982 pthread_t pthread;
983
984 while (((pthread = TAILQ_FIRST(&_thread_fd_table[fd]->r_queue)) != NULL) &&
985 (pthread->interrupted != 0)) {
986 /*
987 * This thread has either been interrupted by a signal or
988 * it has been canceled. Remove it from the queue.
989 */
990 FDQ_REMOVE(&_thread_fd_table[fd]->r_queue, pthread);
991 }
992
993 return (pthread);
994 }
995
996 static inline pthread_t
997 fd_next_writer(int fd)
998 {
999 pthread_t pthread;
1000
1001 while (((pthread = TAILQ_FIRST(&_thread_fd_table[fd]->w_queue)) != NULL) &&
1002 (pthread->interrupted != 0)) {
1003 /*
1004 * This thread has either been interrupted by a signal or
1005 * it has been canceled. Remove it from the queue.
1006 */
1007 FDQ_REMOVE(&_thread_fd_table[fd]->w_queue, pthread);
1008 }
1009
1010 return (pthread);
1011 }
1012
1013 #else
1014
1015 void
1016 _thread_fd_unlock(int fd, int lock_type)
1017 {
1018 }
1019
1020 int
1021 _thread_fd_lock(int fd, int lock_type, struct timespec * timeout)
1022 {
1023 /*
1024 * Insure that the file descriptor table is initialized for this
1025 * entry:
1026 */
1027 return (_thread_fd_table_init(fd));
1028 }
1029
1030 void
1031 _thread_fd_unlock_debug(int fd, int lock_type, char *fname, int lineno)
1032 {
1033 }
1034
1035 int
1036 _thread_fd_lock_debug(int fd, int lock_type, struct timespec * timeout,
1037 char *fname, int lineno)
1038 {
1039 /*
1040 * Insure that the file descriptor table is initialized for this
1041 * entry:
1042 */
1043 return (_thread_fd_table_init(fd));
1044 }
1045
1046 void
1047 _thread_fd_unlock_owned(pthread_t pthread)
1048 {
1049 }
1050
1051 void
1052 _fd_lock_backout(pthread_t pthread)
1053 {
1054 }
1055
1056 #endif
DragonFly BSD