md/windows/ntmisc.c

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * ntmisc.c
 *
 */

#include "primpl.h"
#include <math.h>     /* for fabs() */
#include <windows.h>

char *_PR_MD_GET_ENV(const char *name)
{
    return getenv(name);
}

/*
** _PR_MD_PUT_ENV() -- add or change environment variable
**
**
*/
PRIntn _PR_MD_PUT_ENV(const char *name)
{
    return(putenv(name));
}


/*
 **************************************************************************
 **************************************************************************
 **
 **     Date and time routines
 **
 **************************************************************************
 **************************************************************************
 */

/*
 * The NSPR epoch (00:00:00 1 Jan 1970 UTC) in FILETIME.
 * We store the value in a PRTime variable for convenience.
 */
#ifdef __GNUC__
const PRTime _pr_filetime_offset = 116444736000000000LL;
const PRTime _pr_filetime_divisor = 10LL;
#else
const PRTime _pr_filetime_offset = 116444736000000000i64;
const PRTime _pr_filetime_divisor = 10i64;
#endif

#ifdef WINCE

#define FILETIME_TO_INT64(ft) \
  (((PRInt64)ft.dwHighDateTime) << 32 | (PRInt64)ft.dwLowDateTime)

static void
LowResTime(LPFILETIME lpft)
{
    GetCurrentFT(lpft);
}

typedef struct CalibrationData {
    long double freq;         /* The performance counter frequency */
    long double offset;       /* The low res 'epoch' */
    long double timer_offset; /* The high res 'epoch' */

    /* The last high res time that we returned since recalibrating */
    PRInt64 last;

    PRBool calibrated;

    CRITICAL_SECTION data_lock;
    CRITICAL_SECTION calibration_lock;
    PRInt64 granularity;
} CalibrationData;

static CalibrationData calibration;

typedef void (*GetSystemTimeAsFileTimeFcn)(LPFILETIME);
static GetSystemTimeAsFileTimeFcn ce6_GetSystemTimeAsFileTime = NULL;

static void
NowCalibrate(void)
{
    FILETIME ft, ftStart;
    LARGE_INTEGER liFreq, now;

    if (calibration.freq == 0.0) {
        if(!QueryPerformanceFrequency(&liFreq)) {
            /* High-performance timer is unavailable */
            calibration.freq = -1.0;
        } else {
            calibration.freq = (long double) liFreq.QuadPart;
        }
    }
    if (calibration.freq > 0.0) {
        PRInt64 calibrationDelta = 0;
        /*
         * By wrapping a timeBegin/EndPeriod pair of calls around this loop,
         * the loop seems to take much less time (1 ms vs 15ms) on Vista.
         */
        timeBeginPeriod(1);
        LowResTime(&ftStart);
        do {
            LowResTime(&ft);
        } while (memcmp(&ftStart,&ft, sizeof(ft)) == 0);
        timeEndPeriod(1);

        calibration.granularity =
            (FILETIME_TO_INT64(ft) - FILETIME_TO_INT64(ftStart))/10;

        QueryPerformanceCounter(&now);

        calibration.offset = (long double) FILETIME_TO_INT64(ft);
        calibration.timer_offset = (long double) now.QuadPart;
        /*
         * The windows epoch is around 1600. The unix epoch is around 1970.
         * _pr_filetime_offset is the difference (in windows time units which
         * are 10 times more highres than the JS time unit)
         */
        calibration.offset -= _pr_filetime_offset;
        calibration.offset *= 0.1;
        calibration.last = 0;

        calibration.calibrated = PR_TRUE;
    }
}

#define CALIBRATIONLOCK_SPINCOUNT 0
#define DATALOCK_SPINCOUNT 4096
#define LASTLOCK_SPINCOUNT 4096

void
_MD_InitTime(void)
{
    /* try for CE6 GetSystemTimeAsFileTime first */
    HANDLE h = GetModuleHandleW(L"coredll.dll");
    ce6_GetSystemTimeAsFileTime = (GetSystemTimeAsFileTimeFcn)
                                  GetProcAddressA(h, "GetSystemTimeAsFileTime");

    /* otherwise go the slow route */
    if (ce6_GetSystemTimeAsFileTime == NULL) {
        memset(&calibration, 0, sizeof(calibration));
        NowCalibrate();
        InitializeCriticalSection(&calibration.calibration_lock);
        InitializeCriticalSection(&calibration.data_lock);
    }
}

void
_MD_CleanupTime(void)
{
    if (ce6_GetSystemTimeAsFileTime == NULL) {
        DeleteCriticalSection(&calibration.calibration_lock);
        DeleteCriticalSection(&calibration.data_lock);
    }
}

#define MUTEX_SETSPINCOUNT(m, c)

/*
 *-----------------------------------------------------------------------
 *
 * PR_Now --
 *
 *     Returns the current time in microseconds since the epoch.
 *     The epoch is midnight January 1, 1970 GMT.
 *     The implementation is machine dependent.  This is the
 *     implementation for Windows.
 *     Cf. time_t time(time_t *tp)
 *
 *-----------------------------------------------------------------------
 */

PR_IMPLEMENT(PRTime)
PR_Now(void)
{
    long double lowresTime, highresTimerValue;
    FILETIME ft;
    LARGE_INTEGER now;
    PRBool calibrated = PR_FALSE;
    PRBool needsCalibration = PR_FALSE;
    PRInt64 returnedTime;
    long double cachedOffset = 0.0;

    if (ce6_GetSystemTimeAsFileTime) {
        union {
            FILETIME ft;
            PRTime prt;
        } currentTime;

        PR_ASSERT(sizeof(FILETIME) == sizeof(PRTime));

        ce6_GetSystemTimeAsFileTime(&currentTime.ft);

        /* written this way on purpose, since the second term becomes
         * a constant, and the entire expression is faster to execute.
         */
        return currentTime.prt/_pr_filetime_divisor -
               _pr_filetime_offset/_pr_filetime_divisor;
    }

    do {
        if (!calibration.calibrated || needsCalibration) {
            EnterCriticalSection(&calibration.calibration_lock);
            EnterCriticalSection(&calibration.data_lock);

            /* Recalibrate only if no one else did before us */
            if (calibration.offset == cachedOffset) {
                /*
                 * Since calibration can take a while, make any other
                 * threads immediately wait
                 */
                MUTEX_SETSPINCOUNT(&calibration.data_lock, 0);

                NowCalibrate();

                calibrated = PR_TRUE;

                /* Restore spin count */
                MUTEX_SETSPINCOUNT(&calibration.data_lock, DATALOCK_SPINCOUNT);
            }
            LeaveCriticalSection(&calibration.data_lock);
            LeaveCriticalSection(&calibration.calibration_lock);
        }

        /* Calculate a low resolution time */
        LowResTime(&ft);
        lowresTime =
            ((long double)(FILETIME_TO_INT64(ft) - _pr_filetime_offset)) * 0.1;

        if (calibration.freq > 0.0) {
            long double highresTime, diff;
            DWORD timeAdjustment, timeIncrement;
            BOOL timeAdjustmentDisabled;

            /* Default to 15.625 ms if the syscall fails */
            long double skewThreshold = 15625.25;

            /* Grab high resolution time */
            QueryPerformanceCounter(&now);
            highresTimerValue = (long double)now.QuadPart;

            EnterCriticalSection(&calibration.data_lock);
            highresTime = calibration.offset + 1000000L *
                          (highresTimerValue-calibration.timer_offset)/calibration.freq;
            cachedOffset = calibration.offset;

            /*
             * On some dual processor/core systems, we might get an earlier
             * time so we cache the last time that we returned.
             */
            calibration.last = PR_MAX(calibration.last,(PRInt64)highresTime);
            returnedTime = calibration.last;
            LeaveCriticalSection(&calibration.data_lock);

            /* Get an estimate of clock ticks per second from our own test */
            skewThreshold = calibration.granularity;
            /* Check for clock skew */
            diff = lowresTime - highresTime;

            /*
             * For some reason that I have not determined, the skew can be
             * up to twice a kernel tick. This does not seem to happen by
             * itself, but I have only seen it triggered by another program
             * doing some kind of file I/O. The symptoms are a negative diff
             * followed by an equally large positive diff.
             */
            if (fabs(diff) > 2*skewThreshold) {
                if (calibrated) {
                    /*
                     * If we already calibrated once this instance, and the
                     * clock is still skewed, then either the processor(s) are
                     * wildly changing clockspeed or the system is so busy that
                     * we get switched out for long periods of time. In either
                     * case, it would be infeasible to make use of high
                     * resolution results for anything, so let's resort to old
                     * behavior for this call. It's possible that in the
                     * future, the user will want the high resolution timer, so
                     * we don't disable it entirely.
                     */
                    returnedTime = (PRInt64)lowresTime;
                    needsCalibration = PR_FALSE;
                } else {
                    /*
                     * It is possible that when we recalibrate, we will return
                     * a value less than what we have returned before; this is
                     * unavoidable. We cannot tell the different between a
                     * faulty QueryPerformanceCounter implementation and user
                     * changes to the operating system time. Since we must
                     * respect user changes to the operating system time, we
                     * cannot maintain the invariant that Date.now() never
                     * decreases; the old implementation has this behavior as
                     * well.
                     */
                    needsCalibration = PR_TRUE;
                }
            } else {
                /* No detectable clock skew */
                returnedTime = (PRInt64)highresTime;
                needsCalibration = PR_FALSE;
            }
        } else {
            /* No high resolution timer is available, so fall back */
            returnedTime = (PRInt64)lowresTime;
        }
    } while (needsCalibration);

    return returnedTime;
}

#else

PR_IMPLEMENT(PRTime)
PR_Now(void)
{
    PRTime prt;
    FILETIME ft;
    SYSTEMTIME st;

    GetSystemTime(&st);
    SystemTimeToFileTime(&st, &ft);
    _PR_FileTimeToPRTime(&ft, &prt);
    return prt;
}

#endif

/*
 ***********************************************************************
 ***********************************************************************
 *
 * Process creation routines
 *
 ***********************************************************************
 ***********************************************************************
 */

/*
 * Assemble the command line by concatenating the argv array.
 * On success, this function returns 0 and the resulting command
 * line is returned in *cmdLine.  On failure, it returns -1.
 */
static int assembleCmdLine(char *const *argv, char **cmdLine)
{
    char *const *arg;
    char *p, *q;
    size_t cmdLineSize;
    int numBackslashes;
    int i;
    int argNeedQuotes;

    /*
     * Find out how large the command line buffer should be.
     */
    cmdLineSize = 0;
    for (arg = argv; *arg; arg++) {
        /*
         * \ and " need to be escaped by a \.  In the worst case,
         * every character is a \ or ", so the string of length
         * may double.  If we quote an argument, that needs two ".
         * Finally, we need a space between arguments, and
         * a null byte at the end of command line.
         */
        cmdLineSize += 2 * strlen(*arg)  /* \ and " need to be escaped */
                       + 2                      /* we quote every argument */
                       + 1;                     /* space in between, or final null */
    }
    p = *cmdLine = PR_MALLOC((PRUint32) cmdLineSize);
    if (p == NULL) {
        return -1;
    }

    for (arg = argv; *arg; arg++) {
        /* Add a space to separates the arguments */
        if (arg != argv) {
            *p++ = ' ';
        }
        q = *arg;
        numBackslashes = 0;
        argNeedQuotes = 0;

        /*
         * If the argument is empty or contains white space, it needs to
         * be quoted.
         */
        if (**arg == '\0' || strpbrk(*arg, " \f\n\r\t\v")) {
            argNeedQuotes = 1;
        }

        if (argNeedQuotes) {
            *p++ = '"';
        }
        while (*q) {
            if (*q == '\\') {
                numBackslashes++;
                q++;
            } else if (*q == '"') {
                if (numBackslashes) {
                    /*
                     * Double the backslashes since they are followed
                     * by a quote
                     */
                    for (i = 0; i < 2 * numBackslashes; i++) {
                        *p++ = '\\';
                    }
                    numBackslashes = 0;
                }
                /* To escape the quote */
                *p++ = '\\';
                *p++ = *q++;
            } else {
                if (numBackslashes) {
                    /*
                     * Backslashes are not followed by a quote, so
                     * don't need to double the backslashes.
                     */
                    for (i = 0; i < numBackslashes; i++) {
                        *p++ = '\\';
                    }
                    numBackslashes = 0;
                }
                *p++ = *q++;
            }
        }

        /* Now we are at the end of this argument */
        if (numBackslashes) {
            /*
             * Double the backslashes if we have a quote string
             * delimiter at the end.
             */
            if (argNeedQuotes) {
                numBackslashes *= 2;
            }
            for (i = 0; i < numBackslashes; i++) {
                *p++ = '\\';
            }
        }
        if (argNeedQuotes) {
            *p++ = '"';
        }
    }

    *p = '\0';
    return 0;
}

/*
 * Assemble the environment block by concatenating the envp array
 * (preserving the terminating null byte in each array element)
 * and adding a null byte at the end.
 *
 * Returns 0 on success.  The resulting environment block is returned
 * in *envBlock.  Note that if envp is NULL, a NULL pointer is returned
 * in *envBlock.  Returns -1 on failure.
 */
static int assembleEnvBlock(char **envp, char **envBlock)
{
    char *p;
    char *q;
    char **env;
    char *curEnv;
    char *cwdStart, *cwdEnd;
    size_t envBlockSize;

    if (envp == NULL) {
        *envBlock = NULL;
        return 0;
    }

#ifdef WINCE
    {
        PRUnichar *wideCurEnv = mozce_GetEnvString();
        int len = WideCharToMultiByte(CP_ACP, 0, wideCurEnv, -1,
                                      NULL, 0, NULL, NULL);
        curEnv = (char *) PR_MALLOC(len * sizeof(char));
        WideCharToMultiByte(CP_ACP, 0, wideCurEnv, -1,
                            curEnv, len, NULL, NULL);
        free(wideCurEnv);
    }
#else
    curEnv = GetEnvironmentStrings();
#endif

    cwdStart = curEnv;
    while (*cwdStart) {
        if (cwdStart[0] == '=' && cwdStart[1] != '\0'
            && cwdStart[2] == ':' && cwdStart[3] == '=') {
            break;
        }
        cwdStart += strlen(cwdStart) + 1;
    }
    cwdEnd = cwdStart;
    if (*cwdEnd) {
        cwdEnd += strlen(cwdEnd) + 1;
        while (*cwdEnd) {
            if (cwdEnd[0] != '=' || cwdEnd[1] == '\0'
                || cwdEnd[2] != ':' || cwdEnd[3] != '=') {
                break;
            }
            cwdEnd += strlen(cwdEnd) + 1;
        }
    }
    envBlockSize = cwdEnd - cwdStart;

    for (env = envp; *env; env++) {
        envBlockSize += strlen(*env) + 1;
    }
    envBlockSize++;

    p = *envBlock = PR_MALLOC((PRUint32) envBlockSize);
    if (p == NULL) {
#ifdef WINCE
        PR_Free(curEnv);
#else
        FreeEnvironmentStrings(curEnv);
#endif
        return -1;
    }

    q = cwdStart;
    while (q < cwdEnd) {
        *p++ = *q++;
    }
#ifdef WINCE
    PR_Free(curEnv);
#else
    FreeEnvironmentStrings(curEnv);
#endif

    for (env = envp; *env; env++) {
        q = *env;
        while (*q) {
            *p++ = *q++;
        }
        *p++ = '\0';
    }
    *p = '\0';
    return 0;
}

/*
 * For qsort.  We sort (case-insensitive) the environment strings
 * before generating the environment block.
 */
static int compare(const void *arg1, const void *arg2)
{
    return _stricmp(* (char**)arg1, * (char**)arg2);
}

PRProcess * _PR_CreateWindowsProcess(
    const char *path,
    char *const *argv,
    char *const *envp,
    const PRProcessAttr *attr)
{
#ifdef WINCE
    STARTUPINFOW startupInfo;
    PRUnichar *wideCmdLine;
    PRUnichar *wideCwd;
    int len = 0;
#else
    STARTUPINFO startupInfo;
#endif
    DWORD creationFlags = 0;
    PROCESS_INFORMATION procInfo;
    BOOL retVal;
    char *cmdLine = NULL;
    char *envBlock = NULL;
    char **newEnvp = NULL;
    const char *cwd = NULL; /* current working directory */
    PRProcess *proc = NULL;
    PRBool hasFdInheritBuffer;

    proc = PR_NEW(PRProcess);
    if (!proc) {
        PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
        goto errorExit;
    }

    if (assembleCmdLine(argv, &cmdLine) == -1) {
        PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
        goto errorExit;
    }

#ifndef WINCE
    /*
     * If attr->fdInheritBuffer is not NULL, we need to insert
     * it into the envp array, so envp cannot be NULL.
     */
    hasFdInheritBuffer = (attr && attr->fdInheritBuffer);
    if ((envp == NULL) && hasFdInheritBuffer) {
        envp = environ;
    }

    if (envp != NULL) {
        int idx;
        int numEnv;
        PRBool found = PR_FALSE;

        numEnv = 0;
        while (envp[numEnv]) {
            numEnv++;
        }
        newEnvp = (char **) PR_MALLOC((numEnv + 2) * sizeof(char *));
        for (idx = 0; idx < numEnv; idx++) {
            newEnvp[idx] = envp[idx];
            if (hasFdInheritBuffer && !found
                && !strncmp(newEnvp[idx], "NSPR_INHERIT_FDS=", 17)) {
                newEnvp[idx] = attr->fdInheritBuffer;
                found = PR_TRUE;
            }
        }
        if (hasFdInheritBuffer && !found) {
            newEnvp[idx++] = attr->fdInheritBuffer;
        }
        newEnvp[idx] = NULL;
        qsort((void *) newEnvp, (size_t) idx, sizeof(char *), compare);
    }
    if (assembleEnvBlock(newEnvp, &envBlock) == -1) {
        PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
        goto errorExit;
    }

    ZeroMemory(&startupInfo, sizeof(startupInfo));
    startupInfo.cb = sizeof(startupInfo);

    if (attr) {
        PRBool redirected = PR_FALSE;

        /*
         * XXX the default value for stdin, stdout, and stderr
         * should probably be the console input and output, not
         * those of the parent process.
         */
        startupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
        startupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
        startupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
        if (attr->stdinFd) {
            startupInfo.hStdInput = (HANDLE) attr->stdinFd->secret->md.osfd;
            redirected = PR_TRUE;
        }
        if (attr->stdoutFd) {
            startupInfo.hStdOutput = (HANDLE) attr->stdoutFd->secret->md.osfd;
            redirected = PR_TRUE;
            /*
             * If stdout is redirected, we can assume that the process will
             * not write anything useful to the console windows, and therefore
             * automatically set the CREATE_NO_WINDOW flag.
             */
            creationFlags |= CREATE_NO_WINDOW;
        }
        if (attr->stderrFd) {
            startupInfo.hStdError = (HANDLE) attr->stderrFd->secret->md.osfd;
            redirected = PR_TRUE;
        }
        if (redirected) {
            startupInfo.dwFlags |= STARTF_USESTDHANDLES;
        }
        cwd = attr->currentDirectory;
    }
#endif

#ifdef WINCE
    len = MultiByteToWideChar(CP_ACP, 0, cmdLine, -1, NULL, 0);
    wideCmdLine = (PRUnichar *)PR_MALLOC(len * sizeof(PRUnichar));
    MultiByteToWideChar(CP_ACP, 0, cmdLine, -1, wideCmdLine, len);
    len = MultiByteToWideChar(CP_ACP, 0, cwd, -1, NULL, 0);
    wideCwd = PR_MALLOC(len * sizeof(PRUnichar));
    MultiByteToWideChar(CP_ACP, 0, cwd, -1, wideCwd, len);
    retVal = CreateProcessW(NULL,
                            wideCmdLine,
                            NULL,  /* security attributes for the new
                                    * process */
                            NULL,  /* security attributes for the primary
                                    * thread in the new process */
                            TRUE,  /* inherit handles */
                            creationFlags,
                            envBlock,  /* an environment block, consisting
                                        * of a null-terminated block of
                                        * null-terminated strings.  Each
                                        * string is in the form:
                                        *     name=value
                                        * XXX: usually NULL */
                            wideCwd,  /* current drive and directory */
                            &startupInfo,
                            &procInfo
                           );
    PR_Free(wideCmdLine);
    PR_Free(wideCwd);
#else
    retVal = CreateProcess(NULL,
                           cmdLine,
                           NULL,  /* security attributes for the new
                                   * process */
                           NULL,  /* security attributes for the primary
                                   * thread in the new process */
                           TRUE,  /* inherit handles */
                           creationFlags,
                           envBlock,  /* an environment block, consisting
                                       * of a null-terminated block of
                                       * null-terminated strings.  Each
                                       * string is in the form:
                                       *     name=value
                                       * XXX: usually NULL */
                           cwd,  /* current drive and directory */
                           &startupInfo,
                           &procInfo
                          );
#endif

    if (retVal == FALSE) {
        /* XXX what error code? */
        PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
        goto errorExit;
    }

    CloseHandle(procInfo.hThread);
    proc->md.handle = procInfo.hProcess;
    proc->md.id = procInfo.dwProcessId;

    PR_DELETE(cmdLine);
    if (newEnvp) {
        PR_DELETE(newEnvp);
    }
    if (envBlock) {
        PR_DELETE(envBlock);
    }
    return proc;

errorExit:
    if (cmdLine) {
        PR_DELETE(cmdLine);
    }
    if (newEnvp) {
        PR_DELETE(newEnvp);
    }
    if (envBlock) {
        PR_DELETE(envBlock);
    }
    if (proc) {
        PR_DELETE(proc);
    }
    return NULL;
}  /* _PR_CreateWindowsProcess */

PRStatus _PR_DetachWindowsProcess(PRProcess *process)
{
    CloseHandle(process->md.handle);
    PR_DELETE(process);
    return PR_SUCCESS;
}

/*
 * XXX: This implementation is a temporary quick solution.
 * It can be called by native threads only (not by fibers).
 */
PRStatus _PR_WaitWindowsProcess(PRProcess *process,
                                PRInt32 *exitCode)
{
    DWORD dwRetVal;

    dwRetVal = WaitForSingleObject(process->md.handle, INFINITE);
    if (dwRetVal == WAIT_FAILED) {
        PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
        return PR_FAILURE;
    }
    PR_ASSERT(dwRetVal == WAIT_OBJECT_0);
    if (exitCode != NULL &&
        GetExitCodeProcess(process->md.handle, exitCode) == FALSE) {
        PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
        return PR_FAILURE;
    }
    CloseHandle(process->md.handle);
    PR_DELETE(process);
    return PR_SUCCESS;
}

PRStatus _PR_KillWindowsProcess(PRProcess *process)
{
    /*
     * On Unix, if a process terminates normally, its exit code is
     * between 0 and 255.  So here on Windows, we use the exit code
     * 256 to indicate that the process is killed.
     */
    if (TerminateProcess(process->md.handle, 256)) {
        return PR_SUCCESS;
    }
    PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
    return PR_FAILURE;
}

PRStatus _MD_WindowsGetHostName(char *name, PRUint32 namelen)
{
    PRIntn rv;
    PRInt32 syserror;

    rv = gethostname(name, (PRInt32) namelen);
    if (0 == rv) {
        return PR_SUCCESS;
    }
    syserror = WSAGetLastError();
    PR_ASSERT(WSANOTINITIALISED != syserror);
    _PR_MD_MAP_GETHOSTNAME_ERROR(syserror);
    return PR_FAILURE;
}

PRStatus _MD_WindowsGetSysInfo(PRSysInfo cmd, char *name, PRUint32 namelen)
{
    OSVERSIONINFO osvi;

    PR_ASSERT((cmd == PR_SI_SYSNAME) || (cmd == PR_SI_RELEASE) ||
              (cmd == PR_SI_RELEASE_BUILD));

    ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

    if (! GetVersionEx (&osvi) ) {
        _PR_MD_MAP_DEFAULT_ERROR(GetLastError());
        return PR_FAILURE;
    }

    switch (osvi.dwPlatformId) {
        case VER_PLATFORM_WIN32_NT:
            if (PR_SI_SYSNAME == cmd) {
                (void)PR_snprintf(name, namelen, "Windows_NT");
            }
            else if (PR_SI_RELEASE == cmd) {
                (void)PR_snprintf(name, namelen, "%d.%d",osvi.dwMajorVersion,
                                  osvi.dwMinorVersion);
            }
            else if (PR_SI_RELEASE_BUILD == cmd) {
                (void)PR_snprintf(name, namelen, "%d", osvi.dwBuildNumber);
            }
            break;
        case VER_PLATFORM_WIN32_WINDOWS:
            if (PR_SI_SYSNAME == cmd) {
                if ((osvi.dwMajorVersion > 4) ||
                    ((osvi.dwMajorVersion == 4) && (osvi.dwMinorVersion > 0))) {
                    (void)PR_snprintf(name, namelen, "Windows_98");
                }
                else {
                    (void)PR_snprintf(name, namelen, "Windows_95");
                }
            } else if (PR_SI_RELEASE == cmd) {
                (void)PR_snprintf(name, namelen, "%d.%d",osvi.dwMajorVersion,
                                  osvi.dwMinorVersion);
            } else if (PR_SI_RELEASE_BUILD == cmd) {
                (void)PR_snprintf(name, namelen, "%d", osvi.dwBuildNumber);
            }
            break;
#ifdef VER_PLATFORM_WIN32_CE
        case VER_PLATFORM_WIN32_CE:
            if (PR_SI_SYSNAME == cmd) {
                (void)PR_snprintf(name, namelen, "Windows_CE");
            }
            else if (PR_SI_RELEASE == cmd) {
                (void)PR_snprintf(name, namelen, "%d.%d",osvi.dwMajorVersion,
                                  osvi.dwMinorVersion);
            }
            else if (PR_SI_RELEASE_BUILD == cmd) {
              if (namelen) {
                *name = 0;
              }
            }
            break;
#endif
        default:
            if (PR_SI_SYSNAME == cmd) {
                (void)PR_snprintf(name, namelen, "Windows_Unknown");
            }
            else if (PR_SI_RELEASE == cmd) {
                (void)PR_snprintf(name, namelen, "%d.%d",0,0);
            }
            else if (PR_SI_RELEASE_BUILD == cmd) {
              if (namelen) {
                *name = 0;
              }
            }
            break;
    }
    return PR_SUCCESS;
}

PRStatus _MD_WindowsGetReleaseName(char *name, PRUint32 namelen)
{
    OSVERSIONINFO osvi;

    ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

    if (! GetVersionEx (&osvi) ) {
        _PR_MD_MAP_DEFAULT_ERROR(GetLastError());
        return PR_FAILURE;
    }

    switch (osvi.dwPlatformId) {
        case VER_PLATFORM_WIN32_NT:
        case VER_PLATFORM_WIN32_WINDOWS:
            (void)PR_snprintf(name, namelen, "%d.%d",osvi.dwMajorVersion,
                              osvi.dwMinorVersion);
            break;
        default:
            (void)PR_snprintf(name, namelen, "%d.%d",0,0);
            break;
    }
    return PR_SUCCESS;
}

/*
 **********************************************************************
 *
 * Memory-mapped files
 *
 **********************************************************************
 */

PRStatus _MD_CreateFileMap(PRFileMap *fmap, PRInt64 size)
{
    DWORD dwHi, dwLo;
    DWORD flProtect;
    PROsfd osfd;

    osfd = ( fmap->fd == (PRFileDesc*)-1 )?  -1 : fmap->fd->secret->md.osfd;

    dwLo = (DWORD) (size & 0xffffffff);
    dwHi = (DWORD) (((PRUint64) size >> 32) & 0xffffffff);

    if (fmap->prot == PR_PROT_READONLY) {
        flProtect = PAGE_READONLY;
        fmap->md.dwAccess = FILE_MAP_READ;
    } else if (fmap->prot == PR_PROT_READWRITE) {
        flProtect = PAGE_READWRITE;
        fmap->md.dwAccess = FILE_MAP_WRITE;
    } else {
        PR_ASSERT(fmap->prot == PR_PROT_WRITECOPY);
#ifdef WINCE
        /* WINCE does not have FILE_MAP_COPY. */
        PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
        return PR_FAILURE;
#else
        flProtect = PAGE_WRITECOPY;
        fmap->md.dwAccess = FILE_MAP_COPY;
#endif
    }

    fmap->md.hFileMap = CreateFileMapping(
                            (HANDLE) osfd,
                            NULL,
                            flProtect,
                            dwHi,
                            dwLo,
                            NULL);

    if (fmap->md.hFileMap == NULL) {
        PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
        return PR_FAILURE;
    }
    return PR_SUCCESS;
}

PRInt32 _MD_GetMemMapAlignment(void)
{
    SYSTEM_INFO info;
    GetSystemInfo(&info);
    return info.dwAllocationGranularity;
}

extern PRLogModuleInfo *_pr_shma_lm;

void * _MD_MemMap(
    PRFileMap *fmap,
    PROffset64 offset,
    PRUint32 len)
{
    DWORD dwHi, dwLo;
    void *addr;

    dwLo = (DWORD) (offset & 0xffffffff);
    dwHi = (DWORD) (((PRUint64) offset >> 32) & 0xffffffff);
    if ((addr = MapViewOfFile(fmap->md.hFileMap, fmap->md.dwAccess,
                              dwHi, dwLo, len)) == NULL) {
        {
            LPVOID lpMsgBuf;

            FormatMessage(
                FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                NULL,
                GetLastError(),
                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                (LPTSTR) &lpMsgBuf,
                0,
                NULL
            );
            PR_LOG( _pr_shma_lm, PR_LOG_DEBUG, ("md_memmap(): %s", lpMsgBuf ));
        }
        PR_SetError(PR_UNKNOWN_ERROR, GetLastError());
    }
    return addr;
}

PRStatus _MD_MemUnmap(void *addr, PRUint32 len)
{
    if (UnmapViewOfFile(addr)) {
        return PR_SUCCESS;
    }
    _PR_MD_MAP_DEFAULT_ERROR(GetLastError());
    return PR_FAILURE;
}

PRStatus _MD_CloseFileMap(PRFileMap *fmap)
{
    CloseHandle(fmap->md.hFileMap);
    PR_DELETE(fmap);
    return PR_SUCCESS;
}

PRStatus _MD_SyncMemMap(
    PRFileDesc *fd,
    void *addr,
    PRUint32 len)
{
    PROsfd osfd = fd->secret->md.osfd;

    /* The FlushViewOfFile page on MSDN says:
     *  To flush all the dirty pages plus the metadata for the file and
     *  ensure that they are physically written to disk, call
     *  FlushViewOfFile and then call the FlushFileBuffers function.
     */
    if (FlushViewOfFile(addr, len) && FlushFileBuffers((HANDLE) osfd)) {
        return PR_SUCCESS;
    }
    _PR_MD_MAP_DEFAULT_ERROR(GetLastError());
    return PR_FAILURE;
}

/*
 ***********************************************************************
 *
 * Atomic increment and decrement operations for x86 processors
 *
 * We don't use InterlockedIncrement and InterlockedDecrement
 * because on NT 3.51 and Win95, they return a number with
 * the same sign as the incremented/decremented result, rather
 * than the result itself.  On NT 4.0 these functions do return
 * the incremented/decremented result.
 *
 * The result is returned in the eax register by the inline
 * assembly code.  We disable the harmless "no return value"
 * warning (4035) for these two functions.
 *
 ***********************************************************************
 */

#if defined(_M_IX86) || defined(_X86_)

#pragma warning(disable: 4035)
PRInt32 _PR_MD_ATOMIC_INCREMENT(PRInt32 *val)
{
#if defined(__GNUC__)
    PRInt32 result;
    asm volatile ("lock ; xadd %0, %1"
                  : "=r"(result), "=m"(*val)
                  : "0"(1), "m"(*val));
    return result + 1;
#else
    __asm
    {
        mov ecx, val
        mov eax, 1
        lock xadd dword ptr [ecx], eax
        inc eax
    }
#endif /* __GNUC__ */
}
#pragma warning(default: 4035)

#pragma warning(disable: 4035)
PRInt32 _PR_MD_ATOMIC_DECREMENT(PRInt32 *val)
{
#if defined(__GNUC__)
    PRInt32 result;
    asm volatile ("lock ; xadd %0, %1"
                  : "=r"(result), "=m"(*val)
                  : "0"(-1), "m"(*val));
    //asm volatile("lock ; xadd %0, %1" : "=m" (val), "=a" (result) : "-1" (1));
    return result - 1;
#else
    __asm
    {
        mov ecx, val
        mov eax, 0ffffffffh
        lock xadd dword ptr [ecx], eax
        dec eax
    }
#endif /* __GNUC__ */
}
#pragma warning(default: 4035)

#pragma warning(disable: 4035)
PRInt32 _PR_MD_ATOMIC_ADD(PRInt32 *intp, PRInt32 val)
{
#if defined(__GNUC__)
    PRInt32 result;
    //asm volatile("lock ; xadd %1, %0" : "=m" (intp), "=a" (result) : "1" (val));
    asm volatile ("lock ; xadd %0, %1"
                  : "=r"(result), "=m"(*intp)
                  : "0"(val), "m"(*intp));
    return result + val;
#else
    __asm
    {
        mov ecx, intp
        mov eax, val
        mov edx, eax
        lock xadd dword ptr [ecx], eax
        add eax, edx
    }
#endif /* __GNUC__ */
}
#pragma warning(default: 4035)

#ifdef _PR_HAVE_ATOMIC_CAS

#pragma warning(disable: 4035)
void
PR_StackPush(PRStack *stack, PRStackElem *stack_elem)
{
#if defined(__GNUC__)
    void **tos = (void **) stack;
    void *tmp;

retry:
    if (*tos == (void *) -1) {
        goto retry;
    }

    __asm__("xchg %0,%1"
            : "=r" (tmp), "=m"(*tos)
            : "0" (-1), "m"(*tos));

    if (tmp == (void *) -1) {
        goto retry;
    }

    *(void **)stack_elem = tmp;
    __asm__("" : : : "memory");
    *tos = stack_elem;
#else
    __asm
    {
        mov ebx, stack
        mov ecx, stack_elem
        retry:  mov eax,[ebx]
        cmp eax,-1
        je retry
        mov eax,-1
        xchg dword ptr [ebx], eax
        cmp eax,-1
        je  retry
        mov [ecx],eax
        mov [ebx],ecx
    }
#endif /* __GNUC__ */
}
#pragma warning(default: 4035)

#pragma warning(disable: 4035)
PRStackElem *
PR_StackPop(PRStack *stack)
{
#if defined(__GNUC__)
    void **tos = (void **) stack;
    void *tmp;

retry:
    if (*tos == (void *) -1) {
        goto retry;
    }

    __asm__("xchg %0,%1"
            : "=r" (tmp), "=m"(*tos)
            : "0" (-1), "m"(*tos));

    if (tmp == (void *) -1) {
        goto retry;
    }

    if (tmp != (void *) 0)
    {
        void *next = *(void **)tmp;
        *tos = next;
        *(void **)tmp = 0;
    }
    else {
        *tos = tmp;
    }

    return tmp;
#else
    __asm
    {
        mov ebx, stack
        retry:  mov eax,[ebx]
        cmp eax,-1
        je retry
        mov eax,-1
        xchg dword ptr [ebx], eax
        cmp eax,-1
        je  retry
        cmp eax,0
        je  empty
        mov ecx,[eax]
        mov [ebx],ecx
        mov [eax],0
        jmp done
        empty:
        mov [ebx],eax
        done:
    }
#endif /* __GNUC__ */
}
#pragma warning(default: 4035)

#endif /* _PR_HAVE_ATOMIC_CAS */

#endif /* x86 processors */