Next stage of stdio cleanup: Retire __sFILEX and merge the fields back into

__sFILE.  This was supposed to be done in 6.0.  Some notes:
- Where possible I restored the various lines to their pre-__sFILEX state.
- Retire INITEXTRA() and just initialize the wchar bits (orientation and
  mbstate) explicitly instead.  The various places that used INITEXTRA
  didn't need the locking fields or _up initialized.  (Some places needed
  _up to exist and not be off the end of a NULL or garbage pointer, but
  they didn't require it to be initialized to a specific value.)
- For now, stdio.h "knows" that pthread_t is a 'struct pthread *' to
  avoid namespace pollution of including all the pthread types in stdio.h.
  Once we remove all the inlines and make __sFILE private it can go back
  to using pthread_t, etc.
- This does not remove any of the inlines currently and does not change
  any of the public ABI of 'FILE'.

MFC after:	1 month
Reviewed by:	peter

1 files changed, 16 insertions, 26 deletions

diff --git a/lib/libc/stdio/_flock_stub.c b/lib/libc/stdio/_flock_stub.c
index 716ba60..0b61315 100644
--- a/lib/libc/stdio/_flock_stub.c
+++ b/lib/libc/stdio/_flock_stub.c
@@ -55,31 +55,21 @@ __weak_reference(_flockfile_debug_stub, _flockfile_debug);
 __weak_reference(_ftrylockfile, ftrylockfile);
 __weak_reference(_funlockfile, funlockfile);
 
-/*
- * We need to retain binary compatibility for a while.  So pretend
- * that _lock is part of FILE * even though it is dereferenced off
- * _extra now.  When we stop encoding the size of FILE into binaries
- * this can be changed in stdio.h.  This will reduce the amount of
- * code that has to change in the future (just remove this comment
- * and #define).
- */
-#define _lock _extra
-
 void
 _flockfile(FILE *fp)
 {
 	pthread_t curthread = _pthread_self();
 
-	if (fp->_lock->fl_owner == curthread)
-		fp->_lock->fl_count++;
+	if (fp->_fl_owner == curthread)
+		fp->_fl_count++;
 	else {
 		/*
 		 * Make sure this mutex is treated as a private
 		 * internal mutex:
 		 */
-		_pthread_mutex_lock(&fp->_lock->fl_mutex);
-		fp->_lock->fl_owner = curthread;
-		fp->_lock->fl_count = 1;
+		_pthread_mutex_lock(&fp->_fl_mutex);
+		fp->_fl_owner = curthread;
+		fp->_fl_count = 1;
 	}
 }
 
@@ -98,15 +88,15 @@ _ftrylockfile(FILE *fp)
 	pthread_t curthread = _pthread_self();
 	int	ret = 0;
 
-	if (fp->_lock->fl_owner == curthread)
-		fp->_lock->fl_count++;
+	if (fp->_fl_owner == curthread)
+		fp->_fl_count++;
 	/*
 	 * Make sure this mutex is treated as a private
 	 * internal mutex:
 	 */
-	else if (_pthread_mutex_trylock(&fp->_lock->fl_mutex) == 0) {
-		fp->_lock->fl_owner = curthread;
-		fp->_lock->fl_count = 1;
+	else if (_pthread_mutex_trylock(&fp->_fl_mutex) == 0) {
+		fp->_fl_owner = curthread;
+		fp->_fl_count = 1;
 	}
 	else
 		ret = -1;
@@ -121,26 +111,26 @@ _funlockfile(FILE *fp)
 	/*
 	 * Check if this file is owned by the current thread:
 	 */
-	if (fp->_lock->fl_owner == curthread) {
+	if (fp->_fl_owner == curthread) {
 		/*
 		 * Check if this thread has locked the FILE
 		 * more than once:
 		 */
-		if (fp->_lock->fl_count > 1)
+		if (fp->_fl_count > 1)
 			/*
 			 * Decrement the count of the number of
 			 * times the running thread has locked this
 			 * file:
 			 */
-			fp->_lock->fl_count--;
+			fp->_fl_count--;
 		else {
 			/*
 			 * The running thread will release the
 			 * lock now:
 			 */
-			fp->_lock->fl_count = 0;
-			fp->_lock->fl_owner = NULL;
-			_pthread_mutex_unlock(&fp->_lock->fl_mutex);
+			fp->_fl_count = 0;
+			fp->_fl_owner = NULL;
+			_pthread_mutex_unlock(&fp->_fl_mutex);
 		}
 	}
 }