xref: /titanic_41/usr/src/lib/libc/port/stdio/flush.c (revision 6a634c9dca3093f3922e4b7ab826d7bdf17bf78e)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 /*	Copyright (c) 1988 AT&T	*/
27 /*	  All Rights Reserved  	*/
28 
29 #include "lint.h"
30 #include "mtlib.h"
31 #include "file64.h"
32 #include <sys/types.h>
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <thread.h>
36 #include <synch.h>
37 #include <unistd.h>
38 #include <string.h>
39 #include "stdiom.h"
40 #include <wchar.h>
41 #include <sys/stat.h>
42 #include <stddef.h>
43 #include <errno.h>
44 #include <fcntl.h>
45 
46 #define	_iob	__iob
47 
48 #undef end
49 
50 #define	FILE_ARY_SZ	8 /* a nice size for FILE array & end_buffer_ptrs */
51 
52 #ifdef	_LP64
53 
54 /*
55  * Macros to declare and loop over a fp or fp/xfp combo to
56  * avoid some of the _LP64 ifdef hell.
57  */
58 
59 #define	FPDECL(fp)		FILE *fp
60 #define	FIRSTFP(lp, fp)		fp = lp->iobp
61 #define	NEXTFP(fp)		fp++
62 #define	FPLOCK(fp)		&fp->_lock
63 #define	FPSTATE(fp)		&fp->_state
64 
65 #define	xFILE			FILE
66 
67 #else
68 
69 #define	FPDECL(fp)		FILE *fp; xFILE *x##fp
70 #define	FIRSTFP(lp, fp)		x##fp = lp->iobp; \
71 				fp = x##fp ? &x##fp->_iob : &_iob[0]
72 #define	NEXTFP(fp)		(x##fp ? fp = &(++x##fp)->_iob : ++fp)
73 #define	FPLOCK(fp)		x##fp ? \
74 				    &x##fp->xlock : &_xftab[IOPIND(fp)]._lock
75 #define	FPSTATE(fp)		x##fp ? \
76 				    &x##fp->xstate : &_xftab[IOPIND(fp)]._state
77 
78 /* The extended 32-bit file structure for use in link buffers */
79 typedef struct xFILE {
80 	FILE			_iob;		/* must be first! */
81 	struct xFILEdata	_xdat;
82 } xFILE;
83 
84 #define	xmagic			_xdat._magic
85 #define	xend			_xdat._end
86 #define	xlock			_xdat._lock
87 #define	xstate			_xdat._state
88 
89 #define	FILEx(fp)		((struct xFILE *)(uintptr_t)fp)
90 
91 /*
92  * The magic number stored is actually the pointer scrambled with
93  * a magic number.  Pointers to data items live everywhere in memory
94  * so we scramble the pointer in order to avoid accidental collisions.
95  */
96 #define	XFILEMAGIC		0x63687367
97 #define	XMAGIC(xfp)		((uintptr_t)(xfp) ^ XFILEMAGIC)
98 
99 #endif /* _LP64 */
100 
101 struct _link_	/* manages a list of streams */
102 {
103 	xFILE *iobp;		/* the array of (x)FILE's */
104 				/* NULL for the __first_link in ILP32 */
105 	int	niob;		/* length of the arrays */
106 	struct _link_	*next;	/* next in the list */
107 };
108 
109 /*
110  * With dynamic linking, iob may be in either the library or in the user's
111  * a.out, so the run time linker fixes up the first entry in __first_link at
112  * process startup time.
113  *
114  * In 32 bit processes, we don't have xFILE[FILE_ARY_SZ] but FILE[],
115  * and _xftab[] instead; this is denoted by having iobp set to NULL in
116  * 32 bit mode for the first link entry.
117  */
118 struct _link_ __first_link =	/* first in linked list */
119 {
120 #if !defined(_LP64)
121 	NULL,
122 #else
123 	&_iob[0],
124 #endif
125 	_NFILE,
126 	NULL
127 };
128 
129 /*
130  * Information cached to speed up searches.  We remember where we
131  * last found a free FILE* and we remember whether we saw any fcloses
132  * in between.  We also count the number of chunks we allocated, see
133  * _findiop() for an explanation.
134  * These variables are all protected by _first_link_lock.
135  */
136 static struct _link_ *lastlink = NULL;
137 static int fcloses;
138 static int nchunks;
139 
140 static mutex_t _first_link_lock = DEFAULTMUTEX;
141 
142 static int _fflush_l_iops(void);
143 static FILE *getiop(FILE *, rmutex_t *, mbstate_t *);
144 
145 /*
146  * All functions that understand the linked list of iob's follow.
147  */
148 #pragma weak _cleanup = __cleanup
149 void
__cleanup(void)150 __cleanup(void)		/* called at process end to flush ouput streams */
151 {
152 	(void) fflush(NULL);
153 }
154 
155 /*
156  * For fork1-safety (see libc_prepare_atfork(), etc).
157  */
158 void
stdio_locks()159 stdio_locks()
160 {
161 	(void) mutex_lock(&_first_link_lock);
162 	/*
163 	 * XXX: We should acquire all of the iob locks here.
164 	 */
165 }
166 
167 void
stdio_unlocks()168 stdio_unlocks()
169 {
170 	/*
171 	 * XXX: We should release all of the iob locks here.
172 	 */
173 	(void) mutex_unlock(&_first_link_lock);
174 }
175 
176 void
_flushlbf(void)177 _flushlbf(void)		/* fflush() all line-buffered streams */
178 {
179 	FPDECL(fp);
180 	int i;
181 	struct _link_ *lp;
182 	/* Allow compiler to optimize the loop */
183 	int threaded = __libc_threaded;
184 
185 	if (threaded)
186 		cancel_safe_mutex_lock(&_first_link_lock);
187 
188 	lp = &__first_link;
189 	do {
190 		FIRSTFP(lp, fp);
191 		for (i = lp->niob; --i >= 0; NEXTFP(fp)) {
192 			/*
193 			 * The additional _IONBF check guards againsts
194 			 * allocated but uninitialized iops (see _findiop).
195 			 * We also automatically skip non allocated iop's.
196 			 * Don't block on locks.
197 			 */
198 			if ((fp->_flag & (_IOLBF | _IOWRT | _IONBF)) ==
199 			    (_IOLBF | _IOWRT)) {
200 				if (threaded) {
201 					rmutex_t *lk = FPLOCK(fp);
202 					if (cancel_safe_mutex_trylock(lk) != 0)
203 						continue;
204 					/* Recheck after locking */
205 					if ((fp->_flag & (_IOLBF | _IOWRT)) ==
206 					    (_IOLBF | _IOWRT)) {
207 						(void) _fflush_u(fp);
208 					}
209 					cancel_safe_mutex_unlock(lk);
210 				} else {
211 					(void) _fflush_u(fp);
212 				}
213 			}
214 		}
215 	} while ((lp = lp->next) != NULL);
216 
217 	if (threaded)
218 		cancel_safe_mutex_unlock(&_first_link_lock);
219 }
220 
221 /* allocate an unused stream; NULL if cannot */
222 FILE *
_findiop(void)223 _findiop(void)
224 {
225 	struct _link_ *lp, **prev;
226 
227 	/* used so there only needs to be one malloc() */
228 #ifdef _LP64
229 	typedef	struct	{
230 		struct _link_	hdr;
231 		FILE	iob[FILE_ARY_SZ];
232 	} Pkg;
233 #else
234 	typedef union {
235 		struct {				/* Normal */
236 			struct _link_	hdr;
237 			xFILE	iob[FILE_ARY_SZ];
238 		} Pkgn;
239 		struct {				/* Reversed */
240 			xFILE	iob[FILE_ARY_SZ];
241 			struct _link_	hdr;
242 		} Pkgr;
243 	} Pkg;
244 	uintptr_t delta;
245 #endif
246 	Pkg *pkgp;
247 	struct _link_ *hdr;
248 	FPDECL(fp);
249 	int i;
250 	int threaded = __libc_threaded;
251 
252 	if (threaded)
253 		cancel_safe_mutex_lock(&_first_link_lock);
254 
255 	if (lastlink == NULL) {
256 rescan:
257 		fcloses = 0;
258 		lastlink = &__first_link;
259 	}
260 
261 	lp = lastlink;
262 
263 	/*
264 	 * lock to make testing of fp->_flag == 0 and acquiring the fp atomic
265 	 * and for allocation of new links
266 	 * low contention expected on _findiop(), hence coarse locking.
267 	 * for finer granularity, use fp->_lock for allocating an iop
268 	 * and make the testing of lp->next and allocation of new link atomic
269 	 * using lp->_lock
270 	 */
271 
272 	do {
273 		prev = &lp->next;
274 		FIRSTFP(lp, fp);
275 
276 		for (i = lp->niob; --i >= 0; NEXTFP(fp)) {
277 			FILE *ret;
278 			if (threaded) {
279 				ret = getiop(fp, FPLOCK(fp), FPSTATE(fp));
280 				if (ret != NULL) {
281 					cancel_safe_mutex_unlock(
282 					    &_first_link_lock);
283 					return (ret);
284 				}
285 			} else {
286 				ret = getiop(fp, NULL, FPSTATE(fp));
287 				if (ret != NULL)
288 					return (ret);
289 			}
290 		}
291 	} while ((lastlink = lp = lp->next) != NULL);
292 
293 	/*
294 	 * If there was a sufficient number of  fcloses since we last started
295 	 * at __first_link, we rescan all fp's again.  We do not rescan for
296 	 * all fcloses; that would simplify the algorithm but would make
297 	 * search times near O(n) again.
298 	 * Worst case behaviour would still be pretty bad (open a full set,
299 	 * then continously opening and closing one FILE * gets you a full
300 	 * scan each time).  That's why we over allocate 1 FILE for each
301 	 * 32 chunks.  More over allocation is better; this is a nice
302 	 * empirical value which doesn't cost a lot of memory, doesn't
303 	 * overallocate until we reach 256 FILE *s and keeps the performance
304 	 * pretty close to the optimum.
305 	 */
306 	if (fcloses > nchunks/32)
307 		goto rescan;
308 
309 	/*
310 	 * Need to allocate another and put it in the linked list.
311 	 */
312 	if ((pkgp = malloc(sizeof (Pkg))) == NULL) {
313 		if (threaded)
314 			cancel_safe_mutex_unlock(&_first_link_lock);
315 		return (NULL);
316 	}
317 
318 	(void) memset(pkgp, 0, sizeof (Pkg));
319 
320 #ifdef _LP64
321 	hdr = &pkgp->hdr;
322 	hdr->iobp = &pkgp->iob[0];
323 #else
324 	/*
325 	 * The problem with referencing a word after a FILE* is the possibility
326 	 * of a SIGSEGV if a non-stdio issue FILE structure ends on a page
327 	 * boundary.  We run this check so we never need to run an expensive
328 	 * check like mincore() in order to know whether it is
329 	 * safe to dereference ((xFILE*)fp)->xmagic.
330 	 * We allocate the block with two alternative layouts; if one
331 	 * layout is not properly aligned for our purposes, the other layout
332 	 * will be because the size of _link_ is small compared to
333 	 * sizeof (xFILE).
334 	 * The check performed is this:
335 	 *	If the distance from pkgp to the end of the page is
336 	 *	less than the the offset of the last xmagic field in the
337 	 *	xFILE structure, (the 0x1000 boundary is inside our just
338 	 *	allocated structure) and the distance modulo the size of xFILE
339 	 *	is identical to the offset of the first xmagic in the
340 	 *	structure (i.e., XXXXXX000 points to an xmagic field),
341 	 *	we need to use the reverse structure.
342 	 */
343 	if ((delta = 0x1000 - ((uintptr_t)pkgp & 0xfff)) <=
344 	    offsetof(Pkg, Pkgn.iob[FILE_ARY_SZ-1].xmagic) &&
345 	    delta % sizeof (struct xFILE) ==
346 	    offsetof(Pkg, Pkgn.iob[0].xmagic)) {
347 		/* Use reversed structure */
348 		hdr = &pkgp->Pkgr.hdr;
349 		hdr->iobp = &pkgp->Pkgr.iob[0];
350 	} else {
351 		/* Use normal structure */
352 		hdr = &pkgp->Pkgn.hdr;
353 		hdr->iobp = &pkgp->Pkgn.iob[0];
354 	}
355 #endif /* _LP64 */
356 
357 	hdr->niob = FILE_ARY_SZ;
358 	nchunks++;
359 
360 #ifdef	_LP64
361 	fp = hdr->iobp;
362 	for (i = 0; i < FILE_ARY_SZ; i++)
363 		(void) mutex_init(&fp[i]._lock,
364 		    USYNC_THREAD | LOCK_RECURSIVE, NULL);
365 #else
366 	xfp = hdr->iobp;
367 	fp = &xfp->_iob;
368 
369 	for (i = 0; i < FILE_ARY_SZ; i++) {
370 		xfp[i].xmagic = XMAGIC(&xfp[i]);
371 		(void) mutex_init(&xfp[i].xlock,
372 		    USYNC_THREAD | LOCK_RECURSIVE, NULL);
373 	}
374 #endif	/*	_LP64	*/
375 
376 	lastlink = *prev = hdr;
377 	fp->_ptr = 0;
378 	fp->_base = 0;
379 	fp->_flag = 0377; /* claim the fp by setting low 8 bits */
380 	if (threaded)
381 		cancel_safe_mutex_unlock(&_first_link_lock);
382 
383 	return (fp);
384 }
385 
386 static void
isseekable(FILE * iop)387 isseekable(FILE *iop)
388 {
389 	struct stat64 fstatbuf;
390 	int save_errno;
391 
392 	save_errno = errno;
393 
394 	if (fstat64(GET_FD(iop), &fstatbuf) != 0) {
395 		/*
396 		 * when we don't know what it is we'll
397 		 * do the old behaviour and flush
398 		 * the stream
399 		 */
400 		SET_SEEKABLE(iop);
401 		errno = save_errno;
402 		return;
403 	}
404 
405 	/*
406 	 * check for what is non-SEEKABLE
407 	 * otherwise assume it's SEEKABLE so we get the old
408 	 * behaviour and flush the stream
409 	 */
410 
411 	if (S_ISFIFO(fstatbuf.st_mode) || S_ISCHR(fstatbuf.st_mode) ||
412 	    S_ISSOCK(fstatbuf.st_mode) || S_ISDOOR(fstatbuf.st_mode)) {
413 		CLEAR_SEEKABLE(iop);
414 	} else {
415 		SET_SEEKABLE(iop);
416 	}
417 
418 	errno = save_errno;
419 }
420 
421 #ifdef	_LP64
422 void
_setbufend(FILE * iop,Uchar * end)423 _setbufend(FILE *iop, Uchar *end)	/* set the end pointer for this iop */
424 {
425 	iop->_end = end;
426 
427 	isseekable(iop);
428 }
429 
430 #undef _realbufend
431 
432 Uchar *
_realbufend(FILE * iop)433 _realbufend(FILE *iop)		/* get the end pointer for this iop */
434 {
435 	return (iop->_end);
436 }
437 
438 #else /* _LP64 */
439 
440 /*
441  * Awkward functions not needed for the sane 64 bit environment.
442  */
443 /*
444  * xmagic must not be aligned on a 4K boundary. We guarantee this in
445  * _findiop().
446  */
447 #define	VALIDXFILE(xfp) \
448 	(((uintptr_t)&(xfp)->xmagic & 0xfff) && \
449 	    (xfp)->xmagic == XMAGIC(FILEx(xfp)))
450 
451 static struct xFILEdata *
getxfdat(FILE * iop)452 getxfdat(FILE *iop)
453 {
454 	if (STDIOP(iop))
455 		return (&_xftab[IOPIND(iop)]);
456 	else if (VALIDXFILE(FILEx(iop)))
457 		return (&FILEx(iop)->_xdat);
458 	else
459 		return (NULL);
460 }
461 
462 void
_setbufend(FILE * iop,Uchar * end)463 _setbufend(FILE *iop, Uchar *end)	/* set the end pointer for this iop */
464 {
465 	struct xFILEdata *dat = getxfdat(iop);
466 
467 	if (dat != NULL)
468 		dat->_end = end;
469 
470 	isseekable(iop);
471 
472 	/*
473 	 * For binary compatibility with user programs using the
474 	 * old _bufend macro.  This is *so* broken, fileno()
475 	 * is not the proper index.
476 	 */
477 	if (iop->_magic < _NFILE)
478 		_bufendtab[iop->_magic] = end;
479 
480 }
481 
482 Uchar *
_realbufend(FILE * iop)483 _realbufend(FILE *iop)		/* get the end pointer for this iop */
484 {
485 	struct xFILEdata *dat = getxfdat(iop);
486 
487 	if (dat != NULL)
488 		return (dat->_end);
489 
490 	return (NULL);
491 }
492 
493 /*
494  * _reallock() is invoked in each stdio call through the IOB_LCK() macro,
495  * it is therefor extremely performance sensitive.  We get better performance
496  * by inlining the STDIOP check in IOB_LCK and inlining a custom version
497  * of getfxdat() here.
498  */
499 rmutex_t *
_reallock(FILE * iop)500 _reallock(FILE *iop)
501 {
502 	if (VALIDXFILE(FILEx(iop)))
503 		return (&FILEx(iop)->xlock);
504 
505 	return (NULL);
506 }
507 
508 #endif	/*	_LP64	*/
509 
510 /* make sure _cnt, _ptr are correct */
511 void
_bufsync(FILE * iop,Uchar * bufend)512 _bufsync(FILE *iop, Uchar *bufend)
513 {
514 	ssize_t spaceleft;
515 
516 	spaceleft = bufend - iop->_ptr;
517 	if (bufend < iop->_ptr) {
518 		iop->_ptr = bufend;
519 		iop->_cnt = 0;
520 	} else if (spaceleft < iop->_cnt)
521 		iop->_cnt = spaceleft;
522 }
523 
524 /* really write out current buffer contents */
525 int
_xflsbuf(FILE * iop)526 _xflsbuf(FILE *iop)
527 {
528 	ssize_t n;
529 	Uchar *base = iop->_base;
530 	Uchar *bufend;
531 	ssize_t num_wrote;
532 
533 	/*
534 	 * Hopefully, be stable with respect to interrupts...
535 	 */
536 	n = iop->_ptr - base;
537 	iop->_ptr = base;
538 	bufend = _bufend(iop);
539 	if (iop->_flag & (_IOLBF | _IONBF))
540 		iop->_cnt = 0;		/* always go to a flush */
541 	else
542 		iop->_cnt = bufend - base;
543 
544 	if (_needsync(iop, bufend))	/* recover from interrupts */
545 		_bufsync(iop, bufend);
546 
547 	if (n > 0) {
548 		int fd = GET_FD(iop);
549 		while ((num_wrote = write(fd, base, (size_t)n)) != n) {
550 			if (num_wrote <= 0) {
551 				if (!cancel_active())
552 					iop->_flag |= _IOERR;
553 				return (EOF);
554 			}
555 			n -= num_wrote;
556 			base += num_wrote;
557 		}
558 	}
559 	return (0);
560 }
561 
562 /* flush (write) buffer */
563 int
fflush(FILE * iop)564 fflush(FILE *iop)
565 {
566 	int res;
567 	rmutex_t *lk;
568 
569 	if (iop) {
570 		FLOCKFILE(lk, iop);
571 		res = _fflush_u(iop);
572 		FUNLOCKFILE(lk);
573 	} else {
574 		res = _fflush_l_iops();		/* flush all iops */
575 	}
576 	return (res);
577 }
578 
579 static int
_fflush_l_iops(void)580 _fflush_l_iops(void)		/* flush all buffers */
581 {
582 	FPDECL(iop);
583 
584 	int i;
585 	struct _link_ *lp;
586 	int res = 0;
587 	rmutex_t *lk;
588 	/* Allow the compiler to optimize the load out of the loop */
589 	int threaded = __libc_threaded;
590 
591 	if (threaded)
592 		cancel_safe_mutex_lock(&_first_link_lock);
593 
594 	lp = &__first_link;
595 
596 	do {
597 		/*
598 		 * We need to grab the file locks or file corruption
599 		 * will happen.  But we first check the flags field
600 		 * knowing that when it is 0, it isn't allocated and
601 		 * cannot be allocated while we're holding the
602 		 * _first_link_lock.  And when _IONBF is set (also the
603 		 * case when _flag is 0377, or alloc in progress), we
604 		 * also ignore it.
605 		 *
606 		 * Ignore locked streams; it will appear as if
607 		 * concurrent updates happened after fflush(NULL).  Note
608 		 * that we even attempt to lock if the locking is set to
609 		 * "by caller".  We don't want to penalize callers of
610 		 * __fsetlocking() by not flushing their files.  Note: if
611 		 * __fsetlocking() callers don't employ any locking, they
612 		 * may still face corruption in fflush(NULL); but that's
613 		 * no change from earlier releases.
614 		 */
615 		FIRSTFP(lp, iop);
616 		for (i = lp->niob; --i >= 0; NEXTFP(iop)) {
617 			unsigned int flag = iop->_flag;
618 
619 			/* flag 0, flag 0377, or _IONBF set */
620 			if (flag == 0 || (flag & _IONBF) != 0)
621 				continue;
622 
623 			if (threaded) {
624 				lk = FPLOCK(iop);
625 				if (cancel_safe_mutex_trylock(lk) != 0)
626 					continue;
627 			}
628 
629 			if (!(iop->_flag & _IONBF)) {
630 				/*
631 				 * don't need to worry about the _IORW case
632 				 * since the iop will also marked with _IOREAD
633 				 * or _IOWRT whichever we are really doing
634 				 */
635 				if (iop->_flag & _IOWRT) {
636 					/* Flush write buffers */
637 					res |= _fflush_u(iop);
638 				} else if (iop->_flag & _IOREAD) {
639 					/*
640 					 * flush seekable read buffers
641 					 * don't flush non-seekable read buffers
642 					 */
643 					if (GET_SEEKABLE(iop)) {
644 						res |= _fflush_u(iop);
645 					}
646 				}
647 			}
648 			if (threaded)
649 				cancel_safe_mutex_unlock(lk);
650 		}
651 	} while ((lp = lp->next) != NULL);
652 	if (threaded)
653 		cancel_safe_mutex_unlock(&_first_link_lock);
654 	return (res);
655 }
656 
657 /* flush buffer */
658 int
_fflush_u(FILE * iop)659 _fflush_u(FILE *iop)
660 {
661 	int res = 0;
662 
663 	/* this portion is always assumed locked */
664 	if (!(iop->_flag & _IOWRT)) {
665 		(void) lseek64(GET_FD(iop), -iop->_cnt, SEEK_CUR);
666 		iop->_cnt = 0;
667 		/* needed for ungetc & multibyte pushbacks */
668 		iop->_ptr = iop->_base;
669 		if (iop->_flag & _IORW) {
670 			iop->_flag &= ~_IOREAD;
671 		}
672 		return (0);
673 	}
674 	if (iop->_base != NULL && iop->_ptr > iop->_base) {
675 		res = _xflsbuf(iop);
676 	}
677 	if (iop->_flag & _IORW) {
678 		iop->_flag &= ~_IOWRT;
679 		iop->_cnt = 0;
680 	}
681 	return (res);
682 }
683 
684 /* flush buffer and close stream */
685 int
fclose(FILE * iop)686 fclose(FILE *iop)
687 {
688 	int res = 0;
689 	rmutex_t *lk;
690 
691 	if (iop == NULL) {
692 		return (EOF);		/* avoid passing zero to FLOCKFILE */
693 	}
694 
695 	FLOCKFILE(lk, iop);
696 	if (iop->_flag == 0) {
697 		FUNLOCKFILE(lk);
698 		return (EOF);
699 	}
700 	/* Is not unbuffered and opened for read and/or write ? */
701 	if (!(iop->_flag & _IONBF) && (iop->_flag & (_IOWRT | _IOREAD | _IORW)))
702 		res = _fflush_u(iop);
703 	if (close(GET_FD(iop)) < 0)
704 		res = EOF;
705 	if (iop->_flag & _IOMYBUF) {
706 		(void) free((char *)iop->_base - PUSHBACK);
707 	}
708 	iop->_base = NULL;
709 	iop->_ptr = NULL;
710 	iop->_cnt = 0;
711 	iop->_flag = 0;			/* marks it as available */
712 	FUNLOCKFILE(lk);
713 
714 	if (__libc_threaded)
715 		cancel_safe_mutex_lock(&_first_link_lock);
716 	fcloses++;
717 	if (__libc_threaded)
718 		cancel_safe_mutex_unlock(&_first_link_lock);
719 
720 	return (res);
721 }
722 
723 /* close all open streams */
724 int
fcloseall(void)725 fcloseall(void)
726 {
727 	FPDECL(iop);
728 
729 	struct _link_ *lp;
730 	rmutex_t *lk;
731 
732 	if (__libc_threaded)
733 		cancel_safe_mutex_lock(&_first_link_lock);
734 
735 	lp = &__first_link;
736 
737 	do {
738 		int i;
739 
740 		FIRSTFP(lp, iop);
741 		for (i = lp->niob; --i >= 0; NEXTFP(iop)) {
742 			/* code stolen from fclose(), above */
743 
744 			FLOCKFILE(lk, iop);
745 			if (iop->_flag == 0) {
746 				FUNLOCKFILE(lk);
747 				continue;
748 			}
749 
750 			/* Not unbuffered and opened for read and/or write? */
751 			if (!(iop->_flag & _IONBF) &&
752 			    (iop->_flag & (_IOWRT | _IOREAD | _IORW)))
753 				(void) _fflush_u(iop);
754 			(void) close(GET_FD(iop));
755 			if (iop->_flag & _IOMYBUF)
756 				free((char *)iop->_base - PUSHBACK);
757 			iop->_base = NULL;
758 			iop->_ptr = NULL;
759 			iop->_cnt = 0;
760 			iop->_flag = 0;		/* marks it as available */
761 			FUNLOCKFILE(lk);
762 			fcloses++;
763 		}
764 	} while ((lp = lp->next) != NULL);
765 
766 	if (__libc_threaded)
767 		cancel_safe_mutex_unlock(&_first_link_lock);
768 
769 	return (0);
770 }
771 
772 /* flush buffer, close fd but keep the stream used by freopen() */
773 int
close_fd(FILE * iop)774 close_fd(FILE *iop)
775 {
776 	int res = 0;
777 	mbstate_t *mb;
778 
779 	if (iop == NULL || iop->_flag == 0)
780 		return (EOF);
781 	/* Is not unbuffered and opened for read and/or write ? */
782 	if (!(iop->_flag & _IONBF) && (iop->_flag & (_IOWRT | _IOREAD | _IORW)))
783 		res = _fflush_u(iop);
784 	if (close(GET_FD(iop)) < 0)
785 		res = EOF;
786 	if (iop->_flag & _IOMYBUF) {
787 		(void) free((char *)iop->_base - PUSHBACK);
788 	}
789 	iop->_base = NULL;
790 	iop->_ptr = NULL;
791 	mb = _getmbstate(iop);
792 	if (mb != NULL)
793 		(void) memset(mb, 0, sizeof (mbstate_t));
794 	iop->_cnt = 0;
795 	_setorientation(iop, _NO_MODE);
796 	return (res);
797 }
798 
799 static FILE *
getiop(FILE * fp,rmutex_t * lk,mbstate_t * mb)800 getiop(FILE *fp, rmutex_t *lk, mbstate_t *mb)
801 {
802 	if (lk != NULL && cancel_safe_mutex_trylock(lk) != 0)
803 		return (NULL);	/* locked: fp in use */
804 
805 	if (fp->_flag == 0) {	/* unused */
806 #ifndef	_LP64
807 		fp->__orientation = 0;
808 #endif /* _LP64 */
809 		fp->_cnt = 0;
810 		fp->_ptr = NULL;
811 		fp->_base = NULL;
812 		fp->_flag = 0377;	/* claim the fp by setting low 8 bits */
813 		(void) memset(mb, 0, sizeof (mbstate_t));
814 		FUNLOCKFILE(lk);
815 		return (fp);
816 	}
817 	FUNLOCKFILE(lk);
818 	return (NULL);
819 }
820 
821 #ifndef	_LP64
822 /*
823  * DESCRIPTION:
824  * This function gets the pointer to the mbstate_t structure associated
825  * with the specified iop.
826  *
827  * RETURNS:
828  * If the associated mbstate_t found, the pointer to the mbstate_t is
829  * returned.  Otherwise, NULL is returned.
830  */
831 mbstate_t *
_getmbstate(FILE * iop)832 _getmbstate(FILE *iop)
833 {
834 	struct xFILEdata *dat = getxfdat(iop);
835 
836 	if (dat != NULL)
837 		return (&dat->_state);
838 
839 	return (NULL);
840 }
841 
842 /*
843  * More 32-bit only functions.
844  * They lookup/set large fd's for extended FILE support.
845  */
846 
847 /*
848  * The negative value indicates that Extended fd FILE's has not
849  * been enabled by the user.
850  */
851 static int bad_fd = -1;
852 
853 int
_file_get(FILE * iop)854 _file_get(FILE *iop)
855 {
856 	int altfd;
857 
858 	/*
859 	 * Failure indicates a FILE * not allocated through stdio;
860 	 * it means the flag values are probably bogus and that if
861 	 * a file descriptor is set, it's in _magic.
862 	 * Inline getxfdat() for performance reasons.
863 	 */
864 	if (STDIOP(iop))
865 		altfd = _xftab[IOPIND(iop)]._altfd;
866 	else if (VALIDXFILE(FILEx(iop)))
867 		altfd = FILEx(iop)->_xdat._altfd;
868 	else
869 		return (iop->_magic);
870 	/*
871 	 * if this is not an internal extended FILE then check
872 	 * if _file is being changed from underneath us.
873 	 * It should not be because if
874 	 * it is then then we lose our ability to guard against
875 	 * silent data corruption.
876 	 */
877 	if (!iop->__xf_nocheck && bad_fd > -1 && iop->_magic != bad_fd) {
878 		(void) fprintf(stderr,
879 		    "Application violated extended FILE safety mechanism.\n"
880 		    "Please read the man page for extendedFILE.\nAborting\n");
881 		abort();
882 	}
883 	return (altfd);
884 }
885 
886 int
_file_set(FILE * iop,int fd,const char * type)887 _file_set(FILE *iop, int fd, const char *type)
888 {
889 	struct xFILEdata *dat;
890 	int Fflag;
891 
892 	/* Already known to contain at least one byte */
893 	while (*++type != '\0')
894 		;
895 
896 	Fflag = type[-1] == 'F';
897 	if (!Fflag && bad_fd < 0) {
898 		errno = EMFILE;
899 		return (-1);
900 	}
901 
902 	dat = getxfdat(iop);
903 	iop->__extendedfd = 1;
904 	iop->__xf_nocheck = Fflag;
905 	dat->_altfd = fd;
906 	iop->_magic = (unsigned char)bad_fd;
907 	return (0);
908 }
909 
910 /*
911  * Activates extended fd's in FILE's
912  */
913 
914 static const int tries[] = {196, 120, 60, 3};
915 #define	NTRIES	(sizeof (tries)/sizeof (int))
916 
917 int
enable_extended_FILE_stdio(int fd,int action)918 enable_extended_FILE_stdio(int fd, int action)
919 {
920 	int i;
921 
922 	if (action < 0)
923 		action = SIGABRT;	/* default signal */
924 
925 	if (fd < 0) {
926 		/*
927 		 * search for an available fd and make it the badfd
928 		 */
929 		for (i = 0; i < NTRIES; i++) {
930 			fd = fcntl(tries[i], F_BADFD, action);
931 			if (fd >= 0)
932 				break;
933 		}
934 		if (fd < 0)	/* failed to find an available fd */
935 			return (-1);
936 	} else {
937 		/* caller requests that fd be the chosen badfd */
938 		int nfd = fcntl(fd, F_BADFD, action);
939 		if (nfd < 0 || nfd != fd)
940 			return (-1);
941 	}
942 	bad_fd = fd;
943 	return (0);
944 }
945 #endif
946