runtime/vm/proccpuinfo.cc

// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

#include "vm/globals.h"
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_ANDROID)

#include "vm/proccpuinfo.h"

#include <ctype.h>   // NOLINT
#include <string.h>  // NOLINT

#include "platform/assert.h"

namespace dart {

char* ProcCpuInfo::data_ = nullptr;
intptr_t ProcCpuInfo::datalen_ = 0;

void ProcCpuInfo::Init() {
  // Get the size of the cpuinfo file by reading it until the end. This is
  // required because files under /proc do not always return a valid size
  // when using fseek(0, SEEK_END) + ftell(). Nor can they be mmap()-ed.
  static const char PATHNAME[] = "/proc/cpuinfo";
  FILE* fp = fopen(PATHNAME, "r");
  if (fp != nullptr) {
    for (;;) {
      char buffer[256];
      size_t n = fread(buffer, 1, sizeof(buffer), fp);
      if (n == 0) {
        break;
      }
      datalen_ += n;
    }
    fclose(fp);
  }

  // Read the contents of the cpuinfo file.
  data_ = reinterpret_cast<char*>(malloc(datalen_ + 1));
  fp = fopen(PATHNAME, "r");
  if (fp != nullptr) {
    for (intptr_t offset = 0; offset < datalen_;) {
      size_t n = fread(data_ + offset, 1, datalen_ - offset, fp);
      if (n == 0) {
        break;
      }
      offset += n;
    }
    fclose(fp);
  }

  // Zero-terminate the data.
  data_[datalen_] = '\0';
}

void ProcCpuInfo::Cleanup() {
  ASSERT(data_);
  free(data_);
  data_ = nullptr;
}

char* ProcCpuInfo::FieldStart(const char* field) {
  // Look for first field occurrence, and ensure it starts the line.
  size_t fieldlen = strlen(field);
  char* p = data_;
  for (;;) {
    p = strstr(p, field);
    if (p == nullptr) {
      return nullptr;
    }
    if (p == data_ || p[-1] == '\n') {
      break;
    }
    p += fieldlen;
  }

  // Skip to the first colon followed by a space.
  p = strchr(p + fieldlen, ':');
  if (p == nullptr || (isspace(p[1]) == 0)) {
    return nullptr;
  }
  p += 2;

  return p;
}

bool ProcCpuInfo::FieldContains(const char* field, const char* search_string) {
  ASSERT(data_ != nullptr);
  ASSERT(search_string != nullptr);

  char* p = FieldStart(field);
  if (p == nullptr) {
    return false;
  }

  // Find the end of the line.
  char* q = strchr(p, '\n');
  if (q == nullptr) {
    q = data_ + datalen_;
  }

  char saved_end = *q;
  *q = '\0';
  bool ret = (strcasestr(p, search_string) != nullptr);
  *q = saved_end;

  return ret;
}

// Extract the content of a the first occurrence of a given field in
// the content of the cpuinfo file and return it as a heap-allocated
// string that must be freed by the caller using free.
// Return nullptr if not found.
const char* ProcCpuInfo::ExtractField(const char* field) {
  ASSERT(field != nullptr);
  ASSERT(data_ != nullptr);

  char* p = FieldStart(field);
  if (p == nullptr) {
    return nullptr;
  }

  // Find the end of the line.
  char* q = strchr(p, '\n');
  if (q == nullptr) {
    q = data_ + datalen_;
  }

  intptr_t len = q - p;
  char* result = reinterpret_cast<char*>(malloc(len + 1));
  // Copy the line into result, leaving enough room for a null-terminator.
  char saved_end = *q;
  *q = '\0';
  strncpy(result, p, len);
  result[len] = '\0';
  *q = saved_end;

  return result;
}

bool ProcCpuInfo::HasField(const char* field) {
  ASSERT(field != nullptr);
  ASSERT(data_ != nullptr);
  return (FieldStart(field) != nullptr);
}

}  // namespace dart

#endif  // defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_ANDROID)