[MSAN] extend ioctl interceptor to support BLKSSZGET

[kda]

compiler-rt/lib/msan/tests/msan_test.cpp

714

Is there a device I can easily use to make this function work correctly?

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

598

Please add it to the list instead (the same as done for the other BLK* ioctls).
Also, could you check for more missing BLK ioctls? I see at least a couple in the system header.

[eugenis]

compiler-rt/lib/msan/tests/msan_test.cpp

714

I'd say it's ok not to test it if it is hard to set up. Especially if you don't add any extra code, only a list entry.

[kda]

added to list and dropped test
add a few other BLK ioctls

[kda]

compiler-rt/lib/msan/tests/msan_test.cpp

714

Dropping test.

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

124

some of these are wrong: *SET read from the argument, *GET write to the argument.

Also, some types are wrong, including in the existing code!

BLKRAGET / BLKFRAGET uses uptr,
BLKSECTGET uses short
BLKBSZGET uses int
BLKGETSIZE64 uses u64

Please double check against the kernel source.

129

uptr instead of SIZE_TYPE

[kda]

adjusted types and READ/WRITE

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

124

Oh. That is embarrassing. Thank you.

I used this for the Linux code: https://elixir.bootlin.com/linux/latest/source/block/ioctl.c#L500
Is that the right place?

[eugenis]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

124

No problem! Some of these are still wrong though.
BLKFRASET should be NONE
BLKRAGET / BLKFRAGET should use uptr

[kda]

a few more adjustments

[eugenis]

LGTM

compiler-rt/lib/msan/tests/msan_test.cpp

 }
 #else
 # include <malloc.h>
 # include <sys/sysinfo.h>
 # include <sys/vfs.h>
 # include <mntent.h>
 # include <netinet/ether.h>
 # if defined(__linux__)
-#  include <sys/uio.h>
+#    include <linux/fs.h>
+#    include <sys/uio.h>
 # endif
 #endif
 
 #if defined(__i386__) || defined(__x86_64__)
 # include <emmintrin.h>
 # define MSAN_HAS_M128 1
 #else
 # define MSAN_HAS_M128 0

 
 // FIXME: fails now.
 TEST(MemorySanitizer, DISABLED_ioctl) {
   struct winsize ws;
   EXPECT_EQ(ioctl(2, TIOCGWINSZ, &ws), 0);
   EXPECT_NOT_POISONED(ws.ws_col);
 }
 
+#if defined(__linux__)
+TEST(MemorySanitizer, DISABLED_ioctl_BLKSSZGET) {
+  int arg;
+  EXPECT_POISONED(arg);
+  EXPECT_EQ(ioctl(0, BLKSSZGET, &arg), 0);
+  EXPECT_NOT_POISONED(arg);
+}
+#endif /* defined(__linux__) */
+
 TEST(MemorySanitizer, readlink) {
   char *x = new char[1000];
   readlink(SYMLINK_TO_READ, x, 1000);
   EXPECT_NOT_POISONED(x[0]);
   delete [] x;
 }
 
 TEST(MemorySanitizer, readlinkat) {

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

 #endif
 
 #if (SANITIZER_LINUX && !SANITIZER_ANDROID)
   _(SIOCGETSGCNT, WRITE, struct_sioc_sg_req_sz);
   _(SIOCGETVIFCNT, WRITE, struct_sioc_vif_req_sz);
 #endif
 
 #if SANITIZER_LINUX
+#  include <linux/fs.h>
   // Conflicting request ids.
   // _(CDROMAUDIOBUFSIZ, NONE, 0);
   // _(SNDCTL_TMR_CONTINUE, NONE, 0);
   // _(SNDCTL_TMR_START, NONE, 0);
   // _(SNDCTL_TMR_STOP, NONE, 0);
   // _(SOUND_MIXER_READ_LOUD, WRITE, sizeof(int)); // same as ...READ_ENHANCE
   // _(SOUND_MIXER_READ_MUTE, WRITE, sizeof(int)); // same as ...READ_ENHANCE
   // _(SOUND_MIXER_WRITE_LOUD, WRITE, sizeof(int)); // same as ...WRITE_ENHANCE
   // _(SOUND_MIXER_WRITE_MUTE, WRITE, sizeof(int)); // same as ...WRITE_ENHANCE
   _(BLKFLSBUF, NONE, 0);
   _(BLKGETSIZE, WRITE, sizeof(uptr));
   _(BLKRAGET, WRITE, sizeof(int));
   _(BLKRASET, NONE, 0);
   _(BLKROGET, WRITE, sizeof(int));
   _(BLKROSET, READ, sizeof(int));
   _(BLKRRPART, NONE, 0);
   _(CDROMEJECT, NONE, 0);
   _(CDROMEJECT_SW, NONE, 0);
   _(CDROMMULTISESSION, WRITE, struct_cdrom_multisession_sz);
   _(CDROMPAUSE, NONE, 0);
   _(CDROMPLAYMSF, READ, struct_cdrom_msf_sz);
   _(CDROMPLAYTRKIND, READ, struct_cdrom_ti_sz);
   _(CDROMREADAUDIO, READ, struct_cdrom_read_audio_sz);
   _(CDROMREADCOOKED, READ, struct_cdrom_msf_sz);
   _(CDROMREADMODE1, READ, struct_cdrom_msf_sz);
   _(CDROMREADMODE2, READ, struct_cdrom_msf_sz);
   _(CDROMREADRAW, READ, struct_cdrom_msf_sz);
   _(CDROMREADTOCENTRY, WRITE, struct_cdrom_tocentry_sz);
   _(CDROMREADTOCHDR, WRITE, struct_cdrom_tochdr_sz);
   _(CDROMRESET, NONE, 0);

 
 static void ioctl_common_post(void *ctx, const ioctl_desc *desc, int res, int d,
                               unsigned request, void *arg) {
   if (desc->type == ioctl_desc::WRITE || desc->type == ioctl_desc::READWRITE) {
     // FIXME: add verbose output
     unsigned size = desc->size ? desc->size : IOC_SIZE(request);
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, arg, size);
   }
+#if SANITIZER_LINUX
+  if (request == BLKSSZGET)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, arg, sizeof(int));
+#endif  /* SANITIZER_LINUX */
   if (desc->type != ioctl_desc::CUSTOM)
     return;
   if (request == IOCTL_SIOCGIFCONF) {
     struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg;
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ifc->ifc_ifcu.ifcu_req, ifc->ifc_len);
   }
 }
 
 #endif