SERVER-9325 Add blockCheckSupported and hostInfo support to Solaris/SmartOS

Implement a processinfo_*.cpp file for Solaris, providing support for
blockCheckSupported features and the the hostInfo command.  Rewrite the
readLineFromFile() function from processinfo_linux2.cpp and move it into
processinfo.cpp where it can be called for Solaris as well as Linux.

src/mongo/util/processinfo_sunos5.cpp

@@ -1,6 +1,4 @@
-// processinfo_none.cpp
-
-/*    Copyright 2009 10gen Inc.
+/*    Copyright 2013 10gen Inc.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -15,54 +13,162 @@
  *    limitations under the License.
  */
 
-#include "pch.h"
-#include "processinfo.h"
-
+#include <boost/filesystem.hpp>
+#include <fstream>
 #include <iostream>
-using namespace std;
+#include <malloc.h>
+#include <procfs.h>
+#include <stdio.h>
+#include <string>
+#include <sys/mman.h>
+#include <sys/systeminfo.h>
+#include <sys/utsname.h>
+#include <unistd.h>
+#include <vector>
+
+#include "mongo/util/file.h"
+#include "mongo/util/mongoutils/str.h"
+#include "mongo/util/processinfo.h"
 
 namespace mongo {
 
-    ProcessInfo::ProcessInfo( ProcessId pid ) {
+    /**
+     * Read the first line from a file; return empty string on failure
+     */
+    static string readLineFromFile(const char* fname) {
+        std::string fstr;
+        std::ifstream f(fname);
+        if (f.is_open()) {
+            std::getline(f, fstr);
+        }
+        return fstr;
     }
 
-    ProcessInfo::~ProcessInfo() {
-    }
+    struct ProcPsinfo {
+        ProcPsinfo() {
+            FILE* f = fopen("/proc/self/psinfo", "r");
+            massert(16846,
+                    mongoutils::str::stream() << "couldn't open \"/proc/self/psinfo\": "
+                                              << errnoWithDescription(), 
+                    f);
+            size_t num = fread(&psinfo, sizeof(psinfo), 1, f);
+            int err = errno;
+            fclose(f);
+            massert(16847,
+                    mongoutils::str::stream() << "couldn't read from \"/proc/self/psinfo\": "
+                                              << errnoWithDescription(err), 
+                    num == 1);
+        }
+       psinfo_t psinfo;
+    };
+
+    struct ProcUsage {
+        ProcUsage() {
+            FILE* f = fopen("/proc/self/usage", "r");
+            massert(16848,
+                    mongoutils::str::stream() << "couldn't open \"/proc/self/usage\": "
+                                              << errnoWithDescription(), 
+                    f);
+            size_t num = fread(&prusage, sizeof(prusage), 1, f);
+            int err = errno;
+            fclose(f);
+            massert(16849,
+                    mongoutils::str::stream() << "couldn't read from \"/proc/self/usage\": "
+                                              << errnoWithDescription(err), 
+                    num == 1);
+        }
+       prusage_t prusage;
+    };
+
+    ProcessInfo::ProcessInfo(ProcessId pid) : _pid(pid) { }
+    ProcessInfo::~ProcessInfo() { }
 
     bool ProcessInfo::supported() {
-        return false;
+        return true;
     }
 
     int ProcessInfo::getVirtualMemorySize() {
-        return -1;
+        ProcPsinfo p;
+        return static_cast<int>(p.psinfo.pr_size / 1024);
     }
 
     int ProcessInfo::getResidentSize() {
-        return -1;
+        ProcPsinfo p;
+        return static_cast<int>(p.psinfo.pr_rssize / 1024);
     }
 
-    bool ProcessInfo::checkNumaEnabled() { 
+    void ProcessInfo::getExtraInfo(BSONObjBuilder& info) {
+        ProcUsage p;
+        info.appendNumber("page_faults", static_cast<long long>(p.prusage.pr_majf));
+    }
+
+    /**
+     * Save a BSON obj representing the host system's details
+     */
+    void ProcessInfo::SystemInfo::collectSystemInfo() {
+        struct utsname unameData;
+        if (uname(&unameData) == -1) {
+            log() << "Unable to collect detailed system information: " << strerror(errno) << endl;
+        }
+
+        char buf_64[32];
+        char buf_native[32];
+        if (sysinfo(SI_ARCHITECTURE_64, buf_64, sizeof(buf_64)) != -1 &&
+            sysinfo(SI_ARCHITECTURE_NATIVE, buf_native, sizeof(buf_native)) != -1) {
+            addrSize = mongoutils::str::equals(buf_64, buf_native) ? 64 : 32;
+        }
+        else {
+            log() << "Unable to determine system architecture: " << strerror(errno) << endl;
+        }
+
+        osType = unameData.sysname;
+        osName = mongoutils::str::ltrim(readLineFromFile("/etc/release"));
+        osVersion = unameData.version;
+        pageSize = static_cast<unsigned long long>(sysconf(_SC_PAGESIZE));
+        memSize = pageSize * static_cast<unsigned long long>(sysconf(_SC_PHYS_PAGES));
+        numCores = static_cast<unsigned>(sysconf(_SC_NPROCESSORS_CONF));
+        cpuArch = unameData.machine;
+        hasNuma = checkNumaEnabled();
+
+        BSONObjBuilder bExtra;
+        bExtra.append("kernelVersion", unameData.release);
+        bExtra.append("pageSize", static_cast<long long>(pageSize));
+        bExtra.append("numPages", static_cast<int>(sysconf(_SC_PHYS_PAGES)));
+        bExtra.append("maxOpenFiles", static_cast<int>(sysconf(_SC_OPEN_MAX)));
+        _extraStats = bExtra.obj();
+    }
+
+    bool ProcessInfo::checkNumaEnabled() {
         return false;
     }
 
     bool ProcessInfo::blockCheckSupported() {
-        return false;
-    }
-
-    void ProcessInfo::SystemInfo::collectSystemInfo() {
-
-    }
-
-    void ProcessInfo::getExtraInfo( BSONObjBuilder& info ) {
-        
+        return true;
     }
 
     bool ProcessInfo::blockInMemory(const void* start) {
-        verify(0);
+        char x = 0;
+        if (mincore(static_cast<char*>(const_cast<void*>(alignToStartOfPage(start))),
+                    getPageSize(),
+                    &x)) {
+            log() << "mincore failed: " << errnoWithDescription() << endl;
+            return 1;
+        }
+        return x & 0x1;
     }
 
-    bool ProcessInfo::pagesInMemory(const void* start, size_t numPages, vector<char>* out) {
-        verify(0);
+    bool ProcessInfo::pagesInMemory(const void* start, size_t numPages, std::vector<char>* out) {
+        out->resize(numPages);
+        if (mincore(static_cast<char*>(const_cast<void*>(alignToStartOfPage(start))),
+                    numPages * getPageSize(),
+                    &out->front())) {
+            log() << "mincore failed: " << errnoWithDescription() << endl;
+            return false;
+        }
+        for (size_t i = 0; i < numPages; ++i) {
+            (*out)[i] &= 0x1;
+        }
+        return true;
     }
 
 }