[Sanitizers] Intercept snprintf_l() on FreeBSD

[kutuzov.viktor.84]

Summary

In contrast to Linux, FreeBSD does not omit the *printf_l() functions so we have to intercept them. Particularly, libcxx leverage snprintf_l() for verbalization of numeric values. Since gtest use the standard i/o streams, we get mass false positives on Msan unit tests.

[emaste]

lib/sanitizer_common/sanitizer_common_interceptors.inc

906–908

Just to confirm, the issue reported in this comment is not directly tied to the new *printf_l functionality?

[eugenis]

Please add a test, either in test/asan or in lib/asan/tests/asan_test.cc

lib/sanitizer_common/sanitizer_common_interceptors.inc

892

Why not use VSNPRINTF_INTERCEPTOR_IMPL directly?

Also, what about all the other *printf*_l functions? They do not have to be done in 1 patch, but you'll probably run into issues with them at some point, too.

906–908

It's not.

[kutuzov.viktor.84]

Rewritten with VSNPRINTF_INTERCEPTOR_IMPL.

[kutuzov.viktor.84]

Also, what about all the other *printf*_l functions? They do not have to be done in 1 patch, but you'll probably run into issues with them at some point, too.

Yes, I've added them to my TODO and will provide another patch for the rest of the funcs some time later.

Now it seems I have to add a test case to this patch...

[kutuzov.viktor.84]

A test added.

[eugenis]

lib/asan/tests/asan_test.cc

1289 ↗

(On Diff #17442)

Capital W after an underscore looks unusual.

1298 ↗

(On Diff #17442)

This does not really test much (does it fail before this patch?).
See test/asan/TestCases/printf-*.c for inspiration. No need to repeat all 5 of them for the _l variant, but please add something that verifies that the whole prinf sanitizing machinery is applied in this case.

[kutuzov.viktor.84]

Updated. Thanks, Evgeniy.

[eugenis]

LGTM

lib/sanitizer_common/sanitizer_common_interceptors.inc

#define VSNPRINTF_INTERCEPTOR_IMPL(vname, str, size, ...)                      \
     }                                                                          \
     VPRINTF_INTERCEPTOR_RETURN();                                              \
     return res;                                                                \
   }
 
 // FIXME: under ASan the REAL() call below may write to freed memory and
 // corrupt its metadata. See
 // https://code.google.com/p/address-sanitizer/issues/detail?id=321.
+#define VSNPRINTF_L_INTERCEPTOR_IMPL(vname, str, size, loc, ...)               \
+  {                                                                            \
+    VPRINTF_INTERCEPTOR_ENTER(vname, str, size, loc, __VA_ARGS__)              \
+    if (common_flags()->check_printf) {                                        \
+      printf_common(ctx, format, aq);                                          \
+    }                                                                          \
+    int res = REAL(vname)(str, size, loc, __VA_ARGS__);                        \
+    if (res >= 0) {                                                            \
+      COMMON_INTERCEPTOR_WRITE_RANGE(ctx, str, Min(size, (SIZE_T)(res + 1)));  \
+    }                                                                          \
+    VPRINTF_INTERCEPTOR_RETURN();                                              \
+    return res;                                                                \
+  }
+
+// FIXME: under ASan the REAL() call below may write to freed memory and
+// corrupt its metadata. See
+// https://code.google.com/p/address-sanitizer/issues/detail?id=321.
 #define VASPRINTF_INTERCEPTOR_IMPL(vname, strp, ...)                           \
   {                                                                            \
     VPRINTF_INTERCEPTOR_ENTER(vname, strp, __VA_ARGS__)                        \
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, strp, sizeof(char *));                 \
     if (common_flags()->check_printf) {                                        \
       printf_common(ctx, format, aq);                                          \
     }                                                                          \
     int res = REAL(vname)(strp, __VA_ARGS__);                                  \

 INTERCEPTOR(int, vfprintf, __sanitizer_FILE *stream, const char *format,
             va_list ap)
 VPRINTF_INTERCEPTOR_IMPL(vfprintf, stream, format, ap)
 
 INTERCEPTOR(int, vsnprintf, char *str, SIZE_T size, const char *format,
             va_list ap)
 VSNPRINTF_INTERCEPTOR_IMPL(vsnprintf, str, size, format, ap)
 
+#if SANITIZER_INTERCEPT_PRINTF_L
+INTERCEPTOR(int, vsnprintf_l, char *str, SIZE_T size, void *loc,
+            const char *format, va_list ap)
+VSNPRINTF_L_INTERCEPTOR_IMPL(vsnprintf_l, str, size, loc, format, ap)
+
+INTERCEPTOR(int, snprintf_l, char *str, SIZE_T size, void *loc,
+            const char *format, ...)
+FORMAT_INTERCEPTOR_IMPL(snprintf_l, vsnprintf_l, str, size, loc, format)
+#endif  // SANITIZER_INTERCEPT_PRINTF_L
+
 INTERCEPTOR(int, vsprintf, char *str, const char *format, va_list ap)
 VSPRINTF_INTERCEPTOR_IMPL(vsprintf, str, format, ap)
 
 INTERCEPTOR(int, vasprintf, char **strp, const char *format, va_list ap)
 VASPRINTF_INTERCEPTOR_IMPL(vasprintf, strp, format, ap)
 
 #if SANITIZER_INTERCEPT_ISOC99_PRINTF
 INTERCEPTOR(int, __isoc99_vprintf, const char *format, va_list ap)
#define INIT_PRINTF                     \
   COMMON_INTERCEPT_FUNCTION(vsprintf);  \
   COMMON_INTERCEPT_FUNCTION(vsnprintf); \
   COMMON_INTERCEPT_FUNCTION(vasprintf); \
   COMMON_INTERCEPT_FUNCTION(vfprintf);
 #else
 #define INIT_PRINTF
 #endif
 
+#if SANITIZER_INTERCEPT_PRINTF_L
+#define INIT_PRINTF_L                     \
+  COMMON_INTERCEPT_FUNCTION(snprintf_l);  \
+  COMMON_INTERCEPT_FUNCTION(vsnprintf_l);
+#else
+#define INIT_PRINTF_L
+#endif
+
 #if SANITIZER_INTERCEPT_ISOC99_PRINTF
 #define INIT_ISOC99_PRINTF                       \
   COMMON_INTERCEPT_FUNCTION(__isoc99_printf);    \
   COMMON_INTERCEPT_FUNCTION(__isoc99_sprintf);   \
   COMMON_INTERCEPT_FUNCTION(__isoc99_snprintf);  \
   COMMON_INTERCEPT_FUNCTION(__isoc99_fprintf);   \
   COMMON_INTERCEPT_FUNCTION(__isoc99_vprintf);   \
   COMMON_INTERCEPT_FUNCTION(__isoc99_vsprintf);  \
static void InitializeCommonInterceptors() {
   INIT_PWRITEV;
   INIT_PWRITEV64;
   INIT_PRCTL;
   INIT_LOCALTIME_AND_FRIENDS;
   INIT_STRPTIME;
   INIT_SCANF;
   INIT_ISOC99_SCANF;
   INIT_PRINTF;
+  INIT_PRINTF_L;
   INIT_ISOC99_PRINTF;
   INIT_FREXP;
   INIT_FREXPF_FREXPL;
   INIT_GETPWNAM_AND_FRIENDS;
   INIT_GETPWNAM_R_AND_FRIENDS;
   INIT_GETPWENT;
   INIT_FGETPWENT;
   INIT_GETPWENT_R;

lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPT_LOCALTIME_AND_FRIENDS SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_STRPTIME SI_NOT_WINDOWS
 
 #define SANITIZER_INTERCEPT_SCANF SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_ISOC99_SCANF SI_LINUX_NOT_ANDROID
 
 #ifndef SANITIZER_INTERCEPT_PRINTF
 # define SANITIZER_INTERCEPT_PRINTF SI_NOT_WINDOWS
+# define SANITIZER_INTERCEPT_PRINTF_L SI_FREEBSD
 # define SANITIZER_INTERCEPT_ISOC99_PRINTF SI_LINUX_NOT_ANDROID
 #endif
 
 #define SANITIZER_INTERCEPT_FREXP 1
 #define SANITIZER_INTERCEPT_FREXPF_FREXPL SI_NOT_WINDOWS
 
 #define SANITIZER_INTERCEPT_GETPWNAM_AND_FRIENDS SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT_GETPWNAM_R_AND_FRIENDS \