Add flag to dump the labels when the program terminates.

[martignlo]

I previously used the wrong diff. Sorry!

[martignlo]

Added test.

[pcc]

lib/dfsan/dfsan.cc

277 ↗

(On Diff #16329)

You can skip index 0.

342 ↗

(On Diff #16329)

The other sanitizers use atexit for this type of thing.

test/dfsan/dump_labels.c

3 ↗

(On Diff #16329)

You should also test the case where the program terminates due to running out of labels.

[martignlo]

lib/dfsan/dfsan.cc

277 ↗

(On Diff #16329)

Done.

342 ↗

(On Diff #16329)

Moved the registration to dfsan_init.

test/dfsan/dump_labels.c

3 ↗

(On Diff #16329)

Done.

[pcc]

LGTM

test/dfsan/dump_labels.c

58 ↗

(On Diff #16383)

You could add a CHECK-OOL-NOT line to make sure this line is not printed.

[martignlo]

test/dfsan/dump_labels.c

58 ↗

(On Diff #16383)

Dropped since the exitstatus already captures this.

[martignlo]

Closed by commit rL222425 (authored by @martignlo).

lib/dfsan/dfsan_custom.cc

if (has_size) {
     r = vsprintf(str + off, chunk_format, ap);
   }
   va_end(ap);
 
   free(chunk_format);
   return r;
 }
 
+// Returns the size of a formatted chunk.
+static size_t size_of_chunk(char *str, size_t off, bool has_size, size_t size,
+                            int status) {
+  if (status < 0) {
+    return 0;
+  }
+
+  size_t chunk_size = status;
+
+  // A return value of {v,}snprintf of size or more means that the output was
+  // truncated.
+  if (has_size) {
+    if (off < size) {
+      if (chunk_size >= size - off) {
+        chunk_size -= size - off;
+      }
+    } else {
+      chunk_size = 0;
+    }
+  }
+
+  return chunk_size;
+}
+
 // Formats the input and propagates the input labels to the output. The output
 // is stored in 'str'. If 'has_size' is true, 'size' bounds the number of
 // output bytes. 'format' and 'ap' are the format string and the list of
 // arguments for formatting. Returns the return value vsnprintf would return.
 //
 // The function tokenizes the format string in chunks representing either a
 // constant string or a single format directive (e.g., '%.3f') and formats each
 // chunk independently into the output string. This approach allows to figure
 // out which bytes of the output string depends on which argument and thus to
 // propagate labels more precisely.
 static int format_buffer(char *str, bool has_size, size_t size,
                          const char *format, dfsan_label *va_labels,
                          dfsan_label *ret_label, va_list ap) {
-  InternalMmapVector<Chunk> chunks(8);
   size_t off = 0;
 
   while (*format) {
-    chunks.push_back(Chunk());
-    Chunk& chunk = chunks.back();
-    chunk.ptr = str + off;
-    chunk.arg = nullptr;
-
     int status = 0;
 
     if (*format != '%') {
       // Ordinary character. Consume all the characters until a '%' or the end
       // of the string.
       size_t format_size = 0;
       for (; *format && *format != '%'; ++format, ++format_size) {}
       status = format_chunk(str, off, has_size, size, format - format_size,
                             format_size);
-      chunk.label_type = Chunk::NONE;
+      dfsan_set_label(0, str + off,
+                      size_of_chunk(str, off, has_size, size, status));
     } else {
       // Conversion directive. Consume all the characters until a conversion
       // specifier or the end of the string.
       bool end_format = false;
-#define FORMAT_CHUNK(t)                                                  \
-      format_chunk(str, off, has_size, size, format - format_size,  \
-                   format_size + 1, va_arg(ap, t))
-
+#define FORMAT_CHUNK(t)                                                        \
+  format_chunk(str, off, has_size, size, format - format_size,                 \
+#define LABEL_CHUNK(l)                                                         \
+  dfsan_set_label(l, str + off,                                                \
+                  size_of_chunk(str, off, has_size, size, status));
       for (size_t format_size = 1; *++format && !end_format; ++format_size) {
         switch (*format) {
           case 'd':
           case 'i':
           case 'o':
           case 'u':
           case 'x':
           case 'X':
dfsan_set_label(l, str + off,                                                \
                 status = FORMAT_CHUNK(size_t);
                 break;
               case 't':
                 status = FORMAT_CHUNK(size_t);
                 break;
               default:
                 status = FORMAT_CHUNK(int);
             }
-            chunk.label_type = Chunk::NUMERIC;
+            LABEL_CHUNK(*va_labels++);
             end_format = true;
             break;
 
           case 'a':
           case 'A':
           case 'e':
           case 'E':
           case 'f':
           case 'F':
           case 'g':
           case 'G':
             if (*(format - 1) == 'L') {
               status = FORMAT_CHUNK(long double);
             } else {
               status = FORMAT_CHUNK(double);
             }
-            chunk.label_type = Chunk::NUMERIC;
+            LABEL_CHUNK(*va_labels++);
             end_format = true;
             break;
 
           case 'c':
             status = FORMAT_CHUNK(int);
-            chunk.label_type = Chunk::NUMERIC;
+            LABEL_CHUNK(*va_labels++);
             end_format = true;
             break;
 
-          case 's':
-            chunk.arg = va_arg(ap, char *);
+          case 's': {
+            char* chunk_arg = va_arg(ap, char *);
             status =
                 format_chunk(str, off, has_size, size,
                              format - format_size, format_size + 1,
-                             chunk.arg);
-            chunk.label_type = Chunk::STRING;
+                             chunk_arg);
+            va_labels++;
+            internal_memcpy(
+                shadow_for(str + off), shadow_for(chunk_arg),
+                sizeof(dfsan_label) *
+                    (size_of_chunk(str, off, has_size, size, status)));
             end_format = true;
             break;
+          }
 
           case 'p':
             status = FORMAT_CHUNK(void *);
-            chunk.label_type = Chunk::NUMERIC;
+            LABEL_CHUNK(*va_labels++);
             end_format = true;
             break;
 
-          case 'n':
-            *(va_arg(ap, int *)) = (int)off;
-            chunk.label_type = Chunk::IGNORED;
+          case 'n': {
+            int* chunk_ptr = va_arg(ap, int *);
+            *chunk_ptr = (int)off;
+            va_labels++;
+            dfsan_set_label(0, chunk_ptr, sizeof(chunk_ptr));
             end_format = true;
             break;
+          }
 
           case '%':
             status = format_chunk(str, off, has_size, size,
                                   format - format_size, format_size + 1);
-            chunk.label_type = Chunk::NONE;
+            LABEL_CHUNK(0);
             end_format = true;
             break;
 
           default:
             break;
         }
       }
+#undef LABEL_CHUNK
 #undef FORMAT_CHUNK
     }
 
     if (status < 0) {
       return status;
     }
 
-    // A return value of {v,}snprintf of size or more means that the output was
-    // truncated.
-    if (has_size) {
-      if (off < size) {
-        size_t ustatus = (size_t) status;
-        chunk.size = ustatus >= (size - off) ?
-            ustatus - (size - off) : ustatus;
-      } else {
-        chunk.size = 0;
-      }
-    } else {
-      chunk.size = status;
-    }
     off += status;
   }
 
-  // TODO(martignlo): Decide how to combine labels (e.g., whether to ignore or
-  // not the label of the format string).
-
-  // Label each output chunk according to the label supplied as argument to the
-  // function. We need to go through all the chunks and arguments even if the
-  // string was only partially printed ({v,}snprintf case).
-  for (size_t i = 0; i < chunks.size(); ++i) {
-    const Chunk& chunk = chunks[i];
-    void *chunk_ptr = const_cast<char *>(chunk.ptr);
-
-    switch (chunk.label_type) {
-      case Chunk::NONE:
-        dfsan_set_label(0, chunk_ptr, chunk.size);
-        break;
-      case Chunk::IGNORED:
-        va_labels++;
-        dfsan_set_label(0, chunk_ptr, chunk.size);
-        break;
-      case Chunk::NUMERIC: {
-        dfsan_label label = *va_labels++;
-        dfsan_set_label(label, chunk_ptr, chunk.size);
-        break;
-      }
-      case Chunk::STRING: {
-        // Consume the label of the pointer to the string
-        va_labels++;
-        internal_memcpy(shadow_for(chunk_ptr),
-                        shadow_for(chunk.arg),
-                        sizeof(dfsan_label) * (strlen(chunk.arg)));
-        break;
-      }
-    }
-  }
-
   *ret_label = 0;
 
   // Number of bytes written in total.
   return off;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __dfsw_sprintf(char *str, const char *format, dfsan_label str_label,

test/dfsan/custom.cc

 
 void test_getrusage() {
   struct rusage usage;
   dfsan_set_label(i_label, &usage, sizeof(usage));
   assert(getrusage(RUSAGE_SELF, &usage) == 0);
   ASSERT_READ_ZERO_LABEL(&usage, sizeof(usage));
 }
 
+void test_strcat() {
+  char src[] = "world";
+  char dst[512];
+  strcpy(dst, "hello ");
+
+  dfsan_set_label(i_label, dst + 3, 5);
+  dfsan_set_label(j_label, src + 1, 3);
+  char *ret = strcat(dst, src);
+  assert(ret == dst);
+  assert(strcmp(dst, "hello world") == 0);
+  ASSERT_READ_ZERO_LABEL(dst, 3);
+  ASSERT_READ_LABEL(dst + 3, 3, i_label);
+  ASSERT_READ_ZERO_LABEL(dst + 6, 1);
+  ASSERT_READ_LABEL(dst + 7, 3, j_label);
+  ASSERT_READ_ZERO_LABEL(dst + 10, 2);
+}
+
+void test_strncat() {
+  char src[] = "world";
+  char dst[512];
+  strcpy(dst, "hello ");
+
+  dfsan_set_label(i_label, dst + 3, 5);
+  dfsan_set_label(j_label, src + 1, 3);
+  char *ret = strncat(dst, src, 3);
+  assert(ret == dst);
+  assert(strcmp(dst, "hello wor") == 0);
+  ASSERT_READ_ZERO_LABEL(dst, 3);
+  ASSERT_READ_LABEL(dst + 3, 3, i_label);
+  ASSERT_READ_ZERO_LABEL(dst + 6, 1);
+  ASSERT_READ_LABEL(dst + 7, 2, j_label);
+  ASSERT_READ_ZERO_LABEL(dst + 9, 1);
+}
+
 void test_strcpy() {
   char src[] = "hello world";
   char dst[sizeof(src) + 2];
   dfsan_set_label(0, src, sizeof(src));
   dfsan_set_label(0, dst, sizeof(dst));
   dfsan_set_label(i_label, src + 2, 1);
   dfsan_set_label(j_label, src + 3, 1);
   dfsan_set_label(j_label, dst + 4, 1);
void test_sprintf() {
   char buf[2048];
   memset(buf, 'a', sizeof(buf));
 
   // Test formatting (no conversion specifier).
   assert(sprintf(buf, "Hello world!") == 12);
   assert(strcmp(buf, "Hello world!") == 0);
   ASSERT_READ_LABEL(buf, sizeof(buf), 0);
 
-  // Test for extra arguments.
-  assert(sprintf(buf, "Hello world!", 42, "hello") == 12);
-  assert(strcmp(buf, "Hello world!") == 0);
-  ASSERT_READ_LABEL(buf, sizeof(buf), 0);
-
   // Test formatting & label propagation (multiple conversion specifiers): %s,
   // %d, %n, %f, and %%.
   const char* s = "world";
   int m = 8;
   int d = 27;
   dfsan_set_label(k_label, (void *) (s + 1), 2);
   dfsan_set_label(i_label, &m, sizeof(m));
   dfsan_set_label(j_label, &d, sizeof(d));