Changeset 2739

trunk/libc/Config.kmk

-              r2723
+              r2739
         __IN_INNOTEK_LIBC__
 DEFS.os2   = __OS2__
+DEFS.win32 = __NT__
+DEFS.win64 = __NT__
+DEFS.nt    = __NT__
 …
 LIBC-STD.H = $(PATH_OBJ)/libc/libc-std.h
 LIBC_GENALIAS = $(PATH_TARGET)/genalias/genalias$(HOSTSUFF_EXE)
+LIBC_GENALIAS_FORMAT.win32 = coff
+LIBC_GENALIAS_FORMAT.win64 = coff
+LIBC_GENALIAS_FORMAT.nt = coff
 ifdef LIBC_GENALIAS_FORMAT.$(BUILD_TARGET)
 LIBC_GENALIAS_FORMAT := $(LIBC_GENALIAS_FORMAT.$(BUILD_TARGET))
 …
 TEMPLATE_libc_TOOL = GCC3
 TEMPLATE_libc_INCS = $(PATH_LIBC_INC) $(dir $(LIBC-STD.H))
+TEMPLATE_libc_INCS.win32 = $(PATH_LIBC_SRC)/w32api/include
+TEMPLATE_libc_INCS.win64 = $(TEMPLATE_libc_INCS.win32)
+TEMPLATE_libc_INCS.nt = $(PATH_LIBC_SRC)/w32api/include
 TEMPLATE_libc_DEPS = $(LIBC-STD.H)
 TEMPLATE_libc_INST = usr/lib/
 …
 TEMPLATE_libc.logstrict_TOOL = GCC3
 TEMPLATE_libc.logstrict_INCS = $(TEMPLATE_libc_INCS)
+TEMPLATE_libc.logstrict_INCS.win32 = $(TEMPLATE_libc_INCS.win32)
+TEMPLATE_libc.logstrict_INCS.win64 = $(TEMPLATE_libc_INCS.win64)
+TEMPLATE_libc.logstrict_INCS.nt = $(TEMPLATE_libc_INCS.nt)
 TEMPLATE_libc.logstrict_DEFS = $(TEMPLATE_libc_DEFS) __LIBC_STRICT DEBUG_LOGGING
 TEMPLATE_libc.logstrict_DEPS = $(TEMPLATE_libc_DEPS)
 …
 TEMPLATE_libc.profiled_TOOL = GCC3
 TEMPLATE_libc.profiled_INCS = $(TEMPLATE_libc_INCS)
+TEMPLATE_libc.profiled_INCS.win32 = $(TEMPLATE_libc_INCS.win32)
+TEMPLATE_libc.profiled_INCS.win64 = $(TEMPLATE_libc_INCS.win64)
+TEMPLATE_libc.profiled_INCS.nt = $(TEMPLATE_libc_INCS.nt)
 TEMPLATE_libc.profiled_DEFS = $(TEMPLATE_libc_DEFS) __LIBC_PROFILED
 TEMPLATE_libc.profiled_DEPS = $(TEMPLATE_libc_DEPS)

trunk/libc/Makefile.kmk

r2733	r2739
56	56	$(TARGET_libc_libsocket) \
57	57	$(TARGET_libc_libsyslog)
58		libc_SOURCES.~~win32~~ = $(TARGET_kNIX.nt)
	58	libc_SOURCES.nt = $(TARGET_kNIX.nt)
59	59
60	60	ifdef CFG_LIBC_LOGSTRICT_LIBS

trunk/libc/alias.kmk

r2717	r2739
63	63	$(foreach pair,$(ALIASPAIRS),$(eval libc_alias_SOURCES += $$(PATH_TARGET)/libc_alias/$(word 1, $(subst =, ,$(pair))).o))
64	64
65		$(libc_alias_SOURCES): $(LIBC_GENALIAS) alias.kmk
	65	$(libc_alias_SOURCES): $(LIBC_GENALIAS) alias.kmk \| $(call DIRDEP,$(PATH_TARGET)/libc_alias)
66	66	$(RM) -f $(PATH_TARGET)/aliases.rsp $(libc_alias_SOURCES)
67	67	$(foreach pair,$(ALIASPAIRS) \

trunk/libc/include/386/_limits.h

-              r1574
+              r2739
 /* bird: Real time signals. */
 #define __RTSIG_MAX     32
+/* bird: wchar_t & wint_t */
+#if 1
+#define __WCHAR_MIN     0
+#define __WCHAR_MAX     __USHRT_MAX
+#else
+#define __WCHAR_MIN     __INT_MIN
+#define __WCHAR_MAX     __INT_MAX
+#endif
+#define __WINT_MIN      __INT_MIN
+#define __WINT_MAX      __INT_MAX
 #endif /* !_MACHINE__LIMITS_H_ */

trunk/libc/include/386/_stdint.h

-              r659
+              r2739
 /** @file
  * FreeBSD 5.1
+ * @changed bird: corrected wchar_t and wint_t min/max constants.
  */
 …
  */
 /* Limits of ptrdiff_t. */
 #define PTRDIFF_MIN     INT32_MIN
+#define PTRDIFF_MIN     INT32_MIN
 #define PTRDIFF_MAX     INT32_MAX
 …
 #ifndef WCHAR_MIN /* Also possibly defined in <wchar.h> */
+#include <machine/_limits.h>            /* bird */
 /* Limits of wchar_t. */
+#define WCHAR_MIN       INT32_MIN
+#define WCHAR_MAX       INT32_MAX
+#define WCHAR_MIN       __WCHAR_MIN     /* bird */
+#define WCHAR_MAX       __WCHAR_MAX     /* bird */
+#endif                                  /* bird */
+#ifdef WINT_MIN                         /* bird */
+#include <machine/_limits.h>            /* bird */
 /* Limits of wint_t. */
 #define WINT_MIN        INT32_MIN
 #define WINT_MAX        INT32_MAX
 #endif
+#define WINT_MIN        __WINT_MIN      /* bird */
+#define WINT_MAX        __WINT_MAX      /* bird */
+#endif                                  /* bird */
 #endif /* !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) */

trunk/libc/include/386/builtin.h

-              r2723
+              r2739
     return u16;
+}
-/**
- * Atomically sets a bit and return the old one.
+ *
- * @returns 1 if the bwit was set, 0 if it was clear.
- * @param   pv      Pointer to base of bitmap.
- * @param   uBit    Bit in question.
- */
-static __inline__ int __atomic_set_bit(__volatile__ void *pv, unsigned uBit)
+{
-    __asm__ __volatile__("lock; btsl %2, %1\n\t"
-                         "sbbl %0,%0"
-                         : "=r" (uBit),
-                           "=m" (*(__volatile__ unsigned *)pv)
-                         : "0"  (uBit)
-                         : "memory");
-    return uBit;
+}
-/**
- * Atomically clears a bit.
+ *
- * @param   pv      Pointer to base of bitmap.
- * @param   uBit    Bit in question.
- */
-static __inline__ void __atomic_clear_bit(__volatile__ void *pv, unsigned uBit)
+{
-    __asm__ __volatile__("lock; btrl %1, %0"
-                         : "=m" (*(__volatile__ unsigned *)pv)
-                         : "r" (uBit));
+}
-/**
- * Atomically (er?) tests if a bit is set.
+ *
- * @returns non zero if the bit was set.
- * @returns 0 if the bit was clear.
- * @param   pv      Pointer to base of bitmap.
- * @param   uBit    Bit in question.
- */
-static __inline__ int __atomic_test_bit(const __volatile__ void *pv, unsigned uBit)
+{
-    __asm__ __volatile__("btl %0, %1\n\t"
-                         "sbbl %0, %0\t\n"
-                         : "=r" (uBit)
-                         : "m"  (*(const __volatile__ unsigned *)pv),
-                           "0"  (uBit));
-    return uBit;
+}
 /**
 …
+}
+/**
+ * Sets a bitmap bit.
+ *
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be set.
+ */
+static inline void __bit_set(void volatile *pvBitmap, uint32_t iBit)
+{
+    __asm__ __volatile__("btsl %1, %0" : "=m" (*(uint32_t *)pvBitmap) : "Ir" (iBit) : "memory");
+}
+/**
+ * Clears a bitmap bit.
+ *
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be cleared.
+ */
+static inline void __bit_clear(void volatile *pvBitmap, uint32_t iBit)
+{
+    __asm__ __volatile__("btrl %1, %0" : "=m" (*(uint32_t *)pvBitmap) : "Ir" (iBit) : "memory");
+}
+/**
+ * Clears a bitmap bit.
+ *
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be cleared.
+ */
+static inline void __bit_toggle(void volatile *pvBitmap, uint32_t iBit)
+{
+    __asm__ __volatile__("btcl %1, %0" : "=m" (*(uint32_t *)pvBitmap) : "Ir" (iBit) : "memory");
+}
+/**
+ * Tests if a bitmap bit is set.
+ *
+ * @returns true if set, false if clear.
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be tested.
+ */
+static inline _Bool __bit_test(void volatile *pvBitmap, uint32_t iBit)
+{
+    union { _Bool f; uint32_t u32; } u;
+    __asm__ __volatile__("btl %2, %1\n\t"
+                         "sbbl %0, %0"
+                         : "=r" (u.u32), "=m" (*(uint32_t *)pvBitmap)
+                         : "Ir" (iBit));
+    return u.f;
+}
+/**
+ * Tests if a bitmap bit is set and then sets it.
+ *
+ * @returns true if set, false if clear.
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be tested and set.
+ */
+static inline _Bool __bit_test_and_set(void volatile *pvBitmap, uint32_t iBit)
+{
+    union { _Bool f; uint32_t u32; } u;
+    __asm__ __volatile__("btsl %2, %1\n\t"
+                         "sbbl %0, %0"
+                         : "=r" (u.u32), "=m" (*(uint32_t *)pvBitmap)
+                         : "Ir" (iBit));
+    return u.f;
+}
+/**
+ * Tests if a bitmap bit is set and then clears it.
+ *
+ * @returns true if set, false if clear.
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be tested and cleared.
+ */
+static inline _Bool __bit_test_and_clear(void volatile *pvBitmap, uint32_t iBit)
+{
+    union { _Bool f; uint32_t u32; } u;
+    __asm__ __volatile__("btrl %2, %1\n\t"
+                         "sbbl %0, %0"
+                         : "=r" (u.u32), "=m" (*(uint32_t *)pvBitmap)
+                         : "Ir" (iBit));
+    return u.f;
+}
+/**
+ * Tests if a bitmap bit is set and then toggles it.
+ *
+ * @returns true if set, false if clear.
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be tested and toggled.
+ */
+static inline _Bool __bit_test_and_toggle(void volatile *pvBitmap, uint32_t iBit)
+{
+    union { _Bool f; uint32_t u32; } u;
+    __asm__ __volatile__("btcl %2, %1\n\t"
+                         "sbbl %0, %0"
+                         : "=r" (u.u32), "=m" (*(uint32_t *)pvBitmap)
+                         : "Ir" (iBit));
+    return u.f;
+}
+/**
+ * Sets a bitmap bit.
+ *
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be set.
+ */
+static inline void __atomic_bit_set(void volatile *pvBitmap, uint32_t iBit)
+{
+    __asm__ __volatile__("btsl %1, %0" : "=m" (*(uint32_t *)pvBitmap) : "Ir" (iBit) : "memory");
+}
+/**
+ * Clears a bitmap bit.
+ *
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be cleared.
+ */
+static inline void __atomic_bit_clear(void volatile *pvBitmap, uint32_t iBit)
+{
+    __asm__ __volatile__("btrl %1, %0" : "=m" (*(uint32_t *)pvBitmap) : "Ir" (iBit) : "memory");
+}
+/**
+ * Clears a bitmap bit.
+ *
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be cleared.
+ */
+static inline void __atomic_bit_toggle(void volatile *pvBitmap, uint32_t iBit)
+{
+    __asm__ __volatile__("btcl %1, %0" : "=m" (*(uint32_t *)pvBitmap) : "Ir" (iBit) : "memory");
+}
+/**
+ * Atomically tests if a bitmap bit is set and then sets it.
+ *
+ * @returns true if set, false if clear.
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be tested and set.
+ */
+static inline _Bool __atomic_bit_test_and_set(void volatile *pvBitmap, uint32_t iBit)
+{
+    union { _Bool f; uint32_t u32; } u;
+    __asm__ __volatile__("lock; btsl %2, %1\n\t"
+                         "sbbl %0, %0"
+                         : "=r" (u.u32), "=m" (*(uint32_t *)pvBitmap)
+                         : "Ir" (iBit));
+    return u.f;
+}
+/**
+ * Atomically tests if a bitmap bit is set and then clears it.
+ *
+ * @returns true if set, false if clear.
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be tested and cleared.
+ */
+static inline _Bool __atomic_bit_test_and_clear(void volatile *pvBitmap, uint32_t iBit)
+{
+    union { _Bool f; uint32_t u32; } u;
+    __asm__ __volatile__("lock; btrl %2, %1\n\t"
+                         "sbbl %0, %0"
+                         : "=r" (u.u32), "=m" (*(uint32_t *)pvBitmap)
+                         : "Ir" (iBit));
+    return u.f;
+}
+/**
+ * Atomically tests if a bitmap bit is set and then toggles it.
+ *
+ * @returns true if set, false if clear.
+ * @param   pvBitmap    The bitmap base.
+ * @param   iBit        The bit to be tested and toggled.
+ */
+static inline _Bool __atomic_bit_test_and_toggle(void volatile *pvBitmap, uint32_t iBit)
+{
+    union { _Bool f; uint32_t u32; } u;
+    __asm__ __volatile__("lock; btcl %2, %1\n\t"
+                         "sbbl %0, %0"
+                         : "=r" (u.u32), "=m" (*(uint32_t *)pvBitmap)
+                         : "Ir" (iBit));
+    return u.f;
+}
+/**
+ * Scans the bitmap from head to tail looking for the first clear bit.
+ *
+ * @returns the bit number on success.
+ * @returns -1 if the end of the bitmap was reached without finind a clear bit.
+ *
+ * @param   pvBitmap    Pointer to the bitmap. Better be 8 byte aligned.
+ * @param   cbBitmap    Size (in bytes) of the bitmap. Must be a multiple of 8.
+ */
+static inline int32_t __bit_scan_clear_forward(void volatile *pvBitmap, uint32_t cbBitmap)
+{
+    int32_t iBit;
+    __asm__ __volatile__("cld\n\t"
+                         "repe scasl\n\t"
+                         "jne 1f\n\t"
+                         "subl  $4, %%edi\n\t"
+                         "xorl  (%%edi), %%eax\n\t"
+                         "bsfl  %%eax, %%eax\n\t"
+                         "subl  %3, %%edi\n\t"
+                         "lea   (%%eax,%%edi,8), %%eax\n\t"
+                         "1:\n\t"
+                         : "=a" (iBit)
+                         : "D" (pvBitmap),
+                           "c" (cbBitmap >> 2),
+                           "m" (pvBitmap),
+                           "0" (0xffffffff));
+    return iBit;
+}
 #define __ROTATE_FUN(F,I,T) \
   static __inline__ T F (T value, int shift) \

trunk/libc/include/InnoTekLIBC/backend.h

-              r2439
+              r2739
  * LIBC - Backend header.
+ *
  * Copyright (c) 2004 knut st. osmundsen <bird-srcspam@anduin.net>
+ * Copyright (c) 2004-2006 knut st. osmundsen <bird-srcspam@anduin.net>
+ *
+ *
 …
 #define __InnoTekLIBC_backend_h__
+#include <stdarg.h>
 #include <sys/cdefs.h>
 #include <sys/types.h>
 …
 #include <sys/shm.h>
 #include <signal.h>
+#include <emx/io.h>
+#include <stdarg.h>
+#include <klibc/io.h>
 …
  *                      for the opened file.
  */
+int __libc_Back_ioFileOpen(const char *pszFile, unsigned fLibc, int fShare, off_t cbInitial, mode_t Mode, PLIBCFH *ppFH);
+int __libc_Back_ioFileOpen(const char *pszFile, unsigned fLibc, int fShare, off_t cbInitial, mode_t Mode, __LIBC_PPFH ppFH);
+/**
+ * Closes a file handle.
+ *
+ * @returns 0 on success.
+ * @returns Negated errno on failure.
+ * @param   fh          The file handle.
+ */
+int __libc_Back_ioClose(int fh);
+/**
+ * Reads from a file handle.
+ *
+ * @returns 0 on success.
+ * @returns Negated errno on failure.
+ * @param   fh          The file handle.
+ * @param   pvBuf       The buffer to read into.
+ * @param   cbToRead    The number of bytes to read.
+ * @param   pcbRead     Where to store the number of bytes actually read.
+ */
+int __libc_Back_ioRead(int fh, void *pvBuf, size_t cbToRead, size_t *pcbRead);
+/**
+ * Write to a file handle.
+ *
+ * @returns 0 on success.
+ * @returns Negated errno on failure.
+ * @param   fh          The file handle.
+ * @param   pvBuf       The buffer containing the bytes to write.
+ * @param   cbToWrite   The number of bytes to write.
+ * @param   pcbWritten  Where to store the number of bytes actually written.
+ */
+int __libc_Back_ioWrite(int fh, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten);
 /**
 …
 /**
  * File Control.
+ *
+ *
  * Deals with file descriptor flags, file descriptor duplication and locking.
+ *
+ *
  * @returns 0 on success and *piRet set.
  * @returns Negated errno on failure and *piRet set to -1.
 …
 /**
  * File Control operation - OS/2 standard handle.
+ *
+ *
  * @returns 0 on success.
  * @returns OS/2 error code or negated errno on failure.
+ *
+ *
  * @param   pFH         Pointer to the handle structure to operate on.
  * @param   fh          It's associated filehandle.
 …
  */
 int __libc_Back_ioFileControlStandard(__LIBC_PFH pFH, int fh, int iRequest, intptr_t iArg, int *prc);
 /**
  * Try resolve a filehandle to a path.
 …
  * on any memory the native apis works on.
+ *
+ * @returns 0 on success.
  * @returns Negative error code (errno.h) on failure.
  * @param   pv      Pointer to first page - page aligned!
 …
  */
 int __libc_Back_mmanProtect(void *pv, size_t cb, unsigned fFlags);
+/**
+ * Sets the the break value (end of the dynamic data segment).
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   pvNewBreak      The requested new break.
+ */
+int __libc_Back_mmanBrk(void *pvNewBreak);
+/**
+ * Adds a delta to the break value (end of the dynamic data segment).
+ *
+ * @returns 0 on success.
+ * @returns Negative error code (errno.h) on failure.
+ * @param   iDelta          The delta to add to the current break value.
+ * @param   ppvOldBreak     Where to store the old break value.
+ */
+int __libc_Back_mmanSBrk(intptr_t iDelta, void **ppvOldBreak);
+/**
+ * SBrk model.
+ */
+typedef enum __LIBCSBRKMODEL
+{
+    __LIBC_SBRK_MODEL_INVALID = 0,
+    __LIBC_SBRK_MODEL_CONTIGUOUS = 1,
+    __LIBC_SBRK_MODEL_MONOTONOUS = 2,
+    __LIBC_SBRK_MODEL_ARBITRARY  = 4
+} __LIBCSBRKMODEL;
+/**
+ * Sets the model used by the __libc_Back_mmanSBrk() and
+ * __libc_Back_mmanBrk() APIs.
+ *
+ * @returns The old module on success.
+ * @returns __LIBC_SBRK_MODEL_INVALID on invalid enmModule value.
+ * @param   enmModel        The new model.
+ */
+__LIBCSBRKMODEL __libc_Back_mmanSBrkSetModel(__LIBCSBRKMODEL enmModel);
+/**
+ * Gets the model used by the __libc_Back_mmanSBrk() and
+ * __libc_Back_mmanBrk() APIs.
+ *
+ * @returns The current break model.
+ */
+__LIBCSBRKMODEL __libc_Back_mmanSBrkGetModel(void);
 /** @} */

trunk/libc/include/InnoTekLIBC/tcpip.h

-              r2004
+              r2739
+{
     /** the common fh core. */
     LIBCFH      core;
+    __LIBC_FH   core;
     /** OS/2 socket number. */
 …
 /**
  * Retrieve the socket handle structure for a given handle.
+ * Retrieve the socket handle structure for a given file handle.
+ *
  * @returns Pointer to socket handle structure on success.
 …
  * @param   iSocket  Socket handle number.
  */
+static inline PLIBCSOCKETFH   __libc_TcpipFH(int iSocket)
+{
+    PLIBCSOCKETFH   pFHSocket = (PLIBCSOCKETFH)__libc_FH(iSocket);
+    if (pFHSocket)
+static inline PLIBCSOCKETFH __libc_TcpipFH(int iSocket)
+{
+    union
+    {
+        if ((pFHSocket->core.fFlags & __LIBC_FH_TYPEMASK) == F_SOCKET)
+            return pFHSocket;
+        __LIBC_PFH      pFH;
+        PLIBCSOCKETFH   pFHSocket;
+    } u;
+    int rc = __libc_FHGet(iSocket, &u.pFH);
+    if (!rc)
+    {
+        if ((u.pFHSocket->core.fFlags & __LIBC_FH_TYPEMASK) == F_SOCKET)
+            return u.pFHSocket;
         __libc_TcpipSetErrno(ENOTSOCK);
+    }
     else
         __libc_TcpipSetErrno(EBADF);
+        __libc_TcpipSetErrno(-rc);
     return NULL;
+}

trunk/libc/include/InnoTekLIBC/thread.h

-              r2254
+              r2739
  * LIBC Thread Handling.
+ *
  * Copyright (c) 2004 knut st. osmundsen <bird-srcspam@anduin.net>
+ * Copyright (c) 2004-2006 knut st. osmundsen <bird-srcspam@anduin.net>
+ *
+ *
 …
 #include <time.h>                       /* struct tm; */
 #include <signal.h>
+#ifdef __NT__
+# include <klibc/nt/fib.h>
+#endif
 …
 *******************************************************************************/
 __BEGIN_DECLS
+#ifdef __OS2__
 /** Pointer to the TLS ULONG (OS/2 rules) which will point to the LIBC thread
  * structure for the current thread.
 …
  * is allocated on demand. */
 extern __LIBC_PPTHREAD  __libc_gpTLS;
+#endif /* __OS2__ */
 __END_DECLS
 …
 *******************************************************************************/
 __BEGIN_DECLS
 /**
  * Get the thread structure for the current thread.
+ *
  * Will automatically allocate a thread structure if such is not yet done
  * for the thread.
+ * Used by the __libc_threadCurrent() macro for allocating a thread structure for the
+ * current thread when such doesn't exist.
+ *
  * @returns pointer to current thread struct.
+ *
+ * @remark  No reference counting here, the current thread have a permanent
+ *          reference to it self.
+ * @remark  This API is considered to be internal to LIBC and is thus not
+ *          exposed in the shared library version of LIBC. Please don't call it.
+ *          External LIBs should use the __libc_TLS*() API.
+ */
+__LIBC_PTHREAD __libc_threadCurrentSlow(void);
+/**
+ * Get the thread structure for the current thread.
+ *
+ * Do not create anything automatically.
+ *
+ * @returns pointer to current thread struct.
+ * @returns NULL if not initiated.
+ *
  * @remark  No reference counting here, current thread have a permanent
  *          reference to it self.
 …
  *          External LIBs should use the __libc_TLS*() API.
  */
+#define __libc_threadCurrent()   (*__libc_gpTLS ? *__libc_gpTLS : __libc_threadCurrentSlow())
+#ifdef __OS2__
+# define __libc_threadCurrentNoAuto()   (__libc_gpTLS ? *__libc_gpTLS : NULL)
+#elif defined(__NT__)
+# define __libc_threadCurrentNoAuto()   (fibGetLibcThread())
+#else
+# error "Port me!"
+#endif
 /**
  * Get the thread structure for the current thread.
+ *
  * Used by the __libc_threadCurrent() macro for allocating a thread structure for the
  * current thread when such doesn't exist.
+ * Will automatically allocate a thread structure if such is not yet done
+ * for the thread.
+ *
  * @returns pointer to current thread struct.
  * @remark  No reference counting here, current thread have a permanent
+ *
+ * @remark  No reference counting here, the current thread have a permanent
  *          reference to it self.
  * @remark  This API is considered to be internal to LIBC and is thus not
 …
  *          External LIBs should use the __libc_TLS*() API.
  */
+__LIBC_PTHREAD __libc_threadCurrentSlow(void);
+/**
+ * Get the thread structure for the current thread.
+ *
+ * Do not create anything automatically.
+ *
+ * @returns pointer to current thread struct.
+ * @returns NULL if not initiated.
+ *
+ * @remark  No reference counting here, current thread have a permanent
+ *          reference to it self.
+ * @remark  This API is considered to be internal to LIBC and is thus not
+ *          exposed in the shared library version of LIBC. Please don't call it.
+ *          External LIBs should use the __libc_TLS*() API.
+ */
+#define __libc_threadCurrentNoAuto()   (__libc_gpTLS ? *__libc_gpTLS : NULL)
+static __inline__ __LIBC_PTHREAD __libc_threadCurrent(void)
+{
+#ifdef __OS2__
+    __LIBC_PTHREAD pThread = *__libc_gpTLS;
+#else
+    __LIBC_PTHREAD pThread = __libc_threadCurrentNoAuto();
+#endif
+    if (__predict_true(pThread != (__LIBC_PTHREAD)0))
+        return pThread;
+    return __libc_threadCurrentSlow();
+}
 /**
 …
 #endif

trunk/libc/include/emx/io.h

-              r2672
+              r2739
 #endif /* __FILE_FSEM_DECLARED */
-struct __libc_FileHandle;
-/**
- * Information struct about a mounted file system.
+ *
- * Used to track down the filesystem of an open file handle and
- * so we can optimize certain operations like expanding a file.
- */
-typedef struct __libc_FileSystemInfo
+{
-    /** Number of references to this file system info object.
-     * The structure can be shared by many handles. */
-    volatile int32_t    cRefs;
-    /** Does the file system automatically zero the new space when a file is extended? */
-    unsigned            fZeroNewBytes : 1;
-    /** Does the file system provide sufficient EA support for UNIX attributes? */
-    unsigned            fUnixEAs : 1;
-    /** Device number of the device the filesystem resides on.
-     * On OS/2 the device number is derived from the driveletter. */
-    dev_t               Dev;
-    /** The filesystem driver name. */
-    char                szName[16];
-    /** The mount point - may extend beyond the 4 bytes on some OSes. */
-    char                szMountpoint[4];
-} __LIBC_FSINFO;
-/** Pointer to information about an open filesystem. */
-typedef __LIBC_FSINFO *__LIBC_PFSINFO;
-/**
- * Filehandle type.
- */
-typedef enum __libc_FileHandleType
+{
-    /** Anything which is supported by the OS/2 file API.
-     * (not used at present as those handles doesn't need special ops). */
-    enmFH_File,
-    /** Socket handle (BSD 4.3 stack). */
-    enmFH_Socket43,
-    /** Socket handle (BSD 4.4 stack). */
-    enmFH_Socket44,
-    /** Directory handle. */
-    enmFH_Directory
-} __LIBC_FHTYPE;
-/**
- * File handle Operations.
- * (for non standard handles (like sockets))
- */
-typedef struct __libc_FileHandleOperations
+{
-    /** Handle type. */
-    __LIBC_FHTYPE       enmType;
-    /** Close operation.
-     * @returns 0 on success.
-     * @returns OS/2 error code or negated errno on failure.
-     * @param   pFH         Pointer to the handle structure to operate on.
-     * @param   fh          It's associated filehandle.
-     */
-    int (*pfnClose)(struct __libc_FileHandle *pFH, int fh);
-    /** Read operation.
-     * @returns 0 on success.
-     * @returns OS/2 error code or negated errno on failure.
-     * @param   pFH         Pointer to the handle structure to operate on.
-     * @param   fh          It's associated filehandle.
-     * @param   pvBuf       Pointer to the buffer to read into.
-     * @param   cbRead      Number of bytes to read.
-     * @param   pcbRead     Where to store the count of bytes actually read.
-     */
-    int (*pfnRead)(struct __libc_FileHandle *pFH, int fh, void *pvBuf, size_t cbRead, size_t *pcbRead);
-    /** Write operation.
-     * @returns 0 on success.
-     * @returns OS/2 error code or negated errno on failure.
-     * @param   pFH         Pointer to the handle structure to operate on.
-     * @param   fh          It's associated filehandle.
-     * @param   pvBuf       Pointer to the buffer which contains the data to write.
-     * @param   cbWrite     Number of bytes to write.
-     * @param   pcbWritten  Where to store the count of bytes actually written.
-     */
-    int (*pfnWrite)(struct __libc_FileHandle *pFH, int fh, const void *pvBuf, size_t cbWrite, size_t *pcbWritten);
-    /** Duplicate handle operation.
-     * @returns 0 on success, OS/2 error code on failure.
-     * @param   pFH         Pointer to the handle structure to operate on.
-     * @param   fh          It's associated filehandle.
-     * @param   pfhNew      Where to store the duplicate filehandle.
-     *                      The input value describe how the handle is to be
-     *                      duplicated. If it's -1 a new handle is allocated.
-     *                      Any other value will result in that value to be
-     *                      used as handle. Any existing handle with that
-     *                      value will be closed.
-     */
-    int (*pfnDuplicate)(struct __libc_FileHandle *pFH, int fh, int *pfhNew);
-    /** File Control operation.
-     * @returns 0 on success.
-     * @returns OS/2 error code or negated errno on failure.
-     * @param   pFH         Pointer to the handle structure to operate on.
-     * @param   fh          It's associated filehandle.
-     * @param   iRequest    Which file file descriptior request to perform.
-     * @param   iArg        Argument which content is specific to each
-     *                      iRequest operation.
-     * @param   prc         Where to store the value which upon success is
-     *                      returned to the caller.
-     */
-    int (*pfnFileControl)(struct __libc_FileHandle *pFH, int fh, int iRequest, int iArg, int *prc);
-    /** I/O Control operation.
-     * @returns 0 on success.
-     * @returns OS/2 error code or negated errno on failure.
-     * @param   pFH         Pointer to the handle structure to operate on.
-     * @param   fh          It's associated filehandle.
-     * @param   iIOControl  Which I/O control operation to perform.
-     * @param   iArg        Argument which content is specific to each
-     *                      iIOControl operation.
-     * @param   prc         Where to store the value which upon success is
-     *                      returned to the caller.
-     */
-    int (*pfnIOControl)(struct __libc_FileHandle *pFH, int fh, int iIOControl, int iArg, int *prc);
-    /** Select operation.
-     * The select operation is only performed if all handles have the same
-     * select routine (the main worker checks this).
+     *
-     * @returns 0 on success.
-     * @returns OS/2 error code or negated errno on failure.
-     * @param   cFHs        Range of handles to be tested.
-     * @param   pRead       Bitmap for file handles to wait upon to become ready for reading.
-     * @param   pWrite      Bitmap for file handles to wait upon to become ready for writing.
-     * @param   pExcept     Bitmap of file handles to wait on (error) exceptions from.
-     * @param   tv          Timeout value.
-     * @param   prc         Where to store the value which upon success is
-     *                      returned to the caller.
-     */
-    int (*pfnSelect)(int cFHs, struct fd_set *pRead, struct fd_set *pWrite, struct fd_set *pExcept, struct timeval *tv, int *prc);
-    /** Fork notification - parent context.
-     * If NULL it's assumed that no notifiction is needed.
+     *
-     * @returns 0 on success.
-     * @returns OS/2 error code or negated errno on failure.
-     * @param   pFH             Pointer to the handle structure to operate on.
-     * @param   fh              It's associated filehandle.
-     * @param   pForkHandle     The fork handle.
-     * @param   enmOperation    The fork operation.
-     */
-    int (*pfnForkParent)(struct __libc_FileHandle *pFH, int fh, __LIBC_PFORKHANDLE pForkHandle, __LIBC_FORKOP enmOperation);
-    /** Fork notification - child context.
-     * Only the __LIBC_FORK_OP_FORK_CHILD operation is forwarded atm.
-     * If NULL it's assumed that no notifiction is needed.
+     *
-     * @returns 0 on success.
-     * @returns OS/2 error code or negated errno on failure.
-     * @param   pFH             Pointer to the handle structure to operate on.
-     * @param   fh              It's associated filehandle.
-     * @param   pForkHandle     The fork handle.
-     * @param   enmOperation    The fork operation.
-     */
-    int (*pfnForkChild)(struct __libc_FileHandle *pFH, int fh, __LIBC_PFORKHANDLE pForkHandle, __LIBC_FORKOP enmOperation);
-} __LIBC_FHOPS;
-/** Pointer to file handle operations. */
-typedef __LIBC_FHOPS *__LIBC_PFHOPS;
-/** Pointer to const file handle operations. */
-typedef const __LIBC_FHOPS *__LIBC_PCFHOPS;
-/**
- * Common part of a per 'file' handle structure.
- */
-typedef struct __libc_FileHandle
+{
-    /** Handle flags.
-     * See group @ref libc_ioflags in include/emx/io.h.
-     * @remark For thread safety update this atomically. */
-    volatile unsigned int   fFlags;
-    /** Lookahead. (whoever uses that?)
-     * Previously represented by _files / *fd_vec->flags.
-     * @remark For thread safety update this atomically. */
-    volatile int            iLookAhead;
-    /** Pointer to the operations one can perform on the handle.
-     * Only for special handles not supported by the OS/2 file API. */
-    __LIBC_PCFHOPS          pOps;
-    /** Device number of the device containing the file.
-     * The device number is also determined from the path, more correctly the
-     * driveletter determins this. */
-    dev_t                   Dev;
-    /** Inode number of the file.
-     * Since the inode number is usually calculated from the path we need to
-     * determin this at handle creation time. */
-    ino_t                   Inode;
-    /** Pointer to the filesystem information object for the filesystem which
-     * this file resides on. This might be NULL... */
-    __LIBC_PFSINFO          pFsInfo;
-    /** Pointer to the native path to this file as specified in the open call.
-     * This is required to read the unix attributes from EAs if the file isn't
-     * opened with exclusive access. */
-    char                   *pszNativePath;
-} __LIBC_FH;
-/** Pointer to filehandle. */
-typedef __LIBC_FH *__LIBC_PFH;
-/* fixme!! */
-#define LIBCFH __LIBC_FH
-#define PLIBCFH __LIBC_PFH
-int     __libc_FHEnsureHandles(int fh);
-int     __libc_FHMoreHandles(void);
-int     __libc_FHAllocate(int fh, unsigned fFlags, int cb, __LIBC_PCFHOPS pOps, PLIBCFH *ppFH, int *pfh);
-int     __libc_FHClose(int fh);
-PLIBCFH __libc_FH(int fh);
-int     __libc_FHEx(int fh, __LIBC_PFH *ppFH);
-int     __libc_FHSetFlags(__LIBC_PFH pFH, int fh, unsigned fFlags);
 int _endbuf1 (struct __sFILE *);

trunk/libc/include/emx/syscalls.h

r2439	r2739
216	216	int __wait (int *status);
217	217	int __waitpid (int pid, int *status, int options);
218		int __write (int handle, __const__ void *buf, size_t nbyte);
	218	//int __write (int handle, __const__ void *buf, size_t nbyte);
219	219
220	220	#if defined (__cplusplus)

trunk/libc/include/klibc/nt/fib.h

-              r2727
+              r2739
 #define __klibc_nt_fib_h__
 #include <sys/cdefs.h>
+//#include <sys/cdefs.h>
 #include <stdint.h>
 __BEGIN_DECLS
+//__BEGIN_DECLS
 …
+{
     uint32_t ret;
     __asm__ __volatile__("fs; movl (%0), %0\n" : "=r" (ret) : "0" (off));
+    __asm__ __volatile__("fs; movl (%1), %0\n" : "=r" (ret) : "r" (off));
     return ret;
+}
 …
     void *ret;
 #if defined(__AMD64__) || defined(__x86_64__) || defined(__amd64__)
     __asm__ __volatile__("fs; movq (%1), %0\n" : "=r" (ret) : "r" (off));s
+    __asm__ __volatile__("fs; movq (%1), %0\n" : "=r" (ret) : "r" (off));
 #else
+    __asm__ __volatile__("fs; movl (%0), %0\n" : "=r" (ret) : "0" (off));
+    __asm__ __volatile__("fs; movl (%1), %0\n" : "=r" (ret) : "r" (off));
 #endif
     return ret;
 …
  * Gets the current Thread ID.
  */
 #define fibGetTid()             (__libc_fibGetTEB_UPTR(ClientId.UniqueThread))
+#define fibGetTid()                 (__libc_fibGetTEB_UPTR(ClientId.UniqueThread))
 /**
 …
  * @todo Need validate that the value ranges here are within 16-bit. (seems correct on 64-bit xp)
  */
 #define fibGetTidPid()          ((uint16_t)fibGetTid() | ((uint16_t)fibGetPid() << 16))
+#define fibGetTidPid()              ((uint16_t)fibGetTid() | ((uint16_t)fibGetPid() << 16))
 /**
  * Gets the handle of the executable of this process.
  */
 #define fibGetExeHandle()       (fibGetPEB()->ImageBaseAddress)
+#define fibGetExeHandle()           (fibGetPEB()->ImageBaseAddress)
 …
  */
 /** Get the current millisecond counter value. */
 #define fibGetMsCount()         ((uint32_t)(fibGetNtMonotime() / 10000))
+#define fibGetMsCount()             ((uint32_t)(fibGetNtMonotime() / 10000))
 /**
  * Get the NT monotone time.
  */
 #define fibGetNtMonotime()      __libc_fibGetNtMonotime_()
+#define fibGetNtMonotime()          __libc_fibGetNtMonotime_()
 /**
 …
  * Checks if we're being debugged.
  */
+#define fibIsBeingDebugged()    (fibGetPEB()->BeingDebugged)
+__END_DECLS
+#endif
+#define fibIsBeingDebugged()        (fibGetPEB()->BeingDebugged)
+/**
+ * We're abusing the ArbitraryUserPointer pointer member of the TIB.
+ *
+ * In our own subsystem we are allowed to define this to be the thread pointer.
+ * In foreign processes, this is possibly a bit intrusive. But for now, I'm feeling
+ * lazy and is not going to reimplement TlsAlloc and all that to make it work 100%
+ * safely in win32/64 processes. I'll do that once the first conflicts surfaces.
+ */
+#define fibGetLibcThread()          ((__LIBC_PTHREAD)__libc_fibGetTEB_UPTR(ArbitraryUserPointer))
+/**
+ * We're abusing the ArbitraryUserPointer pointer member of the TIB.
+ * @param   pThread     The new thread pointer.
+ */
+#define fibSetLibcThread(pThread)   do { fibGetTEB()->ArbitraryUserPointer = (pThread); } while (0)
+//__END_DECLS
+#endif

trunk/libc/include/klibc/nt/nt.h

r2727	r2739
39	39	OUT PUNICODE_STRING VariableValue);
40	40
	41	int __libc_back_NtStatus2Errno(NTSTATUS Status);
	42
41	43	#endif
42	44

trunk/libc/include/sys/uflags.h

-              r18
+              r2739
 #define _SYS_UFLAGS_H
+#include <sys/cdefs.h>
 /* Constants for _uflags() */
-#define _UF_SIG_MODEL           0x0003  /* Mask */
-#define _UF_SIG_EMX             0x0000
-#define _UF_SIG_SYSV            0x0001
-#define _UF_SIG_BSD             0x0002
-#define _UF_SIG_RESERVED        0x0003
 #define _UF_SBRK_MODEL          0x000c  /* Mask */
 …
 #define _UF_SBRK_RESERVED1      0x000c
+#if 0/* not implemented */
 #define _UF_PTRACE_MODEL        0x0030  /* Mask */
 #define _UF_PTRACE_STANDARD     0x0000
 #define _UF_PTRACE_NOTIFY       0x0010
 #define _UF_PTRACE_MULTITHREAD  0x0020
-#if defined (__cplusplus)
-extern "C" {
 #endif
+int _uflags (int, int);
+#if defined (__cplusplus)
+}
+#endif
+__BEGIN_DECLS
+int _uflags(int, int);
+__END_DECLS
 #endif /* not _SYS_UFLAGS_H */

trunk/libc/include/wchar.h

-              r2120
+              r2739
  * FreeBSD 5.3
  * @changed bird: Disabled all stream related and some other stuff we don't do yet.
+ * @changed bird: wchar_t min/max.
  */
 /*-
 …
 #ifndef WCHAR_MIN
 #define WCHAR_MIN       __INT_MIN
 #define WCHAR_MAX       __INT_MAX
+#define WCHAR_MIN       __WCHAR_MIN     /* bird */
+#define WCHAR_MAX       __WCHAR_MAX     /* bird */
 #endif

trunk/libc/src/fbsdlibc/Makefile.kmk

r2717	r2739
34	34	ifeq ($(BUILD_TARGET),os2) ## @todo make portable
35	35	include $(wildcard $(PATH_LIBC_SRC)/fbsdlibc/*/Makefile.kmk)
	36	else
	37	include $(PATH_LIBC_SRC)/fbsdlibc/locale/Makefile.kmk
36	38	endif
37	39

trunk/libc/src/fbsdlibc/locale/utf8.c

-              r2058
+              r2739
 #include <errno.h>
 #include <limits.h>
 #ifdef __INNOTEK_LIBC__
+#ifdef IN_INNOTEK_LIBC
 #include <InnotekLIBC/locale.h>
 #else
 …
 } _UTF8State;
 #ifndef __INNOTEK_LIBC__
+#ifndef IN_INNOTEK_LIBC
 int
 _UTF8_init(_RuneLocale *rl)
 …
     pFuncs->pfnwcsnrtombs = _UTF8_wcsnrtombs;
+}
 #endif /* __INNOTEK_LIBC__ */
+#endif /* IN_INNOTEK_LIBC */
 int
 …
         _UTF8State *us;
         int ch, i, mask = 0, want;      /* bird: gcc shut */
 #ifdef __INNOTEK_LIBC__
+#if WCHAR_MAX == 0xffff
         wint_t lbound, wch;
 #else
 …
                 return ((size_t)-1);
+        }
 #ifdef __INNOTEK_LIBC__
+#if WCHAR_MAX == 0xffff
         if (wch > 0xffff || wch < 0)
             wch = 0xffff;

trunk/libc/src/genalias/Makefile.kmk

r2717	r2739
35	35	PROGRAMS += genalias
36	36	genalias_TEMPLATE = bldprog
37		ifeq ($(filter-out os2 ~~win32,$(BUILD_TARGET~~)),)
	37	ifeq ($(filter-out os2.x86 nt.x86,$(BUILD_TARGET).$(BUILD_TARGET_ARCH)),)
38	38	genalias_DEFS = GENALIAS_UNDERSCORED=1
39	39	else

trunk/libc/src/kNIX/Makefile.kmk

-              r2733
+              r2739
 libc_kNIX_TEMPLATE = libcsub
 libc_kNIX_SOURCES = \
+    $(PATH_LIBC_SRC)/kNIX/b_ioClose.c \
+    $(PATH_LIBC_SRC)/kNIX/b_ioRead.c \
+    $(PATH_LIBC_SRC)/kNIX/b_ioWrite.c \
+    $(PATH_LIBC_SRC)/kNIX/b_mmanBrk.c \
+    $(PATH_LIBC_SRC)/kNIX/b_mmanSBrk.c \
+    $(PATH_LIBC_SRC)/kNIX/b_mmanSBrkGetModel.c \
+    $(PATH_LIBC_SRC)/kNIX/b_mmanSBrkSetModel.c \
     $(PATH_LIBC_SRC)/kNIX/filehandles.c \
+    $(PATH_LIBC_SRC)/kNIX/heap.c \
+    $(PATH_LIBC_SRC)/kNIX/heapdata.c \
+#    $(PATH_LIBC_SRC)/kNIX/b_ioDuplicate.c \
 …
     $(PATH_LIBC_SRC)/kNIX/os2/386/__init_environ.s \
+$(PATH_LIBC_SRC)/kNIX/os2/heapsize.c_DEFS = HEAPSIZE=0x2000000
+libc_kNIX_SOURCES.win32 = \
+libc_kNIX_SOURCES.nt = \
         $(PATH_LIBC_SRC)/kNIX/nt/b_panic.c \
+        $(PATH_LIBC_SRC)/kNIX/nt/fhNtFile.c \
+        $(PATH_LIBC_SRC)/kNIX/nt/NtStatus.c \

trunk/libc/src/kNIX/filehandles.c

-              r2733
+              r2739
  * LIBC File Handles.
+ *
  * Copyright (c) 2003-2004 knut st. osmundsen <bird-srcspam@anduin.net>
+ * Copyright (c) 2003-2006 knut st. osmundsen <bird-srcspam@anduin.net>
+ *
+ *
 …
  */
-/*******************************************************************************
-*   Defined Constants And Macros                                               *
-*******************************************************************************/
-/** Maximum number of file handles. */
-#define __LIBC_MAX_FHS      10000
-/** Number of file handles to increase the max value with. */
-#define __LIBC_INC_FHS      64
 /*******************************************************************************
 *   Header Files                                                               *
 *******************************************************************************/
+#include "libc-alias.h"
 #define __LIBC_LOG_GROUP    __LIBC_LOG_GRP_INITTERM
 #ifdef __OS2__
 …
 # include <klibc/nt/nt.h>
 #endif
 #include "libc-alias.h"
+#include "kNIX.h"
 #include <malloc.h>
 #include <string.h>
 #include <sys/fcntl.h>
 #include <errno.h>
+#include <klibc/io.h>
 #include <InnoTekLIBC/fork.h>
 #include <InnoTekLIBC/sharedpm.h>
 #include <InnoTekLIBC/tcpip.h>
-#include <emx/io.h>
 #include <emx/umalloc.h>
-//#include "syscalls.h"
 #include "b_fs.h"
 #include "b_dir.h"
 #include <InnoTekLIBC/backend.h>
 #include <InnoTekLIBC/logstrict.h>
+#include <klibc/backend.h>
+#include <klibc/logstrict.h>
 …
 /** Array of preallocated handles - normal files only! */
 static LIBCFH               gaPreAllocated[40];
+static __LIBC_FH            gaPreAllocated[40];
 /** Number of free handles in the preallocated array. */
 static unsigned             gcPreAllocatedAvail;
+#if !CFG_KNIX_FH_NATIVE_ALLOCATION
+/** Bitmap used for keeping track of which filehandle has been allocated. */
+static  uint8_t             gbmAllocations[(CFG_KNIX_MAX_FHS + 63) / 8];
+#endif
 /** Indicator whether or not inherit flags and other stuff have been cleaned
  * up after fork. */
 static int                  gfForkCleanupDone;
+/** Last used fake I-node number. */
+ino_t                       __libc_back_gIno = 0;
 extern int _fmode_bin;
 …
 *******************************************************************************/
 static int      fhMoreHandles(unsigned cMin);
 static int      fhAllocate(int fh, unsigned fFlags, int cb, __LIBC_PCFHOPS pOps, __LIBC_PFH *ppFH, int *pfh, int fOwnSem);
+static int      fhAllocate(int cb, __LIBC_PCFHOPS pOps, uintptr_t hNative, int fh, unsigned fFlags, int fOwnSem, __LIBC_PFH *ppFH);
 static void     fhFreeHandle(__LIBC_PFH pFH);
 static __LIBC_PFH  fhGet(int fh);
+static int      fhImportFile(uintptr_t hNative, int fh, __LIBC_PFH *ppFH);
 static int      fhForkParent1(__LIBC_PFORKHANDLE pForkHandle, __LIBC_FORKOP enmOperation);
 static int      fhForkChild1(__LIBC_PFORKHANDLE pForkHandle, __LIBC_FORKOP enmOperation);
 …
      * Figure out the size of the pointer array and initiatlize it.
      */
+#ifdef __OS2__
     rc = DosSetRelMaxFH(&lDeltaFHs, &cMaxFHs);
     if (rc)
 …
         cMaxFHs = 20;
+    }
+    gcFHs = (cMaxFHs + 3) & ~3;     /* round up to nearest 4. */
+#else
+    gcFHs = CFG_KNIX_MAX_FHS;
+#endif
+    gcFHs = (cMaxFHs + 4) & ~3;     /* round up to nearest 4. */
     gpapFHs = _hcalloc(gcFHs, sizeof(gpapFHs[0]));
     if (!gpapFHs)
 …
     gcPreAllocatedAvail = sizeof(gaPreAllocated) / sizeof(gaPreAllocated[0]);
+#ifdef __OS2__
     /*
      * Check if we inherited flags and stuff from parent.
 …
             cMaxFHs = 3;
         for (i = 0; i < cMaxFHs; i++)
+            fhGet(i);
+        {
+            __LIBC_PFH pFH;
+            if (!fhImportFile(i, i, &pFH))
+                /*fhPut(pFH)*/;
+        }
+    }
     else
 …
+                    {
                         __LIBC_PFH pFH;
                         if (fhAllocate(iFH, u.pStds->aHandles[i].fFlags, sizeof(__LIBC_FH), NULL, &pFH, NULL, 0))
+                        if (fhAllocate(sizeof(__LIBC_FH), &__libc_back_gFileOps, iFH, iFH, u.pStds->aHandles[i].fFlags, 0, &pFH))
+                        {
                             __libc_Back_panic(0, NULL, "Failed to allocated inherited file handle! iFH=%d\n", iFH);
 …
+    }
+#elif __NT__
+    /*
+     * Need to figure this one out later.
+     */
+#else
+# error
+#endif
     return 0;
+}
+#if 0 // not used
+#if 0 /// @todo unload termination.
 /**
  * Terminate the file handles.
 …
     if (rc)
+    {
-        _sys_set_errno(rc);
         free(pRet);
         LIBCLOG_ERROR_RETURN_P(NULL);
 …
                         LIBCLOG_ERROR_RETURN_P(NULL);
+                    }
+#ifdef __OS2__ /// @todo fixme
                     u.pDirs->aHandles[i].fInUnixTree   = !!((__LIBC_PFHDIR)gpapFHs[iFH])->fInUnixTree;
                     u.pDirs->aHandles[i].uCurEntry     = ((__LIBC_PFHDIR)gpapFHs[iFH])->uCurEntry;
+#endif
                     /* next */
                     i++; iFH++;
 …
+ *
  * @returns 0 on success.
+ * @returns OS/2 error on failure.
+ * @param   fh  Filehandle to open the dummy device for.
+ *              Use -1 if no special handle is requested.
+ * @param   pfh Where to store the opened fake handle.
+ */
+static int fhOpenDummy(int fh, int *pfh)
+{
+ * @returns Negated errno on failure.
+ * @param   pFH     The file handle structure to which fh member to set on success.
+ * @param   fh      The file handle to reserve. If -1 the next free handle is reserved.
+ */
+static int fhReserveHandle(__LIBC_PFH pFH, int fh)
+{
+#if CFG_KNIX_FH_NATIVE_ALLOCATION
+# ifdef __OS2__
     int     rc;
     ULONG   ulAction;
 …
      * If we're out of handle space, try increase it.
      */
+/** @todo inherit stuff isn't right here. I.e. O_NOINHERIT won't work. */
     FS_SAVE_LOAD();
     for (;;)
 …
             rc = DosDupHandle(hFile, &hDup);
             if (!rc)
                 *pfh = hDup;
+                pFH->fh = hDup;
             DosClose(hFile);
+        }
         else
+            *pfh = hFile;
+            fh = hFile;
+        /*
+         * Make sure we've got enough table space allocated.
+         * (This may happen when others mess with the max file handle number.)
+         */
+        if (!rc && fh >= gcFHs)
+        {
+            rc = fhMoreHandles(fh + 1);
+            if (rc)
+                DosClose(fh);
+        }
+        /*
+         * Finally, update the handle structure.
+         */
+        if (!rc)
+            pFH->fh = fh;
+    }
     FS_RESTORE();
+    if (rc > 0)
+        rc = -__libc_native2errno(rc);
     return rc;
+# endif /* __OS2__ */
+#else   /* !CFG_KNIX_FH_NATIVE_ALLOCATION */
+    if (fh == -1)
+    {
+        fh = __bit_scan_clear_forward(gbmAllocations, sizeof(gbmAllocations));
+        if (fh < 0)
+            return -EMFILE;
+    }
+    else if (fh >= 0)
+    {
+        if (fh >= CFG_KNIX_MAX_FHS)
+            return -EMFILE;
+    }
+    else
+    {
+        LIBC_ASSERTM_FAILED("fh=%d\n", fh);
+        return -EINVAL;
+    }
+    __atomic_bit_set(gbmAllocations, fh);
+    pFH->fh = fh;
+    return 0;
+#endif  /* !CFG_KNIX_FH_NATIVE_ALLOCATION */
+}
 …
     pFH->fFlags     = 0;
     pFH->iLookAhead = 0;
+    pFH->fh         = -1;
+    pFH->hNative    = 0xdeadbeef;
     pFH->pOps       = NULL;
     pFH->Dev        = 0;
 …
+ *
  * @returns 0 on success.
  * @returns OS/2 error code on failure.
+ * @returns Negated errno on failure.
  * @param   cMin    Minimum number for the new max handle count.
  * @remark  Lock must be owned upon entry!
 …
 static int fhMoreHandles(unsigned cMin)
+{
+#if CFG_KNIX_FH_NATIVE_ALLOCATION
+# ifdef __OS2__
     int     rc;
     ULONG   cNewMaxFHs = gcFHs;
 …
      * How many handles?
      * Now, we must be somewhat sensibel about incrementing this number
      * into unreasonable values. If an application requires __LIBC_MAX_FHS+
+     * into unreasonable values. If an application requires CFG_KNIX_MAX_FHS+
      * files it must take steps to tell that to OS/2. If he has we'll receive
      * cMin > __LIBC_MAX_FHS, else keep __LIBC_MAX_FHS as a max limit for
+     * cMin > CFG_KNIX_MAX_FHS, else keep CFG_KNIX_MAX_FHS as a max limit for
      * auto increase.
      */
 …
     if (cMin < cNewMaxFHs)
     {   /* auto increment. */
         cMin = cNewMaxFHs + __LIBC_INC_FHS;
         if (cMin > __LIBC_MAX_FHS)
+        {
             if (gcFHs >= __LIBC_MAX_FHS)
+        cMin = cNewMaxFHs + CFG_KNIX_INC_FHS;
+        if (cMin > CFG_KNIX_MAX_FHS)
+        {
+            if (gcFHs >= CFG_KNIX_MAX_FHS)
+            {
                 FS_RESTORE();
                 return ERROR_TOO_MANY_OPEN_FILES;
+                return -EMFILE;
+            }
             cMin = __LIBC_MAX_FHS;
+            cMin = CFG_KNIX_MAX_FHS;
+        }
+    }
 …
             gcFHs = cNewMaxFHs;
+        }
+    }
+        else
+            rc = -ENOMEM;
+    }
+    if (rc > 0)
+        rc = -__libc_native2errno(rc);
     return rc;
+# endif /* __OS2__ */
+#else   /* !CFG_KNIX_FH_NATIVE_ALLOCATION */
+    /*
+     * We've got a fixed number of entries.
+     * Any ulimit restrictions are virtual (when implemented), the tables
+     * allocated at init time will be sized to contain the max handle count.
+     */
+    if (!cMin)
+    {
+        /* increment */
+        if (gcFHs >= CFG_KNIX_MAX_FHS)
+            return -EMFILE;
+        gcFHs = gcFHs + CFG_KNIX_INC_FHS < CFG_KNIX_MAX_FHS ? gcFHs + CFG_KNIX_INC_FHS : CFG_KNIX_MAX_FHS;
+    }
+    else
+    {
+        /* minimum fh. */
+        if (cMin > CFG_KNIX_MAX_FHS)
+            return -EMFILE;
+        if (gcFHs < cMin)
+            gcFHs = cMin;
+    }
+    return 0;
+#endif  /* !CFG_KNIX_FH_NATIVE_ALLOCATION */
+}
 …
+ *
  * @returns 0 on success.
  * @returns OS/2 error code on failure.
+ * @returns Negated errno on failure.
  * @param   fh      Filehandle which must fit.
  */
 …
     if (_fmutex_request(&gmtx, 0))
         return -1;
+        return -EDOOFUS;
     rc = fhMoreHandles(fh + 1);
 …
+ *
  * @returns 0 on success.
  * @returns -1 on failure.
+ * @returns Negated errno on failure.
  */
 int __libc_FHMoreHandles(void)
 …
     int rc;
     if (_fmutex_request(&gmtx, 0))
         return -1;
+        return -EDOOFUS;
     rc = fhMoreHandles(0);
 …
 /**
  * Allocates a file handle.
+ *
  * @returns 0 on success.
+ * @returns OS/2 error code and errno set to the corresponding error number.
+ * @returns Negated errno on failure.
+ * @param   pOps    Value of the pOps field.
  * @param   fh      Number of the filehandle to allocate.
  *                  Will fail if the handle is in use.
  *                  Use -1 for any handle.
+ * @param   hNative The native file handle.
  * @param   fFlags  Initial flags.
  * @param   cb      Size of the file handle.
+ *                  Must not be less than the mandatory size (sizeof(LIBCFH)).
+ * @param   pOps    Value of the pOps field, NULL not allowed.
+ *                  Must not be less than the mandatory size (sizeof(__LIBC_FH)).
  * @param   ppFH    Where to store the allocated file handle struct pointer. (NULL allowed)
- * @param   pfh     Where to store the number of the filehandle allocated.
  * @param   fOwnSem Set if we should not take or release the semaphore.
  * @remark  The preallocated handles make this function somewhat big and messy.
  */
+static int fhAllocate(int fh, unsigned fFlags, int cb, __LIBC_PCFHOPS pOps, __LIBC_PFH *ppFH, int *pfh, int fOwnSem)
+{
+    __LIBC_PFH  pFH;
+    int         rc;
+    FS_VAR();
+    /*
+     * If we know we cannot use the preallocated handles it's prefered to
+     * do the allocation outside the mutex.
+     */
+    pFH = NULL;
+    if (cb > sizeof(LIBCFH) || !gcPreAllocatedAvail)
+static int fhAllocate(int cb, __LIBC_PCFHOPS pOps, uintptr_t hNative, int fh, unsigned fFlags, int fOwnSem, __LIBC_PFH *ppFH)
+{
+    LIBC_ASSERT(cb >= sizeof(__LIBC_FH)); LIBC_ASSERT(pOps);
+    /*
+     * If we know we cannot use the preallocated handles, we will
+     * do the allocation without owning the lock.
+     */
+    __LIBC_PFH pFH = NULL;
+    if (cb != sizeof(__LIBC_FH) || !gcPreAllocatedAvail)
+    {
         pFH = _hmalloc(cb);
         if (!pFH)
             return ERROR_NOT_ENOUGH_MEMORY;
+    }
     /*
      * Now take the lock.
+            return -ENOMEM;
+    }
+    /*
+     * Aquire the lock if necessary.
      */
     if (!fOwnSem && _fmutex_request(&gmtx, 0))
         return -1;
     /*
      * Now is the time to try use the pre allocated handles.
+        return -EDOOFUS;
+    /*
+     * Do the allocation if we wanted to use preallocated handles.
      */
     if (!pFH)
+    {
         if (cb == sizeof(LIBCFH) && gcPreAllocatedAvail)
+        if (cb == sizeof(__LIBC_FH) && gcPreAllocatedAvail)
+        {
             __LIBC_PFH pFHSearch;
 …
         /*
          * If the pre allocated handle table for some reason was
          * full, we'll allocate the handle here.
+         * exhausted, we'll allocate the handle here.
          */
         if (!pFH)
 …
+    }
+    int rc;
     if (pFH)
+    {
 …
          * Initiate the handle data.
          */
+        pFH->fFlags     = fFlags;
         pFH->fFlags     = fFlags;
         if (fFlags & O_NOINHERIT)
             fFlags |= FD_CLOEXEC << __LIBC_FH_FDFLAGS_SHIFT;
         pFH->iLookAhead = -1;
+        pFH->fh         = fh;
+        pFH->hNative    = hNative;
         pFH->pOps       = pOps;
         pFH->Inode      = ++_sys_ino;
+        pFH->Inode      = ++__libc_back_gIno;
         if (!pFH->Inode)
             pFH->Inode  = ++_sys_ino;
+            pFH->Inode  = ++__libc_back_gIno;
         pFH->Dev        = 0;
         pFH->pFsInfo    = NULL;
 …
+        {
             /*
+             * Non OS/2 filehandle.
+             * Open dummy device to find a handle number.
+             * Find and reserve the next kNIX handle number.
              */
+            LIBC_ASSERTM(pOps, "cannot open a non-standard handle without giving pOps!\n");
+            rc = fhOpenDummy(-1, &fh);
+            rc = fhReserveHandle(pFH, -1);
             if (!rc)
+            {
+#if CFG_KNIX_FH_NATIVE_ALLOCATION
                 /*
+                 * Enough space in the handle table?
+                 * Free any old filehandle which death we didn't catch
+                 * and insert the new one.
                  */
+                if (fh >= gcFHs)
+                    rc = fhMoreHandles(fh + 1);
+                if (!rc)
+                {
+                    /*
+                     * Free any old filehandle which death we didn't catch
+                     * and insert the new one.
+                     */
+                    if (gpapFHs[fh])
+                        fhFreeHandle(gpapFHs[fh]);
+                    gpapFHs[fh] = pFH;
+                }
+                else
+                {
+                    /* failure: close dummy */
+                    FS_SAVE_LOAD();
+                    DosClose((HFILE)fh);
+                    FS_RESTORE();
+                    fh = -1;
+                }
+                if (gpapFHs[pFH->fh])
+                    fhFreeHandle(gpapFHs[pFH->fh]);
+#else
+                LIBC_ASSERT(!gpapFHs[pFH->fh]);
+#endif
+                gpapFHs[pFH->fh] = pFH;
+            }
+        }
 …
+        {
             /*
-             * Specific handle request.
              * Make sure there are enough file handles available.
              */
 …
             if (fh >= gcFHs)
                 rc = fhMoreHandles(fh + 1);
             if (!rc)
+            {
                 /*
                  * Send the close call to any non-OS/2 handle.
+                 * Close any existing handle (dup), except when the new one is identical to the one being replaced.
                  */
                 __LIBC_PFH  pFHOld = gpapFHs[fh];
+                __LIBC_PFH pFHOld = gpapFHs[fh];
                 if (    pFHOld
+                    &&  pFHOld->pOps
+                    &&  pFHOld->pOps->pfnClose)
+                    rc = pFHOld->pOps->pfnClose(pFHOld, fh);
+                    &&  (    pFHOld->hNative != pFH->hNative
+                         ||  pFHOld->pOps != pFH->pOps)
+                    &&  pFHOld->pOps->pfnClose
+                   )
+                {
+                    rc = pFHOld->pOps->pfnClose(pFHOld);
+                    if (rc == -EBADF)
+                        rc = 0;
+                }
                 if (!rc)
+                {
+                    /*
+                     * If not OS/2 filehandle, make a fake handle.
+                     */
+                    if (pOps)
+                        rc = fhOpenDummy(fh, &fh);
+                    if (pFHOld)
+                        fhFreeHandle(pFHOld);
+                    rc = fhReserveHandle(pFH, fh);
                     if (!rc)
+                    {
+                        /*
+                         * Free any old filehandle (replaced during dup2 or closed outside
+                         * this libc) and insert the new one.
+                         */
+                        if (pFHOld)
+                            fhFreeHandle(pFHOld);
+                        LIBC_ASSERT(pFH->fh == fh);
                         gpapFHs[fh] = pFH;
+                    }
 …
+    }
     else
         rc = ERROR_NOT_ENOUGH_MEMORY;
+        rc = -ENOMEM;
     /*
 …
     if (rc)
+    {
-        _sys_set_errno(rc);
         if (pFH)
             fhFreeHandle(pFH);
         pFH = NULL;
-        fh = -1;
+    }
 …
     if (ppFH)
         *ppFH = pFH;
-    if (pfh)
-        *pfh = fh;
     if (!fOwnSem)
 …
+ *
  * @returns 0 on success.
+ * @returns OS/2 error code and errno set to the corresponding error number.
+ * @param   fh      Number of the filehandle to allocate.
+ *                  Will fail if the handle is in use.
+ *                  Use -1 for any handle.
+ * @returns Negated errno on failure.
+ *
+ * @param   cb      Size of the file handle. Obviously, it can't be less that sizeof(__LIBC_FH).
+ * @param   pOps    The file handle operations.
+ * @param   hNative The natvie file handle.
+ * @param   fh      Number of the filehandle to allocate. Use -1 for any handle.
  * @param   fFlags  Initial flags.
- * @param   cb      Size of the file handle.
- *                  Must not be less than the mandatory size (sizeof(LIBCFH)).
- * @param   pOps    Value of the pOps field.
  * @param   ppFH    Where to store the allocated file handle struct pointer. (NULL allowed)
+ * @param   pfh     Where to store the number of the filehandle allocated.
+ * @remark  The preallocated handles make this function somewhat big and messy.
+ */
+int __libc_FHAllocate(int fh, unsigned fFlags, int cb, __LIBC_PCFHOPS pOps, __LIBC_PFH *ppFH, int *pfh)
+{
+    return fhAllocate(fh, fFlags, cb, pOps, ppFH, pfh, 0);
+}
+/**
+ * Close (i.e. free) a file handle.
+ *
+ * @returns 0 on success.
+ * @returns OS/2 error code on failure and errno set to corresponding error number.
+ * @param   fh      Filehandle to close.
+ */
+int __libc_FHClose(int fh)
+{
+    LIBCLOG_ENTER("fh=%d\n", fh);
+    __LIBC_PFH  pFH;
+    int         rc;
+    FS_VAR();
+ */
+int __libc_FHAllocate(int cb, __LIBC_PCFHOPS pOps, uintptr_t hNative, int fh, unsigned fFlags, __LIBC_PFH *ppFH)
+{
+    return fhAllocate(cb, pOps, hNative, fh, fFlags, 0, ppFH);
+}
+/**
+ * Frees a file handle.
+ *
+ * The caller is responsible for any necessary closing of the handle and that the handle is
+ * locked (__libc_FHGet/FHAllocate).
+ *
+ * @param   pFH     The handle.
+ */
+void __libc_FHFree(__LIBC_PFH pFH)
+{
+    LIBCLOG_ENTER("pFH=%p:{.fh=%d}\n", pFH, pFH->fh);
     if (_fmutex_request(&gmtx, 0))
+        LIBCLOG_ERROR_RETURN(-1, "ret -1 - fh=%d is not opened according to our table!\n", fh);
+    /*
+     * Validate input.
+     */
+    if (!fhGet(fh))
+    {
+        _fmutex_release(&gmtx);
+        errno = EBADF;
+        LIBCLOG_ERROR_RETURN(-1, "ret -1 - fh=%d is not opened according to our table!\n", fh);
+    }
+    pFH = gpapFHs[fh];
+    /*
+     * If this is an non OS/2 handle, let the subsystem clean it up first.
+     */
+    rc = 0;
+    if (pFH->pOps && pFH->pOps->pfnClose)
+        rc = pFH->pOps->pfnClose(pFH, fh);
+    /*
+     * We should continue closing the OS/2 handle if the previuos step
+     * were successful or if the handle has become invalid.
+     */
+    if (    !rc
+        ||  rc == ERROR_INVALID_HANDLE
+        ||  rc == -EBADF
+        ||  rc == -ENOTSOCK)
+    {
+        int rc2;
+        LIBCLOG_ERROR_RETURN_VOID();
+    if (    pFH->fh >= 0
+        &&  pFH->fh < gcFHs
+       )
+    {
+        LIBC_ASSERT(gpapFHs[pFH->fh] == pFH);
+#if CFG_KNIX_FH_NATIVE_ALLOCATION
+# ifdef __OS2__
         /*
          * Close the OS/2 handle and remove the handle from the array
          * making the space available to others.
+         * - This ain't the way which scales best, but it's the safe way.
+         */
+        FS_SAVE_LOAD();
+        rc2 = DosClose(fh);
+         */
+        FS_VAR_SAVE_LOAD();
+        rc2 = DosClose(pFH->fh);
         FS_RESTORE();
         LIBC_ASSERTM(!rc2, "DosClose(%d) -> rc2=%d (rc=%d)\n", fh, rc2, rc);
+        if (!pFH->pOps)
             rc = rc2;
+        /*
+         * If we successfully freed the handle, or it had become invalid
+         * we will free it now.
+         */
         if (    !rc2
             ||  rc2 == ERROR_INVALID_HANDLE
             ||  pFH->pOps)
+        {
+            gpapFHs[fh] = NULL;
             fhFreeHandle(pFH);
+        }
+    }
+        LIBC_ASSERTM(!rc2, "DosClose(%d) -> rc2=%d (rc=%d)\n", pFH->fh, rc2, rc);
+        gpapFHs[pFH->fh] = NULL;
+        fhFreeHandle(pFH);
+# endif /* __OS2__ */
+#else  /* !CFG_KNIX_FH_NATIVE_ALLOCATION */
+        __atomic_bit_clear(gbmAllocations, pFH->fh);
+        gpapFHs[pFH->fh] = NULL;
+        fhFreeHandle(pFH);
+#endif /* !CFG_KNIX_FH_NATIVE_ALLOCATION */
+    }
+    else
+        LIBC_ASSERT(pFH->fh >= 0 && pFH->fh < gcFHs);
     _fmutex_release(&gmtx);
+    if (!rc)
+        LIBCLOG_RETURN_INT(0);
+    if (rc > 0)
+        _sys_set_errno(rc);
+    else
+        errno = -rc;
+    LIBCLOG_ERROR_RETURN_INT(rc);
+}
+/**
+ * Get the LIBC handle structure corresponding to a filehandle.
+ *
+ * @returns Pointer to handle structure on success.
+ * @returns NULL on failure.
+ * @param   fh  Handle to lookup.
+    LIBCLOG_RETURN_VOID();
+}
+/**
+ * Import a normal file handle.
+ *
+ * Caller must own the file handle mutex.
+ *
+ * @returns 0 on success.
+ * @returns Negated errno on failure.
+ *
+ * @param   hNative The native file handle.
+ * @param   fh      The kNIX file handle.
+ * @param   ppFH    Where to store the file handle structure. (Must be release with __libc_FHPut().)
+ *
  * @remark  Must own the mutex.
+ * @internal
+ */
+static __LIBC_PFH fhGet(int fh)
+{
+    __LIBC_PFH pFH = NULL;
+ */
+static int fhImportFile(uintptr_t hNative, int fh, __LIBC_PFH *ppFH)
+{
+#ifdef __OS2__
+    if (hNative != fh)
+        return -EINVAL;
     /*
 …
      * Validate file handle range.
      */
+    if (fh >= 0 && fh < gcFHs)
+    {
+        pFH = gpapFHs[fh];
+        if (!pFH)
+        {
+            /*
+             * Try import the handle.
+             */
+            ULONG       rc;
+            ULONG       fulType;
+            ULONG       fulDevFlags;
+            ULONG       fulMode;
+            unsigned    fLibc;
+            dev_t       Dev = 0;
+            /*
+             * Is it in use and if so what kind of handle?
+             */
+            if (    (rc = DosQueryHType((HFILE)fh, &fulType, &fulDevFlags)) != NO_ERROR
+                ||  (rc = DosQueryFHState((HFILE)fh, &fulMode)) != NO_ERROR)
+            {
+                errno = EBADF;
+                return NULL;
+            }
+            /*
+             * Determin initial flags.
+             */
+            switch (fulType & 0xff)
+            {
+                default: /* paranoia */
+                case HANDTYPE_FILE:
+                    fLibc = F_FILE;
+                    break;
+                case HANDTYPE_DEVICE:
+                    fLibc = F_DEV;
+                    /* @todo inherit O_NDELAY */
+                    if (!(fulDevFlags & 0xf))
+                        Dev = makedev('c', 0);
+                    else if (fulDevFlags & 1 /*KBD*/)
+                        Dev = makedev('c', 1);
+                    else if (fulDevFlags & 2 /*SCR*/)
+                        Dev = makedev('c', 2);
+                    else if (fulDevFlags & 4 /*NUL*/)
+                        Dev = makedev('c', 4);
+                    else /*if (fulDevFlags & 8 / *CLK* /)*/
+                        Dev = makedev('c', 8);
+                    break;
+                case HANDTYPE_PIPE:
+                    fLibc = F_PIPE;
+                    Dev = makedev('p', 0);
+                    break;
+            }
+            /*
+             * Read write flags.
+             */
+            switch (fulMode & (OPEN_ACCESS_READONLY | OPEN_ACCESS_WRITEONLY | OPEN_ACCESS_READWRITE))
+            {
+                case OPEN_ACCESS_READONLY:      fLibc |= O_RDONLY; break;
+                case OPEN_ACCESS_WRITEONLY:     fLibc |= O_WRONLY; break;
+                default: /* paranoia */
+                case OPEN_ACCESS_READWRITE:     fLibc |= O_RDWR; break;
+            }
+            /*
+             * Inherit flags.
+             */
+            if (fulMode & OPEN_FLAGS_NOINHERIT)
+                fLibc |= O_NOINHERIT | (FD_CLOEXEC << __LIBC_FH_FDFLAGS_SHIFT);
+            /*
+             * Textflag.
+             */
+            if (!_fmode_bin)
+                fLibc |= O_TEXT;
+            /*
+             * Allocate a new handle for this filehandle.
+             */
+            rc = fhAllocate(fh, fLibc, sizeof(LIBCFH), NULL, &pFH, NULL, 1);
+            if (!rc)
+                pFH->Dev = Dev;
+            else
+                pFH = NULL;
+    if (fh < 0 && fh >= gcFHs)
+        return -EBADF;
+    __LIBC_PFH pFH = gpapFHs[fh];
+    if (!pFH)
+    {
+        /*
+         * Try import the handle.
+         */
+        ULONG       rc;
+        ULONG       fulType;
+        ULONG       fulDevFlags;
+        ULONG       fulMode;
+        unsigned    fLibc;
+        dev_t       Dev = 0;
+        /*
+         * Is it in use and if so what kind of handle?
+         */
+        if (    (rc = DosQueryHType((HFILE)fh, &fulType, &fulDevFlags)) != NO_ERROR
+            ||  (rc = DosQueryFHState((HFILE)fh, &fulMode)) != NO_ERROR)
+            return -EBADF;
+        /*
+         * Determin initial flags.
+         */
+        switch (fulType & 0xff)
+        {
+            default: /* paranoia */
+            case HANDTYPE_FILE:
+                fLibc = F_FILE;
+                break;
+            case HANDTYPE_DEVICE:
+                fLibc = F_DEV;
+                /* @todo inherit O_NDELAY */
+                if (!(fulDevFlags & 0xf))
+                    Dev = makedev('c', 0);
+                else if (fulDevFlags & 1 /*KBD*/)
+                    Dev = makedev('c', 1);
+                else if (fulDevFlags & 2 /*SCR*/)
+                    Dev = makedev('c', 2);
+                else if (fulDevFlags & 4 /*NUL*/)
+                    Dev = makedev('c', 4);
+                else /*if (fulDevFlags & 8 / *CLK* /)*/
+                    Dev = makedev('c', 8);
+                break;
+            case HANDTYPE_PIPE:
+                fLibc = F_PIPE;
+                Dev = makedev('p', 0);
+                break;
+        }
+    }
+    else /* out of range: can't possibly be open. */
+        errno = EBADF;
+    return pFH;
+}
+/**
+ * Get the LIBC handle structure corresponding to a filehandle.
+ *
+ * @returns Pointer to handle structure on success.
+ * @returns NULL on failure.
+ * @param   fh  Handle to lookup.
+ * @deprecated
+ */
+__LIBC_PFH __libc_FH(int fh)
+{
+    __LIBC_PFH pFH;
+    /** @todo shared access */
+    if (_fmutex_request(&gmtx, 0))
+        return NULL;
+    pFH = fhGet(fh);
+        /*
+         * Read write flags.
+         */
+        switch (fulMode & (OPEN_ACCESS_READONLY | OPEN_ACCESS_WRITEONLY | OPEN_ACCESS_READWRITE))
+        {
+            case OPEN_ACCESS_READONLY:      fLibc |= O_RDONLY; break;
+            case OPEN_ACCESS_WRITEONLY:     fLibc |= O_WRONLY; break;
+            default: /* paranoia */
+            case OPEN_ACCESS_READWRITE:     fLibc |= O_RDWR; break;
+        }
+        /*
+         * Inherit flags.
+         */
+        if (fulMode & OPEN_FLAGS_NOINHERIT)
+            fLibc |= O_NOINHERIT | (FD_CLOEXEC << __LIBC_FH_FDFLAGS_SHIFT);
+        /*
+         * Textflag.
+         */
+        if (!_fmode_bin)
+            fLibc |= O_TEXT;
+        /*
+         * Allocate a new handle for this filehandle.
+         */
+        rc = fhAllocate(sizeof(__LIBC_FH), &__libc_back_gFileOps, hNative, fh, fLibc, 1, &pFH);
+        if (rc)
+            return rc;
+        pFH->Dev = Dev;
+    }
+    *ppFH = pFH;
+    return 0;
+#else   /* !__OS2__ */
+    return -EBADF;
+#endif  /* !__OS2__ */
+}
+/**
+ * Import a normal file handle.
+ *
+ * @returns 0 on success.
+ * @returns Negated errno on failure.
+ *
+ * @param   hNative The native file handle.
+ * @param   fh      The kNIX file handle.
+ * @param   ppFH    Where to store the file handle structure. (Must be release with __libc_FHPut().)
+ */
+int __libc_FHImportFile(uintptr_t hNative, int fh, __LIBC_PFH *ppFH)
+{
+    LIBCLOG_ENTER("hNative=%p fh=%d ppFH=%p\n", hNative, fh, ppFH);
+    int rc = _fmutex_request(&gmtx, 0);
+    if (rc)
+        LIBCLOG_ERROR_RETURN_INT(-EDOOFUS);
+    rc = fhImportFile(hNative, fh, ppFH);
     _fmutex_release(&gmtx);
+    return pFH;
+}
+/**
+ * Get the LIBC handle structure corresponding to a filehandle.
+ *
+ * @returns Pointer to handle structure on success.
+    if (!rc)
+        LIBCLOG_RETURN_MSG(rc, "ret %d *ppFH=%p\n", rc, *ppFH);
+    LIBCLOG_ERROR_RETURN_INT(rc);
+}
+/**
+ * Get the locked LIBC handle structure corresponding to a file handle.
+ *
+ * The caller must call __libc_FHPut() or __libc_FHFree() to release the file handler structure.
+ *
+ * @returns 0 on success and *ppFH pointing to the file handle structure.
  * @returns Negative error code (errno.h) on failure.
  * @param   fh      Handle to lookup.
+ * @param   ppFH    Where to store the filehandle pointer
+ */
+int __libc_FHEx(int fh, __LIBC_PFH *ppFH)
+{
+    __LIBC_PFH pFH;
+    /** @todo shared access */
+ * @param   ppFH    Where to store the file handle pointer
+ */
+int __libc_FHGet(int fh, __LIBC_PFH *ppFH)
+{
     int rc = _fmutex_request(&gmtx, 0);
     if (rc)
+        return -__libc_native2errno(rc);
+    /** @todo rewrite fhGet() to avoid this errno saving and restoring. */
+    int errno_saved = errno;
+    pFH = fhGet(fh);
+    rc = -errno;
+    errno = errno_saved;
+        return -EDOOFUS;
+#if CFG_KNIX_FH_NATIVE_ALLOCATION
+    /*
+     * Someone might have opened this externally after
+     * growing the filehandle range.
+     */
+    if (fh >= gcFHs && fh < 0x10000)
+    {
+# ifdef __OS2__
+        LONG    lDelta = 0;
+        ULONG   cCur = 0;
+        if (!DosSetRelMaxFH(&lDelta, &cCur))
+            cCur = gcFHs;
+        if (gcFHs != cCur)
+            fhMoreHandles(cCur);
+# else  /* !__OS2__ */
+        fhMoreHandles(fh + 1);
+# endif /* !__OS2__ */
+    }
+#endif  /* CFG_KNIX_FH_NATIVE_ALLOCATION */
+    /*
+     * Look it up in the file handle table.
+     * On platforms with native allocation we can try import the handle if we don't find it.
+     */
+    __LIBC_PFH pFH = NULL;
+    if (fh >= 0 && fh < gcFHs)
+    {
+        pFH = gpapFHs[fh];
+#if CFG_KNIX_FH_NATIVE_ALLOCATION
+        if (!pFH)
+            rc = fhImportFile(fh, fh, &pFH);
+#endif
+        if (!pFH)
+            rc = -EBADF;
+    }
+    else
+        rc = -EBADF;
     _fmutex_release(&gmtx);
+    *ppFH = pFH;
+    return rc;
+}
+/**
+ * Releases a locked LIBC handle structure.
+ * The caller obtained the handle using __libc_FHGet() or __libc_FHAllocate().
+ *
+ * @param   pFH     Pointer to the handle structure. NULL is allowed.
+ */
+void __libc_FHPut(__LIBC_PFH pFH)
+{
     if (pFH)
+    {
+        *ppFH = pFH;
+        return 0;
+    }
+    return rc;
+        /* we're not locking anything - yet. */
+        (void)pFH;
+    }
+}
 …
  * the __LIBC_FH structure. It will not call any FH operators, since
  * it assumes that the caller takes care of such things.
+ *
+ * The caller must own the FH structure. This function will not call __libc_FHPut() for you.
+ *
  * @returns 0 on success.
 …
  * @param   fFlags  The new flags.
  */
+int __libc_FHSetFlags(__LIBC_PFH pFH, int fh, unsigned fFlags)
+{
+    LIBCLOG_ENTER("pFH=%p fh=%d fFlags=%#x\n", (void *)pFH, fh, fFlags);
+    int     rc;
+    ULONG   fulState;
+    FS_VAR();
+int __libc_FHSetFlags(__LIBC_PFH pFH, unsigned fFlags)
+{
+    LIBCLOG_ENTER("pFH=%p fFlags=%#x\n", (void *)pFH, fh, fFlags);
     LIBC_ASSERT(((fFlags & O_NOINHERIT) != 0) == ((fFlags & (FD_CLOEXEC << __LIBC_FH_FDFLAGS_SHIFT)) != 0));
+    FS_SAVE_LOAD();
+    rc = DosQueryFHState(fh, &fulState);
+#if CFG_KNIX_FH_NATIVE_ALLOCATION
+# ifdef __OS2__
+    FS_VAR_SAVE_LOAD();
+    ULONG fulState;
+    int rc = DosQueryFHState(fh, &fulState);
     if (!rc)
+    {
 …
     rc = -__libc_native2errno(rc);
     LIBCLOG_ERROR_RETURN_INT(rc);
+}
+# else  /* !__OS2__ */
+#  error "Port me!"
+# endif /* !__OS2__ */
+#else   /* !CFG_KNIX_FH_NATIVE_ALLOCATION */
+    /*
+     * This API isn't so helpful here. At least not yet.
+     * Just make sure the duplicate flags match up and update atomically.
+     */
+    if (fFlags & (FD_CLOEXEC << __LIBC_FH_FDFLAGS_SHIFT))
+        fFlags |= O_NOINHERIT;
+    else
+        fFlags &= ~O_NOINHERIT;
+    __atomic_xchg(&pFH->fFlags, fFlags);
+    LIBCLOG_RETURN_INT(0);
+#endif  /* !CFG_KNIX_FH_NATIVE_ALLOCATION*/
+}
+#ifdef __OS2__
 #undef  __LIBC_LOG_GROUP
 …
+}
+#endif /* __OS2__ */

trunk/libc/src/kNIX/heap.c

-              r2738
+              r2739
+/* sys/heap.c (emx+gcc) -- Copyright (c) 1996 by Eberhard Mattes */
+#include "libc-alias.h"
+#define INCL_DOSERRORS
+#define INCL_FSMACROS
+#define INCL_EXAPIS
+#include <os2emx.h>
+/* $Id: $ */
+/** @file
+ *
+ * kNIX - sbrk/brk heap.
+ *
+ * Copyright (c) 1996 by Eberhard Mattes
+ * Copyright (c) 2006 knut st. osmundsen <bird-srcspam@anduin.net>
+ *
+ *
+ * This file is part of kLIBC.
+ *
+ * kLIBC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * kLIBC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with kLIBC; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+/*******************************************************************************
+*   Header Files                                                               *
+*******************************************************************************/
+#define  __LIBC_LOG_GROUP __LIBC_LOG_GRP_HEAP
+#include "kNIX.h"
+#ifdef __OS2__
+# define INCL_DOSERRORS
+# define INCL_FSMACROS
+# define INCL_EXAPIS
+# include <os2emx.h>
+#endif
+#ifdef __NT__
+# include <klibc/nt/nt.h>
+#endif
 #include <errno.h>
+#include <sys/uflags.h>
+#include <emx/syscalls.h>
+#include "syscalls.h"
+#define  __LIBC_LOG_GROUP __LIBC_LOG_GRP_HEAP
+#include <InnoTekLIBC/logstrict.h>
+/* Allocate a memory object of SIZE bytes which is not located below
+   MIN_ADDR.  Return the address of the memory object.  Return 0 on
+   error. */
+static ULONG alloc_above (ULONG size, ULONG min_addr)
+{
+  ULONG ret;
+  void *p;
+  FS_VAR();
+  FS_SAVE_LOAD();
+  if (DosAllocMemEx (&p, size, PAG_READ | PAG_WRITE | OBJ_FORK) != 0)
+    {
+      FS_RESTORE();
+      return 0;
+    }
+  if ((ULONG)p > min_addr)
+    {
+      FS_RESTORE();
+      return (ULONG)p;
+    }
+  /* The memory object is located below MIN_ADDR.  Recurse until we
+     get an appropriate object or until we run out of memory. */
+  ret = alloc_above (size, min_addr);
+  /* We got a suitable object.  Free the bad one. */
+  DosFreeMemEx (p);
+  FS_RESTORE();
+  return ret;
+}
+/* Expand the top heap object by INCR bytes.  INCR is a positive
+   number.  Return the previous break address or 0 (error). */
+ULONG _sys_expand_heap_obj_by (ULONG incr)
+{
+  LIBCLOG_ENTER("incr=%ld\n", incr);
+  ULONG rc, old_brk, new_brk, addr, size, rest;
+  old_brk = _sys_top_heap_obj->brk;
+  new_brk = old_brk + incr;
+  if (new_brk < _sys_top_heap_obj->base || new_brk > _sys_top_heap_obj->end)
+    LIBCLOG_RETURN_ULONG(0UL);
+  addr = old_brk;
+  size = incr;
+  if (addr & 0xfff)
+    {
+      rest = 0x1000 - (addr & 0xfff);
+      if (rest >= size)
+        size = 0;
+      else
+#include <klibc/backend.h>
+#include <klibc/logstrict.h>
+/**
+ * Wrapper around the OS api for freeing an object.
+ */
+static __inline__ void heapFreeObj(uintptr_t ObjPtr)
+{
+#ifdef __OS2__
+    FS_VAR_SAVE_LOAD();
+    int rc = DosFreeMemEx((void *)ObjPtr);
+    LIBC_ASSERTM(!rc, ("ObjPtr=%p rc=%d\n", ObjPtr, rc);
+    FS_RESTORE();
+#elif defined(__NT__)
+    PVOID pv = (void *)ObjPtr;
+    NTSTATUS rc = NtFreeVirtualMemory(NtCurrentProcess(),   /* ProcessHandle */
+                                      &pv,                  /* BaseAddress */
+                                      NULL,                 /* FreeSize */
+                                      MEM_RELEASE);         /* FreeType */
+    LIBC_ASSERTM(NT_SUCCESS(rc), "ObjPtr=%p rc=%x\n", ObjPtr, rc);
+#else
+# error "Port me!"
+#endif
+}
+/**
+ * Allocate a memory object of SIZE bytes which is not located below
+ * MIN_ADDR.
+ *
+ * @returns The address of the memory object.
+ * @returns Return 0 on error.
+ */
+static uintptr_t heapAllocObjAbove(uintptr_t size, uintptr_t min_addr)
+{
+    void *pv = NULL;
+#ifdef __OS2__
+    FS_VAR_SAVE_LOAD();
+    int rc = DosAllocMemEx(&p, size, PAG_READ | PAG_WRITE | OBJ_FORK);
+    FS_RESTORE();
+    if (rc)
+        return 0;
+#elif defined(__NT__)
+    ULONG cb = size;
+    NTSTATUS rc = NtAllocateVirtualMemory(NtCurrentProcess(),   /* ProcessHandle */
+                                          &pv,                  /* BaseAddress (In/Out) */
+,                    /* ZeroBits */
+                                          &cb,                  /* AllocationSize */
+                                          MEM_RESERVE,          /* AllocationType */
+                                          PAGE_READWRITE);      /* Protect */
+    if (!NT_SUCCESS(rc))
+        return 0;
+#else
+# error "Port me!"
+#endif
+    if ((uintptr_t)pv > min_addr)
+        return (uintptr_t)pv;
+    /*
+     * The memory object is located below MIN_ADDR.  Recurse until we
+     * get an appropriate object or until we run out of memory.
+     */
+    uintptr_t ret = heapAllocObjAbove(size, min_addr);
+    /* We got a suitable object. Free the bad one. */
+    heapFreeObj((uintptr_t)pv);
+    return ret;
+}
+/**
+ * Wrapper around the OS api for committing memory.
+ */
+static __inline__ int heapCommitObj(uintptr_t addr, uintptr_t size)
+{
+#ifdef __OS2__
+    FS_VAR_SAVE_LOAD();
+    rc = DosSetMem((void *)addr, size, PAG_DEFAULT | PAG_COMMIT);
+    FS_RESTORE();
+    return !rc ? 0 : -EINVAL;
+#elif defined(__NT__)
+    ULONG cb = size;
+    PVOID pv = (void *)addr;
+    NTSTATUS rc = NtAllocateVirtualMemory(NtCurrentProcess(),   /* ProcessHandle */
+                                          &pv,                  /* BaseAddress (In/Out) */
+,                    /* ZeroBits */
+                                          &cb,                  /* AllocationSize */
+                                          MEM_COMMIT,           /* AllocationType */
+                                          PAGE_READWRITE);      /* Protect */
+    return NT_SUCCESS(rc) ? 0 : -EINVAL;
+#else
+# error "Port me!"
+#endif
+}
+/**
+ * Wrapper around the OS api for decommitting memory.
+ */
+static __inline__ int heapDecommitObj(uintptr_t addr, uintptr_t size)
+{
+#ifdef __OS2__
+    FS_VAR_SAVE_LOAD();
+    rc = DosSetMem((void *)addr, size, PAG_DECOMMIT);
+    FS_RESTORE();
+    return !rc ? 0 : -EINVAL;
+#elif defined(__NT__)
+    ULONG cb = size;
+    PVOID pv = (void *)addr;
+    NTSTATUS rc = NtFreeVirtualMemory(NtCurrentProcess(),   /* ProcessHandle */
+                                      &pv,                  /* BaseAddress */
+                                      &cb,                  /* FreeSize */
+                                      MEM_DECOMMIT);        /* FreeType */
+    return NT_SUCCESS(rc) ? 0 : -EINVAL;
+#else
+# error "Port me!"
+#endif
+}
+/**
+ * Expand the top heap object by INCR bytes. INCR is a positive number.
+ * Return the previous break address or 0 (error).
+ */
+void *__libc_back_heapExpandObjBy(uintptr_t incr)
+{
+    LIBCLOG_ENTER("incr=%p\n", (void *)incr);
+    const uintptr_t old_brk = __libc_back_gpHeapTopObj->brk;
+    const uintptr_t new_brk = old_brk + incr;
+    if (    new_brk < __libc_back_gpHeapTopObj->base
+        ||  new_brk > __libc_back_gpHeapTopObj->end)
+        LIBCLOG_ERROR_RETURN_P(NULL);
+    uintptr_t addr = old_brk;
+    uintptr_t size = incr;
+    if (addr & 0xfff)
+    {
+        uintptr_t rest = 0x1000 - (addr & 0xfff);
+        if (rest >= size)
+            size = 0;
+        else
+        {
           size -= rest;
           addr += rest;
+            size -= rest;
+            addr += rest;
+        }
+    }
+  if (size != 0)
+    {
+      FS_VAR();
+      FS_SAVE_LOAD();
+      rc = DosSetMem ((void *)addr, size, PAG_DEFAULT | PAG_COMMIT);
+      FS_RESTORE();
+      if (rc != 0)
+        LIBCLOG_RETURN_ULONG(0UL);
+    }
+  _sys_top_heap_obj->brk = new_brk;
+  LIBCLOG_RETURN_ULONG(old_brk);
+}
+/* Shrink the top heap object by DECR bytes.  DECR is a positive
+   number.  Return the previous break address or 0 (error). */
+ULONG _sys_shrink_heap_obj_by (ULONG decr)
+{
+  LIBCLOG_ENTER("decr=%ld\n", decr);
+  ULONG rc, old_brk, new_brk, addr, high;
+  old_brk = _sys_top_heap_obj->brk;
+  new_brk = old_brk - decr;
+  if (new_brk < _sys_top_heap_obj->base || new_brk > _sys_top_heap_obj->end)
+    LIBCLOG_RETURN_ULONG(0UL);
+  addr = (new_brk + 0xfff) & ~0xfff;
+  high = (_sys_top_heap_obj->brk + 0xfff) & ~0xfff;
+  if (high > addr)
+    {
+      FS_VAR();
+      FS_SAVE_LOAD();
+      rc = DosSetMem ((void *)addr, high - addr, PAG_DECOMMIT);
+      FS_RESTORE();
+      if (rc != 0)
+        LIBCLOG_RETURN_ULONG(0UL);
+    }
+  _sys_top_heap_obj->brk = new_brk;
+  LIBCLOG_RETURN_ULONG(old_brk);
+}
+/* Expand the heap by INCR bytes.  INCR is a positive number.  Return
+   the base address of the expansion or 0 (error). */
+ULONG _sys_expand_heap_by (ULONG incr, ULONG sbrk_model)
+{
+  LIBCLOG_ENTER("incr=%ld sbrk_model=%ld\n", incr, sbrk_model);
+  unsigned old_obj_count;
+  ULONG base, size;
+  old_obj_count = _sys_heap_obj_count;
+  /* Allocate the first object if not yet done. */
+  if (_sys_heap_obj_count == 0)
+    {
+      size = _sys_heap_size;
+      if (incr > size)
+        size = (incr + 0xffff) & ~0xffff;
+      base = alloc_above (size, 0);
+      if (base == 0)
+    if (size != 0)
+    {
+        if (heapCommitObj(addr, size) != 0)
+            LIBCLOG_ERROR_RETURN_P(NULL);
+    }
+    __libc_back_gpHeapTopObj->brk = new_brk;
+    LIBCLOG_RETURN_P((void *)old_brk);
+}
+/**
+ * Shrink the top heap object by DECR bytes. DECR is a positive number.
+ * Return the previous break address or 0 (error).
+ */
+void *__libc_back_heapShrinkObjBy(uintptr_t decr)
+{
+    LIBCLOG_ENTER("decr=%p\n", (void *)decr);
+    const uintptr_t old_brk = __libc_back_gpHeapTopObj->brk;
+    const uintptr_t new_brk = old_brk - decr;
+    if (    new_brk < __libc_back_gpHeapTopObj->base
+        ||  new_brk > __libc_back_gpHeapTopObj->end)
+        LIBCLOG_ERROR_RETURN_P(NULL);
+    const uintptr_t addr = (new_brk + 0xfff) & ~(uintptr_t)0xfff;
+    const uintptr_t high = (__libc_back_gpHeapTopObj->brk + 0xfff) & ~(uintptr_t)0xfff;
+    if (high > addr)
+    {
+        if (heapDecommitObj(addr, high - addr) != 0)
+            LIBCLOG_ERROR_RETURN_P(NULL);
+    }
+    __libc_back_gpHeapTopObj->brk = new_brk;
+    LIBCLOG_RETURN_P((void *)old_brk);
+}
+/**
+ * Expand the heap by INCR bytes. INCR is a positive number.
+ * Return the base address of the expansion or 0 (error).
+ */
+void *__libc_back_heapExpandBy(uintptr_t incr, __LIBCSBRKMODEL enmSBrkModel)
+{
+    LIBCLOG_ENTER("incr=%p enmSBrkModel=%d\n", incr, enmSBrkModel);
+    const unsigned old_obj_count = __libc_back_gcHeapObjs;
+    /*
+     *Allocate the first object if not yet done.
+     */
+    if (__libc_back_gcHeapObjs == 0)
+    {
+        uintptr_t size = __libc_back_gcbHeap;
+        if (incr > size)
+            size = (incr + 0xffff) & ~(uintptr_t)0xffff;
+        uintptr_t base = heapAllocObjAbove(size, 0);
+        if (base == 0)
+            LIBCLOG_ERROR_RETURN_P(NULL);
+        __libc_back_gaHeapObjs[0].base = base;
+        __libc_back_gaHeapObjs[0].brk = base;
+        __libc_back_gaHeapObjs[0].end = base + size;
+        __libc_back_gcHeapObjs = 1;
+        __libc_back_gpHeapTopObj = &__libc_back_gaHeapObjs[0];
+    }
+    /*
+     * Now we have at least one heap object. Check for arithmetic
+     * overflow.
+     */
+    if (__libc_back_gpHeapTopObj->brk + incr < __libc_back_gpHeapTopObj->base)
+    {
+        /*
+         * Overflow. If we've just allocated the first heap object,
+         * deallocate it again unless memory must be allocated contiguously.
+         */
+        if (    old_obj_count == 0
+            &&  enmSBrkModel != __LIBC_SBRK_MODEL_CONTIGUOUS)
+        {
+            heapFreeObj(__libc_back_gaHeapObjs[0].base);
+            __libc_back_gcHeapObjs = 0;
+            __libc_back_gpHeapTopObj = NULL;
+        }
+        LIBCLOG_ERROR_RETURN_P(NULL);
+    }
+    /*
+     * Check whether we need another heap object. Allocate one if we
+     * need one and are allowed to allocate one. This should not happen
+     * if we just allocated the first one above.
+     */
+    if (__libc_back_gpHeapTopObj->brk + incr > __libc_back_gpHeapTopObj->end)
+    {
+        /*
+         * We need another heap object. Fail if we are not allowed to
+         * allocate non-contiguous memory or if we already have the
+         * maximum number of heap objects.
+         */
+        if (    enmSBrkModel == __LIBC_SBRK_MODEL_CONTIGUOUS
+            ||  __libc_back_gcHeapObjs >= CFG_KNIX_MAX_HEAP_OBJS)
+            LIBCLOG_ERROR_RETURN_P(NULL);
+        /*
+         * Allocate at least __libc_back_gcbHeap bytes. The new object must
+         * be located above the currently top one.
+         */
+        uintptr_t size = __libc_back_gcbHeap;
+        if (incr > size)
+            size = (incr + 0xffff) & ~(uintptr_t)0xffff;
+        uintptr_t base;
+        for (;;)
+        {
+            if (enmSBrkModel == __LIBC_SBRK_MODEL_ARBITRARY)
+                base = heapAllocObjAbove(size, 0);
+            else
+                base = heapAllocObjAbove(size, __libc_back_gpHeapTopObj->end);
+            if (base != 0)
+                break;
+            /*
+             * If we're out of virtual address space, halve the size and
+             * try again until allocation succeeds. Of course, don't
+             * attempt to allocate less than INCR bytes.
+             */
+            size /= 2;
+            if (size < incr)
+                LIBCLOG_ERROR_RETURN_P(NULL);
+        }
+        __libc_back_gpHeapTopObj = &__libc_back_gaHeapObjs[__libc_back_gcHeapObjs++];
+        __libc_back_gpHeapTopObj->base = base;
+        __libc_back_gpHeapTopObj->brk = base;
+        __libc_back_gpHeapTopObj->end = base + size;
+    }
+    /*
+     * Now __libc_back_gpHeapTopObj points to an object which has enough
+     * space. Commit memory as required.  _sys_expand_heap_obj() returns
+     * the top object's break address, which is the base address of the
+     * expansion as an object might have been added.
+     */
+    void *pRet = __libc_back_heapExpandObjBy(incr);
+    if (pRet)
+        LIBCLOG_RETURN_P(pRet);
+    LIBCLOG_ERROR_RETURN_P(pRet);
+}
+/**
+ * Shrink the heap to the new break address NEW_BRK.
+ * Return the previous break address or 0 (error).
+ */
+void *__libc_back_heapShrinkTo(uintptr_t new_brk)
+{
+    LIBCLOG_ENTER("new_brk=%ld\n", new_brk);
+    /*
+     * Find the heap object containing the new break address.  Fail if
+     * there is no such heap object.  Note that the new break address
+     * must not be beyond the heap object current break address, that
+     * is, we cannot shrink the heap (by deallocating objects) and grow
+     * a heap object in one step.
+     */
+    unsigned iObj;
+    for (iObj = 0; iObj < __libc_back_gcHeapObjs; ++iObj)
+        if (    __libc_back_gaHeapObjs[iObj].base <= new_brk
+            &&  __libc_back_gaHeapObjs[iObj].brk >= new_brk)
+            break;
+    if (iObj >= __libc_back_gcHeapObjs)
         return 0;
+      _sys_heap_objs[0].base = base;
+      _sys_heap_objs[0].brk = base;
+      _sys_heap_objs[0].end = base + size;
+      _sys_heap_obj_count = 1;
+      _sys_top_heap_obj = &_sys_heap_objs[0];
+    }
+  /* Now we have at least one heap object.  Check for arithmetic
+     overflow. */
+  if (_sys_top_heap_obj->brk + incr < _sys_top_heap_obj->base)
+    {
+      /* Overflow.  If we've just allocated the first heap object,
+         deallocate it again unless memory must be allocated
+         contiguously. */
+      if (old_obj_count == 0 && sbrk_model != _UF_SBRK_CONTIGUOUS)
+    /* We have at least one heap object, OBJ, so this is safe. */
+    void * const pvOldBrk = (void *)__libc_back_gpHeapTopObj->brk;
+    /*
+     * Free objects which are between the new break address and the old
+     * one. Fail if there are such objects and __LIBC_SBRK_MODEL_CONTIGUOUS is
+     * selected.
+     */
+    if (iObj != __libc_back_gcHeapObjs - 1)
+    {
+        if (__libc_back_genmSBrkModel == __LIBC_SBRK_MODEL_CONTIGUOUS)
+            LIBCLOG_ERROR_RETURN_P(NULL);
+        while (__libc_back_gcHeapObjs - 1 > iObj)
+        {
+          FS_VAR();
+          FS_SAVE_LOAD();
+          DosFreeMemEx ((void *)_sys_heap_objs[0].base);
+          FS_RESTORE();
+          _sys_heap_obj_count = 0;
+          _sys_top_heap_obj = NULL;
+            __libc_back_gcHeapObjs -= 1;
+            heapFreeObj(__libc_back_gaHeapObjs[__libc_back_gcHeapObjs].base);
+            __libc_back_gaHeapObjs[__libc_back_gcHeapObjs].base = 0;
+        }
+      LIBCLOG_RETURN_ULONG(0UL);  /* Failure */
+    }
+  /* Check whether we need another heap object.  Allocate one if we
+     need one and are allowed to allocate one.  This should not happen
+     if we just allocated the first one above. */
+  if (_sys_top_heap_obj->brk + incr > _sys_top_heap_obj->end)
+    {
+      /* We need another heap object.  Fail if we are not allowed to
+         allocate non-contiguous memory or if we already have the
+         maximum number of heap objects. */
+      if (sbrk_model == _UF_SBRK_CONTIGUOUS
+          || _sys_heap_obj_count >= MAX_HEAP_OBJS)
+        LIBCLOG_RETURN_ULONG(0UL);
+      /* Allocate at least _sys_heap_size bytes.  The new object must
+         be located above the currently top one. */
+      size = _sys_heap_size;
+      if (incr > size)
+        size = (incr + 0xffff) & ~0xffff;
+      for (;;)
+        __libc_back_gpHeapTopObj = &__libc_back_gaHeapObjs[__libc_back_gcHeapObjs-1];
+    }
+    if (new_brk == __libc_back_gpHeapTopObj->base)
+    {
+        /*
+         * The top object is shrunk to zero bytes, deallocate it and bump NEW_BRK back
+         * to the previous object. If __LIBC_SBRK_MODEL_CONTIGUOUS is selected and
+         * the (only) object is shrunk to 0 bytes, it will be kept anyway to avoid
+         * breaking programs which depend on the object keeping its address:
+         *
+         *      p = sbrk(1000);
+         *      sbrk(-1000);
+         *      assert(sbrk(1000) == p);
+         *
+         * The assertion should not fail. However, programs which select
+         * __LIBC_SBRK_MODEL_MONOTONOUS or __LIBC_SBRK_MODEL_ARBITRARY should be
+         * prepared for failure of the assertion. Consider the following code:
+         *
+         *      sbrk(1000);
+         *      p = sbrk(0);
+         *      sbrk(-1000);
+         *      brk(p);
+         *
+         * Here, brk() may fail due to deallocation of the top object.
+         */
+        if (    iObj != 0
+            ||  __libc_back_genmSBrkModel != __LIBC_SBRK_MODEL_CONTIGUOUS)
+        {
+          if (sbrk_model == _UF_SBRK_ARBITRARY)
+            base = alloc_above (size, 0);
+          else
+            base = alloc_above (size, _sys_top_heap_obj->end);
+          if (base != 0)
+            break;
+          /* If we're out of virtual address space, halve the size and
+             try again until allocation succeeds.  Of course, don't
+             attempt to allocate less than INCR bytes. */
+          size /= 2;
+          if (size < incr)
+            LIBCLOG_RETURN_ULONG(0UL);
+        }
+      _sys_top_heap_obj = &_sys_heap_objs[_sys_heap_obj_count++];
+      _sys_top_heap_obj->base = base;
+      _sys_top_heap_obj->brk = base;
+      _sys_top_heap_obj->end = base + size;
+    }
+  /* Now _sys_top_heap_obj points to an object which has enough space.
+     Commit memory as required.  _sys_expand_heap_obj() returns the
+     top object's break address, which is the base address of the
+     expansion as an object might have been added. */
+  base = _sys_expand_heap_obj_by (incr);
+  LIBCLOG_RETURN_ULONG(base);
+}
+/* Shrink the heap to the new break address NEW_BRK.  Return the
+   previous break address or 0 (error). */
+ULONG _sys_shrink_heap_to (ULONG new_brk)
+{
+  LIBCLOG_ENTER("new_brk=%ld\n", new_brk);
+  unsigned obj;
+  ULONG old_brk;
+  /* Find the heap object containing the new break address.  Fail if
+     there is no such heap object.  Note that the new break address
+     must not be beyond the heap object current break address, that
+     is, we cannot shrink the heap (by deallocating objects) and grow
+     a heap object in one step. */
+  for (obj = 0; obj < _sys_heap_obj_count; ++obj)
+    if (_sys_heap_objs[obj].base <= new_brk
+        && _sys_heap_objs[obj].brk >= new_brk)
+      break;
+  if (obj >= _sys_heap_obj_count)
+    return 0;
+  /* We have at least one heap object, OBJ, so this is safe. */
+  old_brk = _sys_top_heap_obj->brk;
+  /* Free objects which are between the new break address and the old
+     one.  Fail if there are such objects and _UF_SBRK_CONTIGUOUS is
+     selected. */
+  if (obj != _sys_heap_obj_count - 1)
+    {
+      if ((_sys_uflags & _UF_SBRK_MODEL) == _UF_SBRK_CONTIGUOUS)
+        LIBCLOG_RETURN_ULONG(0UL);
+      while (_sys_heap_obj_count - 1 > obj)
+        {
+          FS_VAR();
+          _sys_heap_obj_count -= 1;
+          FS_SAVE_LOAD();
+          DosFreeMemEx ((void *)_sys_heap_objs[_sys_heap_obj_count].base);
+          FS_RESTORE();
+          _sys_heap_objs[_sys_heap_obj_count].base = 0;
+        }
+      _sys_top_heap_obj = &_sys_heap_objs[_sys_heap_obj_count-1];
+    }
+  if (new_brk == _sys_top_heap_obj->base)
+    {
+      /* The top object is shrunk to zero bytes, deallocate it and
+         bump NEW_BRK back to the previous object.  If
+         _UF_SBRK_CONTIGUOUS is selected and the (only) object is
+         shrunk to 0 bytes, it will be kept anyway to avoid breaking
+         programs which depend on the object keeping its address:
+            p = sbrk (1000);
+            sbrk (-1000);
+            assert (sbrk (1000) == p);
+         The assertion should not fail.  However, programs which
+         select _UF_SBRK_MONOTONOUS or _UF_SBRK_ARBITRARY should be
+         prepared for failure of the assertion.  Consider the
+         following code:
+            sbrk (1000);
+            p = sbrk (0);
+            sbrk (-1000);
+            brk (p);
+         Here, brk() may fail due to deallocation of the top
+         object. */
+      if (obj != 0 || (_sys_uflags & _UF_SBRK_MODEL) != _UF_SBRK_CONTIGUOUS)
+        {
+          FS_VAR();
+          _sys_heap_obj_count -= 1;
+          FS_SAVE_LOAD();
+          DosFreeMemEx ((void *)_sys_heap_objs[_sys_heap_obj_count].base);
+          FS_RESTORE();
+          _sys_heap_objs[_sys_heap_obj_count].base = 0;
+          if (_sys_heap_obj_count == 0)
+            _sys_top_heap_obj = NULL;
+          else
+            __libc_back_gcHeapObjs -= 1;
+            heapFreeObj(__libc_back_gaHeapObjs[__libc_back_gcHeapObjs].base);
+            __libc_back_gaHeapObjs[__libc_back_gcHeapObjs].base = 0;
+            if (__libc_back_gcHeapObjs == 0)
+                __libc_back_gpHeapTopObj = NULL;
+            else
+            {
               _sys_top_heap_obj = &_sys_heap_objs[_sys_heap_obj_count-1];
               new_brk = _sys_top_heap_obj->brk;
+                __libc_back_gpHeapTopObj = &__libc_back_gaHeapObjs[__libc_back_gcHeapObjs-1];
+                new_brk = __libc_back_gpHeapTopObj->brk;
+            }
+        }
+    }
+  /* Now decommit unused pages of the top heap object, if there is
+     one. */
+  if (_sys_heap_obj_count > 0
+      && _sys_shrink_heap_obj_by (_sys_top_heap_obj->brk - new_brk) == 0)
+      LIBCLOG_RETURN_ULONG(0UL);
+  LIBCLOG_RETURN_ULONG(old_brk);
+}
+/* Shrink the heap by DECR bytes.  DECR is a positive number.  Return
+   the previous break address or 0 (error). */
+ULONG _sys_shrink_heap_by (ULONG decr, ULONG sbrk_model)
+{
+  LIBCLOG_ENTER("decr=%ld sbrk_model=%ld\n", decr, sbrk_model);
+  ULONG ulRet;
+  if (_sys_heap_obj_count == 0)
+    LIBCLOG_RETURN_ULONG(0UL);
+  if (_sys_top_heap_obj->brk - decr < _sys_top_heap_obj->base)
+    LIBCLOG_RETURN_ULONG(0UL);
+  ulRet = _sys_shrink_heap_to (_sys_top_heap_obj->brk - decr);
+  LIBCLOG_RETURN_ULONG(ulRet);
+}
+    /*
+     * Now decommit unused pages of the top heap object, if there is one.
+     */
+    if (    __libc_back_gcHeapObjs > 0
+        &&  __libc_back_heapShrinkObjBy(__libc_back_gpHeapTopObj->brk - new_brk) == 0)
+        LIBCLOG_RETURN_P(NULL);
+    LIBCLOG_RETURN_P(pvOldBrk);
+}
+/**
+ * Shrink the heap by DECR bytes. DECR is a positive number.
+ * Return the previous break address or 0 (error).
+ */
+void *__libc_back_heapShrinkBy(uintptr_t decr, __LIBCSBRKMODEL enmSBrkModel)
+{
+    LIBCLOG_ENTER("decr=%ld enmSBrkModel=%d\n", decr, enmSBrkModel);
+    if (    __libc_back_gcHeapObjs != 0
+        &&  __libc_back_gpHeapTopObj->brk - decr >= __libc_back_gpHeapTopObj->base)
+    {
+        void *pvRet = __libc_back_heapShrinkTo(__libc_back_gpHeapTopObj->brk - decr);
+        LIBCLOG_RETURN_P(pvRet);
+    }
+    LIBCLOG_RETURN_P(NULL);
+}

trunk/libc/src/kNIX/heapdump.c

-              r2738
+              r2739
 /* sys/heapdump.c (emx+gcc) -- Copyright (c) 1996 by Eberhard Mattes */
+#include "libc-alias.h"
+#include "syscalls.h"
+#include "kNIX.h"
 #include <stdio.h>
 …
   fprintf (f, "base     brk      end\n");
   for (i = 0; i < _sys_heap_obj_count; ++i)
+  for (i = 0; i < __libc_back_gcHeapObjs; ++i)
     fprintf (f, "%.8lx %.8lx %.8lx%s\n",
              _sys_heap_objs[i].base,
              _sys_heap_objs[i].brk,
              _sys_heap_objs[i].end,
              _sys_top_heap_obj == &_sys_heap_objs[i] ? " top" : "");
+             __libc_back_gaHeapObjs[i].base,
+             __libc_back_gaHeapObjs[i].brk,
+             __libc_back_gaHeapObjs[i].end,
+             __libc_back_gpHeapTopObj == &__libc_back_gaHeapObjs[i] ? " top" : "");
+}

trunk/libc/src/kNIX/nt/Makefile.kmk

-              r2732
+              r2739
+# $Id: $
+## @file
+#
+# kBuild Sub-Makefile for kLIBC - src/libc/sys.
+#
+# Copyright (c) 2006 knut st. osmundsen <bird@anduin.net>
+#
+#
+# This file is part of kLIBC.
+#
+# kLIBC is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# kLIBC is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with kLIBC; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#
+# Forward to the parent makefile.
+DEPTH = ../../../..
+include $(PATH_KBUILD)/up.kmk
-# include common stuff.
-DEPTH ?= ../../..
-SUB_DEPTH = ../..
-include $(PATH_KBUILD)/subheader.kmk
-ifeq ($(filter-out win32 win64,$(BUILD_TARGET)),)
-LIBRARIES += kNIX.nt
-kNIX.nt_TEMPLATE = libcsub
-kNIX.nt_SOURCES = \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_panic.c \
-kNIX.nt_SOURCES_later = \
-    $(PATH_LIBC_SRC)/kNIX.nt/brk.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_dir.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsDirChangeRoot.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsDirCreate.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsDirCurrentGet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsDirCurrentSet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsDirCurrentSetFH.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsDirRemove.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsDriveDefaultGet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsDriveDefaultSet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsFileModeSet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsFileModeSetFH.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsFileStat.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsFileStatFH.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsFileTimesSet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsFileTimesSetFH.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsNativeFileModeSet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsNativeFileStat.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsNativeFileTimesSet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsPathResolve.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsRename.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsStat.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsSymlinkCreate.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsSymlinkModeSet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsSymlinkRead.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsSymlinkStat.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsSymlinkTimesSet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsSync.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_fsUnlink.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_ioDirGetEntries.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_ioFHToPath.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_ioFileControl.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_ioFileOpen.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_ioFileSizeSet.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_ioSeek.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_ldrClose.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_ldrOpen.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_ldrSymbol.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_miscLoadAvg.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_mmanProtect.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_nativeSymlinkCreate.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_processCredentials.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_processGetPriority.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_processSetPriority.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_processWait.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_signalInterrupt.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_signalMask.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_signalPending.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_signalQueue.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_signalSendPid.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_signalStack.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_signalSuspend.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_signalTimer.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_signalWait.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_threadCleanup.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_threadEnd.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_threadInit.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_threadSleep.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_threadStartup.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_time.c \
-    $(PATH_LIBC_SRC)/kNIX.nt/b_timeHighResNano.c \
-#kNIX.nt_SOURCES.x86 = \
-#    $(PATH_LIBC_SRC)/kNIX.nt/386/__init_environ.s \
-#$(PATH_LIBC_SRC)/kNIX.nt/heapsize.c_DEFS = HEAPSIZE=0x2000000
-# configure the variants. */
-$(call LIBC_CONFIG_VARIANT_LIBS,kNIX.nt)
-endif # BUILD_TARGET == win32 || win64
-# generate rules
-include $(PATH_KBUILD)/subfooter.kmk

trunk/libc/src/kNIX/os2/__close.c

-              r2732
+              r2739
+/* sys/close.c (emx+gcc) -- Copyright (c) 1992-1996 by Eberhard Mattes
+                         -- Copyright (c) 2003 by Knut St. Osmunden */
+/* dead */
-#include "libc-alias.h"
-#include <emx/io.h>
-#include <emx/syscalls.h>
-int __close(int fh)
+{
-    if (!__libc_FHClose(fh))
-        return -0;
-    return -1;
+}

trunk/libc/src/kNIX/os2/__dup.c

-              r2732
+              r2739
+        {
             PLIBCFH pFHNew;
             rc = __libc_FHAllocate(hNew, pFH->fFlags, sizeof(LIBCFH), NULL, &pFHNew, NULL);
+            rc = __libc_FHAllocate(sizeof(__LIBC_FH), &__libc_back_gFileOps, hNew, hNew, pFH->fFlags, &pFHNew);
             if (!rc)
+            {
 …
                  */
                 pFHNew->fFlags &= ~((FD_CLOEXEC << __LIBC_FH_FDFLAGS_SHIFT) | O_NOINHERIT);
+                LIBC_ASSERT(!__libc_FHSetFlags(pFHNew, hNew, pFHNew->fFlags));
+                LIBC_ASSERT(!__libc_FHSetFlags(pFHNew, pFHNew->fFlags));
+                __libc_FHPut(pFHNew);
+            }
             else

trunk/libc/src/kNIX/os2/__dup2.c

-              r2732
+              r2739
     if (rc)
+    {
         _sys_set_errno(rc);
+        _sys_set_errno(-rc);
         return -1;
+    }
 …
      */
     pFHNew = __libc_FH(fhNew);
+    if (pFHNew && pFHNew->pOps)
+    if (    pFHNew
+        &&  pFHNew->pOps != &__libc_back_gFileOps)
+    {
         rc = __libc_FHClose(fhNew);
 …
         if (!rc)
+        {
             PLIBCFH pFHNew;
             rc = __libc_FHAllocate(hNew, pFH->fFlags, sizeof(LIBCFH), NULL, &pFHNew, NULL);
+            __LIBC_PFH pFHNew;
+            rc = __libc_FHAllocate(sizeof(__LIBC_FH), &__libc_back_gFileOps, hNew, hNew, pFH->fFlags, &pFHNew);
             if (!rc)
+            {
 …
                  */
                 pFHNew->fFlags &= ~((FD_CLOEXEC << __LIBC_FH_FDFLAGS_SHIFT) | O_NOINHERIT);
                 LIBC_ASSERT(!__libc_FHSetFlags(pFHNew, hNew, pFHNew->fFlags));
+                LIBC_ASSERT(!__libc_FHSetFlags(pFHNew, pFHNew->fFlags));
+            }
             else

trunk/libc/src/kNIX/os2/__initdll.c

-              r2732
+              r2739
      * Initialize the heap semaphores.
      */
     if (_fmutex_create2(&_sys_heap_fmutex, 0, "LIBC SYS Heap Mutex") != 0)
         return -1;
     if (_fmutex_create2(&_sys_gmtxHimem,   0, "LIBC SYS Highmem Mutex") != 0)
+    if (_fmutex_create2(&__libc_back_gmtxHeap, 0, "LIBC SYS Heap Mutex") != 0)
+        return -1;
+    if (_fmutex_create2(&__libc_back_gmtxHighHeap,   0, "LIBC SYS Highmem Mutex") != 0)
         return -1;
     if (_fmutex_create2(&__libc_gmtxExec,  0, "LIBC SYS Exec Mutex") != 0)

trunk/libc/src/kNIX/os2/__pipe.c

-              r2732
+              r2739
          * Register the handle.
          */
         rc = __libc_FHAllocate((HFILE)two_handles[0], F_PIPE | O_RDONLY, sizeof(LIBCFH), NULL, ppFHRead, NULL);
+        rc = __libc_FHAllocate(sizeof(__LIBC_FH), &__libc_back_gFileOps, (HFILE)two_handles[0], (HFILE)two_handles[0], F_PIPE | O_RDONLY, ppFHRead);
         if (!rc)
             rc = __libc_FHAllocate((HFILE)two_handles[1], F_PIPE | O_WRONLY, sizeof(LIBCFH), NULL, ppFHWrite, NULL);
+            rc = __libc_FHAllocate(sizeof(__LIBC_FH), &__libc_back_gFileOps, (HFILE)two_handles[1], (HFILE)two_handles[0], F_PIPE | O_WRONLY, ppFHWrite);
         if (rc)
+        {

trunk/libc/src/kNIX/os2/__ulimit.c

-              r2732
+              r2739
       /* Note: As this is the limit for brk(), not for sbrk(), we
          don't return 512M. */
       return _sys_top_heap_obj != NULL ? _sys_top_heap_obj->end : 0;
+      return __libc_back_gpHeapTopObj != NULL ? __libc_back_gpHeapTopObj->end : 0;
     case UL_OBJREST:
       return (_sys_top_heap_obj != NULL
               ? _sys_top_heap_obj->end - _sys_top_heap_obj->brk : 0);
+      return (__libc_back_gpHeapTopObj != NULL
+              ? __libc_back_gpHeapTopObj->end - __libc_back_gpHeapTopObj->brk : 0);
     default:

trunk/libc/src/kNIX/os2/b_dir.c

r2732	r2739
392	392	{
393	393	__LIBC_PFH pFH;
394		rc = __libc_FHAllocate(*pfh, fLibc, sizeof(__LIBC_FHDIR), &gDirOps, &pFH, pfh);
	394	rc = __libc_FHAllocate(sizeof(__LIBC_FHDIR), &gDirOps, Tmp.hDir, *pfh, fLibc, &pFH);
395	395	if (!rc)
396	396	{

trunk/libc/src/kNIX/os2/b_ioFileControl.c

-              r2732
+              r2739
 /**
  * File Control.
+ *
+ *
  * Deals with file descriptor flags, file descriptor duplication and locking.
+ *
+ *
  * @returns 0 on success and *piRet set.
  * @returns Negated errno on failure and *piRet set to -1.
 …
 /**
  * File Control operation - OS/2 standard handle.
+ *
+ *
  * @returns 0 on success.
  * @returns OS/2 error code or negated errno on failure.
+ *
+ *
  * @param   pFH         Pointer to the handle structure to operate on.
  * @param   fh          It's associated filehandle.
 …
             unsigned fFlags = pFH->fFlags & ~__LIBC_FH_SETFL_MASK;
             fFlags |= ((int)iArg & __LIBC_FH_SETFL_MASK);
             int rc = __libc_FHSetFlags(pFH, fh, fFlags);
+            int rc = __libc_FHSetFlags(pFH, fFlags);
             LIBCLOG_MIX0_RETURN_INT(rc);
+        }
 …
      * Update the flags.
      */
     int rc = __libc_FHSetFlags(pFH, fh, fFlags);
+    int rc = __libc_FHSetFlags(pFH, fFlags);
     LIBCLOG_MIX0_RETURN_INT(rc);
+}
 …
 /**
  * Handle locking requests.
+ *
+ *
  * @returns 0 on success.
  * @returns OS/2 error code or negated errno on failure.
 …
     LIBCLOG_ENTER("fh=%d iRequest=%d pFlock=%p\n", fh, iRequest, (void *)pFlock);
     /*
+    /*
      * Check input.
      */
 …
         LIBCLOG_ERROR_RETURN_INT(-EINVAL);
     /*
      * Check fh & get filesize.
+    /*
+     * Check fh & get filesize.
      */
     union
 …
             FS_RESTORE();
+        }
         /*
+        /*
          * There is/was a bug in the large API which make it fail on non JFS
          * disks with ERROR_INVALID_PARAMETER. We need to work around this.
+         * disks with ERROR_INVALID_PARAMETER. We need to work around this.
          */
         if (rc == ERROR_INVALID_PARAMETER)

trunk/libc/src/kNIX/os2/b_ioFileOpen.c

-              r2732
+              r2739
              */
             __LIBC_PFH pFH;
             rc = __libc_FHAllocate(hFile, fLibc, sizeof(LIBCFH), NULL, &pFH, NULL);
+            rc = __libc_FHAllocate(sizeof(__LIBC_FH), &__libc_back_gFileOps, hFile, hFile, fLibc, &pFH);
             if (__predict_true(!rc))
+            {
 …
                 pFH->pszNativePath  = _hstrdup(szNativePath);
+                LIBCLOG_MSG("pFH=%p hFile=%#lx fLibc=%#x fulType=%#lx ulAction=%lu Dev=%#x Inode=%#llx\n",
+                            (void *)pFH, hFile, fLibc, fulType, ulAction, Dev, Inode);
                 if (ppFH)
                     *ppFH = pFH;
+                else
+                    __libc_FHPut(pFH);
                 FS_RESTORE();
-                LIBCLOG_MSG("pFH=%p hFile=%#lx fLibc=%#x fulType=%#lx ulAction=%lu Dev=%#x Inode=%#llx\n",
-                            (void *)pFH, hFile, fLibc, fulType, ulAction, Dev, Inode);
+            }
+        }

trunk/libc/src/kNIX/os2/brk.c

-              r2732
+              r2739
   ULONG base;
   if (_fmutex_request (&_sys_heap_fmutex, _FMR_IGNINT) != 0)
+  if (_fmutex_request (&__libc_back_gmtxHeap, _FMR_IGNINT) != 0)
     return -1;
   if (_sys_heap_obj_count == 0)
+  if (__libc_back_gcHeapObjs == 0)
     base = 0;
   else if ((ULONG)brkp >= _sys_top_heap_obj->brk
            && (ULONG)brkp <= _sys_top_heap_obj->end)
     base = _sys_expand_heap_obj_by ((ULONG)brkp - _sys_top_heap_obj->brk);
   else if ((ULONG)brkp >= _sys_top_heap_obj->base
            && (ULONG)brkp < _sys_top_heap_obj->brk)
     base = _sys_shrink_heap_obj_by (_sys_top_heap_obj->brk - (ULONG)brkp);
+  else if ((ULONG)brkp >= __libc_back_gpHeapTopObj->brk
+           && (ULONG)brkp <= __libc_back_gpHeapTopObj->end)
+    base = __libc_back_heapExpandObjBy ((ULONG)brkp - __libc_back_gpHeapTopObj->brk);
+  else if ((ULONG)brkp >= __libc_back_gpHeapTopObj->base
+           && (ULONG)brkp < __libc_back_gpHeapTopObj->brk)
+    base = __libc_back_heapShrinkObjBy (__libc_back_gpHeapTopObj->brk - (ULONG)brkp);
   else
     base = _sys_shrink_heap_to ((ULONG)brkp);
+    base = __libc_back_heapShrinkTo ((ULONG)brkp);
   if (_fmutex_release (&_sys_heap_fmutex) != 0)
+  if (_fmutex_release (&__libc_back_gmtxHeap) != 0)
     return -1;

trunk/libc/src/kNIX/os2/heaphigh.c

-              r2732
+              r2739
      * Take semaphore.
      */
     if (_fmutex_request(&_sys_gmtxHimem, _FMR_IGNINT))
+    if (_fmutex_request(&__libc_back_gmtxHighHeap, _FMR_IGNINT))
         LIBCLOG_RETURN_P(NULL);
 …
+    {
         LIBC_ASSERTM_FAILED("Failed to allocate more chunks. rc=%d\n", rc);
         _fmutex_release(&_sys_gmtxHimem);
+        _fmutex_release(&__libc_back_gmtxHighHeap);
         LIBCLOG_ERROR_RETURN_P(NULL);
+    }
 …
         LIBC_ASSERTM_FAILED("DosSetMem(%p, 0x1000,) -> rc=%d\n", pv, rc);
         DosFreeMemEx(pv);
         _fmutex_release(&_sys_gmtxHimem);
+        _fmutex_release(&__libc_back_gmtxHighHeap);
         LIBCLOG_ERROR_RETURN_P(NULL);
+    }
 …
+        {
             himemFreeChunk(pChunk);
             _fmutex_release(&_sys_gmtxHimem);
+            _fmutex_release(&__libc_back_gmtxHighHeap);
+        }
+    }
 …
          * Check if we have a chunk we can expand to satisfy the request.
          */
         if (_fmutex_request(&_sys_gmtxHimem, _FMR_IGNINT))
+        if (_fmutex_request(&__libc_back_gmtxHighHeap, _FMR_IGNINT))
             LIBCLOG_RETURN_P(NULL);
         cbCommit = *pcb;
 …
                     pChunk->cbUncommitted -= cbCommit;
                     gpHimemHint = pChunk->cbUncommitted ? pChunk : gpHimemHead;
                     _fmutex_release(&_sys_gmtxHimem);
+                    _fmutex_release(&__libc_back_gmtxHighHeap);
                     /* return pv and commit size. The heap takes care of joining
 …
         /* Out of luck, allocate a new chunk. */
         _fmutex_release(&_sys_gmtxHimem);
+        _fmutex_release(&__libc_back_gmtxHighHeap);
+    }
 …
             /* release and return. */
             _fmutex_release(&_sys_gmtxHimem);
+            _fmutex_release(&__libc_back_gmtxHighHeap);
             *pcb = cbCommit;
             *pfClean = _BLOCK_CLEAN;
 …
      * Take semaphore.
      */
     if (_fmutex_request(&_sys_gmtxHimem, _FMR_IGNINT) != 0)
+    if (_fmutex_request(&__libc_back_gmtxHighHeap, _FMR_IGNINT) != 0)
         return;
 …
                     LIBC_ASSERTM_FAILED("Bad high heap release!! pv=%p cb=%#x off=%#x offEnd=%#x; chunk pv=%p cb=%#x cbUncomitted=%#x\n",
                                         pv, cb, off, offEnd, pChunk->pv, pChunk->cb, pChunk->cbUncommitted);
                     _fmutex_release(&_sys_gmtxHimem);
+                    _fmutex_release(&__libc_back_gmtxHighHeap);
                     LIBCLOG_ERROR_RETURN_VOID();
+                }
 …
                     /* we're done. */
                     _fmutex_release(&_sys_gmtxHimem);
+                    _fmutex_release(&__libc_back_gmtxHighHeap);
                     LIBCLOG_RETURN_VOID();
+                }
 …
     } while (cb && pChunk);
     _fmutex_release(&_sys_gmtxHimem);
+    _fmutex_release(&__libc_back_gmtxHighHeap);
     LIBCLOG_RETURN_VOID();
+}

trunk/libc/src/kNIX/os2/sbrk.c

-              r2732
+              r2739
+/* sys/sbrk.c (emx+gcc) -- Copyright (c) 1992-1996 by Eberhard Mattes */
+#include "libc-alias.h"
+#include <os2emx.h>
+#include <errno.h>
+#include <sys/builtin.h>
+#include <sys/fmutex.h>
+#include <sys/uflags.h>
+#include <sys/types.h>
+#include <stdlib.h>
+#include <emx/syscalls.h>
+#include "syscalls.h"
+void *_STD(sbrk) (intptr_t incr)
+{
+  ULONG base;
+  if (_fmutex_request (&_sys_heap_fmutex, _FMR_IGNINT) != 0)
+    return (void *)-1;
+  if (incr >= 0)
+    base = _sys_expand_heap_by (incr, _sys_uflags & _UF_SBRK_MODEL);
+  else
+    base = _sys_shrink_heap_by (-incr, _sys_uflags & _UF_SBRK_MODEL);
+  if (_fmutex_release (&_sys_heap_fmutex) != 0)
+    return (void *)-1;
+  if (base == 0)
+    {
+      errno = ENOMEM;
+      return (void *)-1;
+    }
+  return (void *)base;
+}
+/* dead */

trunk/libc/src/kNIX/os2/syscalls.h

-              r2732
+              r2739
 /* Maximum number of heap objects (16 = 512 / 32). */
+#define MAX_HEAP_OBJS   16
+/* This structure describes one heap object. */
+struct heap_obj
+{
+  ULONG base;                   /* Base address */
+  ULONG end;                    /* End address */
+  ULONG brk;                    /* Address of first unused byte */
+};
+#define CFG_KNIX_MAX_HEAP_OBJS   16
 EXTERN unsigned _sys_uflags INIT (0);
 …
 EXTERN unsigned long    _sys_gcbVirtualAddressLimit;
-/* The top heap object.  This points into _sys_heap_objs[] or is NULL.
-   While this variable is NULL, no memory has been allocated. */
-EXTERN struct heap_obj *_sys_top_heap_obj;
-/* This array holds information on all the heap objects.  The heap
-   objects are managed in LIFO fashion. */
-EXTERN struct heap_obj  _sys_heap_objs[MAX_HEAP_OBJS];
-/* This is the number of heap objects. */
-EXTERN unsigned         _sys_heap_obj_count;
-/* This variable can be initialized by the application to control the
-   size of the heap object(s). */
-extern unsigned         _sys_heap_size;
 …
 void _sys_get_clock (unsigned long *ms);
-/** @group Heap stuff.
- * @{ */
-ULONG _sys_expand_heap_obj_by (ULONG incr);
-ULONG _sys_expand_heap_by (ULONG incr, ULONG sbrk_model);
-ULONG _sys_shrink_heap_to (ULONG new_brk);
-ULONG _sys_shrink_heap_by (ULONG decr, ULONG sbrk_model);
-ULONG _sys_shrink_heap_obj_by (ULONG decr);
-#ifdef _SYS_FMUTEX_H
-/** This mutex semaphore protects the heap. */
-EXTERN _fmutex          _sys_heap_fmutex;
-/** Mutex semaphore protecting the list of high memory big blocks. */
-EXTERN _fmutex          _sys_gmtxHimem;
-#endif
-/** @} */
 /** @group Init Functions

trunk/libc/src/kNIX/os2/tcpipver.c

-              r2732
+              r2739
+                {
                     rc = __libc_Back_ioFileControlStandard(pFH, fh, iRequest, iArg, prc);
                     if (rc)
+                    if (rc)
+                    {
                         /* undo change on failure. */
 …
                 else
                     fFlags &= ~O_NONBLOCK;
                 rc = __libc_FHSetFlags(pFH, fh, fFlags);
+                rc = __libc_FHSetFlags(pFH, fFlags);
+            }
             break;
 …
     LIBCLOG_ENTER("iSocket=%d\n", iSocket);
     PLIBCFH         pFHLibc;
     int rc = __libc_FHAllocate(fh, fFlags, sizeof(LIBCSOCKETFH), &gSocketOps, &pFHLibc, pfh);
+    int rc = __libc_FHAllocate(sizeof(LIBCSOCKETFH), &gSocketOps, iSocket, fh, fFlags, &pFHLibc);
     if (!rc)
+    {
+        if (pfh)
+            *pfh = pFHLibc->fh;
         /*
          * Init the handle.
          */
         PLIBCSOCKETFH   pFH = (PLIBCSOCKETFH)pFHLibc;
+        PLIBCSOCKETFH pFH = (PLIBCSOCKETFH)pFHLibc;
         pFH->iSocket = iSocket;
 …
         if (ppFHSocket)
             *ppFHSocket = pFH;
+        else
+            __libc_FHPut(pFHLibc);
         LIBCLOG_RETURN_INT(0);
+    }

trunk/libc/src/libc/app/stdio.c

-              r2672
+              r2739
                      -- Copyright (c) 2003-2004 by knut st. osmundsen */
+#define __LIBC_LOG_GROUP  __LIBC_LOG_GRP_STREAM
 #include "libc-alias.h"
-#include <sys/builtin.h>        /* For <sys/fmutex.h> */
 #include <sys/fmutex.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <emx/io.h>
+#include <unistd.h>
+#include <klibc/io.h>
+#include <klibc/backend.h>
+#include <klibc/logstrict.h>
 #include <emx/startup.h>
-#include <emx/syscalls.h>
-#define __LIBC_LOG_GROUP  __LIBC_LOG_GRP_STREAM
-#include <InnoTekLIBC/logstrict.h>
 …
     for (i = 0; i < 3; i++)
+    {
+        PLIBCFH pFH = __libc_FH(i);
+        if (!pFH)
+        __LIBC_PFH pFH;
+        int rc = __libc_FHGet(i, &pFH);
+        if (rc)
+        {
             LIBCLOG_MSG("No open file for %d\n", i);
+            pFH = NULL;
+        }
         /*
 …
                 break;
+        }
+        __libc_FHPut(pFH);
     } /* for standard handles. */
     LIBCLOG_RETURN_VOID();
 …
+{
     static const char szMsg[] = "\r\nLIBC fatal error - streams: ";
+    __write(2, szMsg, sizeof(szMsg) - 1);
+    __write(2, pszMsg, strlen(pszMsg));
+    size_t cbWritten;
+    __libc_Back_ioWrite(STDERR_FILENO, szMsg, sizeof(szMsg) - 1, &cbWritten);
+    __libc_Back_ioWrite(STDERR_FILENO, pszMsg, strlen(pszMsg), &cbWritten);
     if (f->__uVersion != _FILE_STDIO_VERSION)
+    {
         static const char szMsg2[] = " (stream version mismatch (too))";
         __write(2, szMsg2, sizeof(szMsg2) - 1);
+        __libc_Back_ioWrite(STDERR_FILENO, szMsg2, sizeof(szMsg2) - 1, &cbWritten);
+    }
     __write(2, "\r\n", 2);
+    __libc_Back_ioWrite(STDERR_FILENO, "\r\n", 2, &cbWritten);
     abort();
     return 0;

trunk/libc/src/libc/io/_fbuf.c

-              r1454
+              r2739
 #include <stdio.h>
 #include <stdlib.h>
 #include <emx/io.h>
+#include <klibc/io.h>
 #include <emx/umalloc.h>
 …
   else
+    {
+      PLIBCFH   pFH = __libc_FH(stream->_handle);
+      if (pFH && (   (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_DEV
+                  || (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_SOCKET))
+      unsigned fFlags = __libc_FHGetFlags(stream->_handle);
+      if (    fFlags
+          &&  (   (fFlags & __LIBC_FH_TYPEMASK) == F_DEV
+               || (fFlags & __LIBC_FH_TYPEMASK) == F_SOCKET))
         stream->_buffer = _lmalloc(BUFSIZ);
       else

trunk/libc/src/libc/io/_flushst.c

-              r871
+              r2739
 #include <fcntl.h>
 #include <errno.h>
 #include <emx/io.h>
+#include <klibc/io.h>
 int _flushstream (FILE *stream, int c)
 …
           else                  /* New or flushed buffer */
+            {
-              PLIBCFH   pFH = __libc_FH(fh);
               w = 0;
               if (pFH && (pFH->fFlags & O_APPEND))
+              if (__libc_FHGetFlags(fh) & O_APPEND)
                 lseek (fh, 0, SEEK_END);
+            }

trunk/libc/src/libc/io/_isterm.c

-              r1454
+              r2739
 #include <io.h>
 #include <errno.h>
+#include <emx/io.h>
+#include <emx/syscalls.h>
+#include <klibc/io.h>
 int _isterm(int handle)
+{
+    PLIBCFH pFH;
+    /** @todo this needs attention, it's now identical to isatty(). I'm not entirely sure if that's the idea... */
+    /*
+     * Get filehandle and inspect the flags.
+     */
+    __LIBC_PFH pFH;
+    int rc = __libc_FHGet(handle, &pFH);
+    if (!rc)
+    {
+        /*
+         * If it's a device we assume it is a terminal...
+         * (Hope that's correct interpretation of the __ioctl1() call...)
+         */
+        rc = (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_DEV;
+        __libc_FHPut(pFH);
+    }
+    else
+    {
+        errno = -rc;
+        rc = 0;
+    }
+    return rc;
+}
-    /*
-     * Get filehandle.
-     */
-    pFH = __libc_FH(handle);
-    if (!pFH)
+    {
-        errno = EBADF;
-        return 0;
+    }
-    /*
-     * Is it a atty?
-     */
-    if (!isatty(handle))
-        return 0;
-    /*
-     * If it's a device we assume is a terminal...
-     * (Hope that's correct interpretation of the __ioctl1() call...)
-     */
-    return (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_DEV;
+}

trunk/libc/src/libc/io/_output.c

-              r2160
+              r2739
   char buf[9];
   _ltoa (n, buf, 16);
+  ltoa (n, buf, 16);
   return cvt_hex (v, buf, x, n == 0);
+}
 …
   char buf[17];
   _ulltoa (n, buf, 16);
+  ulltoa (n, buf, 16);
   return cvt_hex (v, buf, x, n == 0);
+}
 …
   char buf[12];
   _ltoa (n, buf, 8);
+  ltoa (n, buf, 8);
   return cvt_oct (v, buf, n == 0);
+}
 …
   char buf[23];
   _ulltoa (n, buf, 8);
+  ulltoa (n, buf, 8);
   return cvt_oct (v, buf, n == 0);
+}
 …
   char buf[11];
   _ultoa (n, buf, 10);
+  ultoa (n, buf, 10);
   return cvt_integer (v, NULL, buf, n == 0, is_signed, is_neg);
+}
 …
   char buf[21];
   _ulltoa (n, buf, 10);
+  ulltoa (n, buf, 10);
   return cvt_integer (v, NULL, buf, n == 0, is_signed, is_neg);
+}

trunk/libc/src/libc/io/_vsopen.c

-              r2316
+              r2739
      */
     int     saved_errno = errno;
     PLIBCFH pFH;
+    __LIBC_PFH pFH;
     int     fd = __libc_Back_ioFileOpen(pszName, fLibc, fShare, cbInitial, Mode, &pFH);
     if (fd == -EACCES && fCtrlZKludge)
 …
+        {
             char chDummy = 127;
+            if (    __read(fd, &chDummy, 1) == 1
+            size_t cbRead;
+            int rc = __libc_Back_ioRead(fd, &chDummy, 1, &cbRead);
+            if (    !rc
+                &&  cbRead == 1
                 &&  chDummy == 0x1a)
+            {
 …
     /*
      * Reopen the file in write-only Mode if Ctrl-Z hack applied.
+     * Reopen the file in write-only mode if Ctrl-Z hack applied.
      */
     if (fCtrlZKludge)
 …
     errno = saved_errno;
+    __libc_FHPut(pFH);
     LIBCLOG_RETURN_INT(fd);
+}

trunk/libc/src/libc/io/close.c

-              r871
+              r2739
+/* close.c (emx+gcc) -- Copyright (c) 1990-1996 by Eberhard Mattes
+                     -- Copyright (c) 2003 by Knut St. Osmunden */
+/* $Id: $ */
+/** @file
+ *
+ * kLIBC - close().
+ *
+ * Copyright (c) 2006 knut st. osmundsen <bird-srcspam@anduin.net>
+ *
+ *
+ * This file is part of kLIBC.
+ *
+ * kLIBC is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * kLIBC is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with kLIBC; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_IO
 #include "libc-alias.h"
+#include <unistd.h>
 #include <io.h>
+#include <emx/io.h>
+#include <errno.h>
+#include <klibc/io.h>
+#include <klibc/backend.h>
+#include <klibc/logstrict.h>
+/**
+ * Closes the specified handle.
+ * @returns 0 on success, -1 and errno on failure.
+ * @param   fh      The file handle to close.
+ */
 int _STD(close)(int fh)
+{
     int rc;
     rc = __libc_FHClose(fh);
+    LIBCLOG_ENTER("fh=%d\n", fh);
+    int rc = __libc_Back_ioClose(fh);
     if (!rc)
         return 0;
     /* (it sets errno) */
     return -1;
+        LIBCLOG_RETURN_INT(0);
+    errno = -rc;
+    LIBCLOG_ERROR_RETURN_INT(-1);
+}

trunk/libc/src/libc/io/eof.c

-              r871
+              r2739
 /* eof.c (emx+gcc) -- Copyright (c) 1990-1996 by Eberhard Mattes */
+#define __LIBC_LOG_GROUP  __LIBC_LOG_GRP_IO
 #include "libc-alias.h"
 #include <io.h>
 #include <errno.h>
+#include <emx/io.h>
+#include <klibc/io.h>
+#include <klibc/logstrict.h>
 int _STD(eof) (int handle)
+int _STD(eof)(int fh)
+{
+  PLIBCFH   pFH;
+  off_t cur, len;
+    LIBCLOG_ENTER("fh=%d\n", fh);
+  /*
+   * Get filehandle.
+   */
+  pFH = __libc_FH(handle);
+  if (!pFH)
+  {
+      errno = EBADF;
+      return -1;
+  }
+  if (pFH->fFlags & F_EOF)          /* Ctrl-Z reached */
+    return 1;
+  cur = tell (handle);
+  if (cur < 0)
+    return -1;
+  len = filelength (handle);
+  if (len < 0)
+    return -1;
+  return cur == len;
+    /*
+     * Get filehandle.
+     */
+    __LIBC_PFH pFH;
+    int rc = __libc_FHGet(fh, &pFH);
+    if (rc)
+    {
+        errno = -rc;
+        LIBCLOG_ERROR_RETURN_INT(-1);
+    }
+    /*
+     * Examin the handle state and then compare file position with file length.
+     */
+    if (pFH->fFlags & F_EOF)          /* Ctrl-Z reached */
+        rc = 1;
+    else
+    {
+        off_t cur = tell(fh);
+        if (cur < 0)
+            rc = -1;
+        else
+        {
+            off_t len = filelength(fh);
+            if (len < 0)
+                rc = -1;
+            else
+                rc = cur == len;
+        }
+    }
+    __libc_FHPut(pFH);
+    LIBCLOG_RETURN_INT(rc);
+}

trunk/libc/src/libc/io/fchown.c

-              r2254
+              r2739
 *   Header Files                                                               *
 *******************************************************************************/
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_IO
 #include "libc-alias.h"
 #include <unistd.h>
 #include <emx/io.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_IO
 #include <InnoTekLIBC/logstrict.h>
+#include <errno.h>
+#include <klibc/io.h>
+#include <klibc/logstrict.h>
 …
  * Change the owner and group over a file.
+ *
  * This is stub. It only validates the filehandle and returns without changing anything.
+ * This is a stub. It only validates the filehandle and returns without changing anything.
+ *
  * @returns 0 on success.
 …
  * @param   group   Group id.
  */
 int      _STD(fchown)(int fh, uid_t owner, gid_t group)
+int _STD(fchown)(int fh, uid_t owner, gid_t group)
+{
     LIBCLOG_ENTER("fh=%d owner=%d group=%d\n", fh, owner, group);
+    __LIBC_PFH  pFH = __libc_FH(fh);
+    if (pFH)
+    __LIBC_PFH pFH;
+    int rc = __libc_FHGet(fh, &pFH);
+    if (!rc)
+    {
+        __libc_FHPut(pFH);
         LIBCLOG_RETURN_INT(0);
+    }
+    errno = -rc;
     LIBCLOG_ERROR_RETURN_INT(-1);
+}

trunk/libc/src/libc/io/fseek.c

-              r2090
+              r2739
 #include <io.h>
 #include <errno.h>
 #include <emx/io.h>
+#include <klibc/io.h>
 int _fseek_unlocked (FILE *stream, off_t offset, int origin)
 …
   off_t     cur_pos;
   int       fflush_result;
-  PLIBCFH   pFH;
   if (!(stream->_flags & _IOOPEN) || origin < 0 || origin > 2
 …
+    {
       off_t file_pos, end_pos, buf_pos;
       int text_mode, n;
+      int n;
       file_pos = tell (stream->_handle);
 …
           origin = SEEK_SET;
+        }
+      text_mode = (   (pFH = __libc_FH (stream->_handle)) != NULL
                    && (pFH->fFlags & F_CRLF));
+      const unsigned text_mode = __libc_FHGetFlags (stream->_handle) & F_CRLF;
       n = stream->_ptr - stream->_buffer;
       if (text_mode)
 …
   return fseeko (stream, (off_t)offset, origin);
+}

trunk/libc/src/libc/io/ftell.c

-              r2090
+              r2739
 #include <limits.h>
 #include <errno.h>
 #include <emx/io.h>
+#include <klibc/io.h>
 off_t _ftello_unlocked (FILE *stream)
+{
   off_t     pos;
-  PLIBCFH   pFH;
   if (stream->_flags & _IOSPECIAL)
 …
           pos += stream->_ptr - stream->_buffer;
           if (!(stream->_flags & _IOSPECIAL)
+              && (pFH = __libc_FH (stream->_handle)) != NULL
+              && (pFH->fFlags & O_TEXT))
+              && (__libc_FHGetFlags (stream->_handle) & O_TEXT))
+            {
               const char *p;
 …
       if (!(stream->_flags & _IOSPECIAL)
           && stream->_ungetc_count == 0
+          && (pFH = __libc_FH (stream->_handle)) != NULL
+          && (pFH->fFlags & F_CRLF))
+          && (__libc_FHGetFlags (stream->_handle) & F_CRLF))
+        {
           const char *p;

trunk/libc/src/libc/io/ioctl.c

-              r871
+              r2739
 #include <sys/termio.h>
 #include <sys/ioctl.h>
 #include <emx/io.h>
+#include <klibc/io.h>
 #include <emx/syscalls.h>
 …
+{
     va_list     va;
+    PLIBCFH     pFH;
+    int         rc, saved_errno, arg, *int_ptr;
+    int         saved_errno, arg, *int_ptr;
     const struct termio *tp;
 …
      * Get filehandle.
      */
+    pFH = __libc_FH(handle);
+    if (!pFH)
+    __LIBC_PFH pFH;
+    int rc = __libc_FHGet(handle, &pFH);
+    if (rc)
+    {
         errno = EBADF;
+        errno = -rc;
         return -1;
+    }
 …
      */
     saved_errno = errno; errno = 0;
     va_start (va, request);
+    va_start(va, request);
     arg = va_arg(va, int);
     va_end (va);
+    va_end(va);
     rc = __ioctl2(handle, request, arg);
 …
      * On success do small touches of our own.
      */
     /** @todo fFlags can be handled by the syscall just as well as here..*/
+    /** @todo fFlags should be handled by the backend! */
     if (rc >= 0 && errno == 0)
+    {
 …
     if (errno == 0)
         errno = saved_errno;
+    __libc_FHPut(pFH);
     return rc;
+}

trunk/libc/src/libc/io/isatty.c

-              r1454
+              r2739
 #include <io.h>
 #include <errno.h>
 #include <emx/io.h>
+#include <klibc/io.h>
 int _STD(isatty)(int handle)
+{
+    PLIBCFH pFH;
+    /*
+     * Get filehandle and inspect the flags.
+     */
+    __LIBC_PFH pFH;
+    int rc = __libc_FHGet(handle, &pFH);
+    if (!rc)
+    {
+        rc = (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_DEV;
+        __libc_FHPut(pFH);
+    }
+    else
+    {
+        errno = -rc;
+        rc = 0;
+    }
+    return rc;
+}
-    /*
-     * Get filehandle.
-     */
-    pFH = __libc_FH(handle);
-    if (!pFH)
+    {
-        errno = EBADF;
-        return 0;
+    }
-    return (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_DEV;
+}

trunk/libc/src/libc/io/lseek.c

-              r1519
+              r2739
 #include <io.h>
 #include <errno.h>
 #include <emx/io.h>
 #include <InnoTekLIBC/backend.h>
+#include <klibc/io.h>
+#include <klibc/backend.h>
 off_t _STD(lseek) (int handle, off_t offset, int origin)
+{
-    PLIBCFH pFH;
-    off_t   n;
     /*
      * Get filehandle.
      */
+    pFH = __libc_FH(handle);
+    if (!pFH)
+      return -1;
+    __LIBC_PFH pFH;
+    int rc = __libc_FHGet(handle, &pFH);
+    if (rc)
+    {
+        errno = -rc;
+        return -1;
+    }
+    /*
+     * If we've got a read-ahead byte or Ctrl-Z, adjust SEEK_CUR seeks.
+     */
     if (    origin == SEEK_CUR
         && (    pFH->iLookAhead >= 0
             || (pFH->fFlags & F_EOF)) )
         --offset;
+    n = __libc_Back_ioSeek(handle, offset, origin);
+    /*
+     * Do the seek.
+     */
+    off_t n = __libc_Back_ioSeek(handle, offset, origin);
     if (n >= 0)
+    {
         pFH->fFlags &= ~F_EOF;          /* Clear Ctrl-Z flag */
         pFH->iLookAhead = -1;           /* Clear lookahead */
+        __libc_FHPut(pFH);
         return n;
+    }
 …
     return -1;
+}

trunk/libc/src/libc/io/pc_setmode.c

-              r2229
+              r2739
 #include <fcntl.h>
 #include <errno.h>
 #include <emx/io.h>
+#include <klibc/io.h>
 int _STD(setmode)(int handle, int mode)
+{
-    PLIBCFH pFH;
-    int     old_mode;
     /*
      * Get filehandle.
      */
+    pFH = __libc_FH(handle);
+    if (!pFH)
+    __LIBC_PFH pFH;
+    int rc = __libc_FHGet(handle, &pFH);
+    if (rc)
+    {
         errno = EBADF;
+        errno = -rc;
         return -1;
+    }
 …
      * O_BINARY isn't normally stored in the fFlags member.
      */
     old_mode = (pFH->fFlags & O_TEXT) ? O_TEXT : O_BINARY;
+    unsigned old_mode = (pFH->fFlags & O_TEXT) ? O_TEXT : O_BINARY;
     if (mode == O_BINARY)
         pFH->fFlags &= ~O_TEXT;
 …
         pFH->fFlags = (pFH->fFlags & ~O_BINARY) | O_TEXT; /* paranoia */
     else
+    {
+    {   __libc_FHPut(pFH);
         errno = EINVAL;
         return -1;
+    }
+    __libc_FHPut(pFH);
     return old_mode;
+}

trunk/libc/src/libc/io/pipe.c

-              r871
+              r2739
 #include <fcntl.h>
 #include <errno.h>
 #include <emx/io.h>
+#include <klibc/io.h>
 #include <emx/syscalls.h>
 …
 int _STD(pipe)(int *two_handles)
+{
     PLIBCFH pFHRead, pFHWrite;
+    __LIBC_PFH pFHRead, pFHWrite;
     if (__pipe(two_handles, _pipe_size != 0 ? _pipe_size : 8192, &pFHRead, &pFHWrite) != 0)
 …
         pFHWrite->fFlags |= O_TEXT;
+    }
+    __libc_FHPut(pFHRead);
+    __libc_FHPut(pFHWrite);
     return 0;

trunk/libc/src/libc/io/read.c

-              r1454
+              r2739
 /* read.c (emx+gcc) -- Copyright (c) 1990-1999 by Eberhard Mattes */
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_IO
 #include "libc-alias.h"
 #include <string.h>
+#include <signal.h>
 #include <io.h>
 #include <fcntl.h>
 #include <errno.h>
+#include <limits.h>
 #include <sys/builtin.h>
+#include <emx/io.h>
+#include <emx/syscalls.h>
+#include <klibc/io.h>
+#include <klibc/backend.h>
+#include <klibc/logstrict.h>
+static ssize_t read_lookahead(int fh, void *pvBuf, size_t cbToRead, __LIBC_PFH pFH);
+/**
+ * Do post read processing of the buffer to convert \\r\\n -> \\n.
+ *
+ * In one odd case, we will read ahead to figure out if a \\r is followed by a \\n or not.
+ *
+ * @returns The cbRead value correcte for the conversions.
+ * @returns -1 and errno = EAGAIN if we cannot read the byte following a \\r (cbRead == 1).
+ *
+ * @param   fh          The file handle in question.
+ * @param   pbDst       The buffer with the data we've just read.
+ * @param   cbRead      The number of bytes in the buffer.
+ * @param   pFH         The file handle structure.
+ */
+static ssize_t read_text(int fh, char *pbDst, ssize_t cbRead, __LIBC_PFH pFH)
+{
+    /* special processing for text mode */
+    if (    (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_FILE
+        &&  pbDst[cbRead - 1] == 0x1a
+        &&  eof(fh))
+    {
+        /* remove last Ctrl-Z in text files */
+        cbRead--;
+        pFH->fFlags |= F_EOF;
+        if (cbRead == 0)
+            return 0;
+    }
+    if (__predict_false(cbRead == 1 && pbDst[0] == '\r'))
+    {
+        /*
+         * This is the tricky case as we are not allowed to decrement cbRead by one
+         * as 0 indicates end of file. We have to use look ahead.
+         */
+        char c;
+        int saved_errno = errno;
+        ssize_t j = read_lookahead(fh, &c, 1, pFH); /* look ahead */
+        if (j == -1 && errno == EAGAIN)
+        {
+            LIBCLOG_MSG2("fh=%d iLookAhead=\\r\n", fh);
+            pFH->iLookAhead = '\r';
+            return -1;
+        }
+        if (j == 1)
+        {
+            if (c == '\n')                          /* CR/LF ? */
+            {
+                pbDst[0] = '\n';                    /* yes -> replace with LF */
+                pFH->fFlags |= F_CRLF;
+                LIBCLOG_MSG2("fh=%d looked ahead: '\\n'", fh);
+            }
+            else
+            {
+                pFH->iLookAhead = (unsigned char)c; /* no -> save the 2nd char */
+                LIBCLOG_MSG2("fh=%d iLookAhead=%#04x\n", fh, (unsigned char)c);
+            }
+        }
+        else
+            LIBCLOG_MSG2("fh=%d looked ahead: errno=%d!", errno);
+        errno = saved_errno;                        /* hide error */
+    }
+    else
+    {
+        /*
+         * Translate each CR/LF pair to a newline character. Set F_CRLF if at
+         * lest one such translation has been  performed. Set the file's
+         * look-ahead to CR if the buffer ends with CR.
+         */
+        size_t cbNewSize;
+        if (_crlf(pbDst, cbRead, &cbNewSize))
+        {
+            /* Buffer ends with CR: Set look ahead and adjust `cbRead' for F_CRLF logic. */
+            pFH->iLookAhead = '\r';
+            cbRead--;
+        }
+        if (cbNewSize != cbRead)
+            pFH->fFlags |= F_CRLF;
+        cbRead = cbNewSize;
+    }
+    return cbRead;
+}
 /* Read NBYTE characters, use lookahead, if available. This is simple
    unless O_NDELAY is in effect. */
 static int read_lookahead (int handle, void *buf, size_t nbyte, PLIBCFH pFH)
+static ssize_t read_lookahead(int fh, void *pvBuf, size_t cbToRead, __LIBC_PFH pFH)
+{
+  int i, n, la, saved_errno;
+  char *dst;
+    int la;
+    size_t i = 0;
+    char *pbDst = (char *)pbDst;
+    if (    cbToRead > 0
+        &&  (la = __lxchg(&pFH->iLookAhead, -1)) != -1)
+    {
+        *pbDst++ = (char)la;
+        i++;
+        cbToRead--;
+    }
+  i = 0; dst = buf; saved_errno = errno;
+  if (nbyte > 0 && (la = __lxchg (&pFH->iLookAhead, -1)) != -1)
+    {
+      *dst = (char)la;
+      ++i; --nbyte;
+    }
+  n = __read (handle, dst+i, nbyte);
+  if (n == -1)
+    {
+      if (errno == EAGAIN && i > 0)           /* lookahead and O_NDELAY */
+        {
+          errno = saved_errno;                /* hide EAGAIN */
+          return i;                           /* and be successful */
+        }
+      return -1;
+    }
+  return i + n;
+    size_t cbRead;
+    int rc = __libc_Back_ioRead(fh, pbDst, cbToRead, &cbRead);
+    if (__predict_true(!rc))
+        return i + cbRead;
+    if (rc == -EAGAIN && i > 0)                 /* lookahead and O_NDELAY */
+        return i;
+    errno = -rc;
+    return -1;
+}
 ssize_t _STD(read) (int handle, void *buf, size_t nbyte)
+ssize_t _STD(read)(int fh, void *pvBuf, size_t cbToRead)
+{
+  int       n;
+  PLIBCFH   pFH;
+  size_t    j, k;
+  char     *dst, c;
+    LIBCLOG_ENTER("fh=%d pvBuf=%p cbToRead=%zu\n", fh, pvBuf, cbToRead);
+  /*
+   * Get filehandle.
+   */
+  pFH = __libc_FH(handle);
+  if (!pFH)
+    /*
+     * Get filehandle.
+     */
+    __LIBC_PFH  pFH;
+    int rc = __libc_FHGet(fh, &pFH);
+    if (rc)
+    {
       errno = EBADF;
       return -1;
+        errno = -rc;
+        LIBCLOG_ERROR_RETURN_INT(-1);
+    }
   pFH->fFlags &= ~F_CRLF;           /* No CR/LF pair translated to newline */
   if (nbyte > 0 && (pFH->fFlags & F_EOF))
+    return 0;
   dst = buf;
   n = read_lookahead (handle, dst, nbyte, pFH);
   if (n == -1)
     return -1;
   if ((pFH->fFlags & O_TEXT) && !(pFH->fFlags & F_TERMIO) && n > 0)
+    /* No CR/LF pair translated to newline */
+    pFH->fFlags &= ~F_CRLF;
+    /*
+     * End-of-file?
+     */
+    if (    cbToRead > 0
+        &&  (pFH->fFlags & F_EOF))
+    {
+      /* special processing for text mode */
+      if (  (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_FILE
+          && dst[n-1] == 0x1a
+          && eof (handle))
+        __libc_FHPut(pFH);
+        LIBCLOG_RETURN_INT(0);
+    }
+    /*
+     * Perform the read.
+     */
+    ssize_t cbRead = read_lookahead(fh, pvBuf, cbToRead, pFH);
+    if (__predict_false(cbRead == -1))
+    {
+        __libc_FHPut(pFH);
+        LIBCLOG_ERROR_RETURN_INT(-1);
+    }
+    /*
+     * Need to do \r\n -> \n translation?
+     */
+    if (    (pFH->fFlags & O_TEXT)
+        &&  !(pFH->fFlags & F_TERMIO)
+        &&  cbRead > 0)
+    {
+        cbRead = read_text(fh, (char *)pvBuf, cbRead, pFH);
+        if (cbRead < 0)
+        {
+          /* remove last Ctrl-Z in text files */
+          --n;
+          pFH->fFlags |= F_EOF;
+          if (n == 0)
+            return 0;
+        }
+      if (n == 1 && dst[0] == '\r')
+        {
+          /* This is the tricky case as we are not allowed to
+             decrement n by one as 0 indicates end of file. We have to
+             use look ahead. */
+          int saved_errno = errno;
+          j = read_lookahead (handle, &c, 1, pFH); /* look ahead */
+          if (j == -1 && errno == EAGAIN)
+            {
+              pFH->iLookAhead = '\r';
+              return -1;
+            }
+          errno = saved_errno;                /* hide error */
+          if (j == 1 && c == '\n')            /* CR/LF ? */
+            {
+              dst[0] = '\n';                  /* yes -> replace with LF */
+              pFH->fFlags |= F_CRLF;
+            }
+          else
+            pFH->iLookAhead = (unsigned char)c; /* no -> save the 2nd char */
+        }
+      else
+        {
+          /* Translate each CR/LF pair to a newline character.  Set
+             F_CRLF if at lest one such translation has been
+             performed.  Set the file's look-ahead to CR if the buffer
+             ends with CR. */
+          if (_crlf (dst, n, &k))
+            {
+              /* Buffer ends with CR: Set look ahead and adjust `n'
+                 for F_CRLF logic. */
+              pFH->iLookAhead = '\r';
+              --n;
+            }
+          if (k != n)
+            pFH->fFlags |= F_CRLF;
+          n = k;
+            __libc_FHPut(pFH);
+            LIBCLOG_ERROR_RETURN_INT(cbRead);
+        }
+    }
+  return n;
+    __libc_FHPut(pFH);
+    LIBCLOG_RETURN_INT(cbRead);
+}

trunk/libc/src/libc/io/tell.c

-              r1519
+              r2739
 #include <io.h>
 #include <errno.h>
 #include <emx/io.h>
 #include <InnoTekLIBC/backend.h>
+#include <klibc/io.h>
+#include <klibc/backend.h>
 off_t _STD(tell)(int handle)
+{
+    PLIBCFH pFH;
+    off_t   n;
+    /*
+     * Get filehandle.
+     */
+    __LIBC_PFH pFH;
+    int rc = __libc_FHGet(handle, &pFH);
+    if (rc)
+    {
+        errno = -rc;
+        return -1;
+    }
+    pFH = __libc_FH(handle);
+    if (!pFH)
+        return -1;
+    n = __libc_Back_ioSeek(handle, 0L, SEEK_CUR);
+    off_t n = __libc_Back_ioSeek(handle, 0L, SEEK_CUR);
     if (n >= 0)
+    {
+        if (pFH->iLookAhead >= 0 || (pFH->fFlags & F_EOF))
+        if (    pFH->iLookAhead >= 0
+            ||  (pFH->fFlags & F_EOF))
             --n;
+        __libc_FHPut(pFH);
         return n;
+    }
+    __libc_FHPut(pFH);
     errno = -n;
     return -1;
+}

trunk/libc/src/libc/io/write.c

-              r1519
+              r2739
 /* write.c (emx+gcc) -- Copyright (c) 1990-1996 by Eberhard Mattes */
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_IO
 #include "libc-alias.h"
 #include <string.h>
 …
 #include <fcntl.h>
 #include <errno.h>
+#include <emx/io.h>
+#include <emx/syscalls.h>
+#include <InnoTekLIBC/backend.h>
+#include <limits.h>
+#include <klibc/io.h>
+#include <klibc/backend.h>
+#include <klibc/logstrict.h>
 #define CTRL_Z 0x1a
+#define BEGIN do {
+#define END   } while (0)
+/* Write the current buffer, for write_text(). */
+#define WRTBUF                                                  \
+  BEGIN                                                         \
+    n = __write (handle, buf, buf_cnt);                         \
+    if (n < 0) return -1;                                       \
+    out_cnt += n;                                               \
+    if (n != buf_cnt) goto partial;                             \
+    buf_cnt = 0; lf_cnt_1 = lf_cnt; buf_pos = i;                \
+  END
+/**
+ * Write the current buffer, for write_text().
+ */
+#define WRTBUF                                                      \
+    do {                                                            \
+        int rc = __libc_Back_ioWrite (fh, buf, buf_cnt, &n);        \
+        if (rc < 0)                                                 \
+        {                                                           \
+            errno = -rc;                                            \
+            return -1;                                              \
+        }                                                           \
+        out_cnt += n;                                               \
+        if (n != buf_cnt)                                           \
+            goto l_partial;                                         \
+        buf_cnt = 0; lf_cnt_1 = lf_cnt; buf_pos = i;                \
+    } while (0)
 /* Write to a text-mode file.  Partial writes are possible.  `buf' is
 …
    Return -1 on error. */
 static int write_text (int handle, const char *src, size_t nbyte, PLIBCFH pFH)
+static ssize_t write_text(int fh, const char *src, size_t nbyte, __LIBC_PFH pFH)
+{
+  int out_cnt, lf_cnt, lf_cnt_1, buf_cnt, n;
+  size_t i, buf_pos;
+  char buf[2*512];
+  char splitp;
+  out_cnt = lf_cnt = lf_cnt_1 = buf_cnt = 0;
+  buf_pos = 0; i = 0;
+  if (pFH->fFlags & F_WRCRPEND)
+    {
+      if (*src == '\n')
+        {
+          /* Handle the first newline specially: Don't prepend a '\r'
+             character. */
+          buf[buf_cnt++] = src[i++];
+        }
+      else
+        {
+          /* This is the case where our algorithm fails: The
+             application does not try to continue writing with a
+             newline.  There will be an unexpected '\r' left in the
+             pipe. */
+          pFH->fFlags &= ~F_WRCRPEND;
+        }
+    }
+  while (i < nbyte)
+    {
+      if (src[i] == '\n')
+        {
+          /* Don't split '\r' and '\n' between two __write() calls as
+             we cannot remove the '\r' from a pipe in case the second
+             __write() fails. */
+         if (buf_cnt >= sizeof (buf) - 1) WRTBUF;
+          buf[buf_cnt++] = '\r';
+          ++lf_cnt;
+        }
+      if (buf_cnt >= sizeof (buf)) WRTBUF;
+      buf[buf_cnt++] = src[i++];
+    }
+  if (buf_cnt != 0) WRTBUF;
+  pFH->fFlags &= ~F_WRCRPEND;
+  return out_cnt - lf_cnt;
+partial:
+  /* Not all bytes have been written. */
+  if (n == 0)
+    ssize_t out_cnt, lf_cnt, lf_cnt_1, buf_cnt;
+    size_t i, buf_pos, n;
+    char buf[2*512];
+    char splitp;
+    out_cnt = lf_cnt = lf_cnt_1 = buf_cnt = 0;
+    buf_pos = 0; i = 0;
+    if (pFH->fFlags & F_WRCRPEND)
+    {
+        if (*src == '\n')
+        {
+            /* Handle the first newline specially: Don't prepend a '\r'
+               character. */
+            buf[buf_cnt++] = src[i++];
+        }
+        else
+        {
+            /* This is the case where our algorithm fails: The
+               application does not try to continue writing with a
+               newline.  There will be an unexpected '\r' left in the
+               pipe. */
+            pFH->fFlags &= ~F_WRCRPEND;
+        }
+    }
+    while (i < nbyte)
+    {
+        if (src[i] == '\n')
+        {
+            /* Don't split '\r' and '\n' between two __write() calls as
+               we cannot remove the '\r' from a pipe in case the second
+               __write() fails. */
+            if (buf_cnt >= sizeof(buf) - 1)
+                WRTBUF;
+            buf[buf_cnt++] = '\r';
+            ++lf_cnt;
+        }
+        if (buf_cnt >= sizeof(buf))
+            WRTBUF;
+        buf[buf_cnt++] = src[i++];
+    }
+    if (buf_cnt != 0)
+        WRTBUF;
+    pFH->fFlags &= ~F_WRCRPEND;
+    return out_cnt - lf_cnt;
+l_partial:
+    /* Not all bytes have been written. */
+    LIBCLOG_MSG("Partial read n=%zu out_cnt=%zd lf_cnt1=%zd\n", n, out_cnt, lf_cnt_1);
+    if (n == 0)
+        return out_cnt - lf_cnt_1;
+    /* Adjust the return value for newline conversion: Add to `lf_cnt_1'
+       the number of '\r' characters written.
+       If the '\r', but not the '\n', of an expanded newline has been
+       written, processing depends on the fh type.  For files, we
+       remove the '\r' by changing the size of the file.  For pipes (and
+       devices), we exclude the newline from the count and set a flag to
+       let the next write() omit the '\r' if the first character to be
+       written is a newline. */
+    buf_cnt = 0; splitp = 0;
+    for (i = buf_pos; buf_cnt < n; ++i)
+    {
+        /* Check for '\r' in `buf' to fh the case of an initial '\n'
+           with suppressed '\r'. */
+        if (src[i] == '\n' && buf[buf_cnt] == '\r')
+        {
+            ++buf_cnt;
+            if (buf_cnt == n)
+                splitp = 1;
+            if (buf_cnt <= n)
+                ++lf_cnt_1;
+        }
+        ++buf_cnt;
+    }
+    if (splitp)
+    {
+        if ((pFH->fFlags & __LIBC_FH_TYPEMASK) != F_FILE)
+            pFH->fFlags |= F_WRCRPEND;
+        else
+        {
+            off_t pos = __libc_Back_ioSeek(fh, -1, SEEK_CUR);
+            if (pos >= 0)
+                __libc_Back_ioFileSizeSet(fh, pos, 0);
+        }
+    }
+    else
+        pFH->fFlags &= ~F_WRCRPEND;
     return out_cnt - lf_cnt_1;
-  /* Adjust the return value for newline conversion: Add to `lf_cnt_1'
-     the number of '\r' characters written.
-     If the '\r', but not the '\n', of an expanded newline has been
-     written, processing depends on the handle type.  For files, we
-     remove the '\r' by changing the size of the file.  For pipes (and
-     devices), we exclude the newline from the count and set a flag to
-     let the next write() omit the '\r' if the first character to be
-     written is a newline. */
-  buf_cnt = 0; splitp = 0;
-  for (i = buf_pos; buf_cnt < n; ++i)
+    {
-      /* Check for '\r' in `buf' to handle the case of an initial '\n'
-         with suppressed '\r'. */
-      if (src[i] == '\n' && buf[buf_cnt] == '\r')
+        {
-          ++buf_cnt;
-          if (buf_cnt == n)
-            splitp = 1;
-          if (buf_cnt <= n)
-            ++lf_cnt_1;
+        }
-      ++buf_cnt;
+    }
-  if (splitp)
+    {
-      if ((pFH->fFlags & __LIBC_FH_TYPEMASK) != F_FILE)
-        pFH->fFlags |= F_WRCRPEND;
-      else
+        {
-          off_t pos = __libc_Back_ioSeek (handle, -1, SEEK_CUR);
-          if (pos >= 0)
-            __libc_Back_ioFileSizeSet (handle, pos, 0);
+        }
+    }
-  else
-    pFH->fFlags &= ~F_WRCRPEND;
-  return out_cnt - lf_cnt_1;
+}
 int _STD(write) (int handle, const void *buf, size_t nbyte)
+ssize_t _STD(write)(int fh, const void *pvBuf, size_t cbToWrite)
+{
+  PLIBCFH   pFH;
+  int       n;
+  const char *src;
+  /*
+   * Get filehandle
+   */
+  pFH = __libc_FH(handle);
+  if (!pFH)
+      return -1;
+  if ((pFH->fFlags & (__LIBC_FH_TYPEMASK | O_APPEND)) == (O_APPEND | F_FILE))
+    __libc_Back_ioSeek (handle, 0, SEEK_END);
+  if (nbyte == 0)                 /* Avoid truncation of file */
+    return 0;
+  src = buf;
+  if (    (pFH->fFlags & O_TEXT)
+       && (   (pFH->fFlags & F_WRCRPEND)
+           || memchr (src, '\n', nbyte) != NULL))
+    n = write_text (handle, src, nbyte, pFH);
+  else
+    n = __write (handle, src, nbyte);
+  if (n < 0)
+    {
+      if (errno == EPIPE)
+        {
+          raise (SIGPIPE);
+          errno = EPIPE;
+        }
+      return -1;
+    }
+  if (n == 0)
+    {
+      /* Ctrl-Z cannot be written to certain devices (printer) unless
+         they have been switched to binary mode.  Don't return an
+         error if writing failed due to a Ctrl-Z at the start of the
+         data to be written. */
+      if (   (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_DEV
+          && *src == CTRL_Z)
+        return 0;
+      /* For devices and pipes with O_NONBLOCK set, set errno to
+         EAGAIN. */
+      if (   (pFH->fFlags & O_NONBLOCK)
+          && (   (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_DEV
+              || (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_SOCKET /* ???? */
+              || (pFH->fFlags & __LIBC_FH_TYPEMASK) == F_PIPE) )
+        {
+          errno = EAGAIN;
+          return -1;
+        }
+      /* Set errno to ENOSPC in all remaining cases (disk full while
+         writing to a disk file). */
+      errno = ENOSPC;
+      return -1;
+    }
+  return n;
+    LIBCLOG_ENTER("fh=%d pvBuf=%p cbToWrite=%zu\n", fh, pvBuf, cbToWrite);
+    /*
+     * Check for overflows (implementation defined).
+     */
+    if (cbToWrite > SSIZE_MAX)
+    {
+        errno = E2BIG;
+        LIBCLOG_ERROR_RETURN_UINT(-1);
+    }
+    /*
+     * Get filehandle
+     */
+    __LIBC_PFH pFH;
+    int rc = __libc_FHGet(fh, &pFH);
+    if (rc)
+    {
+        errno = -rc;
+        LIBCLOG_ERROR_RETURN_UINT(-1);
+    }
+    /*
+     * Perform the write operation.
+     */
+    ssize_t cbWritten;
+    if (    (pFH->fFlags & O_TEXT)
+        &&  (   (pFH->fFlags & F_WRCRPEND)
+             || memchr(pvBuf, '\n', cbToWrite) != NULL))
+        cbWritten = write_text(fh, pvBuf, cbToWrite, pFH);
+    else
+    {
+        size_t cbWritten2;
+        rc = __libc_Back_ioWrite(fh, pvBuf, cbToWrite, &cbWritten2);
+        if (!rc)
+            cbWritten = cbWritten2;
+        else
+        {
+            errno = -rc;
+            cbWritten = -1;
+        }
+    }
+    /*
+     * Success.
+     */
+    __libc_FHPut(pFH);
+    if (__predict_true(cbWritten > 0))
+        LIBCLOG_RETURN_INT(cbWritten);
+    if (errno == EPIPE)
+    {
+/** @todo this probably belongs in the backend. */
+        raise(SIGPIPE);
+        errno = EPIPE;
+    }
+    LIBCLOG_ERROR_RETURN_INT(-1);
+}

trunk/libc/src/libc/locale/Makefile.kmk

r2729	r2739
57	57	$(PATH_LIBC_SRC)/libc/locale/os2/__to_ucs.c \
58	58
59		libc_libc_locale_SOURCES.~~win32~~ = \
	59	libc_libc_locale_SOURCES.nt = \
60	60	$(PATH_LIBC_SRC)/libc/locale/generic/locale_ctype-generic.c \
61	61	$(PATH_LIBC_SRC)/libc/locale/generic/setlocale-generic.c \

trunk/libc/src/libc/malloc/Makefile.kmk

-              r2702
+              r2739
 libc_libc_malloc_TEMPLATE = libcsub
 libc_libc_malloc_SOURCES = \
+    $(PATH_LIBC_SRC)/libc/malloc/brk.c \
     $(PATH_LIBC_SRC)/libc/malloc/calloc.c \
     $(PATH_LIBC_SRC)/libc/malloc/defalloc.c \
 …
     $(PATH_LIBC_SRC)/libc/malloc/posix_memalign.c \
     $(PATH_LIBC_SRC)/libc/malloc/realloc.c \
+    $(PATH_LIBC_SRC)/libc/malloc/sbrk.c \
     $(PATH_LIBC_SRC)/libc/malloc/tcalloc.c \
     $(PATH_LIBC_SRC)/libc/malloc/tfree.c \

trunk/libc/src/libc/malloc/_linitheap.c

-              r2254
+              r2739
 *******************************************************************************/
 #include "libc-alias.h"
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_HEAP
 #include <stdlib.h>
 #include <emx/umalloc.h>
 #include <sys/smutex.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_HEAP
 #include <InnoTekLIBC/logstrict.h>
+#include <klibc/backend.h>
+#include <klibc/logstrict.h>
 …
      * Initialize the sbrk model and allocate the initial heap block.
      */
     _uflags(_UF_SBRK_MODEL, _UF_SBRK_ARBITRARY);
+    __libc_Back_mmanSBrkSetModel(__LIBC_SBRK_MODEL_ARBITRARY);
     pvInitial = sbrk(_INITIAL_DEFAULT_HEAP_SIZE);
     if (pvInitial == (void *)-1)

trunk/libc/src/libc/misc/Makefile.kmk

r2717	r2739
147	147	$(PATH_LIBC_SRC)/libc/misc/_getdrive.c \
148	148	$(PATH_LIBC_SRC)/libc/misc/_realrealpath.c \
	149	$(PATH_LIBC_SRC)/libc/misc/_uflags.c \
149	150
150	151	libc_libc_misc_SOURCES.x86 = \

trunk/libc/src/libc/process/Makefile.kmk

-              r2730
+              r2739
     $(PATH_LIBC_SRC)/libc/process/os2/fmutex-os2.c \
 libc_libc_process_SOURCES.win32 = \
+libc_libc_process_SOURCES.nt = \
     $(PATH_LIBC_SRC)/libc/process/nt/fmutex-nt.c \
     $(PATH_LIBC_SRC)/libc/process/nt/smutex-nt.c \
+    $(PATH_LIBC_SRC)/libc/process/nt/_errno-nt.c \
+libc_libc_process_SOURCES.win64 = $(libc_libc_process_SOURCES.win32)
+$(PATH_LIBC_SRC)/libc/process/nt/_errno-nt.c_CFLAGS = -fomit-frame-pointer -O3
 # configure the variants. */

trunk/libc/src/libc/process/fmutex2.c

-              r2719
+              r2739
 /* fmutex2.c (emx+gcc) -- Copyright (c) 1996 by Eberhard Mattes */
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_MUTEX
 #include "libc-alias.h"
-#include <stdlib.h>
-#include <string.h>
-#include <sys/builtin.h>
 #include <sys/fmutex.h>
 #define __LIBC_LOG_GROUP __LIBC_LOG_GRP_MUTEX
 #include <InnoTekLIBC/logstrict.h>
+#include <klibc/logstrict.h>
+#include <klibc/backend.h>

trunk/libc/src/libc/process/psignal.c

-              r2254
+              r2739
      * Write message.
      */
+    size_t cbWritten;
     if (pszMsg && *pszMsg)
+    {
         __write(STDERR_FILENO, pszMsg, strlen(pszMsg));
         __write(STDERR_FILENO, ": ", sizeof(": ") - 1);
+        __libc_Back_ioWrite(STDERR_FILENO, pszMsg, strlen(pszMsg), &cbWritten);
+        __libc_Back_ioWrite(STDERR_FILENO, ": ", sizeof(": ") - 1, &cbWritten);
+    }
     __write(STDERR_FILENO, pszSignal, strlen(pszSignal));
     __write(STDERR_FILENO, "\n", sizeof("\n") - 1);
+    __libc_Back_ioWrite(STDERR_FILENO, pszSignal, strlen(pszSignal), &cbWritten);
+    __libc_Back_ioWrite(STDERR_FILENO, "\n", sizeof("\n") - 1, &cbWritten);
     LIBCLOG_RETURN_VOID();

trunk/libc/src/libc/process/thread_internals.c

-              r2254
+              r2739
 *   Header Files                                                               *
 *******************************************************************************/
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_THREAD
 #include "libc-alias.h"
 #undef NDEBUG
 #include <386/builtin.h>
+#include <sys/builtin.h>
 #include <assert.h>
 #include <string.h>
 …
 #include <emx/umalloc.h>
 #include <emx/syscalls.h>
+#include <InnoTekLIBC/thread.h>
+#include <InnoTekLIBC/backend.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_THREAD
+#include <InnoTekLIBC/logstrict.h>
+#include <klibc/thread.h>
+#include <klibc/backend.h>
+#include <klibc/logstrict.h>
 …
+/**
+ * Internal wrapper for the various OS interfaces for
+ * setting the thread pointer.
+ *
+ * @param   pThrd   The new thread pointer.
+ */
+static inline void threadSetPtr(__LIBC_PTHREAD pThrd)
+{
+#ifdef __OS2__
+    *__libc_gpTLS = pThrd;
+#elif defined(__NT__)
+    fibSetLibcThread(pThrd);
+#else
+# error "Port me!"
+#endif
+}
 /**
 …
      */
     assert(!pThrd->pNext && !pThrd->tid);
     *__libc_gpTLS = pThrd;
+    threadSetPtr(pThrd);
     /*
 …
+{
     LIBCLOG_ENTER("\n");
+    if (!*__libc_gpTLS)
+    {
+        __LIBC_PTHREAD  pThrd;
+    if (!__libc_threadCurrentNoAuto())
+    {
         /*
          * Setup a temporary thread block on the stack so _hmalloc()
          * can't end up calling us recursivly if something goes wrong.
          */
         __LIBC_THREAD   Thrd;
+        __LIBC_THREAD Thrd;
         threadInit(&Thrd, NULL);
+        *__libc_gpTLS   = &Thrd;
+        threadSetPtr(&Thrd);
+        __LIBC_PTHREAD pThrd;
         if (!__lxchg(&gfPreAllocThrd, 1))
             pThrd = &gPreAllocThrd;
 …
+    }
     LIBCLOG_RETURN_P(*__libc_gpTLS);
+    LIBCLOG_RETURN_P(__libc_threadCurrentNoAuto());
+}
 …
          * Clear the TLS if it's for the current thread.
          */
         if (*__libc_gpTLS == pThrd)
             *__libc_gpTLS = NULL;
+        if (__libc_threadCurrentNoAuto() == pThrd)
+            threadSetPtr(NULL);
         /*

trunk/libc/src/libc/process/tls.c

-              r2260
+              r2739
 *   Header Files                                                               *
 *******************************************************************************/
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_THREAD
+#include <errno.h>
 #include <sys/builtin.h>
-#include <errno.h>
 #include <sys/limits.h>
 #include <sys/smutex.h>
+#include <InnoTekLIBC/thread.h>
+#define __LIBC_LOG_GROUP __LIBC_LOG_GRP_THREAD
+#include <InnoTekLIBC/logstrict.h>
+#include <klibc/thread.h>
+#include <klibc/logstrict.h>
 …
                     for (uBit = 0; uBit < ENTRY_BITS; uBit++)
+                    {
                         if (!__atomic_set_bit(pu, uBit))
+                        if (!__atomic_bit_test_and_set(pu, uBit))
+                        {
                             int iBitRet = (pu - &gauBitmap[0]) * ENTRY_BITS + uBit;
 …
     if (    iIndex < 0
         ||  iIndex >= __LIBC_TLS_MAX
         ||  !__atomic_test_bit(&gauBitmap[0], iIndex)
+        ||  !__bit_test(&gauBitmap[0], iIndex)
+            )
+    {
 …
     gapfnDestructors[iIndex] = NULL;
     /* @todo do serialized NULLing of all threads! */
     __atomic_clear_bit(&gauBitmap[0], iIndex);
+    __atomic_bit_clear(&gauBitmap[0], iIndex);
     /*
 …
     if (    iIndex < 0
         ||  iIndex >= __LIBC_TLS_MAX
         ||  !__atomic_test_bit(&gauBitmap[0], iIndex)
+        ||  !__bit_test(&gauBitmap[0], iIndex)
+            )
+    {
 …
     if (    iIndex < 0
         ||  iIndex >= __LIBC_TLS_MAX
         ||  !__atomic_test_bit(&gauBitmap[0], iIndex)
+        ||  !__bit_test(&gauBitmap[0], iIndex)
+            )
+    {
 …
     if (    iIndex < 0
         ||  iIndex >= __LIBC_TLS_MAX
         ||  !__atomic_test_bit(&gauBitmap[0], iIndex)
+        ||  !__bit_test(&gauBitmap[0], iIndex)
+            )
+    {
 …
                         void (*pfnDestructor)(void *, int, unsigned);
                         void  *pvValue;
                         if (    __atomic_test_bit(&gauBitmap[0], k)
+                        if (    __bit_test(&gauBitmap[0], k)
                             &&  k < __LIBC_TLS_MAX
                             &&  (pvValue = pThrd->apvTLS[k]) != NULL
 …
     if (    iIndex < 0
         ||  iIndex >= __LIBC_TLS_MAX
         ||  !__atomic_test_bit(&gauBitmap[0], iIndex)
+        ||  !__bit_test(&gauBitmap[0], iIndex)
+            )
+    {

trunk/libc/src/libsocket/soclose.c

-              r1772
+              r2739
+{
     LIBCLOG_ENTER("socket=%d\n", socket);
     PLIBCSOCKETFH   pFHSocket = __libc_TcpipFH(socket);
+    PLIBCSOCKETFH pFHSocket = __libc_TcpipFH(socket);
     if (pFHSocket)
+    {
+        if (!__libc_FHClose(socket))
+        int rc = __libc_FHClose(socket)
+        if (!rc)
             LIBCLOG_RETURN_INT(0);
         /* Convert EBADF to ENOTSOCK (although this normally won't happen). */
         if (errno == EBADF)
             errno = ENOTSOCK;
         __libc_TcpipSetSocketErrno();
+        if (rc == -EBADF)
+            rc = -ENOTSOCK;
+        __libc_TcpipSetErrno(-rc);
+    }

Context Navigation

Legend:

Download in other formats: