sys_info_posix.cc 5.86 KB
Newer Older
1
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 3 4 5 6 7
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/sys_info.h"

#include <errno.h>
8 9
#include <stddef.h>
#include <stdint.h>
10
#include <string.h>
11
#include <sys/param.h>
12
#include <sys/resource.h>
13
#include <sys/utsname.h>
14 15
#include <unistd.h>

16
#include "base/files/file_util.h"
17
#include "base/lazy_instance.h"
18
#include "base/logging.h"
19
#include "base/strings/utf_string_conversions.h"
20
#include "base/sys_info_internal.h"
21
#include "base/threading/thread_restrictions.h"
22
#include "build/build_config.h"
23

24 25 26 27 28 29 30
#if defined(OS_ANDROID)
#include <sys/vfs.h>
#define statvfs statfs  // Android uses a statvfs-like statfs struct and call.
#else
#include <sys/statvfs.h>
#endif

31 32 33 34 35
#if defined(OS_LINUX)
#include <linux/magic.h>
#include <sys/vfs.h>
#endif

36
namespace {
37

38
#if !defined(OS_OPENBSD)
39
int NumberOfProcessors() {
40 41 42 43 44 45 46 47 48 49 50 51 52 53
  // sysconf returns the number of "logical" (not "physical") processors on both
  // Mac and Linux.  So we get the number of max available "logical" processors.
  //
  // Note that the number of "currently online" processors may be fewer than the
  // returned value of NumberOfProcessors(). On some platforms, the kernel may
  // make some processors offline intermittently, to save power when system
  // loading is low.
  //
  // One common use case that needs to know the processor count is to create
  // optimal number of threads for optimization. It should make plan according
  // to the number of "max available" processors instead of "currently online"
  // ones. The kernel should be smart enough to make all processors online when
  // it has sufficient number of threads waiting to run.
  long res = sysconf(_SC_NPROCESSORS_CONF);
54 55 56 57 58 59
  if (res == -1) {
    NOTREACHED();
    return 1;
  }

  return static_cast<int>(res);
60
}
61

62 63
base::LazyInstance<
    base::internal::LazySysInfoValue<int, NumberOfProcessors> >::Leaky
64 65 66
    g_lazy_number_of_processors = LAZY_INSTANCE_INITIALIZER;
#endif

avi's avatar
avi committed
67
int64_t AmountOfVirtualMemory() {
68 69 70 71 72 73 74 75 76
  struct rlimit limit;
  int result = getrlimit(RLIMIT_DATA, &limit);
  if (result != 0) {
    NOTREACHED();
    return 0;
  }
  return limit.rlim_cur == RLIM_INFINITY ? 0 : limit.rlim_cur;
}

77 78
base::LazyInstance<
    base::internal::LazySysInfoValue<int64_t, AmountOfVirtualMemory>>::Leaky
79 80
    g_lazy_virtual_memory = LAZY_INSTANCE_INITIALIZER;

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
#if defined(OS_LINUX)
bool IsStatsZeroIfUnlimited(const base::FilePath& path) {
  struct statfs stats;

  if (HANDLE_EINTR(statfs(path.value().c_str(), &stats)) != 0)
    return false;

  switch (stats.f_type) {
    case TMPFS_MAGIC:
    case HUGETLBFS_MAGIC:
    case RAMFS_MAGIC:
      return true;
  }
  return false;
}
#endif

98 99 100 101 102 103 104
bool GetDiskSpaceInfo(const base::FilePath& path,
                      int64_t* available_bytes,
                      int64_t* total_bytes) {
  struct statvfs stats;
  if (HANDLE_EINTR(statvfs(path.value().c_str(), &stats)) != 0)
    return false;

105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
#if defined(OS_LINUX)
  const bool zero_size_means_unlimited =
      stats.f_blocks == 0 && IsStatsZeroIfUnlimited(path);
#else
  const bool zero_size_means_unlimited = false;
#endif

  if (available_bytes) {
    *available_bytes =
        zero_size_means_unlimited
            ? std::numeric_limits<int64_t>::max()
            : static_cast<int64_t>(stats.f_bavail) * stats.f_frsize;
  }

  if (total_bytes) {
    *total_bytes = zero_size_means_unlimited
                       ? std::numeric_limits<int64_t>::max()
                       : static_cast<int64_t>(stats.f_blocks) * stats.f_frsize;
  }
124 125 126
  return true;
}

127 128
}  // namespace

129 130
namespace base {

131 132 133 134
#if !defined(OS_OPENBSD)
int SysInfo::NumberOfProcessors() {
  return g_lazy_number_of_processors.Get().value();
}
135
#endif
136

137
// static
avi's avatar
avi committed
138
int64_t SysInfo::AmountOfVirtualMemory() {
139 140 141
  return g_lazy_virtual_memory.Get().value();
}

142
// static
avi's avatar
avi committed
143
int64_t SysInfo::AmountOfFreeDiskSpace(const FilePath& path) {
144 145
  base::ThreadRestrictions::AssertIOAllowed();

146 147 148 149 150 151 152 153 154 155 156 157
  int64_t available;
  if (!GetDiskSpaceInfo(path, &available, nullptr))
    return -1;
  return available;
}

// static
int64_t SysInfo::AmountOfTotalDiskSpace(const FilePath& path) {
  base::ThreadRestrictions::AssertIOAllowed();

  int64_t total;
  if (!GetDiskSpaceInfo(path, nullptr, &total))
158
    return -1;
159
  return total;
160 161
}

162
#if !defined(OS_MACOSX) && !defined(OS_ANDROID)
163 164
// static
std::string SysInfo::OperatingSystemName() {
165
  struct utsname info;
166 167
  if (uname(&info) < 0) {
    NOTREACHED();
168
    return std::string();
169 170 171
  }
  return std::string(info.sysname);
}
172
#endif
173

174
#if !defined(OS_MACOSX) && !defined(OS_ANDROID)
175 176
// static
std::string SysInfo::OperatingSystemVersion() {
177
  struct utsname info;
178 179
  if (uname(&info) < 0) {
    NOTREACHED();
180
    return std::string();
181 182 183
  }
  return std::string(info.release);
}
184
#endif
185

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
#if !defined(OS_MACOSX) && !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
// static
void SysInfo::OperatingSystemVersionNumbers(int32_t* major_version,
                                            int32_t* minor_version,
                                            int32_t* bugfix_version) {
  struct utsname info;
  if (uname(&info) < 0) {
    NOTREACHED();
    *major_version = 0;
    *minor_version = 0;
    *bugfix_version = 0;
    return;
  }
  int num_read = sscanf(info.release, "%d.%d.%d", major_version, minor_version,
                        bugfix_version);
  if (num_read < 1)
    *major_version = 0;
  if (num_read < 2)
    *minor_version = 0;
  if (num_read < 3)
    *bugfix_version = 0;
}
#endif

210
// static
211
std::string SysInfo::OperatingSystemArchitecture() {
212
  struct utsname info;
213 214
  if (uname(&info) < 0) {
    NOTREACHED();
215
    return std::string();
216
  }
217 218 219 220 221 222 223
  std::string arch(info.machine);
  if (arch == "i386" || arch == "i486" || arch == "i586" || arch == "i686") {
    arch = "x86";
  } else if (arch == "amd64") {
    arch = "x86_64";
  }
  return arch;
224 225
}

226 227 228 229 230
// static
size_t SysInfo::VMAllocationGranularity() {
  return getpagesize();
}

231
}  // namespace base