libsanitizer/sanitizer_common/sanitizer_suppressions.cpp

   1 //===-- sanitizer_suppressions.cpp ----------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Suppression parsing/matching code.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "sanitizer_suppressions.h"
  14
  15 #include "sanitizer_allocator_internal.h"
  16 #include "sanitizer_common.h"
  17 #include "sanitizer_flags.h"
  18 #include "sanitizer_file.h"
  19 #include "sanitizer_libc.h"
  20 #include "sanitizer_placement_new.h"
  21
  22 namespace __sanitizer {
  23
  24 SuppressionContext::SuppressionContext(const char *suppression_types[],
  25                                        int suppression_types_num)
  26     : suppression_types_(suppression_types),
  27       suppression_types_num_(suppression_types_num),
  28       can_parse_(true) {
  29   CHECK_LE(suppression_types_num_, kMaxSuppressionTypes);
  30   internal_memset(has_suppression_type_, 0, suppression_types_num_);
  31 }
  32
  33 #if !SANITIZER_FUCHSIA
  34 static bool GetPathAssumingFileIsRelativeToExec(const char *file_path,
  35                                                 /*out*/char *new_file_path,
  36                                                 uptr new_file_path_size) {
  37   InternalMmapVector<char> exec(kMaxPathLength);
  38   if (ReadBinaryNameCached(exec.data(), exec.size())) {
  39     const char *file_name_pos = StripModuleName(exec.data());
  40     uptr path_to_exec_len = file_name_pos - exec.data();
  41     internal_strncat(new_file_path, exec.data(),
  42                      Min(path_to_exec_len, new_file_path_size - 1));
  43     internal_strncat(new_file_path, file_path,
  44                      new_file_path_size - internal_strlen(new_file_path) - 1);
  45     return true;
  46   }
  47   return false;
  48 }
  49
  50 static const char *FindFile(const char *file_path,
  51                             /*out*/char *new_file_path,
  52                             uptr new_file_path_size) {
  53   // If we cannot find the file, check if its location is relative to
  54   // the location of the executable.
  55   if (!FileExists(file_path) && !IsAbsolutePath(file_path) &&
  56       GetPathAssumingFileIsRelativeToExec(file_path, new_file_path,
  57                                           new_file_path_size)) {
  58     return new_file_path;
  59   }
  60   return file_path;
  61 }
  62 #else
  63 static const char *FindFile(const char *file_path, char *, uptr) {
  64   return file_path;
  65 }
  66 #endif
  67
  68 void SuppressionContext::ParseFromFile(const char *filename) {
  69   if (filename[0] == '\0')
  70     return;
  71
  72   InternalMmapVector<char> new_file_path(kMaxPathLength);
  73   filename = FindFile(filename, new_file_path.data(), new_file_path.size());
  74
  75   // Read the file.
  76   VPrintf(1, "%s: reading suppressions file at %s\n",
  77           SanitizerToolName, filename);
  78   char *file_contents;
  79   uptr buffer_size;
  80   uptr contents_size;
  81   if (!ReadFileToBuffer(filename, &file_contents, &buffer_size,
  82                         &contents_size)) {
  83     Printf("%s: failed to read suppressions file '%s'\n", SanitizerToolName,
  84            filename);
  85     Die();
  86   }
  87
  88   Parse(file_contents);
  89   UnmapOrDie(file_contents, contents_size);
  90 }
  91
  92 bool SuppressionContext::Match(const char *str, const char *type,
  93                                Suppression **s) {
  94   can_parse_ = false;
  95   if (!HasSuppressionType(type))
  96     return false;
  97   for (uptr i = 0; i < suppressions_.size(); i++) {
  98     Suppression &cur = suppressions_[i];
  99     if (0 == internal_strcmp(cur.type, type) && TemplateMatch(cur.templ, str)) {
 100       *s = &cur;
 101       return true;
 102     }
 103   }
 104   return false;
 105 }
 106
 107 static const char *StripPrefix(const char *str, const char *prefix) {
 108   while (*str && *str == *prefix) {
 109     str++;
 110     prefix++;
 111   }
 112   if (!*prefix)
 113     return str;
 114   return 0;
 115 }
 116
 117 void SuppressionContext::Parse(const char *str) {
 118   // Context must not mutate once Match has been called.
 119   CHECK(can_parse_);
 120   const char *line = str;
 121   while (line) {
 122     while (line[0] == ' ' || line[0] == '\t')
 123       line++;
 124     const char *end = internal_strchr(line, '\n');
 125     if (end == 0)
 126       end = line + internal_strlen(line);
 127     if (line != end && line[0] != '#') {
 128       const char *end2 = end;
 129       while (line != end2 &&
 130              (end2[-1] == ' ' || end2[-1] == '\t' || end2[-1] == '\r'))
 131         end2--;
 132       int type;
 133       for (type = 0; type < suppression_types_num_; type++) {
 134         const char *next_char = StripPrefix(line, suppression_types_[type]);
 135         if (next_char && *next_char == ':') {
 136           line = ++next_char;
 137           break;
 138         }
 139       }
 140       if (type == suppression_types_num_) {
 141         Printf("%s: failed to parse suppressions\n", SanitizerToolName);
 142         Die();
 143       }
 144       Suppression s;
 145       s.type = suppression_types_[type];
 146       s.templ = (char*)InternalAlloc(end2 - line + 1);
 147       internal_memcpy(s.templ, line, end2 - line);
 148       s.templ[end2 - line] = 0;
 149       suppressions_.push_back(s);
 150       has_suppression_type_[type] = true;
 151     }
 152     if (end[0] == 0)
 153       break;
 154     line = end + 1;
 155   }
 156 }
 157
 158 uptr SuppressionContext::SuppressionCount() const {
 159   return suppressions_.size();
 160 }
 161
 162 bool SuppressionContext::HasSuppressionType(const char *type) const {
 163   for (int i = 0; i < suppression_types_num_; i++) {
 164     if (0 == internal_strcmp(type, suppression_types_[i]))
 165       return has_suppression_type_[i];
 166   }
 167   return false;
 168 }
 169
 170 const Suppression *SuppressionContext::SuppressionAt(uptr i) const {
 171   CHECK_LT(i, suppressions_.size());
 172   return &suppressions_[i];
 173 }
 174
 175 void SuppressionContext::GetMatched(
 176     InternalMmapVector<Suppression *> *matched) {
 177   for (uptr i = 0; i < suppressions_.size(); i++)
 178     if (atomic_load_relaxed(&suppressions_[i].hit_count))
 179       matched->push_back(&suppressions_[i]);
 180 }
 181
 182 }  // namespace __sanitizer