[sanitizer] Add most ioctls from /usr/include/sound/.

[earthdok]

Two things:

• I had to skip the ioctls defined in emu10k1.h and asequencer.h (mostly because the struct definitions there depend on DECLARE_BITMAP, which isn't defined in any of the headers I have on my machine. But we could redefine that macro - it's rather trivial).
• I had to flip READ and WRITE to make it work. Looks like we interpret "WRITE" as "writes to memory", whereas in Linux "_IOW" means "writes to the device". So in most cases our WRITE maps to _IOR and READ maps to _IOR, but I suspect this may not be an exact mapping.

[earthdok]

Should be: "WRITE maps to _IOR and READ maps to _IOW"

[eugenis]

I think you are correct about _IOW and _IOR.
Please add a test for at least one of these, to see that there is no systematic error here (I realize that testing all of them is hardly possible).
LGTM

lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

663

Why not add READWRITE here in the same commit?

[earthdok]

to see that there is no systematic error here

Would you consider the fact that this fixed my content_unittests crashes to be sufficient verification? (Obviously for regression testing one test would do nothing).

lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

663

fixed

[earthdok]

• add missing READWRITE condition
• add a test

[eugenis]

LGTM

lib/msan/lit_tests/ioctl_sound.cc

+// RUN: %clangxx_msan -m64 -O0 -g %s -o %t && %t
+// RUN: %clangxx_msan -m64 -O3 -g %s -o %t && %t
+
+#include <assert.h>
+#include <fcntl.h>
+#include <sound/asound.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char **argv) {
+  int fd = open("/dev/snd/controlC0", O_RDONLY);
+  if (fd < 0) {
+    printf("Unable to open sound device.");
+    return 0;
+  }
+  snd_ctl_card_info info;
+  assert(__msan_test_shadow(&info, sizeof(info)) != -1);
+  assert(ioctl(fd, SNDRV_CTL_IOCTL_CARD_INFO, &info) >= 0);
+  assert(__msan_test_shadow(&info, sizeof(info)) == -1);
+  close(fd);
+  return 0;
+}

lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

 //===-- sanitizer_common_interceptors_ioctl.inc -----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Ioctl handling in common sanitizer interceptors.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_flags.h"
 
 struct ioctl_desc {
   unsigned req;
-  // FIXME: support read+write arguments. Those are currently marked as WRITE.
+  // FIXME: support read+write arguments. Currently READWRITE and WRITE do the
+  // same thing.
+  // XXX: The declarations below may use WRITE instead of READWRITE, unless
+  // explicitly noted.
   enum {
     NONE,
     READ,
     WRITE,
+    READWRITE,
     CUSTOM
-  } type : 2;
-  unsigned size : 30;
+  } type : 3;
+  unsigned size : 29;
   const char* name;
 };
 
 const unsigned ioctl_table_max = 500;
 static ioctl_desc ioctl_table[ioctl_table_max];
 static unsigned ioctl_table_size = 0;
 
 // This can not be declared as a global, because references to struct_*_sz
#if SANITIZER_LINUX
   _(VT_GETSTATE, WRITE, struct_vt_stat_sz);
   _(VT_OPENQRY, WRITE, sizeof(int));
   _(VT_RELDISP, NONE, 0);
   _(VT_RESIZE, READ, struct_vt_sizes_sz);
   _(VT_RESIZEX, READ, struct_vt_consize_sz);
   _(VT_SENDSIG, NONE, 0);
   _(VT_SETMODE, READ, struct_vt_mode_sz);
   _(VT_WAITACTIVE, NONE, 0);
+
+  // <sound/asound.h>. READWRITE is used correctly in this group.
+  _(SNDRV_HWDEP_IOCTL_PVERSION, WRITE, sizeof(int))
+  _(SNDRV_HWDEP_IOCTL_INFO, WRITE, struct_snd_hwdep_info_sz)
+  _(SNDRV_HWDEP_IOCTL_DSP_STATUS, WRITE, struct_snd_hwdep_dsp_status_sz)
+  _(SNDRV_HWDEP_IOCTL_DSP_LOAD, READ, struct_snd_hwdep_dsp_image_sz)
+  _(SNDRV_PCM_IOCTL_PVERSION, WRITE, sizeof(int))
+  _(SNDRV_PCM_IOCTL_INFO, WRITE, struct_snd_pcm_info_sz)
+  _(SNDRV_PCM_IOCTL_TSTAMP, READ, sizeof(int))
+  _(SNDRV_PCM_IOCTL_TTSTAMP, READ, sizeof(int))
+  _(SNDRV_PCM_IOCTL_HW_REFINE, READWRITE, struct_snd_pcm_hw_params_sz)
+  _(SNDRV_PCM_IOCTL_HW_PARAMS, READWRITE, struct_snd_pcm_hw_params_sz)
+  _(SNDRV_PCM_IOCTL_HW_FREE, NONE, 0)
+  _(SNDRV_PCM_IOCTL_SW_PARAMS, READWRITE, struct_snd_pcm_sw_params_sz)
+  _(SNDRV_PCM_IOCTL_STATUS, WRITE, struct_snd_pcm_status_sz)
+  _(SNDRV_PCM_IOCTL_DELAY, WRITE, snd_pcm_sframes_t_sz)
+  _(SNDRV_PCM_IOCTL_HWSYNC, NONE, 0)
+  _(SNDRV_PCM_IOCTL_SYNC_PTR, READWRITE, struct_snd_pcm_sync_ptr_sz)
+  _(SNDRV_PCM_IOCTL_CHANNEL_INFO, WRITE, struct_snd_pcm_channel_info_sz)
+  _(SNDRV_PCM_IOCTL_PREPARE, NONE, 0)
+  _(SNDRV_PCM_IOCTL_RESET, NONE, 0)
+  _(SNDRV_PCM_IOCTL_START, NONE, 0)
+  _(SNDRV_PCM_IOCTL_DROP, NONE, 0)
+  _(SNDRV_PCM_IOCTL_DRAIN, NONE, 0)
+  _(SNDRV_PCM_IOCTL_PAUSE, READ, sizeof(int))
+  _(SNDRV_PCM_IOCTL_REWIND, READ, snd_pcm_uframes_t_sz)
+  _(SNDRV_PCM_IOCTL_RESUME, NONE, 0)
+  _(SNDRV_PCM_IOCTL_XRUN, NONE, 0)
+  _(SNDRV_PCM_IOCTL_FORWARD, READ, snd_pcm_uframes_t_sz)
+  _(SNDRV_PCM_IOCTL_WRITEI_FRAMES, READ, struct_snd_xferi_sz)
+  _(SNDRV_PCM_IOCTL_READI_FRAMES, WRITE, struct_snd_xferi_sz)
+  _(SNDRV_PCM_IOCTL_WRITEN_FRAMES, READ, struct_snd_xfern_sz)
+  _(SNDRV_PCM_IOCTL_READN_FRAMES, WRITE, struct_snd_xfern_sz)
+  _(SNDRV_PCM_IOCTL_LINK, READ, sizeof(int))
+  _(SNDRV_PCM_IOCTL_UNLINK, NONE, 0)
+  _(SNDRV_RAWMIDI_IOCTL_PVERSION, WRITE, sizeof(int))
+  _(SNDRV_RAWMIDI_IOCTL_INFO, WRITE, struct_snd_rawmidi_info_sz)
+  _(SNDRV_RAWMIDI_IOCTL_PARAMS, READWRITE, struct_snd_rawmidi_params_sz)
+  _(SNDRV_RAWMIDI_IOCTL_STATUS, READWRITE, struct_snd_rawmidi_status_sz)
+  _(SNDRV_RAWMIDI_IOCTL_DROP, READ, sizeof(int))
+  _(SNDRV_RAWMIDI_IOCTL_DRAIN, READ, sizeof(int))
+  _(SNDRV_TIMER_IOCTL_PVERSION, WRITE, sizeof(int))
+  _(SNDRV_TIMER_IOCTL_NEXT_DEVICE, READWRITE, struct_snd_timer_id_sz)
+  _(SNDRV_TIMER_IOCTL_TREAD, READ, sizeof(int))
+  _(SNDRV_TIMER_IOCTL_GINFO, READWRITE, struct_snd_timer_ginfo_sz)
+  _(SNDRV_TIMER_IOCTL_GPARAMS, READ, struct_snd_timer_gparams_sz)
+  _(SNDRV_TIMER_IOCTL_GSTATUS, READWRITE, struct_snd_timer_gstatus_sz)
+  _(SNDRV_TIMER_IOCTL_SELECT, READ, struct_snd_timer_select_sz)
+  _(SNDRV_TIMER_IOCTL_INFO, WRITE, struct_snd_timer_info_sz)
+  _(SNDRV_TIMER_IOCTL_PARAMS, READ, struct_snd_timer_params_sz)
+  _(SNDRV_TIMER_IOCTL_STATUS, WRITE, struct_snd_timer_status_sz)
+  _(SNDRV_TIMER_IOCTL_START, NONE, 0)
+  _(SNDRV_TIMER_IOCTL_STOP, NONE, 0)
+  _(SNDRV_TIMER_IOCTL_CONTINUE, NONE, 0)
+  _(SNDRV_TIMER_IOCTL_PAUSE, NONE, 0)
+  _(SNDRV_CTL_IOCTL_PVERSION, WRITE, sizeof(int))
+  _(SNDRV_CTL_IOCTL_CARD_INFO, WRITE, struct_snd_ctl_card_info_sz)
+  _(SNDRV_CTL_IOCTL_ELEM_LIST, READWRITE, struct_snd_ctl_elem_list_sz)
+  _(SNDRV_CTL_IOCTL_ELEM_INFO, READWRITE, struct_snd_ctl_elem_info_sz)
+  _(SNDRV_CTL_IOCTL_ELEM_READ, READWRITE, struct_snd_ctl_elem_value_sz)
+  _(SNDRV_CTL_IOCTL_ELEM_WRITE, READWRITE, struct_snd_ctl_elem_value_sz)
+  _(SNDRV_CTL_IOCTL_ELEM_LOCK, READ, struct_snd_ctl_elem_id_sz)
+  _(SNDRV_CTL_IOCTL_ELEM_UNLOCK, READ, struct_snd_ctl_elem_id_sz)
+  _(SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS, READWRITE, sizeof(int))
+  _(SNDRV_CTL_IOCTL_ELEM_ADD, READWRITE, struct_snd_ctl_elem_info_sz)
+  _(SNDRV_CTL_IOCTL_ELEM_REPLACE, READWRITE, struct_snd_ctl_elem_info_sz)
+  _(SNDRV_CTL_IOCTL_ELEM_REMOVE, READWRITE, struct_snd_ctl_elem_id_sz)
+  _(SNDRV_CTL_IOCTL_TLV_READ, READWRITE, struct_snd_ctl_tlv_sz)
+  _(SNDRV_CTL_IOCTL_TLV_WRITE, READWRITE, struct_snd_ctl_tlv_sz)
+  _(SNDRV_CTL_IOCTL_TLV_COMMAND, READWRITE, struct_snd_ctl_tlv_sz)
+  _(SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE, READWRITE, sizeof(int))
+  _(SNDRV_CTL_IOCTL_HWDEP_INFO, WRITE, struct_snd_hwdep_info_sz)
+  _(SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE, WRITE, sizeof(int))
+  _(SNDRV_CTL_IOCTL_PCM_INFO, READWRITE, struct_snd_pcm_info_sz)
+  _(SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE, READ, sizeof(int))
+  _(SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE, READWRITE, sizeof(int))
+  _(SNDRV_CTL_IOCTL_RAWMIDI_INFO, READWRITE, struct_snd_rawmidi_info_sz)
+  _(SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE, READ, sizeof(int))
+  _(SNDRV_CTL_IOCTL_POWER, READWRITE, sizeof(int))
+  _(SNDRV_CTL_IOCTL_POWER_STATE, WRITE, sizeof(int))
+
+  // <sound/asound_fm.h>. READWRITE is used correctly in this group.
+  _(SNDRV_DM_FM_IOCTL_INFO, WRITE, struct_snd_dm_fm_info_sz)
+  _(SNDRV_DM_FM_IOCTL_RESET, NONE, 0)
+  _(SNDRV_DM_FM_IOCTL_PLAY_NOTE, READ, struct_snd_dm_fm_note_sz)
+  _(SNDRV_DM_FM_IOCTL_SET_VOICE, READ, struct_snd_dm_fm_voice_sz)
+  _(SNDRV_DM_FM_IOCTL_SET_PARAMS, READ, struct_snd_dm_fm_params_sz)
+  _(SNDRV_DM_FM_IOCTL_SET_MODE, READ, sizeof(int))
+  _(SNDRV_DM_FM_IOCTL_SET_CONNECTION, READ, sizeof(int))
+  _(SNDRV_DM_FM_IOCTL_CLEAR_PATCHES, NONE, 0)
+
+  // <sound/hdsp.h>. READWRITE is used correctly in this group.
+  _(SNDRV_HDSP_IOCTL_GET_PEAK_RMS, WRITE, struct_hdsp_peak_rms_sz)
+  _(SNDRV_HDSP_IOCTL_GET_CONFIG_INFO, WRITE, struct_hdsp_config_info_sz)
+  _(SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE, READ, struct_hdsp_firmware_sz)
+  _(SNDRV_HDSP_IOCTL_GET_VERSION, WRITE, struct_hdsp_version_sz)
+  _(SNDRV_HDSP_IOCTL_GET_MIXER, WRITE, struct_hdsp_mixer_sz)
+  _(SNDRV_HDSP_IOCTL_GET_9632_AEB, WRITE, struct_hdsp_9632_aeb_sz)
+
+  // <sound/hdspm.h>. READWRITE is used correctly in this group.
+  _(SNDRV_HDSPM_IOCTL_GET_PEAK_RMS, WRITE, struct_hdspm_peak_rms_sz)
+  _(SNDRV_HDSPM_IOCTL_GET_CONFIG, WRITE, struct_hdspm_config_sz)
+  _(SNDRV_HDSPM_IOCTL_GET_LTC, WRITE, struct_hdspm_mixer_ioctl_sz)
+  _(SNDRV_HDSPM_IOCTL_GET_STATUS, WRITE, struct_hdspm_status_sz)
+  _(SNDRV_HDSPM_IOCTL_GET_VERSION, WRITE, struct_hdspm_version_sz)
+  _(SNDRV_HDSPM_IOCTL_GET_MIXER, WRITE, struct_hdspm_mixer_ioctl_sz)
+
+  // <sound/sb16_csp.h>. READWRITE is used correctly in this group.
+  _(SNDRV_SB_CSP_IOCTL_INFO, WRITE, struct_snd_sb_csp_info_sz)
+  _(SNDRV_SB_CSP_IOCTL_LOAD_CODE, READ, struct_snd_sb_csp_microcode_sz)
+  _(SNDRV_SB_CSP_IOCTL_UNLOAD_CODE, NONE, 0)
+  _(SNDRV_SB_CSP_IOCTL_START, READ, struct_snd_sb_csp_start_sz)
+  _(SNDRV_SB_CSP_IOCTL_STOP, NONE, 0)
+  _(SNDRV_SB_CSP_IOCTL_PAUSE, NONE, 0)
+  _(SNDRV_SB_CSP_IOCTL_RESTART, NONE, 0)
+
+  // <sound/sfnt_info.h>. READWRITE is used correctly in this group.
+  _(SNDRV_EMUX_IOCTL_VERSION, WRITE, sizeof(unsigned int))
+  _(SNDRV_EMUX_IOCTL_LOAD_PATCH, READWRITE, struct_soundfont_patch_info_sz)
+  _(SNDRV_EMUX_IOCTL_RESET_SAMPLES, NONE, 0)
+  _(SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES, NONE, 0)
+  _(SNDRV_EMUX_IOCTL_MEM_AVAIL, READ, sizeof(int))
+  _(SNDRV_EMUX_IOCTL_MISC_MODE, READWRITE, struct_snd_emux_misc_mode_sz)
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   // _(SIOCDEVPLIP, WRITE, struct_ifreq_sz); // the same as EQL_ENSLAVE
   _(CYGETDEFTHRESH, WRITE, sizeof(int));
   _(CYGETDEFTIMEOUT, WRITE, sizeof(int));
   _(CYGETMON, WRITE, struct_cyclades_monitor_sz);
   _(CYGETTHRESH, WRITE, sizeof(int));
static const ioctl_desc *ioctl_lookup(unsigned req) {
   const ioctl_desc *desc = ioctl_table_lookup(req);
   if (desc) return desc;
 
   // Try stripping access size from the request id.
   desc = ioctl_table_lookup(req & ~0x3fff0000U);
   // Sanity check: requests that encode access size are either read or write and
   // have size of 0 in the table.
   if (desc && desc->size == 0 &&
-      (desc->type == ioctl_desc::WRITE || desc->type == ioctl_desc::READ))
+      (desc->type == ioctl_desc::READWRITE || desc->type == ioctl_desc::WRITE ||
+       desc->type == ioctl_desc::READ))
     return desc;
   return 0;
 }
 
 static void ioctl_common_pre(void *ctx, const ioctl_desc *desc, int d,
                              unsigned request, void *arg) {
-  if (desc->type == ioctl_desc::READ) {
+  if (desc->type == ioctl_desc::READ || desc->type == ioctl_desc::READWRITE) {
     unsigned size = desc->size ? desc->size : IOC_SIZE(request);
     COMMON_INTERCEPTOR_READ_RANGE(ctx, arg, size);
   }
   if (desc->type != ioctl_desc::CUSTOM)
     return;
   switch (request) {
     case 0x00008912: {  // SIOCGIFCONF
       struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg;
       COMMON_INTERCEPTOR_READ_RANGE(ctx, &ifc->ifc_len, sizeof(ifc->ifc_len));
       break;
     }
   }
   return;
 }
 
 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) {
+  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 (desc->type != ioctl_desc::CUSTOM)
     return;
   switch (request) {
     case 0x00008912: {  // SIOCGIFCONF
       struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg;
       COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ifc->ifc_ifcu.ifcu_req, ifc->ifc_len);
       break;
     }
   }
   return;
 }

lib/sanitizer_common/sanitizer_platform_limits_posix.h

#if SANITIZER_LINUX && !SANITIZER_ANDROID
   extern unsigned struct_unimapinit_sz;
 #endif
 
 #if !SANITIZER_ANDROID && !SANITIZER_MAC
   extern unsigned struct_sioc_sg_req_sz;
   extern unsigned struct_sioc_vif_req_sz;
 #endif
 
+#if SANITIZER_LINUX
+  extern unsigned snd_pcm_sframes_t_sz;
+  extern unsigned snd_pcm_uframes_t_sz;
+  extern unsigned struct_hdsp_9632_aeb_sz;
+  extern unsigned struct_hdsp_config_info_sz;
+  extern unsigned struct_hdsp_firmware_sz;
+  extern unsigned struct_hdspm_config_sz;
+  extern unsigned struct_hdsp_mixer_sz;
+  extern unsigned struct_hdspm_mixer_ioctl_sz;
+  extern unsigned struct_hdspm_peak_rms_sz;
+  extern unsigned struct_hdspm_status_sz;
+  extern unsigned struct_hdspm_version_sz;
+  extern unsigned struct_hdsp_peak_rms_sz;
+  extern unsigned struct_hdsp_version_sz;
+  extern unsigned struct_snd_ctl_card_info_sz;
+  extern unsigned struct_snd_ctl_elem_id_sz;
+  extern unsigned struct_snd_ctl_elem_info_sz;
+  extern unsigned struct_snd_ctl_elem_list_sz;
+  extern unsigned struct_snd_ctl_elem_value_sz;
+  extern unsigned struct_snd_ctl_tlv_sz;
+  extern unsigned struct_snd_dm_fm_info_sz;
+  extern unsigned struct_snd_dm_fm_note_sz;
+  extern unsigned struct_snd_dm_fm_params_sz;
+  extern unsigned struct_snd_dm_fm_voice_sz;
+  extern unsigned struct_snd_emux_misc_mode_sz;
+  extern unsigned struct_snd_hwdep_dsp_image_sz;
+  extern unsigned struct_snd_hwdep_dsp_status_sz;
+  extern unsigned struct_snd_hwdep_info_sz;
+  extern unsigned struct_snd_pcm_channel_info_sz;
+  extern unsigned struct_snd_pcm_hw_params_sz;
+  extern unsigned struct_snd_pcm_info_sz;
+  extern unsigned struct_snd_pcm_status_sz;
+  extern unsigned struct_snd_pcm_sw_params_sz;
+  extern unsigned struct_snd_pcm_sync_ptr_sz;
+  extern unsigned struct_snd_rawmidi_info_sz;
+  extern unsigned struct_snd_rawmidi_params_sz;
+  extern unsigned struct_snd_rawmidi_status_sz;
+  extern unsigned struct_snd_sb_csp_info_sz;
+  extern unsigned struct_snd_sb_csp_microcode_sz;
+  extern unsigned struct_snd_sb_csp_start_sz;
+  extern unsigned struct_snd_timer_ginfo_sz;
+  extern unsigned struct_snd_timer_gparams_sz;
+  extern unsigned struct_snd_timer_gstatus_sz;
+  extern unsigned struct_snd_timer_id_sz;
+  extern unsigned struct_snd_timer_info_sz;
+  extern unsigned struct_snd_timer_params_sz;
+  extern unsigned struct_snd_timer_select_sz;
+  extern unsigned struct_snd_timer_status_sz;
+  extern unsigned struct_snd_xferi_sz;
+  extern unsigned struct_snd_xfern_sz;
+  extern unsigned struct_soundfont_patch_info_sz;
+#endif
+
   // ioctl request identifiers
 
   // A special value to mark ioctls that are not present on the target platform,
   // when it can not be determined without including any system headers.
   extern unsigned IOCTL_NOT_PRESENT;
 
   extern unsigned IOCTL_FIOASYNC;
   extern unsigned IOCTL_FIOCLEX;
#if SANITIZER_LINUX && !SANITIZER_ANDROID
   extern unsigned IOCTL_SIOCNRSETPARMS;
   extern unsigned IOCTL_SNDCTL_DSP_GETISPACE;
   extern unsigned IOCTL_SNDCTL_DSP_GETOSPACE;
   extern unsigned IOCTL_TIOCGSERIAL;
   extern unsigned IOCTL_TIOCSERGETMULTI;
   extern unsigned IOCTL_TIOCSERSETMULTI;
   extern unsigned IOCTL_TIOCSSERIAL;
 #endif
+#if SANITIZER_LINUX
+  extern unsigned IOCTL_SNDRV_HWDEP_IOCTL_PVERSION;
+  extern unsigned IOCTL_SNDRV_HWDEP_IOCTL_INFO;
+  extern unsigned IOCTL_SNDRV_HWDEP_IOCTL_DSP_STATUS;
+  extern unsigned IOCTL_SNDRV_HWDEP_IOCTL_DSP_LOAD;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_PVERSION;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_INFO;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_TSTAMP;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_TTSTAMP;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_HW_REFINE;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_HW_PARAMS;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_HW_FREE;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_SW_PARAMS;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_STATUS;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_DELAY;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_HWSYNC;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_SYNC_PTR;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_CHANNEL_INFO;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_PREPARE;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_RESET;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_START;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_DROP;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_DRAIN;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_PAUSE;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_REWIND;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_RESUME;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_XRUN;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_FORWARD;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_WRITEI_FRAMES;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_READI_FRAMES;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_WRITEN_FRAMES;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_READN_FRAMES;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_LINK;
+  extern unsigned IOCTL_SNDRV_PCM_IOCTL_UNLINK;
+  extern unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_PVERSION;
+  extern unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_INFO;
+  extern unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_PARAMS;
+  extern unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_STATUS;
+  extern unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_DROP;
+  extern unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_DRAIN;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_PVERSION;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_NEXT_DEVICE;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_TREAD;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_GINFO;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_GPARAMS;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_GSTATUS;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_SELECT;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_INFO;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_PARAMS;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_STATUS;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_START;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_STOP;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_CONTINUE;
+  extern unsigned IOCTL_SNDRV_TIMER_IOCTL_PAUSE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_PVERSION;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_CARD_INFO;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_LIST;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_INFO;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_READ;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_WRITE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_LOCK;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_UNLOCK;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_ADD;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_REPLACE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_REMOVE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_TLV_READ;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_TLV_WRITE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_TLV_COMMAND;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_HWDEP_INFO;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_PCM_INFO;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_RAWMIDI_INFO;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_POWER;
+  extern unsigned IOCTL_SNDRV_CTL_IOCTL_POWER_STATE;
+  extern unsigned IOCTL_SNDRV_DM_FM_IOCTL_INFO;
+  extern unsigned IOCTL_SNDRV_DM_FM_IOCTL_RESET;
+  extern unsigned IOCTL_SNDRV_DM_FM_IOCTL_PLAY_NOTE;
+  extern unsigned IOCTL_SNDRV_DM_FM_IOCTL_SET_VOICE;
+  extern unsigned IOCTL_SNDRV_DM_FM_IOCTL_SET_PARAMS;
+  extern unsigned IOCTL_SNDRV_DM_FM_IOCTL_SET_MODE;
+  extern unsigned IOCTL_SNDRV_DM_FM_IOCTL_SET_CONNECTION;
+  extern unsigned IOCTL_SNDRV_DM_FM_IOCTL_CLEAR_PATCHES;
+  extern unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_PEAK_RMS;
+  extern unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_CONFIG_INFO;
+  extern unsigned IOCTL_SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE;
+  extern unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_VERSION;
+  extern unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_MIXER;
+  extern unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_9632_AEB;
+  extern unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_PEAK_RMS;
+  extern unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_CONFIG;
+  extern unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_LTC;
+  extern unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_STATUS;
+  extern unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_VERSION;
+  extern unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_MIXER;
+  extern unsigned IOCTL_SNDRV_SB_CSP_IOCTL_INFO;
+  extern unsigned IOCTL_SNDRV_SB_CSP_IOCTL_LOAD_CODE;
+  extern unsigned IOCTL_SNDRV_SB_CSP_IOCTL_UNLOAD_CODE;
+  extern unsigned IOCTL_SNDRV_SB_CSP_IOCTL_START;
+  extern unsigned IOCTL_SNDRV_SB_CSP_IOCTL_STOP;
+  extern unsigned IOCTL_SNDRV_SB_CSP_IOCTL_PAUSE;
+  extern unsigned IOCTL_SNDRV_SB_CSP_IOCTL_RESTART;
+  extern unsigned IOCTL_SNDRV_EMUX_IOCTL_VERSION;
+  extern unsigned IOCTL_SNDRV_EMUX_IOCTL_LOAD_PATCH;
+  extern unsigned IOCTL_SNDRV_EMUX_IOCTL_RESET_SAMPLES;
+  extern unsigned IOCTL_SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES;
+  extern unsigned IOCTL_SNDRV_EMUX_IOCTL_MEM_AVAIL;
+  extern unsigned IOCTL_SNDRV_EMUX_IOCTL_MISC_MODE;
+#endif
 
   extern const int errno_EOWNERDEAD;
 }  // namespace __sanitizer
 
 #define CHECK_TYPE_SIZE(TYPE) \
   COMPILER_CHECK(sizeof(__sanitizer_##TYPE) == sizeof(TYPE))
 
 #define CHECK_SIZE_AND_OFFSET(CLASS, MEMBER)                       \

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

 
 #if SANITIZER_MAC
 #include <net/ethernet.h>
 #include <sys/filio.h>
 #include <sys/mount.h>
 #include <sys/sockio.h>
 #endif
 
+#if SANITIZER_LINUX
+#include <sound/asound.h>
+#include <sound/asound_fm.h>
+#include <sound/hdsp.h>
+#include <sound/hdspm.h>
+#include <sound/sb16_csp.h>
+#include <sound/sfnt_info.h>
+#endif
+
 namespace __sanitizer {
   unsigned struct_utsname_sz = sizeof(struct utsname);
   unsigned struct_stat_sz = sizeof(struct stat);
 #if !SANITIZER_IOS
   unsigned struct_stat64_sz = sizeof(struct stat64);
 #endif // !SANITIZER_IOS
   unsigned struct_rusage_sz = sizeof(struct rusage);
   unsigned struct_tm_sz = sizeof(struct tm);
#endif
   unsigned struct_unimapinit_sz = sizeof(struct unimapinit);
 #endif
 
 #if !SANITIZER_ANDROID && !SANITIZER_MAC
   unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
   unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
 #endif
 
+#if SANITIZER_LINUX
+  unsigned snd_pcm_sframes_t_sz = sizeof(snd_pcm_sframes_t);
+  unsigned snd_pcm_uframes_t_sz = sizeof(snd_pcm_uframes_t);
+  unsigned struct_hdsp_9632_aeb_sz = sizeof(struct hdsp_9632_aeb);
+  unsigned struct_hdsp_config_info_sz = sizeof(struct hdsp_config_info);
+  unsigned struct_hdsp_firmware_sz = sizeof(struct hdsp_firmware);
+  unsigned struct_hdspm_config_sz = sizeof(struct hdspm_config);
+  unsigned struct_hdsp_mixer_sz = sizeof(struct hdsp_mixer);
+  unsigned struct_hdspm_mixer_ioctl_sz = sizeof(struct hdspm_mixer_ioctl);
+  unsigned struct_hdspm_peak_rms_sz = sizeof(struct hdspm_peak_rms);
+  unsigned struct_hdspm_status_sz = sizeof(struct hdspm_status);
+  unsigned struct_hdspm_version_sz = sizeof(struct hdspm_version);
+  unsigned struct_hdsp_peak_rms_sz = sizeof(struct hdsp_peak_rms);
+  unsigned struct_hdsp_version_sz = sizeof(struct hdsp_version);
+  unsigned struct_snd_ctl_card_info_sz = sizeof(struct snd_ctl_card_info);
+  unsigned struct_snd_ctl_elem_id_sz = sizeof(struct snd_ctl_elem_id);
+  unsigned struct_snd_ctl_elem_info_sz = sizeof(struct snd_ctl_elem_info);
+  unsigned struct_snd_ctl_elem_list_sz = sizeof(struct snd_ctl_elem_list);
+  unsigned struct_snd_ctl_elem_value_sz = sizeof(struct snd_ctl_elem_value);
+  unsigned struct_snd_ctl_tlv_sz = sizeof(struct snd_ctl_tlv);
+  unsigned struct_snd_dm_fm_info_sz = sizeof(struct snd_dm_fm_info);
+  unsigned struct_snd_dm_fm_note_sz = sizeof(struct snd_dm_fm_note);
+  unsigned struct_snd_dm_fm_params_sz = sizeof(struct snd_dm_fm_params);
+  unsigned struct_snd_dm_fm_voice_sz = sizeof(struct snd_dm_fm_voice);
+  unsigned struct_snd_emux_misc_mode_sz = sizeof(struct snd_emux_misc_mode);
+  unsigned struct_snd_hwdep_dsp_image_sz = sizeof(struct snd_hwdep_dsp_image);
+  unsigned struct_snd_hwdep_dsp_status_sz = sizeof(struct snd_hwdep_dsp_status);
+  unsigned struct_snd_hwdep_info_sz = sizeof(struct snd_hwdep_info);
+  unsigned struct_snd_pcm_channel_info_sz = sizeof(struct snd_pcm_channel_info);
+  unsigned struct_snd_pcm_hw_params_sz = sizeof(struct snd_pcm_hw_params);
+  unsigned struct_snd_pcm_info_sz = sizeof(struct snd_pcm_info);
+  unsigned struct_snd_pcm_status_sz = sizeof(struct snd_pcm_status);
+  unsigned struct_snd_pcm_sw_params_sz = sizeof(struct snd_pcm_sw_params);
+  unsigned struct_snd_pcm_sync_ptr_sz = sizeof(struct snd_pcm_sync_ptr);
+  unsigned struct_snd_rawmidi_info_sz = sizeof(struct snd_rawmidi_info);
+  unsigned struct_snd_rawmidi_params_sz = sizeof(struct snd_rawmidi_params);
+  unsigned struct_snd_rawmidi_status_sz = sizeof(struct snd_rawmidi_status);
+  unsigned struct_snd_sb_csp_info_sz = sizeof(struct snd_sb_csp_info);
+  unsigned struct_snd_sb_csp_microcode_sz = sizeof(struct snd_sb_csp_microcode);
+  unsigned struct_snd_sb_csp_start_sz = sizeof(struct snd_sb_csp_start);
+  unsigned struct_snd_timer_ginfo_sz = sizeof(struct snd_timer_ginfo);
+  unsigned struct_snd_timer_gparams_sz = sizeof(struct snd_timer_gparams);
+  unsigned struct_snd_timer_gstatus_sz = sizeof(struct snd_timer_gstatus);
+  unsigned struct_snd_timer_id_sz = sizeof(struct snd_timer_id);
+  unsigned struct_snd_timer_info_sz = sizeof(struct snd_timer_info);
+  unsigned struct_snd_timer_params_sz = sizeof(struct snd_timer_params);
+  unsigned struct_snd_timer_select_sz = sizeof(struct snd_timer_select);
+  unsigned struct_snd_timer_status_sz = sizeof(struct snd_timer_status);
+  unsigned struct_snd_xferi_sz = sizeof(struct snd_xferi);
+  unsigned struct_snd_xfern_sz = sizeof(struct snd_xfern);
+  unsigned struct_soundfont_patch_info_sz = sizeof(struct soundfont_patch_info);
+#endif
+
   unsigned IOCTL_NOT_PRESENT = 0;
 
   unsigned IOCTL_FIOASYNC = FIOASYNC;
   unsigned IOCTL_FIOCLEX = FIOCLEX;
   unsigned IOCTL_FIOGETOWN = FIOGETOWN;
   unsigned IOCTL_FIONBIO = FIONBIO;
   unsigned IOCTL_FIONCLEX = FIONCLEX;
   unsigned IOCTL_FIOSETOWN = FIOSETOWN;
#endif
   unsigned IOCTL_SIOCNRSETPARMS = SIOCNRSETPARMS;
   unsigned IOCTL_SNDCTL_DSP_GETISPACE = SNDCTL_DSP_GETISPACE;
   unsigned IOCTL_SNDCTL_DSP_GETOSPACE = SNDCTL_DSP_GETOSPACE;
   unsigned IOCTL_TIOCGSERIAL = TIOCGSERIAL;
   unsigned IOCTL_TIOCSERGETMULTI = TIOCSERGETMULTI;
   unsigned IOCTL_TIOCSERSETMULTI = TIOCSERSETMULTI;
   unsigned IOCTL_TIOCSSERIAL = TIOCSSERIAL;
 #endif
+#if SANITIZER_LINUX
+  unsigned IOCTL_SNDRV_HWDEP_IOCTL_PVERSION = SNDRV_HWDEP_IOCTL_PVERSION;
+  unsigned IOCTL_SNDRV_HWDEP_IOCTL_INFO = SNDRV_HWDEP_IOCTL_INFO;
+  unsigned IOCTL_SNDRV_HWDEP_IOCTL_DSP_STATUS = SNDRV_HWDEP_IOCTL_DSP_STATUS;
+  unsigned IOCTL_SNDRV_HWDEP_IOCTL_DSP_LOAD = SNDRV_HWDEP_IOCTL_DSP_LOAD;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_PVERSION = SNDRV_PCM_IOCTL_PVERSION;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_INFO = SNDRV_PCM_IOCTL_INFO;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_TSTAMP = SNDRV_PCM_IOCTL_TSTAMP;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_TTSTAMP = SNDRV_PCM_IOCTL_TTSTAMP;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_HW_REFINE = SNDRV_PCM_IOCTL_HW_REFINE;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_HW_PARAMS = SNDRV_PCM_IOCTL_HW_PARAMS;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_HW_FREE = SNDRV_PCM_IOCTL_HW_FREE;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_SW_PARAMS = SNDRV_PCM_IOCTL_SW_PARAMS;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_STATUS = SNDRV_PCM_IOCTL_STATUS;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_DELAY = SNDRV_PCM_IOCTL_DELAY;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_HWSYNC = SNDRV_PCM_IOCTL_HWSYNC;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_SYNC_PTR = SNDRV_PCM_IOCTL_SYNC_PTR;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_CHANNEL_INFO = SNDRV_PCM_IOCTL_CHANNEL_INFO;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_PREPARE = SNDRV_PCM_IOCTL_PREPARE;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_RESET = SNDRV_PCM_IOCTL_RESET;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_START = SNDRV_PCM_IOCTL_START;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_DROP = SNDRV_PCM_IOCTL_DROP;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_DRAIN = SNDRV_PCM_IOCTL_DRAIN;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_PAUSE = SNDRV_PCM_IOCTL_PAUSE;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_REWIND = SNDRV_PCM_IOCTL_REWIND;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_RESUME = SNDRV_PCM_IOCTL_RESUME;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_XRUN = SNDRV_PCM_IOCTL_XRUN;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_FORWARD = SNDRV_PCM_IOCTL_FORWARD;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_WRITEI_FRAMES = SNDRV_PCM_IOCTL_WRITEI_FRAMES;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_READI_FRAMES = SNDRV_PCM_IOCTL_READI_FRAMES;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_WRITEN_FRAMES = SNDRV_PCM_IOCTL_WRITEN_FRAMES;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_READN_FRAMES = SNDRV_PCM_IOCTL_READN_FRAMES;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_LINK = SNDRV_PCM_IOCTL_LINK;
+  unsigned IOCTL_SNDRV_PCM_IOCTL_UNLINK = SNDRV_PCM_IOCTL_UNLINK;
+  unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_PVERSION = SNDRV_RAWMIDI_IOCTL_PVERSION;
+  unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_INFO = SNDRV_RAWMIDI_IOCTL_INFO;
+  unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_PARAMS = SNDRV_RAWMIDI_IOCTL_PARAMS;
+  unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_STATUS = SNDRV_RAWMIDI_IOCTL_STATUS;
+  unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_DROP = SNDRV_RAWMIDI_IOCTL_DROP;
+  unsigned IOCTL_SNDRV_RAWMIDI_IOCTL_DRAIN = SNDRV_RAWMIDI_IOCTL_DRAIN;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_PVERSION = SNDRV_TIMER_IOCTL_PVERSION;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_NEXT_DEVICE = SNDRV_TIMER_IOCTL_NEXT_DEVICE;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_TREAD = SNDRV_TIMER_IOCTL_TREAD;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_GINFO = SNDRV_TIMER_IOCTL_GINFO;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_GPARAMS = SNDRV_TIMER_IOCTL_GPARAMS;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_GSTATUS = SNDRV_TIMER_IOCTL_GSTATUS;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_SELECT = SNDRV_TIMER_IOCTL_SELECT;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_INFO = SNDRV_TIMER_IOCTL_INFO;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_PARAMS = SNDRV_TIMER_IOCTL_PARAMS;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_STATUS = SNDRV_TIMER_IOCTL_STATUS;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_START = SNDRV_TIMER_IOCTL_START;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_STOP = SNDRV_TIMER_IOCTL_STOP;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_CONTINUE = SNDRV_TIMER_IOCTL_CONTINUE;
+  unsigned IOCTL_SNDRV_TIMER_IOCTL_PAUSE = SNDRV_TIMER_IOCTL_PAUSE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_PVERSION = SNDRV_CTL_IOCTL_PVERSION;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_CARD_INFO = SNDRV_CTL_IOCTL_CARD_INFO;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_LIST = SNDRV_CTL_IOCTL_ELEM_LIST;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_INFO = SNDRV_CTL_IOCTL_ELEM_INFO;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_READ = SNDRV_CTL_IOCTL_ELEM_READ;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_WRITE = SNDRV_CTL_IOCTL_ELEM_WRITE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_LOCK = SNDRV_CTL_IOCTL_ELEM_LOCK;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_UNLOCK = SNDRV_CTL_IOCTL_ELEM_UNLOCK;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS =
+      SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_ADD = SNDRV_CTL_IOCTL_ELEM_ADD;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_REPLACE = SNDRV_CTL_IOCTL_ELEM_REPLACE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_ELEM_REMOVE = SNDRV_CTL_IOCTL_ELEM_REMOVE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_TLV_READ = SNDRV_CTL_IOCTL_TLV_READ;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_TLV_WRITE = SNDRV_CTL_IOCTL_TLV_WRITE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_TLV_COMMAND = SNDRV_CTL_IOCTL_TLV_COMMAND;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE =
+      SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_HWDEP_INFO = SNDRV_CTL_IOCTL_HWDEP_INFO;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE =
+      SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_PCM_INFO = SNDRV_CTL_IOCTL_PCM_INFO;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE =
+      SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE =
+      SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_RAWMIDI_INFO = SNDRV_CTL_IOCTL_RAWMIDI_INFO;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE =
+      SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_POWER = SNDRV_CTL_IOCTL_POWER;
+  unsigned IOCTL_SNDRV_CTL_IOCTL_POWER_STATE = SNDRV_CTL_IOCTL_POWER_STATE;
+  unsigned IOCTL_SNDRV_DM_FM_IOCTL_INFO = SNDRV_DM_FM_IOCTL_INFO;
+  unsigned IOCTL_SNDRV_DM_FM_IOCTL_RESET = SNDRV_DM_FM_IOCTL_RESET;
+  unsigned IOCTL_SNDRV_DM_FM_IOCTL_PLAY_NOTE = SNDRV_DM_FM_IOCTL_PLAY_NOTE;
+  unsigned IOCTL_SNDRV_DM_FM_IOCTL_SET_VOICE = SNDRV_DM_FM_IOCTL_SET_VOICE;
+  unsigned IOCTL_SNDRV_DM_FM_IOCTL_SET_PARAMS = SNDRV_DM_FM_IOCTL_SET_PARAMS;
+  unsigned IOCTL_SNDRV_DM_FM_IOCTL_SET_MODE = SNDRV_DM_FM_IOCTL_SET_MODE;
+  unsigned IOCTL_SNDRV_DM_FM_IOCTL_SET_CONNECTION =
+      SNDRV_DM_FM_IOCTL_SET_CONNECTION;
+  unsigned IOCTL_SNDRV_DM_FM_IOCTL_CLEAR_PATCHES =
+      SNDRV_DM_FM_IOCTL_CLEAR_PATCHES;
+  unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_PEAK_RMS = SNDRV_HDSP_IOCTL_GET_PEAK_RMS;
+  unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_CONFIG_INFO =
+      SNDRV_HDSP_IOCTL_GET_CONFIG_INFO;
+  unsigned IOCTL_SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE =
+      SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE;
+  unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_VERSION = SNDRV_HDSP_IOCTL_GET_VERSION;
+  unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_MIXER = SNDRV_HDSP_IOCTL_GET_MIXER;
+  unsigned IOCTL_SNDRV_HDSP_IOCTL_GET_9632_AEB = SNDRV_HDSP_IOCTL_GET_9632_AEB;
+  unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_PEAK_RMS =
+      SNDRV_HDSPM_IOCTL_GET_PEAK_RMS;
+  unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_CONFIG = SNDRV_HDSPM_IOCTL_GET_CONFIG;
+  unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_LTC = SNDRV_HDSPM_IOCTL_GET_LTC;
+  unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_STATUS = SNDRV_HDSPM_IOCTL_GET_STATUS;
+  unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_VERSION = SNDRV_HDSPM_IOCTL_GET_VERSION;
+  unsigned IOCTL_SNDRV_HDSPM_IOCTL_GET_MIXER = SNDRV_HDSPM_IOCTL_GET_MIXER;
+  unsigned IOCTL_SNDRV_SB_CSP_IOCTL_INFO = SNDRV_SB_CSP_IOCTL_INFO;
+  unsigned IOCTL_SNDRV_SB_CSP_IOCTL_LOAD_CODE = SNDRV_SB_CSP_IOCTL_LOAD_CODE;
+  unsigned IOCTL_SNDRV_SB_CSP_IOCTL_UNLOAD_CODE =
+      SNDRV_SB_CSP_IOCTL_UNLOAD_CODE;
+  unsigned IOCTL_SNDRV_SB_CSP_IOCTL_START = SNDRV_SB_CSP_IOCTL_START;
+  unsigned IOCTL_SNDRV_SB_CSP_IOCTL_STOP = SNDRV_SB_CSP_IOCTL_STOP;
+  unsigned IOCTL_SNDRV_SB_CSP_IOCTL_PAUSE = SNDRV_SB_CSP_IOCTL_PAUSE;
+  unsigned IOCTL_SNDRV_SB_CSP_IOCTL_RESTART = SNDRV_SB_CSP_IOCTL_RESTART;
+  unsigned IOCTL_SNDRV_EMUX_IOCTL_VERSION = SNDRV_EMUX_IOCTL_VERSION;
+  unsigned IOCTL_SNDRV_EMUX_IOCTL_LOAD_PATCH = SNDRV_EMUX_IOCTL_LOAD_PATCH;
+  unsigned IOCTL_SNDRV_EMUX_IOCTL_RESET_SAMPLES =
+      SNDRV_EMUX_IOCTL_RESET_SAMPLES;
+  unsigned IOCTL_SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES =
+      SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES;
+  unsigned IOCTL_SNDRV_EMUX_IOCTL_MEM_AVAIL = SNDRV_EMUX_IOCTL_MEM_AVAIL;
+  unsigned IOCTL_SNDRV_EMUX_IOCTL_MISC_MODE = SNDRV_EMUX_IOCTL_MISC_MODE;
+#endif
 
 // EOWNERDEAD is not present in some older platforms.
 #if defined(EOWNERDEAD)
   extern const int errno_EOWNERDEAD = EOWNERDEAD;
 #else
   extern const int errno_EOWNERDEAD = -1;
 #endif
 }  // namespace __sanitizer

lib/sanitizer_common/scripts/check_lint.sh

 ASAN_LIT_TEST_LINT_FILTER=${ASAN_TEST_LINT_FILTER},-whitespace/line_length
 TSAN_RTL_LINT_FILTER=${COMMON_LINT_FILTER}
 TSAN_TEST_LINT_FILTER=${TSAN_RTL_LINT_FILTER},-runtime/threadsafe_fn,-runtime/int
 TSAN_LIT_TEST_LINT_FILTER=${TSAN_TEST_LINT_FILTER},-whitespace/line_length
 MSAN_RTL_LINT_FILTER=${COMMON_LINT_FILTER}
 LSAN_RTL_LINT_FILTER=${COMMON_LINT_FILTER}
 LSAN_LIT_TEST_LINT_FILTER=${LSAN_RTL_LINT_FILTER},-whitespace/line_length
 DFSAN_RTL_LINT_FILTER=${COMMON_LINT_FILTER},-runtime/int,-runtime/printf,-runtime/references
-COMMON_RTL_INC_LINT_FILTER=${COMMON_LINT_FILTER},-runtime/int,-runtime/sizeof,-runtime/printf
+COMMON_RTL_INC_LINT_FILTER=${COMMON_LINT_FILTER},-runtime/int,-runtime/sizeof,-runtime/printf,-readability/fn_size
 SANITIZER_INCLUDES_LINT_FILTER=${COMMON_LINT_FILTER},-runtime/int
 MKTEMP="mktemp -q /tmp/tmp.XXXXXXXXXX"
 cd ${LLVM_CHECKOUT}
 
 EXITSTATUS=0
 ERROR_LOG=$(${MKTEMP})
 
 run_lint() {