1// Copyright (c) 2011 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "base/sys_info.h" 6 7#include <errno.h> 8#include <string.h> 9#include <sys/param.h> 10#include <sys/resource.h> 11#include <sys/utsname.h> 12#include <unistd.h> 13 14#include "base/basictypes.h" 15#include "base/files/file_util.h" 16#include "base/lazy_instance.h" 17#include "base/logging.h" 18#include "base/strings/utf_string_conversions.h" 19#include "base/sys_info_internal.h" 20#include "base/threading/thread_restrictions.h" 21 22#if defined(OS_ANDROID) 23#include <sys/vfs.h> 24#define statvfs statfs // Android uses a statvfs-like statfs struct and call. 25#else 26#include <sys/statvfs.h> 27#endif 28 29namespace { 30 31#if !defined(OS_OPENBSD) 32int NumberOfProcessors() { 33 // sysconf returns the number of "logical" (not "physical") processors on both 34 // Mac and Linux. So we get the number of max available "logical" processors. 35 // 36 // Note that the number of "currently online" processors may be fewer than the 37 // returned value of NumberOfProcessors(). On some platforms, the kernel may 38 // make some processors offline intermittently, to save power when system 39 // loading is low. 40 // 41 // One common use case that needs to know the processor count is to create 42 // optimal number of threads for optimization. It should make plan according 43 // to the number of "max available" processors instead of "currently online" 44 // ones. The kernel should be smart enough to make all processors online when 45 // it has sufficient number of threads waiting to run. 46 long res = sysconf(_SC_NPROCESSORS_CONF); 47 if (res == -1) { 48 NOTREACHED(); 49 return 1; 50 } 51 52 return static_cast<int>(res); 53} 54 55base::LazyInstance< 56 base::internal::LazySysInfoValue<int, NumberOfProcessors> >::Leaky 57 g_lazy_number_of_processors = LAZY_INSTANCE_INITIALIZER; 58#endif 59 60int64 AmountOfVirtualMemory() { 61 struct rlimit limit; 62 int result = getrlimit(RLIMIT_DATA, &limit); 63 if (result != 0) { 64 NOTREACHED(); 65 return 0; 66 } 67 return limit.rlim_cur == RLIM_INFINITY ? 0 : limit.rlim_cur; 68} 69 70base::LazyInstance< 71 base::internal::LazySysInfoValue<int64, AmountOfVirtualMemory> >::Leaky 72 g_lazy_virtual_memory = LAZY_INSTANCE_INITIALIZER; 73 74} // namespace 75 76namespace base { 77 78#if !defined(OS_OPENBSD) 79int SysInfo::NumberOfProcessors() { 80 return g_lazy_number_of_processors.Get().value(); 81} 82#endif 83 84// static 85int64 SysInfo::AmountOfVirtualMemory() { 86 return g_lazy_virtual_memory.Get().value(); 87} 88 89// static 90int64 SysInfo::AmountOfFreeDiskSpace(const FilePath& path) { 91 base::ThreadRestrictions::AssertIOAllowed(); 92 93 struct statvfs stats; 94 if (HANDLE_EINTR(statvfs(path.value().c_str(), &stats)) != 0) 95 return -1; 96 return static_cast<int64>(stats.f_bavail) * stats.f_frsize; 97} 98 99#if !defined(OS_MACOSX) && !defined(OS_ANDROID) 100// static 101std::string SysInfo::OperatingSystemName() { 102 struct utsname info; 103 if (uname(&info) < 0) { 104 NOTREACHED(); 105 return std::string(); 106 } 107 return std::string(info.sysname); 108} 109#endif 110 111#if !defined(OS_MACOSX) && !defined(OS_ANDROID) 112// static 113std::string SysInfo::OperatingSystemVersion() { 114 struct utsname info; 115 if (uname(&info) < 0) { 116 NOTREACHED(); 117 return std::string(); 118 } 119 return std::string(info.release); 120} 121#endif 122 123// static 124std::string SysInfo::OperatingSystemArchitecture() { 125 struct utsname info; 126 if (uname(&info) < 0) { 127 NOTREACHED(); 128 return std::string(); 129 } 130 std::string arch(info.machine); 131 if (arch == "i386" || arch == "i486" || arch == "i586" || arch == "i686") { 132 arch = "x86"; 133 } else if (arch == "amd64") { 134 arch = "x86_64"; 135 } 136 return arch; 137} 138 139// static 140size_t SysInfo::VMAllocationGranularity() { 141 return getpagesize(); 142} 143 144} // namespace base 145