[dfsan] Expose dfsan_get_track_origins to get origin tracking status

[stephan.yichao.zhao]

Summary

This allows application code checks if origin tracking is on before
printing out traces.

-dfsan-track-origins can be 0,1,2.
The current code only distinguishes 1 and 2 in compile time, but not at runtime.
Made runtime distinguish 1 and 2 too.

[stephan.yichao.zhao]

added a missing file

[stephan.yichao.zhao]

update

[browneee]

compiler-rt/include/sanitizer/dfsan_interface.h

145

Comment here should explain the meaning of different return values, or link to something that does.

compiler-rt/lib/dfsan/dfsan.cpp

55

We're missing documentation for these options (e.g. https://clang.llvm.org/docs/MemorySanitizer.html#origin-tracking )

[stephan.yichao.zhao]

Added more comments to dfsan_get_track_origins.

[stephan.yichao.zhao]

compiler-rt/lib/dfsan/dfsan.cpp

55

The doc diff for origin tracking has never been submitted. I will add one soon.

compiler-rt/include/sanitizer/dfsan_interface.h

 /// \returns The number of symbols that should have been written to \p out_buf
 /// (not including trailing null byte '\0'). Thus, the string is truncated iff
 /// return value is not less than \p out_buf_size.
 size_t dfsan_sprint_stack_trace(char *out_buf, size_t out_buf_size);
 
 /// Retrieves the very first origin associated with the data at the given
 /// address.
 dfsan_origin dfsan_get_init_origin(const void *addr);
+
+/// Returns the value of -dfsan-track-origins.
+/// * 0: do not track origins.
+/// * 1: track origins at memory store operations.
+/// * 2: track origins at memory load and store operations.
+int dfsan_get_track_origins(void);
 #ifdef __cplusplus
 }  // extern "C"
 
 template <typename T>
 void dfsan_set_label(dfsan_label label, T &data) { // NOLINT
   dfsan_set_label(label, (void *)&data, sizeof(T));
 }
 
 #endif
 
 #endif  // DFSAN_INTERFACE_H

compiler-rt/lib/dfsan/dfsan.cpp

 SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL u64
     __dfsan_retval_tls[kDFsanRetvalTlsSize / sizeof(u64)];
 SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL u32 __dfsan_retval_origin_tls;
 SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL u64
     __dfsan_arg_tls[kDFsanArgTlsSize / sizeof(u64)];
 SANITIZER_INTERFACE_ATTRIBUTE THREADLOCAL u32
     __dfsan_arg_origin_tls[kDFsanArgOriginTlsSize / sizeof(u32)];
 
 // Instrumented code may set this value in terms of -dfsan-track-origins.
 // * undefined or 0: do not track origins.
 // * 1: track origins at memory store operations.
-// * 2: TODO: track origins at memory store operations and callsites.
+// * 2: track origins at memory load and store operations.
+//      TODO: track callsites.
 extern "C" SANITIZER_WEAK_ATTRIBUTE const int __dfsan_track_origins;
 
-int __dfsan_get_track_origins() {
+extern "C" SANITIZER_INTERFACE_ATTRIBUTE int dfsan_get_track_origins() {
   return &__dfsan_track_origins ? __dfsan_track_origins : 0;
 }
 
 // On Linux/x86_64, memory is laid out as follows:
 //
 //  +--------------------+ 0x800000000000 (top of memory)
 //  |    application 3   |
 //  +--------------------+ 0x700000000000

 
 bool dfsan_inited = false;
 bool dfsan_init_is_running = false;
 
 void dfsan_copy_memory(void *dst, const void *src, uptr size) {
   internal_memcpy(dst, src, size);
   internal_memcpy((void *)shadow_for(dst), (const void *)shadow_for(src),
                   size * sizeof(dfsan_label));
-  if (__dfsan_get_track_origins())
+  if (dfsan_get_track_origins())
     dfsan_mem_origin_transfer(dst, src, size);
 }
 
 }  // namespace __dfsan
 
 // If the label s is tainted, set the size bytes from the address p to be a new
 // origin chain with the previous ID o and the current stack trace. This is
 // used by instrumentation to reduce code size when too much code is inserted.
if (!MmapFixedSuperNoReserve(beg_aligned, end_aligned - beg_aligned))
       Die();
   }
 }
 
 void SetShadow(dfsan_label label, void *addr, uptr size, dfsan_origin origin) {
   if (0 != label) {
     const uptr beg_shadow_addr = (uptr)__dfsan::shadow_for(addr);
     WriteShadowWithSize(label, beg_shadow_addr, size);
-    if (__dfsan_get_track_origins())
+    if (dfsan_get_track_origins())
       SetOrigin(addr, size, origin);
     return;
   }
 
-  if (__dfsan_get_track_origins())
+  if (dfsan_get_track_origins())
     ReleaseOrigins(addr, size);
 
   ReleaseOrClearShadows(addr, size);
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE void __dfsan_set_label(
     dfsan_label label, dfsan_origin origin, void *addr, uptr size) {
   SetShadow(label, addr, size, origin);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void dfsan_set_label(dfsan_label label, void *addr, uptr size) {
   dfsan_origin init_origin = 0;
-  if (label && __dfsan_get_track_origins()) {
+  if (label && dfsan_get_track_origins()) {
     GET_CALLER_PC_BP;
     GET_STORE_STACK_TRACE_PC_BP(pc, bp);
     init_origin = ChainOrigin(0, &stack, true);
   }
   SetShadow(label, addr, size, init_origin);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void dfsan_add_label(dfsan_label label, void *addr, uptr size) {
   if (0 == label)
     return;
 
-  if (__dfsan_get_track_origins()) {
+  if (dfsan_get_track_origins()) {
     GET_CALLER_PC_BP;
     GET_STORE_STACK_TRACE_PC_BP(pc, bp);
     dfsan_origin init_origin = ChainOrigin(0, &stack, true);
     SetOrigin(addr, size, init_origin);
   }
 
   for (dfsan_label *labelp = shadow_for(addr); size != 0; --size, ++labelp)
     *labelp |= label;
Printf(
       "  %sTaint value 0x%x (at %p) has invalid origin tracking. This can "
       "be a DFSan bug.%s\n",
       d.Warning(), label, address, d.Default());
 }
 
 bool PrintOriginTraceToStr(const void *addr, const char *description,
                            InternalScopedString *out) {
   CHECK(out);
-  CHECK(__dfsan_get_track_origins());
+  CHECK(dfsan_get_track_origins());
   Decorator d;
 
   const dfsan_label label = *__dfsan::shadow_for(addr);
   CHECK(label);
 
   const dfsan_origin origin = *__dfsan::origin_for(addr);
 
   out->append("  %sTaint value 0x%x (at %p) origin tracking (%s)%s\n",
bool PrintOriginTraceToStr(const void *addr, const char *description,
 
   return found;
 }
 
 }  // namespace
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE void dfsan_print_origin_trace(
     const void *addr, const char *description) {
-  if (!__dfsan_get_track_origins()) {
+  if (!dfsan_get_track_origins()) {
     PrintNoOriginTrackingWarning();
     return;
   }
 
   const dfsan_label label = *__dfsan::shadow_for(addr);
   if (!label) {
     PrintNoTaintWarning(addr);
     return;
if (!success)
     PrintInvalidOriginWarning(label, addr);
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE size_t
 dfsan_sprint_origin_trace(const void *addr, const char *description,
                           char *out_buf, size_t out_buf_size) {
   CHECK(out_buf);
 
-  if (!__dfsan_get_track_origins()) {
+  if (!dfsan_get_track_origins()) {
     PrintNoOriginTrackingWarning();
     return 0;
   }
 
   const dfsan_label label = *__dfsan::shadow_for(addr);
   if (!label) {
     PrintNoTaintWarning(addr);
     return 0;
if (out_buf_size) {
     out_buf[out_buf_size - 1] = '\0';
   }
 
   return trace.length();
 }
 
 extern "C" SANITIZER_INTERFACE_ATTRIBUTE dfsan_origin
 dfsan_get_init_origin(const void *addr) {
-  if (!__dfsan_get_track_origins())
+  if (!dfsan_get_track_origins())
     return 0;
 
   const dfsan_label label = *__dfsan::shadow_for(addr);
   if (!label)
     return 0;
 
   const dfsan_origin origin = *__dfsan::origin_for(addr);
 
void dfsan_clear_arg_tls(uptr offset, uptr size) {
   internal_memset((void *)((uptr)__dfsan_arg_tls + offset), 0, size);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void dfsan_clear_thread_local_state() {
   internal_memset(__dfsan_arg_tls, 0, sizeof(__dfsan_arg_tls));
   internal_memset(__dfsan_retval_tls, 0, sizeof(__dfsan_retval_tls));
 
-  if (__dfsan_get_track_origins()) {
+  if (dfsan_get_track_origins()) {
     internal_memset(__dfsan_arg_origin_tls, 0, sizeof(__dfsan_arg_origin_tls));
     internal_memset(&__dfsan_retval_origin_tls, 0,
                     sizeof(__dfsan_retval_origin_tls));
   }
 }
 
 extern "C" void dfsan_flush() {
   const uptr maxVirtualAddress = GetMaxUserVirtualAddress();
static void DFsanInit(int argc, char **argv, char **envp) {
   SanitizerToolName = "DataflowSanitizer";
 
   AvoidCVE_2016_2143();
 
   InitializeFlags();
 
   CheckASLR();
 
-  InitShadow(__dfsan_get_track_origins());
+  InitShadow(dfsan_get_track_origins());
 
   initialize_interceptors();
 
   // Set up threads
   DFsanTSDInit(DFsanTSDDtor);
 
   dfsan_allocator_init();
 

compiler-rt/lib/dfsan/done_abilist.txt

 fun:dfsan_sprint_origin_trace=uninstrumented
 fun:dfsan_sprint_origin_trace=discard
 fun:dfsan_sprint_stack_trace=uninstrumented
 fun:dfsan_sprint_stack_trace=discard
 fun:dfsan_get_origin=uninstrumented
 fun:dfsan_get_origin=custom
 fun:dfsan_get_init_origin=uninstrumented
 fun:dfsan_get_init_origin=discard
-
+fun:dfsan_get_track_origins=uninstrumented
+fun:dfsan_get_track_origins=discard
 
 ###############################################################################
 # glibc
 ###############################################################################
 # Functions of memory allocators
 fun:__libc_memalign=discard
 fun:aligned_alloc=discard
 fun:calloc=discard

compiler-rt/test/dfsan/dfsan_get_track_origins.c

+// RUN: %clang_dfsan -DTRACK_ORIGINS=2 -mllvm -dfsan-track-origins=2 %s -o %t && %run %t
+// RUN: %clang_dfsan -DTRACK_ORIGINS=1 -mllvm -dfsan-track-origins=1 %s -o %t && %run %t
+// RUN: %clang_dfsan -DTRACK_ORIGINS=0 %s -o %t && %run %t
+//
+// REQUIRES: x86_64-target-arch
+
+#include <sanitizer/dfsan_interface.h>
+
+#include <assert.h>
+
+int main(int argc, char *argv[]) {
+  assert(dfsan_get_track_origins() == TRACK_ORIGINS);
+}

llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

bool DataFlowSanitizer::runImpl(Module &M) {
   ArgOriginTLSTy = ArrayType::get(OriginTy, NumOfElementsInArgOrgTLS);
   ArgOriginTLS = GetOrInsertGlobal("__dfsan_arg_origin_tls", ArgOriginTLSTy);
   RetvalOriginTLS = GetOrInsertGlobal("__dfsan_retval_origin_tls", OriginTy);
 
   (void)Mod->getOrInsertGlobal("__dfsan_track_origins", OriginTy, [&] {
     Changed = true;
     return new GlobalVariable(
         M, OriginTy, true, GlobalValue::WeakODRLinkage,
-        ConstantInt::getSigned(OriginTy, shouldTrackOrigins()),
+        ConstantInt::getSigned(OriginTy,
+                               shouldTrackOrigins() ? ClTrackOrigins : 0),
         "__dfsan_track_origins");
   });
 
   injectMetadataGlobals(M);
 
   initializeCallbackFunctions(M);
   initializeRuntimeFunctions(M);
 

llvm/test/Instrumentation/DataFlowSanitizer/basic.ll

 ; RUN: opt < %s -dfsan -S | FileCheck %s --check-prefixes=CHECK,CHECK_NO_ORIGIN -DSHADOW_XOR_MASK=87960930222080 --dump-input-context=100
-; RUN: opt < %s -dfsan -dfsan-track-origins=1  -S | FileCheck %s --check-prefixes=CHECK,CHECK_ORIGIN -DSHADOW_XOR_MASK=87960930222080 --dump-input-context=100
+; RUN: opt < %s -dfsan -dfsan-track-origins=1  -S | FileCheck %s --check-prefixes=CHECK,CHECK_ORIGIN1 -DSHADOW_XOR_MASK=87960930222080 --dump-input-context=100
+; RUN: opt < %s -dfsan -dfsan-track-origins=2  -S | FileCheck %s --check-prefixes=CHECK_ORIGIN2 -DSHADOW_XOR_MASK=87960930222080 --dump-input-context=100
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: @__dfsan_arg_tls = external thread_local(initialexec) global [100 x i64]
 ; CHECK: @__dfsan_retval_tls = external thread_local(initialexec) global [100 x i64]
 ; CHECK: @__dfsan_arg_origin_tls = external thread_local(initialexec) global [200 x i32]
 ; CHECK: @__dfsan_retval_origin_tls = external thread_local(initialexec) global i32
 ; CHECK_NO_ORIGIN: @__dfsan_track_origins = weak_odr constant i32 0
-; CHECK_ORIGIN: @__dfsan_track_origins = weak_odr constant i32 1
+; CHECK_ORIGIN1: @__dfsan_track_origins = weak_odr constant i32 1
+; CHECK_ORIGIN2: @__dfsan_track_origins = weak_odr constant i32 2
 ; CHECK: @__dfsan_shadow_width_bits = weak_odr constant i32 [[#SBITS:]]
 ; CHECK: @__dfsan_shadow_width_bytes = weak_odr constant i32 [[#SBYTES:]]
 
 define i8 @load(i8* %p) {
   ; CHECK-LABEL: define i8 @load.dfsan
   ; CHECK: xor i64 {{.*}}, [[SHADOW_XOR_MASK]]
   ; CHECK: ret i8 %a
   %a = load i8, i8* %p