X-Git-Url: https://git.saurik.com/apple/libc.git/blobdiff_plain/6465356a983ac139f81d3b7913cdb548477c346c..refs/heads/master:/stdio/FreeBSD/findfp.c?ds=inline

diff --git a/stdio/FreeBSD/findfp.c b/stdio/FreeBSD/findfp.c
index a384327..233ca39 100644
--- a/stdio/FreeBSD/findfp.c
+++ b/stdio/FreeBSD/findfp.c
@@ -30,6 +30,9 @@
  * SUCH DAMAGE.
  */
 
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcomma"
+
 #if defined(LIBC_SCCS) && !defined(lint)
 static char sccsid[] = "@(#)findfp.c	8.2 (Berkeley) 1/4/94";
 #endif /* LIBC_SCCS and not lint */
@@ -54,9 +57,9 @@ __FBSDID("$FreeBSD: src/lib/libc/stdio/findfp.c,v 1.34 2009/12/05 19:31:38 ed Ex
 #include "local.h"
 #include "glue.h"
 
-int	__sdidinit;
+pthread_once_t	__sdidinit;
 
-#if !TARGET_OS_EMBEDDED
+#if !TARGET_OS_IPHONE
 #define	NDYNAMIC 10		/* add ten more whenever necessary */
 #else
 #define	NDYNAMIC 1		/* add one at a time on embedded */
@@ -72,21 +75,20 @@ int	__sdidinit;
 	._write = __swrite,		\
 	._extra = __sFX + file,         \
 }
-#define __sFXInit       {.fl_mutex = PTHREAD_MUTEX_INITIALIZER}
   /* set counted */
-#define __sFXInit3      {.fl_mutex = PTHREAD_MUTEX_INITIALIZER, .counted = 1}
+#define __sFXInit3      {.fl_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER, .counted = 1}
 
-static int __scounted;		/* streams counted against STREAM_MAX */
-static int __stream_max;
+static int64_t __scounted;		/* streams counted against STREAM_MAX */
+static int64_t __stream_max;
 
-#if !TARGET_OS_EMBEDDED
+#if !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
 /* usual and usual_extra are data pigs. See 7929728. For embedded we should
  * always allocate dynamically, and probably should for desktop too. */
 				/* the usual - (stdin + stdout + stderr) */
 static FILE usual[FOPEN_MAX - 3];
 static struct __sFILEX usual_extra[FOPEN_MAX - 3];
 static struct glue uglue = { NULL, FOPEN_MAX - 3, usual };
-#endif /* !TARGET_OS_EMBEDDED */
+#endif /* !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR) */
 
 static struct __sFILEX __sFX[3] = {__sFXInit3, __sFXInit3, __sFXInit3};
 
@@ -105,7 +107,7 @@ FILE *__stdinp = &__sF[0];
 FILE *__stdoutp = &__sF[1];
 FILE *__stderrp = &__sF[2];
 
-#if !TARGET_OS_EMBEDDED
+#if !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
 struct glue __sglue = { &uglue, 3, __sF };
 static struct glue *lastglue = &uglue;
 #else
@@ -115,40 +117,33 @@ static struct glue *lastglue = &__sglue;
 
 static struct glue *	moreglue(int);
 
-static spinlock_t thread_lock = _SPINLOCK_INITIALIZER;
-#define THREAD_LOCK()	if (__isthreaded) _SPINLOCK(&thread_lock)
-#define THREAD_UNLOCK()	if (__isthreaded) _SPINUNLOCK(&thread_lock)
-
-#if NOT_YET
-#define	SET_GLUE_PTR(ptr, val)	atomic_set_rel_ptr(&(ptr), (uintptr_t)(val))
-#else
-#define	SET_GLUE_PTR(ptr, val)	ptr = val
-#endif
+static pthread_mutex_t filelist_lock = PTHREAD_MUTEX_INITIALIZER;
+#define FILELIST_LOCK()	do { pthread_mutex_lock(&filelist_lock); } while(0)
+#define FILELIST_UNLOCK()	do { pthread_mutex_unlock(&filelist_lock); } while(0)
 
 static struct glue *
-moreglue(n)
-	int n;
+moreglue(int n)
 {
 	struct glue *g;
-	static const FILE empty;
 	FILE *p;
-	static const struct __sFILEX emptyx = __sFXInit;
 	struct __sFILEX *fx;
+	size_t align;
 
-	g = (struct glue *)malloc(sizeof(*g) + ALIGNBYTES + n * sizeof(FILE) +
+	align = __alignof__( (struct { FILE f; struct __sFILEX s; }){} );
+	g = (struct glue *)malloc(sizeof(*g) + align + n * sizeof(FILE) +
 	    n * sizeof(struct __sFILEX));
 	if (g == NULL)
 		return (NULL);
-	p = (FILE *)ALIGN(g + 1);
+	p = (FILE *)roundup((uintptr_t)(g + 1), align);
 	fx = (struct __sFILEX *)&p[n];
 	g->next = NULL;
 	g->niobs = n;
 	g->iobs = p;
         
 	while (--n >= 0) {
-		*p = empty;
+		bzero(p, sizeof(*p));
 		p->_extra = fx;
-		*p->_extra = emptyx;
+		INITEXTRA(p);
 		p++, fx++;
 	}
 	return (g);
@@ -164,36 +159,45 @@ __sfp(int count)
 	int	n;
 	struct glue *g;
 
-	if (!__sdidinit)
-		__sinit();
+	pthread_once(&__sdidinit, __sinit);
 
 	if (count) {
-		if (__scounted >= __stream_max) {
-			THREAD_UNLOCK();
-			errno = EMFILE;
+		int64_t new = OSAtomicIncrement64(&__scounted);
+		if (new > __stream_max) {
+			/* Greater than the saved limit, check again with getrlimit. */
+			if (new > (__stream_max = sysconf(_SC_STREAM_MAX))){
+				OSAtomicDecrement64(&__scounted);
+				errno = EMFILE;
+				return NULL;
+			}
+		}
+		/* Overflowing #streams beyond RLIMIT_INFINITY */
+		if (new < 0) {
+			errno = EOVERFLOW;
 			return NULL;
 		}
-		OSAtomicIncrement32(&__scounted);
 	}
 	/*
 	 * The list must be locked because a FILE may be updated.
 	 */
-	THREAD_LOCK();
+	FILELIST_LOCK();
 	for (g = &__sglue; g != NULL; g = g->next) {
 		for (fp = g->iobs, n = g->niobs; --n >= 0; fp++)
 			if (fp->_flags == 0)
 				goto found;
 	}
-	THREAD_UNLOCK();	/* don't hold lock while malloc()ing. */
+	FILELIST_UNLOCK();	/* don't hold lock while malloc()ing. */
 	if ((g = moreglue(NDYNAMIC)) == NULL)
 		return (NULL);
-	THREAD_LOCK();		/* reacquire the lock */
-	SET_GLUE_PTR(lastglue->next, g); /* atomically append glue to list */
+	FILELIST_LOCK();		/* reacquire the lock */
+	lastglue->next = g; /* atomically append glue to list */
 	lastglue = g;		/* not atomic; only accessed when locked */
 	fp = g->iobs;
 found:
 	fp->_flags = 1;		/* reserve this slot; caller sets real flags */
-	THREAD_UNLOCK();
+	FILELIST_UNLOCK();
+	
+	/* _flags = 1 means the FILE* is in use, and this thread owns the object while it is being initialized */
 	fp->_p = NULL;		/* no current pointer */
 	fp->_w = 0;		/* nothing to read or write */
 	fp->_r = 0;
@@ -219,10 +223,16 @@ __private_extern__ void
 __sfprelease(FILE *fp)
 {
 	if (fp->_counted) {
-		OSAtomicDecrement32(&__scounted);
+		OSAtomicDecrement64(&__scounted);
 		fp->_counted = 0;
 	}
+	
+	pthread_mutex_destroy(&fp->_extra->fl_mutex);
+	
+	/* Make sure nobody else is enumerating the list while we clear the "in use" _flags field. */
+	FILELIST_LOCK();
 	fp->_flags = 0;
+	FILELIST_UNLOCK();
 }
 
 /*
@@ -247,10 +257,10 @@ f_prealloc(void)
 	for (g = &__sglue; (n -= g->niobs) > 0 && g->next; g = g->next)
 		/* void */;
 	if ((n > 0) && ((g = moreglue(n)) != NULL)) {
-		THREAD_LOCK();
-		SET_GLUE_PTR(lastglue->next, g);
+		FILELIST_LOCK();
+		lastglue->next = g;
 		lastglue = g;
-		THREAD_UNLOCK();
+		FILELIST_UNLOCK();
 	}
 }
 
@@ -262,7 +272,7 @@ f_prealloc(void)
  * The name `_cleanup' is, alas, fairly well known outside stdio.
  */
 void
-_cleanup()
+_cleanup(void)
 {
 	/* (void) _fwalk(fclose); */
 	(void) _fwalk(__sflush);		/* `cheating' */
@@ -272,27 +282,23 @@ _cleanup()
  * __sinit() is called whenever stdio's internal variables must be set up.
  */
 void
-__sinit()
+__sinit(void)
 {
-	THREAD_LOCK();
-	if (__sdidinit == 0) {
-#if !TARGET_OS_EMBEDDED
-		int i;
+#if !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
+	int i;
 #endif
-		/* Make sure we clean up on exit. */
-		__cleanup = _cleanup;		/* conservative */
-		__stream_max = sysconf(_SC_STREAM_MAX);
-		__scounted = 3;			/* std{in,out,err} already exists */
 
-#if !TARGET_OS_EMBEDDED
-		/* Set _extra for the usual suspects. */
-		for (i = 0; i < FOPEN_MAX - 3; i++) {
-			usual[i]._extra = &usual_extra[i];
-			INITEXTRA(&usual[i]);
-		}
-#endif
+	/* Make sure we clean up on exit. */
+	__cleanup = _cleanup;		/* conservative */
+	__stream_max = sysconf(_SC_STREAM_MAX);
+	__scounted = 3;			/* std{in,out,err} already exists */
 
-		__sdidinit = 1;
+#if !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
+	/* Set _extra for the usual suspects. */
+	for (i = 0; i < FOPEN_MAX - 3; i++) {
+		usual[i]._extra = &usual_extra[i];
+		INITEXTRA(&usual[i]);
 	}
-	THREAD_UNLOCK();
+#endif
 }
+#pragma clang diagnostic pop