1 files changed, 159 insertions, 45 deletions

diff --git a/linden/indra/llcommon/llsys.cpp b/linden/indra/llcommon/llsys.cpp
index 48f2474..25749e1 100644
--- a/linden/indra/llcommon/llsys.cpp
+++ b/linden/indra/llcommon/llsys.cpp
@@ -31,9 +31,13 @@
 #include "llsys.h"
 
 #include <iostream>
-#include <zlib/zlib.h>
+#ifdef LL_STANDALONE
+# include <zlib.h>
+#else
+# include "zlib/zlib.h"
+#endif
 
-#include "processor.h"
+#include "llprocessor.h"
 
 #if LL_WINDOWS
 #       define WIN32_LEAN_AND_MEAN
@@ -44,6 +48,8 @@
 #       include <sys/utsname.h>
 #elif LL_LINUX
 #       include <sys/utsname.h>
+#       include <unistd.h>
+#       include <sys/sysinfo.h>
 const char MEMINFO_FILE[] = "/proc/meminfo";
 const char CPUINFO_FILE[] = "/proc/cpuinfo";
 #endif
@@ -182,7 +188,7 @@ LLOSInfo::LLOSInfo() :
         }
 #else
         struct utsname un;
-        if(0==uname(&un))
+        if(uname(&un) != -1)
         {
                 mOSString.append(un.sysname);
                 mOSString.append(" ");
@@ -252,13 +258,12 @@ U32 LLOSInfo::getProcessVirtualSizeKB()
 #if LL_WINDOWS
 #endif
 #if LL_LINUX
-        FILE* status_filep = LLFile::fopen("/proc/self/status", "r");   /* Flawfinder: ignore */
+        FILE* status_filep = LLFile::fopen("/proc/self/status", "rb");
         S32 numRead = 0;                
         char buff[STATUS_SIZE];         /* Flawfinder: ignore */
-        bzero(buff, STATUS_SIZE);
 
-        rewind(status_filep);
-        fread(buff, 1, STATUS_SIZE-2, status_filep);
+        size_t nbytes = fread(buff, 1, STATUS_SIZE-1, status_filep);
+        buff[nbytes] = '\0';
 
         // All these guys return numbers in KB
         char *memp = strstr(buff, "VmSize:");
@@ -267,6 +272,24 @@ U32 LLOSInfo::getProcessVirtualSizeKB()
                 numRead += sscanf(memp, "%*s %u", &virtual_size);
         }
         fclose(status_filep);
+#elif LL_SOLARIS
+        char proc_ps[LL_MAX_PATH];
+        sprintf(proc_ps, "/proc/%d/psinfo", (int)getpid());
+        int proc_fd = -1;
+        if((proc_fd = open(proc_ps, O_RDONLY)) == -1){
+                llwarns << "unable to open " << proc_ps << llendl;
+                return 0;
+        }
+        psinfo_t proc_psinfo;
+        if(read(proc_fd, &proc_psinfo, sizeof(psinfo_t)) != sizeof(psinfo_t)){
+                llwarns << "Unable to read " << proc_ps << llendl;
+                close(proc_fd);
+                return 0;
+        }
+
+        close(proc_fd);
+
+        virtual_size = proc_psinfo.pr_size;
 #endif
         return virtual_size;
 }
@@ -278,15 +301,14 @@ U32 LLOSInfo::getProcessResidentSizeKB()
 #if LL_WINDOWS
 #endif
 #if LL_LINUX
-        FILE* status_filep = LLFile::fopen("/proc/self/status", "r");   /* Flawfinder: ignore */
+        FILE* status_filep = LLFile::fopen("/proc/self/status", "rb");
         if (status_filep != NULL)
         {
                 S32 numRead = 0;
                 char buff[STATUS_SIZE];         /* Flawfinder: ignore */
-                bzero(buff, STATUS_SIZE);
 
-                rewind(status_filep);
-                fread(buff, 1, STATUS_SIZE-2, status_filep);
+                size_t nbytes = fread(buff, 1, STATUS_SIZE-1, status_filep);
+                buff[nbytes] = '\0';
 
                 // All these guys return numbers in KB
                 char *memp = strstr(buff, "VmRSS:");
@@ -296,47 +318,126 @@ U32 LLOSInfo::getProcessResidentSizeKB()
                 }
                 fclose(status_filep);
         }
+#elif LL_SOLARIS
+        char proc_ps[LL_MAX_PATH];
+        sprintf(proc_ps, "/proc/%d/psinfo", (int)getpid());
+        int proc_fd = -1;
+        if((proc_fd = open(proc_ps, O_RDONLY)) == -1){
+                llwarns << "unable to open " << proc_ps << llendl;
+                return 0;
+        }
+        psinfo_t proc_psinfo;
+        if(read(proc_fd, &proc_psinfo, sizeof(psinfo_t)) != sizeof(psinfo_t)){
+                llwarns << "Unable to read " << proc_ps << llendl;
+                close(proc_fd);
+                return 0;
+        }
+
+        close(proc_fd);
+
+        resident_size = proc_psinfo.pr_rssize;
 #endif
         return resident_size;
 }
 
 LLCPUInfo::LLCPUInfo()
 {
+        std::ostringstream out;
         CProcessor proc;
         const ProcessorInfo* info = proc.GetCPUInfo();
-        mHasSSE = (info->_Ext.SSE_StreamingSIMD_Extensions != 0);
-        mHasSSE2 = (info->_Ext.SSE2_StreamingSIMD2_Extensions != 0);
+        // proc.WriteInfoTextFile("procInfo.txt");
+        mHasSSE = info->_Ext.SSE_StreamingSIMD_Extensions;
+        mHasSSE2 = info->_Ext.SSE2_StreamingSIMD2_Extensions;
+        mHasAltivec = info->_Ext.Altivec_Extensions;
         mCPUMhz = (S32)(proc.GetCPUFrequency(50)/1000000.0);
         mFamily.assign( info->strFamily );
+        mCPUString = "Unknown";
+
+#if LL_WINDOWS || LL_DARWIN || LL_SOLARIS
+        out << proc.strCPUName;
+        if (200 < mCPUMhz && mCPUMhz < 10000)           // *NOTE: cpu speed is often way wrong, do a sanity check
+        {
+                out << " (" << mCPUMhz << " MHz)";
+        }
+        mCPUString = out.str();
+        
+#elif LL_LINUX
+        std::map< LLString, LLString > cpuinfo;
+        FILE* cpuinfo_fp = LLFile::fopen(CPUINFO_FILE, "rb");
+        if(cpuinfo_fp)
+        {
+                char line[MAX_STRING];
+                memset(line, 0, MAX_STRING);
+                while(fgets(line, MAX_STRING, cpuinfo_fp))
+                {
+                        // /proc/cpuinfo on Linux looks like:
+                        // name\t*: value\n
+                        char* tabspot = strchr( line, '\t' );
+                        if (tabspot == NULL)
+                                continue;
+                        char* colspot = strchr( tabspot, ':' );
+                        if (colspot == NULL)
+                                continue;
+                        char* spacespot = strchr( colspot, ' ' );
+                        if (spacespot == NULL)
+                                continue;
+                        char* nlspot = strchr( line, '\n' );
+                        if (nlspot == NULL)
+                                nlspot = line + strlen( line ); // Fallback to terminating NUL
+                        std::string linename( line, tabspot );
+                        LLString llinename(linename);
+                        LLString::toLower(llinename);
+                        std::string lineval( spacespot + 1, nlspot );
+                        cpuinfo[ llinename ] = lineval;
+                }
+                fclose(cpuinfo_fp);
+        }
+# if LL_X86
+        LLString flags = " " + cpuinfo["flags"] + " ";
+        LLString::toLower(flags);
+        mHasSSE = ( flags.find( " sse " ) != std::string::npos );
+        mHasSSE2 = ( flags.find( " sse2 " ) != std::string::npos );
+        
+        F64 mhz;
+        if (LLString::convertToF64(cpuinfo["cpu mhz"], mhz)
+            && 200.0 < mhz && mhz < 10000.0)
+        {
+                mCPUMhz = (S32)llrint(mhz);
+        }
+        if (!cpuinfo["model name"].empty())
+                mCPUString = cpuinfo["model name"];
+# endif // LL_X86
+#endif // LL_LINUX
 }
 
+bool LLCPUInfo::hasAltivec() const
+{
+        return mHasAltivec;
+}
 
-std::string LLCPUInfo::getCPUString() const
+bool LLCPUInfo::hasSSE() const
 {
-#if LL_WINDOWS || LL_DARWIN
-        std::ostringstream out;
+        return mHasSSE;
+}
 
-        CProcessor proc;
-        (void) proc.GetCPUInfo();
-        out << proc.strCPUName << " ";
-        
-        F32 freq = (F32)(proc.GetCPUFrequency(50) / 1000000.0);
+bool LLCPUInfo::hasSSE2() const
+{
+        return mHasSSE2;
+}
 
-        // cpu speed is often way wrong, do a sanity check
-        if (200.f < freq && freq < 10000.f)
-        {
-                out << "(" << (S32)(freq) << " MHz)";
-        }
+S32 LLCPUInfo::getMhz() const
+{
+        return mCPUMhz;
+}
 
-        return out.str();
-#else
-        return "Can't get terse CPU information";
-#endif
+std::string LLCPUInfo::getCPUString() const
+{
+        return mCPUString;
 }
 
 void LLCPUInfo::stream(std::ostream& s) const
 {
-#if LL_WINDOWS || LL_DARWIN
+#if LL_WINDOWS || LL_DARWIN || LL_SOLARIS
         // gather machine information.
         char proc_buf[CPUINFO_BUFFER_SIZE];             /* Flawfinder: ignore */
         CProcessor proc;
@@ -346,38 +447,41 @@ void LLCPUInfo::stream(std::ostream& s) const
         }
         else
         {
-                s << "Unable to collect processor info";
+                s << "Unable to collect processor information" << std::endl;
         }
 #else
         // *NOTE: This works on linux. What will it do on other systems?
-        FILE* cpuinfo = LLFile::fopen(CPUINFO_FILE, "r");               /* Flawfinder: ignore */
+        FILE* cpuinfo = LLFile::fopen(CPUINFO_FILE, "rb");
         if(cpuinfo)
         {
-                char line[MAX_STRING];          /* Flawfinder: ignore */
+                char line[MAX_STRING];
                 memset(line, 0, MAX_STRING);
                 while(fgets(line, MAX_STRING, cpuinfo))
                 {
-                        line[strlen(line)-1] = ' ';              /*Flawfinder: ignore*/
+                        line[strlen(line)-1] = ' ';
                         s << line;
                 }
                 fclose(cpuinfo);
+                s << std::endl;
         }
         else
         {
-                s << "Unable to collect memory information";
+                s << "Unable to collect processor information" << std::endl;
         }
 #endif
+        // These are interesting as they reflect our internal view of the
+        // CPU's attributes regardless of platform
+        s << "->mHasSSE:     " << (U32)mHasSSE << std::endl;
+        s << "->mHasSSE2:    " << (U32)mHasSSE2 << std::endl;
+        s << "->mHasAltivec: " << (U32)mHasAltivec << std::endl;
+        s << "->mCPUMhz:     " << mCPUMhz << std::endl;
+        s << "->mCPUString:  " << mCPUString << std::endl;
 }
 
 LLMemoryInfo::LLMemoryInfo()
 {
 }
 
-#if LL_LINUX
-#include <unistd.h>
-#include <sys/sysinfo.h>
-#endif
-
 U32 LLMemoryInfo::getPhysicalMemory() const
 {
 #if LL_WINDOWS
@@ -399,7 +503,8 @@ U32 LLMemoryInfo::getPhysicalMemory() const
 #elif LL_LINUX
 
         return getpagesize() * get_phys_pages();
-
+#elif LL_SOLARIS
+        return getpagesize() * sysconf(_SC_PHYS_PAGES);
 #else
         return 0;
 
@@ -433,10 +538,15 @@ void LLMemoryInfo::stream(std::ostream& s) const
         {
                 s << "Unable to collect memory information";
         }
-        
+#elif LL_SOLARIS
+        U64 phys = 0;
+
+        phys = (U64)(sysconf(_SC_PHYS_PAGES)) * (U64)(sysconf(_SC_PAGESIZE)/1024);
+
+        s << "Total Physical Kb:  " << phys << std::endl;
 #else
         // *NOTE: This works on linux. What will it do on other systems?
-        FILE* meminfo = LLFile::fopen(MEMINFO_FILE,"r");                /* Flawfinder: ignore */
+        FILE* meminfo = LLFile::fopen(MEMINFO_FILE,"rb");
         if(meminfo)
         {
                 char line[MAX_STRING];          /* Flawfinder: ignore */
@@ -491,7 +601,11 @@ BOOL gunzip_file(const char *srcfile, const char *dstfile)
         do
         {
                 bytes = gzread(src, buffer, UNCOMPRESS_BUFFER_SIZE);
-                fwrite(buffer, sizeof(U8), bytes, dst);
+                size_t nwrit = fwrite(buffer, sizeof(U8), bytes, dst);
+                if (nwrit < (size_t) bytes)
+                {
+                        llerrs << "Short write on " << tmpfile << llendl;
+                }
         } while(gzeof(src) == 0);
         fclose(dst); 
         dst = NULL;