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