Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 373 insertions, 0 deletions

diff --git a/nsprpub/pr/src/misc/prsystem.c b/nsprpub/pr/src/misc/prsystem.c
new file mode 100644
index 0000000000..dba093e9b1
--- /dev/null
+++ b/nsprpub/pr/src/misc/prsystem.c
@@ -0,0 +1,373 @@
+/* -*- Mode: C++; tab-width: 4; 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/. */
+
+#include "primpl.h"
+#include "prsystem.h"
+#include "prprf.h"
+#include "prlong.h"
+
+#if defined(OS2)
+#define INCL_DOS
+#define INCL_DOSMISC
+#include <os2.h>
+/* define the required constant if it is not already defined in the headers */
+#ifndef QSV_NUMPROCESSORS
+#define QSV_NUMPROCESSORS 26
+#endif
+#endif
+
+/* BSD-derived systems use sysctl() to get the number of processors */
+#if defined(BSDI) || defined(FREEBSD) || defined(NETBSD) \
+    || defined(OPENBSD) || defined(DRAGONFLY) || defined(DARWIN)
+#define _PR_HAVE_SYSCTL
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#endif
+
+#if defined(DARWIN)
+#include <mach/mach_init.h>
+#include <mach/mach_host.h>
+#include <mach/mach_port.h>
+#endif
+
+#if defined(HPUX)
+#include <sys/mpctl.h>
+#include <sys/pstat.h>
+#endif
+
+#if defined(XP_UNIX)
+#include <unistd.h>
+#include <sys/utsname.h>
+#endif
+
+#if defined(LINUX)
+#include <string.h>
+#include <ctype.h>
+#define MAX_LINE 512
+#endif
+
+#if defined(AIX)
+#include <cf.h>
+#include <sys/cfgodm.h>
+#endif
+
+PR_IMPLEMENT(char) PR_GetDirectorySeparator(void)
+{
+    return PR_DIRECTORY_SEPARATOR;
+}  /* PR_GetDirectorySeparator */
+
+/*
+** OBSOLETE -- the function name is misspelled.
+*/
+PR_IMPLEMENT(char) PR_GetDirectorySepartor(void)
+{
+#if defined(DEBUG)
+    static PRBool warn = PR_TRUE;
+    if (warn) {
+        warn = _PR_Obsolete("PR_GetDirectorySepartor()",
+                            "PR_GetDirectorySeparator()");
+    }
+#endif
+    return PR_GetDirectorySeparator();
+}  /* PR_GetDirectorySepartor */
+
+PR_IMPLEMENT(char) PR_GetPathSeparator(void)
+{
+    return PR_PATH_SEPARATOR;
+}  /* PR_GetPathSeparator */
+
+PR_IMPLEMENT(PRStatus) PR_GetSystemInfo(PRSysInfo cmd, char *buf, PRUint32 buflen)
+{
+    PRUintn len = 0;
+
+    if (!_pr_initialized) {
+        _PR_ImplicitInitialization();
+    }
+
+    switch(cmd)
+    {
+        case PR_SI_HOSTNAME:
+        case PR_SI_HOSTNAME_UNTRUNCATED:
+            if (PR_FAILURE == _PR_MD_GETHOSTNAME(buf, (PRUintn)buflen)) {
+                return PR_FAILURE;
+            }
+
+            if (cmd == PR_SI_HOSTNAME_UNTRUNCATED) {
+                break;
+            }
+            /*
+             * On some platforms a system does not have a hostname and
+             * its IP address is returned instead.   The following code
+             * should be skipped on those platforms.
+             */
+#ifndef _PR_GET_HOST_ADDR_AS_NAME
+            /* Return the unqualified hostname */
+            while (buf[len] && (len < buflen)) {
+                if (buf[len] == '.') {
+                    buf[len] = '\0';
+                    break;
+                }
+                len += 1;
+            }
+#endif
+            break;
+
+        case PR_SI_SYSNAME:
+            /* Return the operating system name */
+#if defined(XP_UNIX) || defined(WIN32)
+            if (PR_FAILURE == _PR_MD_GETSYSINFO(cmd, buf, (PRUintn)buflen)) {
+                return PR_FAILURE;
+            }
+#else
+            (void)PR_snprintf(buf, buflen, _PR_SI_SYSNAME);
+#endif
+            break;
+
+        case PR_SI_RELEASE:
+            /* Return the version of the operating system */
+#if defined(XP_UNIX) || defined(WIN32)
+            if (PR_FAILURE == _PR_MD_GETSYSINFO(cmd, buf, (PRUintn)buflen)) {
+                return PR_FAILURE;
+            }
+#endif
+#if defined(XP_OS2)
+            {
+                ULONG os2ver[2] = {0};
+                DosQuerySysInfo(QSV_VERSION_MINOR, QSV_VERSION_REVISION,
+                                &os2ver, sizeof(os2ver));
+                /* Formatting for normal usage (2.11, 3.0, 4.0, 4.5); officially,
+                   Warp 4 is version 2.40.00, WSeB 2.45.00 */
+                if (os2ver[0] < 30)
+                    (void)PR_snprintf(buf, buflen, "%s%lu",
+                                      "2.", os2ver[0]);
+                else if (os2ver[0] < 45)
+                    (void)PR_snprintf(buf, buflen, "%lu%s%lu",
+                                      os2ver[0]/10, ".", os2ver[1]);
+                else
+                    (void)PR_snprintf(buf, buflen, "%.1f",
+                                      os2ver[0]/10.0);
+            }
+#endif /* OS2 */
+            break;
+
+        case PR_SI_RELEASE_BUILD:
+          /* Return the version of the operating system */
+#if defined(XP_UNIX) || defined(WIN32)
+            if (PR_FAILURE == _PR_MD_GETSYSINFO(cmd, buf, (PRUintn)buflen)) {
+              return PR_FAILURE;
+            }
+#else
+            if (buflen) {
+                *buf = 0;
+            }
+#endif /* XP_UNIX || WIN32 */
+            break;
+
+        case PR_SI_ARCHITECTURE:
+            /* Return the architecture of the machine (ie. x86, mips, alpha, ...)*/
+            (void)PR_snprintf(buf, buflen, _PR_SI_ARCHITECTURE);
+            break;
+        default:
+            PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
+            return PR_FAILURE;
+    }
+    return PR_SUCCESS;
+}
+
+/*
+** PR_GetNumberOfProcessors()
+**
+** Implementation notes:
+**   Every platform does it a bit different.
+**     numCpus is the returned value.
+**   for each platform's "if defined" section
+**     declare your local variable
+**     do your thing, assign to numCpus
+**   order of the if defined()s may be important,
+**     especially for unix variants. Do platform
+**     specific implementations before XP_UNIX.
+**
+*/
+PR_IMPLEMENT(PRInt32) PR_GetNumberOfProcessors( void )
+{
+    PRInt32     numCpus;
+#if defined(WIN32)
+    SYSTEM_INFO     info;
+
+    GetSystemInfo( &info );
+    numCpus = info.dwNumberOfProcessors;
+#elif defined(OS2)
+    DosQuerySysInfo( QSV_NUMPROCESSORS, QSV_NUMPROCESSORS, &numCpus, sizeof(numCpus));
+#elif defined(_PR_HAVE_SYSCTL)
+    int mib[2];
+    int rc;
+    size_t len = sizeof(numCpus);
+
+    mib[0] = CTL_HW;
+#ifdef HW_NCPUONLINE
+    mib[1] = HW_NCPUONLINE;
+#else
+    mib[1] = HW_NCPU;
+#endif
+    rc = sysctl( mib, 2, &numCpus, &len, NULL, 0 );
+    if ( -1 == rc )  {
+        numCpus = -1; /* set to -1 for return value on error */
+        _PR_MD_MAP_DEFAULT_ERROR( _MD_ERRNO() );
+    }
+#elif defined(HPUX)
+    numCpus = mpctl( MPC_GETNUMSPUS, 0, 0 );
+    if ( numCpus < 1 )  {
+        numCpus = -1; /* set to -1 for return value on error */
+        _PR_MD_MAP_DEFAULT_ERROR( _MD_ERRNO() );
+    }
+#elif defined(RISCOS)
+    numCpus = 1;
+#elif defined(LINUX)
+    /* for the benefit of devices with advanced power-saving, that
+       actually hotplug their cpus in heavy load, try to figure out
+       the real number of CPUs */
+    char buf[MAX_LINE];
+    FILE *fin;
+    const char *cpu_present = "/sys/devices/system/cpu/present";
+    size_t strsize;
+    numCpus = 0;
+    fin = fopen(cpu_present, "r");
+    if (fin != NULL) {
+        if (fgets(buf, MAX_LINE, fin) != NULL) {
+            /* check that the format is what we expect */
+            if (buf[0] == '0') {
+                strsize = strlen(buf);
+                if (strsize == 1) {
+                    /* single core */
+                    numCpus = 1;
+                } else if (strsize >= 3 && strsize <= 5) {
+                    /* should be of the form 0-999 */
+                    /* parse the part after the 0-, note count is 0-based */
+                    if (buf[1] == '-' && isdigit(buf[2])) {
+                        numCpus = 1 + atoi(buf + 2);
+                    }
+                }
+            }
+        }
+        fclose(fin);
+    }
+    /* if that fails, fall back to more standard methods */
+    if (!numCpus) {
+        numCpus = sysconf( _SC_NPROCESSORS_CONF );
+    }
+#elif defined(XP_UNIX)
+    numCpus = sysconf( _SC_NPROCESSORS_CONF );
+#else
+#error "An implementation is required"
+#endif
+    return(numCpus);
+} /* end PR_GetNumberOfProcessors() */
+
+/*
+** PR_GetPhysicalMemorySize()
+**
+** Implementation notes:
+**   Every platform does it a bit different.
+**     bytes is the returned value.
+**   for each platform's "if defined" section
+**     declare your local variable
+**     do your thing, assign to bytes.
+**
+*/
+PR_IMPLEMENT(PRUint64) PR_GetPhysicalMemorySize(void)
+{
+    PRUint64 bytes = 0;
+
+#if defined(LINUX) || defined(SOLARIS)
+
+    long pageSize = sysconf(_SC_PAGESIZE);
+    long pageCount = sysconf(_SC_PHYS_PAGES);
+    if (pageSize >= 0 && pageCount >= 0) {
+        bytes = (PRUint64) pageSize * pageCount;
+    }
+
+#elif defined(NETBSD) || defined(OPENBSD) \
+    || defined(FREEBSD) || defined(DRAGONFLY)
+
+    int mib[2];
+    int rc;
+#ifdef HW_PHYSMEM64
+    uint64_t memSize;
+#else
+    unsigned long memSize;
+#endif
+    size_t len = sizeof(memSize);
+
+    mib[0] = CTL_HW;
+#ifdef HW_PHYSMEM64
+    mib[1] = HW_PHYSMEM64;
+#else
+    mib[1] = HW_PHYSMEM;
+#endif
+    rc = sysctl(mib, 2, &memSize, &len, NULL, 0);
+    if (-1 != rc)  {
+        bytes = memSize;
+    }
+
+#elif defined(HPUX)
+
+    struct pst_static info;
+    int result = pstat_getstatic(&info, sizeof(info), 1, 0);
+    if (result == 1) {
+        bytes = (PRUint64) info.physical_memory * info.page_size;
+    }
+
+#elif defined(DARWIN)
+
+    mach_port_t mach_host = mach_host_self();
+    struct host_basic_info hInfo;
+    mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT;
+
+    int result = host_info(mach_host,
+                           HOST_BASIC_INFO,
+                           (host_info_t) &hInfo,
+                           &count);
+    mach_port_deallocate(mach_task_self(), mach_host);
+    if (result == KERN_SUCCESS) {
+        bytes = hInfo.max_mem;
+    }
+
+#elif defined(WIN32)
+
+    MEMORYSTATUSEX memStat;
+    memStat.dwLength = sizeof(memStat);
+    if (GlobalMemoryStatusEx(&memStat)) {
+        bytes = memStat.ullTotalPhys;
+    }
+
+#elif defined(OS2)
+
+    ULONG ulPhysMem;
+    DosQuerySysInfo(QSV_TOTPHYSMEM,
+                    QSV_TOTPHYSMEM,
+                    &ulPhysMem,
+                    sizeof(ulPhysMem));
+    bytes = ulPhysMem;
+
+#elif defined(AIX)
+
+    if (odm_initialize() == 0) {
+        int how_many;
+        struct CuAt *obj = getattr("sys0", "realmem", 0, &how_many);
+        if (obj != NULL) {
+            bytes = (PRUint64) atoi(obj->value) * 1024;
+            free(obj);
+        }
+        odm_terminate();
+    }
+
+#else
+
+    PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
+
+#endif
+
+    return bytes;
+} /* end PR_GetPhysicalMemorySize() */