| 1 |
// Copyright (c) the JPEG XL Project Authors. All rights reserved. |
| 2 |
// |
| 3 |
// Use of this source code is governed by a BSD-style |
| 4 |
// license that can be found in the LICENSE file. |
| 5 |
|
| 6 |
#ifndef LIB_JXL_SANITIZERS_H_ |
| 7 |
#define LIB_JXL_SANITIZERS_H_ |
| 8 |
|
| 9 |
#include <cstddef> |
| 10 |
|
| 11 |
#include "lib/jxl/base/compiler_specific.h" |
| 12 |
#include "lib/jxl/base/sanitizer_definitions.h" |
| 13 |
|
| 14 |
#if JXL_MEMORY_SANITIZER |
| 15 |
#include <algorithm> |
| 16 |
#include <cinttypes> // PRId64 |
| 17 |
#include <cstdio> |
| 18 |
#include <string> |
| 19 |
#include <vector> |
| 20 |
|
| 21 |
#include "lib/jxl/base/rect.h" |
| 22 |
#include "lib/jxl/base/status.h" |
| 23 |
#include "sanitizer/msan_interface.h" |
| 24 |
#endif |
| 25 |
|
| 26 |
namespace jxl { |
| 27 |
namespace msan { |
| 28 |
|
| 29 |
#if JXL_MEMORY_SANITIZER |
| 30 |
|
| 31 |
// Chosen so that kSanitizerSentinel is four copies of kSanitizerSentinelByte. |
| 32 |
constexpr uint8_t kSanitizerSentinelByte = 0x48; |
| 33 |
constexpr float kSanitizerSentinel = 205089.125f; |
| 34 |
|
| 35 |
static JXL_INLINE JXL_MAYBE_UNUSED void PoisonMemory(const volatile void* m, |
| 36 |
size_t size) { |
| 37 |
__msan_poison(m, size); |
| 38 |
} |
| 39 |
|
| 40 |
static JXL_INLINE JXL_MAYBE_UNUSED void UnpoisonMemory(const volatile void* m, |
| 41 |
size_t size) { |
| 42 |
__msan_unpoison(m, size); |
| 43 |
} |
| 44 |
|
| 45 |
static JXL_INLINE JXL_MAYBE_UNUSED void MemoryIsInitialized( |
| 46 |
const volatile void* m, size_t size) { |
| 47 |
__msan_check_mem_is_initialized(m, size); |
| 48 |
} |
| 49 |
|
| 50 |
// Mark all the bytes of an image (including padding) as poisoned bytes. |
| 51 |
template <typename Pixels> |
| 52 |
static JXL_INLINE JXL_MAYBE_UNUSED void PoisonImage(const Pixels& im) { |
| 53 |
PoisonMemory(im.bytes(), im.bytes_per_row() * im.ysize()); |
| 54 |
} |
| 55 |
|
| 56 |
namespace { |
| 57 |
|
| 58 |
// Print the uninitialized regions of an image. |
| 59 |
template <typename Pixels> |
| 60 |
static JXL_INLINE JXL_MAYBE_UNUSED void PrintImageUninitialized( |
| 61 |
const Pixels& im) { |
| 62 |
fprintf(stderr, |
| 63 |
"Uninitialized regions for image of size %" PRIu64 "x%" PRIu64 ":\n", |
| 64 |
static_cast<uint64_t>(im.xsize()), static_cast<uint64_t>(im.ysize())); |
| 65 |
|
| 66 |
// A segment of uninitialized pixels in a row, in the format [first, second). |
| 67 |
typedef std::pair<size_t, size_t> PixelSegment; |
| 68 |
|
| 69 |
// Helper class to merge and print a list of rows of PixelSegment that may be |
| 70 |
// the same over big ranges of rows. This compacts the output to ranges of |
| 71 |
// rows like "[y0, y1): [x0, x1) [x2, x3)". |
| 72 |
class RowsMerger { |
| 73 |
public: |
| 74 |
// Add a new row the list of rows. If the row is the same as the previous |
| 75 |
// one it will be merged showing a range of rows [y0, y1), but if the new |
| 76 |
// row is different the current range of rows (if any) will be printed and a |
| 77 |
// new one will be started. |
| 78 |
void AddRow(size_t y, std::vector<PixelSegment>&& new_row) { |
| 79 |
if (start_y_ != -1 && new_row != segments_) { |
| 80 |
PrintRow(y); |
| 81 |
} |
| 82 |
if (new_row.empty()) { |
| 83 |
// Skip ranges with no uninitialized pixels. |
| 84 |
start_y_ = -1; |
| 85 |
segments_.clear(); |
| 86 |
return; |
| 87 |
} |
| 88 |
if (start_y_ == -1) { |
| 89 |
start_y_ = y; |
| 90 |
segments_ = std::move(new_row); |
| 91 |
} |
| 92 |
} |
| 93 |
|
| 94 |
// Print the contents of the range of rows [start_y_, end_y) if any. |
| 95 |
void PrintRow(size_t end_y) { |
| 96 |
if (start_y_ == -1) return; |
| 97 |
if (segments_.empty()) { |
| 98 |
start_y_ = -1; |
| 99 |
return; |
| 100 |
} |
| 101 |
if (end_y - start_y_ > 1) { |
| 102 |
fprintf(stderr, " y=[%" PRId64 ", %" PRIu64 "):", |
| 103 |
static_cast<int64_t>(start_y_), static_cast<uint64_t>(end_y)); |
| 104 |
} else { |
| 105 |
fprintf(stderr, " y=[%" PRId64 "]:", static_cast<int64_t>(start_y_)); |
| 106 |
} |
| 107 |
for (const auto& seg : segments_) { |
| 108 |
if (seg.first + 1 == seg.second) { |
| 109 |
fprintf(stderr, " [%" PRId64 "]", static_cast<int64_t>(seg.first)); |
| 110 |
} else { |
| 111 |
fprintf(stderr, " [%" PRId64 ", %" PRIu64 ")", |
| 112 |
static_cast<int64_t>(seg.first), |
| 113 |
static_cast<uint64_t>(seg.second)); |
| 114 |
} |
| 115 |
} |
| 116 |
fprintf(stderr, "\n"); |
| 117 |
start_y_ = -1; |
| 118 |
} |
| 119 |
|
| 120 |
private: |
| 121 |
std::vector<PixelSegment> segments_; |
| 122 |
// Row number of the first row in the range of rows that have |segments| as |
| 123 |
// the undefined segments. |
| 124 |
ssize_t start_y_ = -1; |
| 125 |
} rows_merger; |
| 126 |
|
| 127 |
class SegmentsMerger { |
| 128 |
public: |
| 129 |
void AddValue(size_t x) { |
| 130 |
if (row.empty() || row.back().second != x) { |
| 131 |
row.emplace_back(x, x + 1); |
| 132 |
} else { |
| 133 |
row.back().second = x + 1; |
| 134 |
} |
| 135 |
} |
| 136 |
|
| 137 |
std::vector<PixelSegment> row; |
| 138 |
}; |
| 139 |
|
| 140 |
for (size_t y = 0; y < im.ysize(); y++) { |
| 141 |
auto* row = im.Row(y); |
| 142 |
SegmentsMerger seg_merger; |
| 143 |
size_t x = 0; |
| 144 |
while (x < im.xsize()) { |
| 145 |
intptr_t ret = |
| 146 |
__msan_test_shadow(row + x, (im.xsize() - x) * sizeof(row[0])); |
| 147 |
if (ret < 0) break; |
| 148 |
size_t next_x = x + ret / sizeof(row[0]); |
| 149 |
seg_merger.AddValue(next_x); |
| 150 |
x = next_x + 1; |
| 151 |
} |
| 152 |
rows_merger.AddRow(y, std::move(seg_merger.row)); |
| 153 |
} |
| 154 |
rows_merger.PrintRow(im.ysize()); |
| 155 |
} |
| 156 |
|
| 157 |
// Check that all the pixels in the provided rect of the image are initialized |
| 158 |
// (not poisoned). If any of the values is poisoned it will abort. |
| 159 |
template <typename Pixels> |
| 160 |
static JXL_INLINE JXL_MAYBE_UNUSED void CheckImageInitialized( |
| 161 |
const Pixels& im, const Rect& r, size_t c, const char* message) { |
| 162 |
JXL_DASSERT(r.x0() <= im.xsize()); |
| 163 |
JXL_DASSERT(r.x0() + r.xsize() <= im.xsize()); |
| 164 |
JXL_DASSERT(r.y0() <= im.ysize()); |
| 165 |
JXL_DASSERT(r.y0() + r.ysize() <= im.ysize()); |
| 166 |
for (size_t y = r.y0(); y < r.y0() + r.ysize(); y++) { |
| 167 |
const auto* row = im.Row(y); |
| 168 |
intptr_t ret = __msan_test_shadow(row + r.x0(), sizeof(*row) * r.xsize()); |
| 169 |
if (ret != -1) { |
| 170 |
JXL_DEBUG( |
| 171 |
1, |
| 172 |
"Checking an image of %" PRIu64 " x %" PRIu64 ", rect x0=%" PRIu64 |
| 173 |
", y0=%" PRIu64 |
| 174 |
", " |
| 175 |
"xsize=%" PRIu64 ", ysize=%" PRIu64, |
| 176 |
static_cast<uint64_t>(im.xsize()), static_cast<uint64_t>(im.ysize()), |
| 177 |
static_cast<uint64_t>(r.x0()), static_cast<uint64_t>(r.y0()), |
| 178 |
static_cast<uint64_t>(r.xsize()), static_cast<uint64_t>(r.ysize())); |
| 179 |
size_t x = ret / sizeof(*row); |
| 180 |
JXL_DEBUG(1, |
| 181 |
"CheckImageInitialized failed at x=%" PRIu64 ", y=%" PRIu64 |
| 182 |
", c=%" PRIu64 ": %s", |
| 183 |
static_cast<uint64_t>(r.x0() + x), static_cast<uint64_t>(y), |
| 184 |
static_cast<uint64_t>(c), message ? message : ""); |
| 185 |
PrintImageUninitialized(im); |
| 186 |
} |
| 187 |
// This will report an error if memory is not initialized. |
| 188 |
__msan_check_mem_is_initialized(row + r.x0(), sizeof(*row) * r.xsize()); |
| 189 |
} |
| 190 |
} |
| 191 |
|
| 192 |
template <typename Image> |
| 193 |
static JXL_INLINE JXL_MAYBE_UNUSED void CheckImageInitialized( |
| 194 |
const Image& im, const Rect& r, const char* message) { |
| 195 |
for (size_t c = 0; c < 3; c++) { |
| 196 |
std::string str_message(message); |
| 197 |
str_message += " c=" + std::to_string(c); |
| 198 |
CheckImageInitialized(im.Plane(c), r, c, str_message.c_str()); |
| 199 |
} |
| 200 |
} |
| 201 |
|
| 202 |
} // namespace |
| 203 |
|
| 204 |
#define JXL_CHECK_IMAGE_INITIALIZED(im, r) \ |
| 205 |
::jxl::msan::CheckImageInitialized(im, r, "im=" #im ", r=" #r); |
| 206 |
|
| 207 |
#define JXL_CHECK_PLANE_INITIALIZED(im, r, c) \ |
| 208 |
::jxl::msan::CheckImageInitialized(im, r, c, "im=" #im ", r=" #r ", c=" #c); |
| 209 |
|
| 210 |
#else // JXL_MEMORY_SANITIZER |
| 211 |
|
| 212 |
// In non-msan mode these functions don't use volatile since it is not needed |
| 213 |
// for the empty functions. |
| 214 |
|
| 215 |
static JXL_INLINE JXL_MAYBE_UNUSED void PoisonMemory(const void* m, |
| 216 |
size_t size) {} |
| 217 |
static JXL_INLINE JXL_MAYBE_UNUSED void UnpoisonMemory(const void* m, |
| 218 |
size_t size) {} |
| 219 |
static JXL_INLINE JXL_MAYBE_UNUSED void MemoryIsInitialized(const void* m, |
| 220 |
size_t size) {} |
| 221 |
|
| 222 |
template <typename Pixels> |
| 223 |
static JXL_INLINE JXL_MAYBE_UNUSED void PoisonImage(const Pixels& im) {} |
| 224 |
|
| 225 |
#define JXL_CHECK_IMAGE_INITIALIZED(im, r) |
| 226 |
#define JXL_CHECK_PLANE_INITIALIZED(im, r, c) |
| 227 |
|
| 228 |
#endif |
| 229 |
|
| 230 |
} // namespace msan |
| 231 |
} // namespace jxl |
| 232 |
|
| 233 |
#endif // LIB_JXL_SANITIZERS_H_ |