libc/malloc_debug/Config.cpp

/*
 * Copyright (C) 2015 The Android Open Source Project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <sys/cdefs.h>

#include <string>
#include <vector>

#include <sys/system_properties.h>

#include <private/bionic_macros.h>

#include "Config.h"
#include "debug_log.h"

// Config constants
static constexpr uint8_t DEFAULT_FILL_ALLOC_VALUE = 0xeb;
static constexpr uint8_t DEFAULT_FILL_FREE_VALUE = 0xef;

static constexpr uint8_t DEFAULT_FRONT_GUARD_VALUE = 0xaa;
static constexpr uint8_t DEFAULT_REAR_GUARD_VALUE = 0xbb;

// Used as the default for all guard values.
static constexpr size_t DEFAULT_GUARD_BYTES = 32;
static constexpr size_t MAX_GUARD_BYTES = 16384;

static constexpr size_t DEFAULT_BACKTRACE_FRAMES = 16;
static constexpr size_t MAX_BACKTRACE_FRAMES = 256;

static constexpr size_t DEFAULT_EXPAND_BYTES = 16;
static constexpr size_t MAX_EXPAND_BYTES = 16384;

static constexpr size_t DEFAULT_FREE_TRACK_ALLOCATIONS = 100;
static constexpr size_t MAX_FREE_TRACK_ALLOCATIONS = 16384;

static constexpr size_t DEFAULT_RECORD_ALLOCS = 8000000;
static constexpr size_t MAX_RECORD_ALLOCS = 50000000;
static constexpr const char DEFAULT_RECORD_ALLOCS_FILE[] = "/data/local/tmp/record_allocs.txt";

struct Option {
  Option(std::string name, uint64_t option, bool combo_option = false, bool* config = nullptr)
      : name(name), option(option), combo_option(combo_option), config(config) {}
  virtual ~Option() = default;

  std::string name;

  uint64_t option;
  // If set to true, then all of the options following are set on until
  // the combo_option value is set to false.
  bool combo_option = false;
  bool* config;

  virtual bool ParseValue(const std::string& option_name, const std::string& value) const;

  virtual void SetDefault() const { }
};

bool Option::ParseValue(const std::string& option_name, const std::string& raw_value) const {
  if (!raw_value.empty()) {
    error_log("%s: value set for option '%s' which does not take a value",
              getprogname(), option_name.c_str());
    return false;
  }
  return true;
}

struct OptionString : public Option {
  OptionString(std::string name, uint64_t option, std::string default_value,
                std::string* value, bool combo_option = false,
                bool* config = nullptr)
      : Option(name, option, combo_option, config), default_value(default_value), value(value) {}
  virtual ~OptionString() = default;

  std::string default_value;
  std::string* value;

  bool ParseValue(const std::string& option_name, const std::string& value) const override;

  void SetDefault() const override { if (value) *value = default_value; }
};

bool OptionString::ParseValue(const std::string&, const std::string& raw_value) const {
  if (!raw_value.empty()) {
    *value = raw_value;
  }
  return true;
}

struct OptionSizeT : public Option {
  OptionSizeT(std::string name, size_t default_value, size_t min_value, size_t max_value,
          uint64_t option, size_t* value, bool combo_option = false, bool* config = nullptr)
      : Option(name, option, combo_option, config), default_value(default_value),
        min_value(min_value), max_value(max_value), value(value) {}
  virtual ~OptionSizeT() = default;

  size_t default_value;
  size_t min_value;
  size_t max_value;

  size_t* value;

  bool ParseValue(const std::string& option_name, const std::string& value) const override;

  void SetDefault() const override { if (value) *value = default_value; }
};

bool OptionSizeT::ParseValue(const std::string& option_name, const std::string& raw_value) const {
  if (raw_value.empty()) {
    // Value should have been set by the SetDefault() pass.
    return true;
  }

  // Parse the value into a size_t value.
  errno = 0;
  char* end;
  long parsed_value = strtol(raw_value.c_str(), &end, 10);
  if (errno != 0) {
    error_log("%s: bad value for option '%s': %s", getprogname(), option_name.c_str(),
              strerror(errno));
    return false;
  }
  if (end == raw_value.c_str()) {
    error_log("%s: bad value for option '%s'", getprogname(), option_name.c_str());
    return false;
  }
  if (static_cast<size_t>(end - raw_value.c_str()) != raw_value.size()) {
    error_log("%s: bad value for option '%s', non space found after option: %s",
              getprogname(), option_name.c_str(), end);
    return false;
  }
  if (parsed_value < 0) {
    error_log("%s: bad value for option '%s', value cannot be negative: %ld",
              getprogname(), option_name.c_str(), parsed_value);
    return false;
  }

  if (static_cast<size_t>(parsed_value) < min_value) {
    error_log("%s: bad value for option '%s', value must be >= %zu: %ld",
              getprogname(), option_name.c_str(), min_value, parsed_value);
    return false;
  }
  if (static_cast<size_t>(parsed_value) > max_value) {
    error_log("%s: bad value for option '%s', value must be <= %zu: %ld",
              getprogname(), option_name.c_str(), max_value, parsed_value);
    return false;
  }
  *value = static_cast<size_t>(parsed_value);
  return true;
}

class PropertyParser {
 public:
  explicit PropertyParser(const char* property) : cur_(property) {}

  bool Get(std::string* property, std::string* value);

  bool Done() { return done_; }

  void LogUsage();

 private:
  const char* cur_ = nullptr;

  bool done_ = false;

  DISALLOW_COPY_AND_ASSIGN(PropertyParser);
};

bool PropertyParser::Get(std::string* property, std::string* value) {
  // Process each property name we can find.
  while (isspace(*cur_))
    ++cur_;

  if (*cur_ == '\0') {
    done_ = true;
    return false;
  }

  const char* start = cur_;
  while (!isspace(*cur_) && *cur_ != '=' && *cur_ != '\0')
    ++cur_;

  *property = std::string(start, cur_ - start);

  // Skip any spaces after the name.
  while (isspace(*cur_))
    ++cur_;

  value->clear();
  if (*cur_ == '=') {
    ++cur_;
    // Skip the space after the equal.
    while (isspace(*cur_))
      ++cur_;

    start = cur_;
    while (!isspace(*cur_) && *cur_ != '\0')
      ++cur_;

    if (cur_ != start) {
      *value = std::string(start, cur_ - start);
    }
  }
  return true;
}

void PropertyParser::LogUsage() {
  error_log("malloc debug options usage:");
  error_log("");
  error_log("  front_guard[=XX]");
  error_log("    Enables a front guard on all allocations. If XX is set");
  error_log("    it sets the number of bytes in the guard. The default is");
  error_log("    %zu bytes, the max bytes is %zu.", DEFAULT_GUARD_BYTES, MAX_GUARD_BYTES);
  error_log("");
  error_log("  rear_guard[=XX]");
  error_log("    Enables a rear guard on all allocations. If XX is set");
  error_log("    it sets the number of bytes in the guard. The default is");
  error_log("    %zu bytes, the max bytes is %zu.", DEFAULT_GUARD_BYTES, MAX_GUARD_BYTES);
  error_log("");
  error_log("  guard[=XX]");
  error_log("    Enables both a front guard and a rear guard on all allocations.");
  error_log("    If XX is set it sets the number of bytes in both guards.");
  error_log("    The default is %zu bytes, the max bytes is %zu.",
            DEFAULT_GUARD_BYTES, MAX_GUARD_BYTES);
  error_log("");
  error_log("  backtrace[=XX]");
  error_log("    Enable capturing the backtrace at the point of allocation.");
  error_log("    If XX is set it sets the number of backtrace frames.");
  error_log("    The default is %zu frames, the max number of frames is %zu.",
            DEFAULT_BACKTRACE_FRAMES, MAX_BACKTRACE_FRAMES);
  error_log("");
  error_log("  backtrace_enable_on_signal[=XX]");
  error_log("    Enable capturing the backtrace at the point of allocation.");
  error_log("    The backtrace capture is not enabled until the process");
  error_log("    receives a signal. If XX is set it sets the number of backtrace");
  error_log("    frames. The default is %zu frames, the max number of frames is %zu.",
            DEFAULT_BACKTRACE_FRAMES, MAX_BACKTRACE_FRAMES);
  error_log("");
  error_log("  fill_on_alloc[=XX]");
  error_log("    On first allocation, fill with the value 0x%02x.", DEFAULT_FILL_ALLOC_VALUE);
  error_log("    If XX is set it will only fill up to XX bytes of the");
  error_log("    allocation. The default is to fill the entire allocation.");
  error_log("");
  error_log("  fill_on_free[=XX]");
  error_log("    On free, fill with the value 0x%02x. If XX is set it will",
            DEFAULT_FILL_FREE_VALUE);
  error_log("    only fill up to XX bytes of the allocation. The default is to");
  error_log("    fill the entire allocation.");
  error_log("");
  error_log("  fill[=XX]");
  error_log("    On both first allocation free, fill with the value 0x%02x on",
            DEFAULT_FILL_ALLOC_VALUE);
  error_log("    first allocation and the value 0x%02x. If XX is set, only fill",
            DEFAULT_FILL_FREE_VALUE);
  error_log("    up to XX bytes. The default is to fill the entire allocation.");
  error_log("");
  error_log("  expand_alloc[=XX]");
  error_log("    Allocate an extra number of bytes for every allocation call.");
  error_log("    If XX is set, that is the number of bytes to expand the");
  error_log("    allocation by. The default is %zu bytes, the max bytes is %zu.",
            DEFAULT_EXPAND_BYTES, MAX_EXPAND_BYTES);
  error_log("");
  error_log("  free_track[=XX]");
  error_log("    When a pointer is freed, do not free the memory right away.");
  error_log("    Instead, keep XX of these allocations around and then verify");
  error_log("    that they have not been modified when the total number of freed");
  error_log("    allocations exceeds the XX amount. When the program terminates,");
  error_log("    the rest of these allocations are verified. When this option is");
  error_log("    enabled, it automatically records the backtrace at the time of the free.");
  error_log("    The default is to record %zu allocations, the max allocations",
            DEFAULT_FREE_TRACK_ALLOCATIONS);
  error_log("    to record is %zu.", MAX_FREE_TRACK_ALLOCATIONS);
  error_log("");
  error_log("  free_track_backtrace_num_frames[=XX]");
  error_log("    This option only has meaning if free_track is set. This indicates");
  error_log("    how many backtrace frames to capture when an allocation is freed.");
  error_log("    If XX is set, that is the number of frames to capture. If XX");
  error_log("    is set to zero, then no backtrace will be captured.");
  error_log("    The default is to record %zu frames, the max number of frames is %zu.",
            DEFAULT_BACKTRACE_FRAMES, MAX_BACKTRACE_FRAMES);
  error_log("");
  error_log("  leak_track");
  error_log("    Enable the leak tracking of memory allocations.");
  error_log("");
  error_log("  record_allocs[=XX]");
  error_log("    Record every single allocation/free call. When a specific signal");
  error_log("    is sent to the process, the contents of recording are written to");
  error_log("    a file (%s) and the recording is cleared.", DEFAULT_RECORD_ALLOCS_FILE);
  error_log("    If XX is set, that is the total number of allocations/frees that can");
  error_log("    recorded. of frames to capture. The default value is %zu.", DEFAULT_RECORD_ALLOCS);
  error_log("    If the allocation list fills up, all further allocations are not recorded.");
  error_log("");
  error_log("  record_alloc_file[=FILE]");
  error_log("    This option only has meaning if the record_allocs options has been specified.");
  error_log("    This is the name of the file to which recording information will be dumped.");
  error_log("    The default is %s.", DEFAULT_RECORD_ALLOCS_FILE);
}

// This function is designed to be called once. A second call will not
// reset all variables.
bool Config::SetFromProperties() {
  char property_str[PROP_VALUE_MAX];
  memset(property_str, 0, sizeof(property_str));
  if (!__system_property_get("libc.debug.malloc.options", property_str)) {
    return false;
  }

  // Initialize a few default values.
  fill_alloc_value = DEFAULT_FILL_ALLOC_VALUE;
  fill_free_value = DEFAULT_FILL_FREE_VALUE;
  front_guard_value = DEFAULT_FRONT_GUARD_VALUE;
  rear_guard_value = DEFAULT_REAR_GUARD_VALUE;
  backtrace_signal = SIGRTMAX - 19;
  record_allocs_signal = SIGRTMAX - 18;
  free_track_backtrace_num_frames = 0;
  record_allocs_file.clear();

  // Parse the options are of the format:
  //   option_name or option_name=XX

  // Supported options:
  const OptionSizeT option_guard(
      "guard", DEFAULT_GUARD_BYTES, 1, MAX_GUARD_BYTES, 0, nullptr, true);
  // Enable front guard. Value is the size of the guard.
  const OptionSizeT option_front_guard(
      "front_guard", DEFAULT_GUARD_BYTES, 1, MAX_GUARD_BYTES, FRONT_GUARD,
      &this->front_guard_bytes, true);
  // Enable end guard. Value is the size of the guard.
  const OptionSizeT option_rear_guard(
      "rear_guard", DEFAULT_GUARD_BYTES, 1, MAX_GUARD_BYTES, REAR_GUARD, &this->rear_guard_bytes,
      true);

  // Enable logging the backtrace on allocation. Value is the total
  // number of frames to log.
  const OptionSizeT option_backtrace(
      "backtrace", DEFAULT_BACKTRACE_FRAMES, 1, MAX_BACKTRACE_FRAMES, BACKTRACE | TRACK_ALLOCS,
      &this->backtrace_frames, false, &this->backtrace_enabled);
  // Enable gathering backtrace values on a signal.
  const OptionSizeT option_backtrace_enable_on_signal(
      "backtrace_enable_on_signal", DEFAULT_BACKTRACE_FRAMES, 1, MAX_BACKTRACE_FRAMES,
      BACKTRACE | TRACK_ALLOCS, &this->backtrace_frames, false, &this->backtrace_enable_on_signal);

  const OptionSizeT option_fill("fill", SIZE_MAX, 1, SIZE_MAX, 0, nullptr, true);
  // Fill the allocation with an arbitrary pattern on allocation.
  // Value is the number of bytes of the allocation to fill
  // (default entire allocation).
  const OptionSizeT option_fill_on_alloc(
      "fill_on_alloc", SIZE_MAX, 1, SIZE_MAX, FILL_ON_ALLOC, &this->fill_on_alloc_bytes, true);
  // Fill the allocation with an arbitrary pattern on free.
  // Value is the number of bytes of the allocation to fill
  // (default entire allocation).
  const OptionSizeT option_fill_on_free(
      "fill_on_free", SIZE_MAX, 1, SIZE_MAX, FILL_ON_FREE, &this->fill_on_free_bytes, true);

  // Expand the size of every alloc by this number bytes. Value is
  // the total number of bytes to expand every allocation by.
  const OptionSizeT option_expand_alloc(
      "expand_alloc", DEFAULT_EXPAND_BYTES, 1, MAX_EXPAND_BYTES, EXPAND_ALLOC,
      &this->expand_alloc_bytes);

  // Keep track of the freed allocations and verify at a later date
  // that they have not been used. Turning this on, also turns on
  // fill on free.
  const OptionSizeT option_free_track(
      "free_track", DEFAULT_FREE_TRACK_ALLOCATIONS, 1, MAX_FREE_TRACK_ALLOCATIONS,
      FREE_TRACK | FILL_ON_FREE, &this->free_track_allocations);
  // Number of backtrace frames to keep when free_track is enabled. If this
  // value is set to zero, no backtrace will be kept.
  const OptionSizeT option_free_track_backtrace_num_frames(
      "free_track_backtrace_num_frames", DEFAULT_BACKTRACE_FRAMES, 0, MAX_BACKTRACE_FRAMES, 0,
      &this->free_track_backtrace_num_frames);

  // Enable printing leaked allocations.
  const Option option_leak_track("leak_track", LEAK_TRACK | TRACK_ALLOCS);

  const OptionSizeT option_record_allocs(
      "record_allocs", DEFAULT_RECORD_ALLOCS, 1, MAX_RECORD_ALLOCS, RECORD_ALLOCS,
      &this->record_allocs_num_entries);
  const OptionString option_record_allocs_file(
      "record_allocs_file", 0, DEFAULT_RECORD_ALLOCS_FILE, &this->record_allocs_file);

  const Option* option_list[] = {
    &option_guard, &option_front_guard, &option_rear_guard,
    &option_backtrace, &option_backtrace_enable_on_signal,
    &option_fill, &option_fill_on_alloc, &option_fill_on_free,
    &option_expand_alloc,
    &option_free_track, &option_free_track_backtrace_num_frames,
    &option_leak_track,
    &option_record_allocs, &option_record_allocs_file,
  };

  // Set defaults for all of the options.
  for (size_t i = 0; i < sizeof(option_list)/sizeof(Option*); i++) {
    option_list[i]->SetDefault();
  }

  // Process each property name we can find.
  PropertyParser parser(property_str);
  bool valid = true;
  std::string property;
  std::string value;
  while (valid && parser.Get(&property, &value)) {
    bool found = false;
    for (size_t i = 0; i < sizeof(option_list)/sizeof(Option*); i++) {
      if (property == option_list[i]->name) {
        if (option_list[i]->option == 0 && option_list[i]->combo_option) {
          const std::string* option_name = &option_list[i]->name;
          i++;
          for (; i < sizeof(option_list)/sizeof(Option*) && option_list[i]->combo_option; i++) {
            if (!option_list[i]->ParseValue(*option_name, value)) {
              valid = false;
              break;
            }
            if (option_list[i]->config) {
              *option_list[i]->config = true;
            }
            options |= option_list[i]->option;
          }
          if (!valid) {
            break;
          }
        } else {
          if (!option_list[i]->ParseValue(option_list[i]->name, value)) {
            valid = false;
            break;
          }
          if (option_list[i]->config) {
            *option_list[i]->config = true;
          }
          options |= option_list[i]->option;
        }
        found = true;
        break;
      }
    }
    if (valid && !found) {
      error_log("%s: unknown option %s", getprogname(), property.c_str());
      valid = false;
      break;
    }
  }

  valid = valid && parser.Done();

  if (valid) {
    // It's necessary to align the front guard to MINIMUM_ALIGNMENT_BYTES to
    // make sure that the header is aligned properly.
    if (options & FRONT_GUARD) {
      front_guard_bytes = BIONIC_ALIGN(front_guard_bytes, MINIMUM_ALIGNMENT_BYTES);
    }
  } else {
    parser.LogUsage();
  }

  return valid;
}