contrib/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors_ioctl.inc

   1 //===-- sanitizer_common_interceptors_ioctl.inc -----------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Ioctl handling in common sanitizer interceptors.
  10 //===----------------------------------------------------------------------===//
  11
  12 #if !SANITIZER_NETBSD
  13
  14 #include "sanitizer_flags.h"
  15
  16 struct ioctl_desc {
  17   unsigned req;
  18   // FIXME: support read+write arguments. Currently READWRITE and WRITE do the
  19   // same thing.
  20   // XXX: The declarations below may use WRITE instead of READWRITE, unless
  21   // explicitly noted.
  22   enum {
  23     NONE,
  24     READ,
  25     WRITE,
  26     READWRITE,
  27     CUSTOM
  28   } type : 3;
  29   unsigned size : 29;
  30   const char* name;
  31 };
  32
  33 const unsigned ioctl_table_max = 500;
  34 static ioctl_desc ioctl_table[ioctl_table_max];
  35 static unsigned ioctl_table_size = 0;
  36
  37 // This can not be declared as a global, because references to struct_*_sz
  38 // require a global initializer. And this table must be available before global
  39 // initializers are run.
  40 static void ioctl_table_fill() {
  41 #define _(rq, tp, sz)                                    \
  42   if (IOCTL_##rq != IOCTL_NOT_PRESENT) {                 \
  43     CHECK(ioctl_table_size < ioctl_table_max);           \
  44     ioctl_table[ioctl_table_size].req = IOCTL_##rq;      \
  45     ioctl_table[ioctl_table_size].type = ioctl_desc::tp; \
  46     ioctl_table[ioctl_table_size].size = sz;             \
  47     ioctl_table[ioctl_table_size].name = #rq;            \
  48     ++ioctl_table_size;                                  \
  49   }
  50
  51   _(FIOASYNC, READ, sizeof(int));
  52   _(FIOCLEX, NONE, 0);
  53   _(FIOGETOWN, WRITE, sizeof(int));
  54   _(FIONBIO, READ, sizeof(int));
  55   _(FIONCLEX, NONE, 0);
  56   _(FIOSETOWN, READ, sizeof(int));
  57   _(SIOCATMARK, WRITE, sizeof(int));
  58   _(SIOCGIFCONF, CUSTOM, 0);
  59   _(SIOCGPGRP, WRITE, sizeof(int));
  60   _(SIOCSPGRP, READ, sizeof(int));
  61 #if !SANITIZER_SOLARIS
  62   _(TIOCCONS, NONE, 0);
  63 #endif
  64   _(TIOCEXCL, NONE, 0);
  65   _(TIOCGETD, WRITE, sizeof(int));
  66   _(TIOCGPGRP, WRITE, pid_t_sz);
  67   _(TIOCGWINSZ, WRITE, struct_winsize_sz);
  68   _(TIOCMBIC, READ, sizeof(int));
  69   _(TIOCMBIS, READ, sizeof(int));
  70   _(TIOCMGET, WRITE, sizeof(int));
  71   _(TIOCMSET, READ, sizeof(int));
  72   _(TIOCNOTTY, NONE, 0);
  73   _(TIOCNXCL, NONE, 0);
  74   _(TIOCOUTQ, WRITE, sizeof(int));
  75   _(TIOCPKT, READ, sizeof(int));
  76   _(TIOCSCTTY, NONE, 0);
  77   _(TIOCSETD, READ, sizeof(int));
  78   _(TIOCSPGRP, READ, pid_t_sz);
  79   _(TIOCSTI, READ, sizeof(char));
  80   _(TIOCSWINSZ, READ, struct_winsize_sz);
  81
  82 #if !SANITIZER_IOS
  83   _(SIOCADDMULTI, READ, struct_ifreq_sz);
  84   _(SIOCDELMULTI, READ, struct_ifreq_sz);
  85   _(SIOCGIFADDR, WRITE, struct_ifreq_sz);
  86   _(SIOCGIFBRDADDR, WRITE, struct_ifreq_sz);
  87   _(SIOCGIFDSTADDR, WRITE, struct_ifreq_sz);
  88   _(SIOCGIFFLAGS, WRITE, struct_ifreq_sz);
  89   _(SIOCGIFMETRIC, WRITE, struct_ifreq_sz);
  90   _(SIOCGIFMTU, WRITE, struct_ifreq_sz);
  91   _(SIOCGIFNETMASK, WRITE, struct_ifreq_sz);
  92   _(SIOCSIFADDR, READ, struct_ifreq_sz);
  93   _(SIOCSIFBRDADDR, READ, struct_ifreq_sz);
  94   _(SIOCSIFDSTADDR, READ, struct_ifreq_sz);
  95   _(SIOCSIFFLAGS, READ, struct_ifreq_sz);
  96   _(SIOCSIFMETRIC, READ, struct_ifreq_sz);
  97   _(SIOCSIFMTU, READ, struct_ifreq_sz);
  98   _(SIOCSIFNETMASK, READ, struct_ifreq_sz);
  99 #endif
 100
 101 #if (SANITIZER_LINUX && !SANITIZER_ANDROID)
 102   _(SIOCGETSGCNT, WRITE, struct_sioc_sg_req_sz);
 103   _(SIOCGETVIFCNT, WRITE, struct_sioc_vif_req_sz);
 104 #endif
 105
 106 #if SANITIZER_LINUX
 107   // Conflicting request ids.
 108   // _(CDROMAUDIOBUFSIZ, NONE, 0);
 109   // _(SNDCTL_TMR_CONTINUE, NONE, 0);
 110   // _(SNDCTL_TMR_START, NONE, 0);
 111   // _(SNDCTL_TMR_STOP, NONE, 0);
 112   // _(SOUND_MIXER_READ_LOUD, WRITE, sizeof(int)); // same as ...READ_ENHANCE
 113   // _(SOUND_MIXER_READ_MUTE, WRITE, sizeof(int)); // same as ...READ_ENHANCE
 114   // _(SOUND_MIXER_WRITE_LOUD, WRITE, sizeof(int)); // same as ...WRITE_ENHANCE
 115   // _(SOUND_MIXER_WRITE_MUTE, WRITE, sizeof(int)); // same as ...WRITE_ENHANCE
 116   _(BLKFLSBUF, NONE, 0);
 117   _(BLKGETSIZE, WRITE, sizeof(uptr));
 118   _(BLKRAGET, WRITE, sizeof(int));
 119   _(BLKRASET, NONE, 0);
 120   _(BLKROGET, WRITE, sizeof(int));
 121   _(BLKROSET, READ, sizeof(int));
 122   _(BLKRRPART, NONE, 0);
 123   _(CDROMEJECT, NONE, 0);
 124   _(CDROMEJECT_SW, NONE, 0);
 125   _(CDROMMULTISESSION, WRITE, struct_cdrom_multisession_sz);
 126   _(CDROMPAUSE, NONE, 0);
 127   _(CDROMPLAYMSF, READ, struct_cdrom_msf_sz);
 128   _(CDROMPLAYTRKIND, READ, struct_cdrom_ti_sz);
 129   _(CDROMREADAUDIO, READ, struct_cdrom_read_audio_sz);
 130   _(CDROMREADCOOKED, READ, struct_cdrom_msf_sz);
 131   _(CDROMREADMODE1, READ, struct_cdrom_msf_sz);
 132   _(CDROMREADMODE2, READ, struct_cdrom_msf_sz);
 133   _(CDROMREADRAW, READ, struct_cdrom_msf_sz);
 134   _(CDROMREADTOCENTRY, WRITE, struct_cdrom_tocentry_sz);
 135   _(CDROMREADTOCHDR, WRITE, struct_cdrom_tochdr_sz);
 136   _(CDROMRESET, NONE, 0);
 137   _(CDROMRESUME, NONE, 0);
 138   _(CDROMSEEK, READ, struct_cdrom_msf_sz);
 139   _(CDROMSTART, NONE, 0);
 140   _(CDROMSTOP, NONE, 0);
 141   _(CDROMSUBCHNL, WRITE, struct_cdrom_subchnl_sz);
 142   _(CDROMVOLCTRL, READ, struct_cdrom_volctrl_sz);
 143   _(CDROMVOLREAD, WRITE, struct_cdrom_volctrl_sz);
 144   _(CDROM_GET_UPC, WRITE, 8);
 145   _(EVIOCGABS, WRITE, struct_input_absinfo_sz); // fixup
 146   _(EVIOCGBIT, WRITE, struct_input_id_sz); // fixup
 147   _(EVIOCGEFFECTS, WRITE, sizeof(int));
 148   _(EVIOCGID, WRITE, struct_input_id_sz);
 149   _(EVIOCGKEY, WRITE, 0);
 150   _(EVIOCGKEYCODE, WRITE, sizeof(int) * 2);
 151   _(EVIOCGLED, WRITE, 0);
 152   _(EVIOCGNAME, WRITE, 0);
 153   _(EVIOCGPHYS, WRITE, 0);
 154   _(EVIOCGRAB, READ, sizeof(int));
 155   _(EVIOCGREP, WRITE, sizeof(int) * 2);
 156   _(EVIOCGSND, WRITE, 0);
 157   _(EVIOCGSW, WRITE, 0);
 158   _(EVIOCGUNIQ, WRITE, 0);
 159   _(EVIOCGVERSION, WRITE, sizeof(int));
 160   _(EVIOCRMFF, READ, sizeof(int));
 161   _(EVIOCSABS, READ, struct_input_absinfo_sz); // fixup
 162   _(EVIOCSFF, READ, struct_ff_effect_sz);
 163   _(EVIOCSKEYCODE, READ, sizeof(int) * 2);
 164   _(EVIOCSREP, READ, sizeof(int) * 2);
 165   _(FDCLRPRM, NONE, 0);
 166   _(FDDEFPRM, READ, struct_floppy_struct_sz);
 167   _(FDFLUSH, NONE, 0);
 168   _(FDFMTBEG, NONE, 0);
 169   _(FDFMTEND, NONE, 0);
 170   _(FDFMTTRK, READ, struct_format_descr_sz);
 171   _(FDGETDRVPRM, WRITE, struct_floppy_drive_params_sz);
 172   _(FDGETDRVSTAT, WRITE, struct_floppy_drive_struct_sz);
 173   _(FDGETDRVTYP, WRITE, 16);
 174   _(FDGETFDCSTAT, WRITE, struct_floppy_fdc_state_sz);
 175   _(FDGETMAXERRS, WRITE, struct_floppy_max_errors_sz);
 176   _(FDGETPRM, WRITE, struct_floppy_struct_sz);
 177   _(FDMSGOFF, NONE, 0);
 178   _(FDMSGON, NONE, 0);
 179   _(FDPOLLDRVSTAT, WRITE, struct_floppy_drive_struct_sz);
 180   _(FDRAWCMD, WRITE, struct_floppy_raw_cmd_sz);
 181   _(FDRESET, NONE, 0);
 182   _(FDSETDRVPRM, READ, struct_floppy_drive_params_sz);
 183   _(FDSETEMSGTRESH, NONE, 0);
 184   _(FDSETMAXERRS, READ, struct_floppy_max_errors_sz);
 185   _(FDSETPRM, READ, struct_floppy_struct_sz);
 186   _(FDTWADDLE, NONE, 0);
 187   _(FDWERRORCLR, NONE, 0);
 188   _(FDWERRORGET, WRITE, struct_floppy_write_errors_sz);
 189   _(HDIO_DRIVE_CMD, WRITE, sizeof(int));
 190   _(HDIO_GETGEO, WRITE, struct_hd_geometry_sz);
 191   _(HDIO_GET_32BIT, WRITE, sizeof(int));
 192   _(HDIO_GET_DMA, WRITE, sizeof(int));
 193   _(HDIO_GET_IDENTITY, WRITE, struct_hd_driveid_sz);
 194   _(HDIO_GET_KEEPSETTINGS, WRITE, sizeof(int));
 195   _(HDIO_GET_MULTCOUNT, WRITE, sizeof(int));
 196   _(HDIO_GET_NOWERR, WRITE, sizeof(int));
 197   _(HDIO_GET_UNMASKINTR, WRITE, sizeof(int));
 198   _(HDIO_SET_32BIT, NONE, 0);
 199   _(HDIO_SET_DMA, NONE, 0);
 200   _(HDIO_SET_KEEPSETTINGS, NONE, 0);
 201   _(HDIO_SET_MULTCOUNT, NONE, 0);
 202   _(HDIO_SET_NOWERR, NONE, 0);
 203   _(HDIO_SET_UNMASKINTR, NONE, 0);
 204   _(MTIOCGET, WRITE, struct_mtget_sz);
 205   _(MTIOCPOS, WRITE, struct_mtpos_sz);
 206   _(MTIOCTOP, READ, struct_mtop_sz);
 207   _(PPPIOCGASYNCMAP, WRITE, sizeof(int));
 208   _(PPPIOCGDEBUG, WRITE, sizeof(int));
 209   _(PPPIOCGFLAGS, WRITE, sizeof(int));
 210   _(PPPIOCGUNIT, WRITE, sizeof(int));
 211   _(PPPIOCGXASYNCMAP, WRITE, sizeof(int) * 8);
 212   _(PPPIOCSASYNCMAP, READ, sizeof(int));
 213   _(PPPIOCSDEBUG, READ, sizeof(int));
 214   _(PPPIOCSFLAGS, READ, sizeof(int));
 215   _(PPPIOCSMAXCID, READ, sizeof(int));
 216   _(PPPIOCSMRU, READ, sizeof(int));
 217   _(PPPIOCSXASYNCMAP, READ, sizeof(int) * 8);
 218   _(SIOCADDRT, READ, struct_rtentry_sz);
 219   _(SIOCDARP, READ, struct_arpreq_sz);
 220   _(SIOCDELRT, READ, struct_rtentry_sz);
 221   _(SIOCDRARP, READ, struct_arpreq_sz);
 222   _(SIOCGARP, WRITE, struct_arpreq_sz);
 223   _(SIOCGIFENCAP, WRITE, sizeof(int));
 224   _(SIOCGIFHWADDR, WRITE, struct_ifreq_sz);
 225   _(SIOCGIFMAP, WRITE, struct_ifreq_sz);
 226   _(SIOCGIFMEM, WRITE, struct_ifreq_sz);
 227   _(SIOCGIFNAME, NONE, 0);
 228   _(SIOCGIFSLAVE, NONE, 0);
 229   _(SIOCGRARP, WRITE, struct_arpreq_sz);
 230   _(SIOCGSTAMP, WRITE, timeval_sz);
 231   _(SIOCSARP, READ, struct_arpreq_sz);
 232   _(SIOCSIFENCAP, READ, sizeof(int));
 233   _(SIOCSIFHWADDR, READ, struct_ifreq_sz);
 234   _(SIOCSIFLINK, NONE, 0);
 235   _(SIOCSIFMAP, READ, struct_ifreq_sz);
 236   _(SIOCSIFMEM, READ, struct_ifreq_sz);
 237   _(SIOCSIFSLAVE, NONE, 0);
 238   _(SIOCSRARP, READ, struct_arpreq_sz);
 239   _(SNDCTL_COPR_HALT, WRITE, struct_copr_debug_buf_sz);
 240   _(SNDCTL_COPR_LOAD, READ, struct_copr_buffer_sz);
 241   _(SNDCTL_COPR_RCODE, WRITE, struct_copr_debug_buf_sz);
 242   _(SNDCTL_COPR_RCVMSG, WRITE, struct_copr_msg_sz);
 243   _(SNDCTL_COPR_RDATA, WRITE, struct_copr_debug_buf_sz);
 244   _(SNDCTL_COPR_RESET, NONE, 0);
 245   _(SNDCTL_COPR_RUN, WRITE, struct_copr_debug_buf_sz);
 246   _(SNDCTL_COPR_SENDMSG, READ, struct_copr_msg_sz);
 247   _(SNDCTL_COPR_WCODE, READ, struct_copr_debug_buf_sz);
 248   _(SNDCTL_COPR_WDATA, READ, struct_copr_debug_buf_sz);
 249   _(SNDCTL_DSP_GETBLKSIZE, WRITE, sizeof(int));
 250   _(SNDCTL_DSP_GETFMTS, WRITE, sizeof(int));
 251   _(SNDCTL_DSP_NONBLOCK, NONE, 0);
 252   _(SNDCTL_DSP_POST, NONE, 0);
 253   _(SNDCTL_DSP_RESET, NONE, 0);
 254   _(SNDCTL_DSP_SETFMT, WRITE, sizeof(int));
 255   _(SNDCTL_DSP_SETFRAGMENT, WRITE, sizeof(int));
 256   _(SNDCTL_DSP_SPEED, WRITE, sizeof(int));
 257   _(SNDCTL_DSP_STEREO, WRITE, sizeof(int));
 258   _(SNDCTL_DSP_SUBDIVIDE, WRITE, sizeof(int));
 259   _(SNDCTL_DSP_SYNC, NONE, 0);
 260   _(SNDCTL_FM_4OP_ENABLE, READ, sizeof(int));
 261   _(SNDCTL_FM_LOAD_INSTR, READ, struct_sbi_instrument_sz);
 262   _(SNDCTL_MIDI_INFO, WRITE, struct_midi_info_sz);
 263   _(SNDCTL_MIDI_PRETIME, WRITE, sizeof(int));
 264   _(SNDCTL_SEQ_CTRLRATE, WRITE, sizeof(int));
 265   _(SNDCTL_SEQ_GETINCOUNT, WRITE, sizeof(int));
 266   _(SNDCTL_SEQ_GETOUTCOUNT, WRITE, sizeof(int));
 267   _(SNDCTL_SEQ_NRMIDIS, WRITE, sizeof(int));
 268   _(SNDCTL_SEQ_NRSYNTHS, WRITE, sizeof(int));
 269   _(SNDCTL_SEQ_OUTOFBAND, READ, struct_seq_event_rec_sz);
 270   _(SNDCTL_SEQ_PANIC, NONE, 0);
 271   _(SNDCTL_SEQ_PERCMODE, NONE, 0);
 272   _(SNDCTL_SEQ_RESET, NONE, 0);
 273   _(SNDCTL_SEQ_RESETSAMPLES, READ, sizeof(int));
 274   _(SNDCTL_SEQ_SYNC, NONE, 0);
 275   _(SNDCTL_SEQ_TESTMIDI, READ, sizeof(int));
 276   _(SNDCTL_SEQ_THRESHOLD, READ, sizeof(int));
 277   _(SNDCTL_SYNTH_INFO, WRITE, struct_synth_info_sz);
 278   _(SNDCTL_SYNTH_MEMAVL, WRITE, sizeof(int));
 279   _(SNDCTL_TMR_METRONOME, READ, sizeof(int));
 280   _(SNDCTL_TMR_SELECT, WRITE, sizeof(int));
 281   _(SNDCTL_TMR_SOURCE, WRITE, sizeof(int));
 282   _(SNDCTL_TMR_TEMPO, WRITE, sizeof(int));
 283   _(SNDCTL_TMR_TIMEBASE, WRITE, sizeof(int));
 284   _(SOUND_MIXER_READ_ALTPCM, WRITE, sizeof(int));
 285   _(SOUND_MIXER_READ_BASS, WRITE, sizeof(int));
 286   _(SOUND_MIXER_READ_CAPS, WRITE, sizeof(int));
 287   _(SOUND_MIXER_READ_CD, WRITE, sizeof(int));
 288   _(SOUND_MIXER_READ_DEVMASK, WRITE, sizeof(int));
 289   _(SOUND_MIXER_READ_ENHANCE, WRITE, sizeof(int));
 290   _(SOUND_MIXER_READ_IGAIN, WRITE, sizeof(int));
 291   _(SOUND_MIXER_READ_IMIX, WRITE, sizeof(int));
 292   _(SOUND_MIXER_READ_LINE, WRITE, sizeof(int));
 293   _(SOUND_MIXER_READ_LINE1, WRITE, sizeof(int));
 294   _(SOUND_MIXER_READ_LINE2, WRITE, sizeof(int));
 295   _(SOUND_MIXER_READ_LINE3, WRITE, sizeof(int));
 296   _(SOUND_MIXER_READ_MIC, WRITE, sizeof(int));
 297   _(SOUND_MIXER_READ_OGAIN, WRITE, sizeof(int));
 298   _(SOUND_MIXER_READ_PCM, WRITE, sizeof(int));
 299   _(SOUND_MIXER_READ_RECLEV, WRITE, sizeof(int));
 300   _(SOUND_MIXER_READ_RECMASK, WRITE, sizeof(int));
 301   _(SOUND_MIXER_READ_RECSRC, WRITE, sizeof(int));
 302   _(SOUND_MIXER_READ_SPEAKER, WRITE, sizeof(int));
 303   _(SOUND_MIXER_READ_STEREODEVS, WRITE, sizeof(int));
 304   _(SOUND_MIXER_READ_SYNTH, WRITE, sizeof(int));
 305   _(SOUND_MIXER_READ_TREBLE, WRITE, sizeof(int));
 306   _(SOUND_MIXER_READ_VOLUME, WRITE, sizeof(int));
 307   _(SOUND_MIXER_WRITE_ALTPCM, WRITE, sizeof(int));
 308   _(SOUND_MIXER_WRITE_BASS, WRITE, sizeof(int));
 309   _(SOUND_MIXER_WRITE_CD, WRITE, sizeof(int));
 310   _(SOUND_MIXER_WRITE_ENHANCE, WRITE, sizeof(int));
 311   _(SOUND_MIXER_WRITE_IGAIN, WRITE, sizeof(int));
 312   _(SOUND_MIXER_WRITE_IMIX, WRITE, sizeof(int));
 313   _(SOUND_MIXER_WRITE_LINE, WRITE, sizeof(int));
 314   _(SOUND_MIXER_WRITE_LINE1, WRITE, sizeof(int));
 315   _(SOUND_MIXER_WRITE_LINE2, WRITE, sizeof(int));
 316   _(SOUND_MIXER_WRITE_LINE3, WRITE, sizeof(int));
 317   _(SOUND_MIXER_WRITE_MIC, WRITE, sizeof(int));
 318   _(SOUND_MIXER_WRITE_OGAIN, WRITE, sizeof(int));
 319   _(SOUND_MIXER_WRITE_PCM, WRITE, sizeof(int));
 320   _(SOUND_MIXER_WRITE_RECLEV, WRITE, sizeof(int));
 321   _(SOUND_MIXER_WRITE_RECSRC, WRITE, sizeof(int));
 322   _(SOUND_MIXER_WRITE_SPEAKER, WRITE, sizeof(int));
 323   _(SOUND_MIXER_WRITE_SYNTH, WRITE, sizeof(int));
 324   _(SOUND_MIXER_WRITE_TREBLE, WRITE, sizeof(int));
 325   _(SOUND_MIXER_WRITE_VOLUME, WRITE, sizeof(int));
 326   _(SOUND_PCM_READ_BITS, WRITE, sizeof(int));
 327   _(SOUND_PCM_READ_CHANNELS, WRITE, sizeof(int));
 328   _(SOUND_PCM_READ_FILTER, WRITE, sizeof(int));
 329   _(SOUND_PCM_READ_RATE, WRITE, sizeof(int));
 330   _(SOUND_PCM_WRITE_CHANNELS, WRITE, sizeof(int));
 331   _(SOUND_PCM_WRITE_FILTER, WRITE, sizeof(int));
 332   _(TCFLSH, NONE, 0);
 333   _(TCGETA, WRITE, struct_termio_sz);
 334   _(TCGETS, WRITE, struct_termios_sz);
 335   _(TCSBRK, NONE, 0);
 336   _(TCSBRKP, NONE, 0);
 337   _(TCSETA, READ, struct_termio_sz);
 338   _(TCSETAF, READ, struct_termio_sz);
 339   _(TCSETAW, READ, struct_termio_sz);
 340   _(TCSETS, READ, struct_termios_sz);
 341   _(TCSETSF, READ, struct_termios_sz);
 342   _(TCSETSW, READ, struct_termios_sz);
 343   _(TCXONC, NONE, 0);
 344   _(TIOCGLCKTRMIOS, WRITE, struct_termios_sz);
 345   _(TIOCGSOFTCAR, WRITE, sizeof(int));
 346   _(TIOCINQ, WRITE, sizeof(int));
 347   _(TIOCLINUX, READ, sizeof(char));
 348   _(TIOCSERCONFIG, NONE, 0);
 349   _(TIOCSERGETLSR, WRITE, sizeof(int));
 350   _(TIOCSERGWILD, WRITE, sizeof(int));
 351   _(TIOCSERSWILD, READ, sizeof(int));
 352   _(TIOCSLCKTRMIOS, READ, struct_termios_sz);
 353   _(TIOCSSOFTCAR, READ, sizeof(int));
 354   _(VT_ACTIVATE, NONE, 0);
 355   _(VT_DISALLOCATE, NONE, 0);
 356   _(VT_GETMODE, WRITE, struct_vt_mode_sz);
 357   _(VT_GETSTATE, WRITE, struct_vt_stat_sz);
 358   _(VT_OPENQRY, WRITE, sizeof(int));
 359   _(VT_RELDISP, NONE, 0);
 360   _(VT_RESIZE, READ, struct_vt_sizes_sz);
 361   _(VT_RESIZEX, READ, struct_vt_consize_sz);
 362   _(VT_SENDSIG, NONE, 0);
 363   _(VT_SETMODE, READ, struct_vt_mode_sz);
 364   _(VT_WAITACTIVE, NONE, 0);
 365 #endif
 366
 367 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 368   // _(SIOCDEVPLIP, WRITE, struct_ifreq_sz); // the same as EQL_ENSLAVE
 369   _(CYGETDEFTHRESH, WRITE, sizeof(int));
 370   _(CYGETDEFTIMEOUT, WRITE, sizeof(int));
 371   _(CYGETMON, WRITE, struct_cyclades_monitor_sz);
 372   _(CYGETTHRESH, WRITE, sizeof(int));
 373   _(CYGETTIMEOUT, WRITE, sizeof(int));
 374   _(CYSETDEFTHRESH, NONE, 0);
 375   _(CYSETDEFTIMEOUT, NONE, 0);
 376   _(CYSETTHRESH, NONE, 0);
 377   _(CYSETTIMEOUT, NONE, 0);
 378   _(EQL_EMANCIPATE, WRITE, struct_ifreq_sz);
 379   _(EQL_ENSLAVE, WRITE, struct_ifreq_sz);
 380   _(EQL_GETMASTRCFG, WRITE, struct_ifreq_sz);
 381   _(EQL_GETSLAVECFG, WRITE, struct_ifreq_sz);
 382   _(EQL_SETMASTRCFG, WRITE, struct_ifreq_sz);
 383   _(EQL_SETSLAVECFG, WRITE, struct_ifreq_sz);
 384   _(EVIOCGKEYCODE_V2, WRITE, struct_input_keymap_entry_sz);
 385   _(EVIOCGPROP, WRITE, 0);
 386   _(EVIOCSKEYCODE_V2, READ, struct_input_keymap_entry_sz);
 387   _(FS_IOC_GETFLAGS, WRITE, sizeof(int));
 388   _(FS_IOC_GETVERSION, WRITE, sizeof(int));
 389   _(FS_IOC_SETFLAGS, READ, sizeof(int));
 390   _(FS_IOC_SETVERSION, READ, sizeof(int));
 391   _(GIO_CMAP, WRITE, 48);
 392   _(GIO_FONT, WRITE, 8192);
 393   _(GIO_SCRNMAP, WRITE, e_tabsz);
 394   _(GIO_UNIMAP, WRITE, struct_unimapdesc_sz);
 395   _(GIO_UNISCRNMAP, WRITE, sizeof(short) * e_tabsz);
 396   _(KDADDIO, NONE, 0);
 397   _(KDDELIO, NONE, 0);
 398   _(KDDISABIO, NONE, 0);
 399   _(KDENABIO, NONE, 0);
 400   _(KDGETKEYCODE, WRITE, struct_kbkeycode_sz);
 401   _(KDGETLED, WRITE, 1);
 402   _(KDGETMODE, WRITE, sizeof(int));
 403   _(KDGKBDIACR, WRITE, struct_kbdiacrs_sz);
 404   _(KDGKBENT, WRITE, struct_kbentry_sz);
 405   _(KDGKBLED, WRITE, sizeof(int));
 406   _(KDGKBMETA, WRITE, sizeof(int));
 407   _(KDGKBMODE, WRITE, sizeof(int));
 408   _(KDGKBSENT, WRITE, struct_kbsentry_sz);
 409   _(KDGKBTYPE, WRITE, 1);
 410   _(KDMAPDISP, NONE, 0);
 411   _(KDMKTONE, NONE, 0);
 412   _(KDSETKEYCODE, READ, struct_kbkeycode_sz);
 413   _(KDSETLED, NONE, 0);
 414   _(KDSETMODE, NONE, 0);
 415   _(KDSIGACCEPT, NONE, 0);
 416   _(KDSKBDIACR, READ, struct_kbdiacrs_sz);
 417   _(KDSKBENT, READ, struct_kbentry_sz);
 418   _(KDSKBLED, NONE, 0);
 419   _(KDSKBMETA, NONE, 0);
 420   _(KDSKBMODE, NONE, 0);
 421   _(KDSKBSENT, READ, struct_kbsentry_sz);
 422   _(KDUNMAPDISP, NONE, 0);
 423   _(KIOCSOUND, NONE, 0);
 424   _(LPABORT, NONE, 0);
 425   _(LPABORTOPEN, NONE, 0);
 426   _(LPCAREFUL, NONE, 0);
 427   _(LPCHAR, NONE, 0);
 428   _(LPGETIRQ, WRITE, sizeof(int));
 429   _(LPGETSTATUS, WRITE, sizeof(int));
 430   _(LPRESET, NONE, 0);
 431   _(LPSETIRQ, NONE, 0);
 432   _(LPTIME, NONE, 0);
 433   _(LPWAIT, NONE, 0);
 434   _(MTIOCGETCONFIG, WRITE, struct_mtconfiginfo_sz);
 435   _(MTIOCSETCONFIG, READ, struct_mtconfiginfo_sz);
 436   _(PIO_CMAP, NONE, 0);
 437   _(PIO_FONT, READ, 8192);
 438   _(PIO_SCRNMAP, READ, e_tabsz);
 439   _(PIO_UNIMAP, READ, struct_unimapdesc_sz);
 440   _(PIO_UNIMAPCLR, READ, struct_unimapinit_sz);
 441   _(PIO_UNISCRNMAP, READ, sizeof(short) * e_tabsz);
 442   _(SCSI_IOCTL_PROBE_HOST, READ, sizeof(int));
 443   _(SCSI_IOCTL_TAGGED_DISABLE, NONE, 0);
 444   _(SCSI_IOCTL_TAGGED_ENABLE, NONE, 0);
 445   _(SNDCTL_DSP_GETISPACE, WRITE, struct_audio_buf_info_sz);
 446   _(SNDCTL_DSP_GETOSPACE, WRITE, struct_audio_buf_info_sz);
 447   _(TIOCGSERIAL, WRITE, struct_serial_struct_sz);
 448   _(TIOCSERGETMULTI, WRITE, struct_serial_multiport_struct_sz);
 449   _(TIOCSERSETMULTI, READ, struct_serial_multiport_struct_sz);
 450   _(TIOCSSERIAL, READ, struct_serial_struct_sz);
 451
 452   // The following ioctl requests are shared between AX25, IPX, netrom and
 453   // mrouted.
 454   // _(SIOCAIPXITFCRT, READ, sizeof(char));
 455   // _(SIOCAX25GETUID, READ, struct_sockaddr_ax25_sz);
 456   // _(SIOCNRGETPARMS, WRITE, struct_nr_parms_struct_sz);
 457   // _(SIOCAIPXPRISLT, READ, sizeof(char));
 458   // _(SIOCNRSETPARMS, READ, struct_nr_parms_struct_sz);
 459   // _(SIOCAX25ADDUID, READ, struct_sockaddr_ax25_sz);
 460   // _(SIOCNRDECOBS, NONE, 0);
 461   // _(SIOCAX25DELUID, READ, struct_sockaddr_ax25_sz);
 462   // _(SIOCIPXCFGDATA, WRITE, struct_ipx_config_data_sz);
 463   // _(SIOCAX25NOUID, READ, sizeof(int));
 464   // _(SIOCNRRTCTL, READ, sizeof(int));
 465   // _(SIOCAX25DIGCTL, READ, sizeof(int));
 466   // _(SIOCAX25GETPARMS, WRITE, struct_ax25_parms_struct_sz);
 467   // _(SIOCAX25SETPARMS, READ, struct_ax25_parms_struct_sz);
 468 #endif
 469 #undef _
 470 }
 471
 472 static bool ioctl_initialized = false;
 473
 474 struct ioctl_desc_compare {
 475   bool operator()(const ioctl_desc& left, const ioctl_desc& right) const {
 476     return left.req < right.req;
 477   }
 478 };
 479
 480 static void ioctl_init() {
 481   ioctl_table_fill();
 482   Sort(ioctl_table, ioctl_table_size, ioctl_desc_compare());
 483
 484   bool bad = false;
 485   for (unsigned i = 0; i < ioctl_table_size - 1; ++i) {
 486     if (ioctl_table[i].req >= ioctl_table[i + 1].req) {
 487       Printf("Duplicate or unsorted ioctl request id %x >= %x (%s vs %s)\n",
 488              ioctl_table[i].req, ioctl_table[i + 1].req, ioctl_table[i].name,
 489              ioctl_table[i + 1].name);
 490       bad = true;
 491     }
 492   }
 493
 494   if (bad) Die();
 495
 496   ioctl_initialized = true;
 497 }
 498
 499 // Handle the most evil ioctls that encode argument value as part of request id.
 500 static unsigned ioctl_request_fixup(unsigned req) {
 501 #if SANITIZER_LINUX
 502   // Strip size and event number.
 503   const unsigned kEviocgbitMask =
 504       (IOC_SIZEMASK << IOC_SIZESHIFT) | EVIOC_EV_MAX;
 505   if ((req & ~kEviocgbitMask) == IOCTL_EVIOCGBIT)
 506     return IOCTL_EVIOCGBIT;
 507   // Strip absolute axis number.
 508   if ((req & ~EVIOC_ABS_MAX) == IOCTL_EVIOCGABS)
 509     return IOCTL_EVIOCGABS;
 510   if ((req & ~EVIOC_ABS_MAX) == IOCTL_EVIOCSABS)
 511     return IOCTL_EVIOCSABS;
 512 #endif
 513   return req;
 514 }
 515
 516 static const ioctl_desc *ioctl_table_lookup(unsigned req) {
 517   int left = 0;
 518   int right = ioctl_table_size;
 519   while (left < right) {
 520     int mid = (left + right) / 2;
 521     if (ioctl_table[mid].req < req)
 522       left = mid + 1;
 523     else
 524       right = mid;
 525   }
 526   if (left == right && ioctl_table[left].req == req)
 527     return ioctl_table + left;
 528   else
 529     return nullptr;
 530 }
 531
 532 static bool ioctl_decode(unsigned req, ioctl_desc *desc) {
 533   CHECK(desc);
 534   desc->req = req;
 535   desc->name = "<DECODED_IOCTL>";
 536   desc->size = IOC_SIZE(req);
 537   // Sanity check.
 538   if (desc->size > 0xFFFF) return false;
 539   unsigned dir = IOC_DIR(req);
 540   switch (dir) {
 541     case IOC_NONE:
 542       desc->type = ioctl_desc::NONE;
 543       break;
 544     case IOC_READ | IOC_WRITE:
 545       desc->type = ioctl_desc::READWRITE;
 546       break;
 547     case IOC_READ:
 548       desc->type = ioctl_desc::WRITE;
 549       break;
 550     case IOC_WRITE:
 551       desc->type = ioctl_desc::READ;
 552       break;
 553     default:
 554       return false;
 555   }
 556   // Size can be 0 iff type is NONE.
 557   if ((desc->type == IOC_NONE) != (desc->size == 0)) return false;
 558   // Sanity check.
 559   if (IOC_TYPE(req) == 0) return false;
 560   return true;
 561 }
 562
 563 static const ioctl_desc *ioctl_lookup(unsigned req) {
 564   req = ioctl_request_fixup(req);
 565   const ioctl_desc *desc = ioctl_table_lookup(req);
 566   if (desc) return desc;
 567
 568   // Try stripping access size from the request id.
 569   desc = ioctl_table_lookup(req & ~(IOC_SIZEMASK << IOC_SIZESHIFT));
 570   // Sanity check: requests that encode access size are either read or write and
 571   // have size of 0 in the table.
 572   if (desc && desc->size == 0 &&
 573       (desc->type == ioctl_desc::READWRITE || desc->type == ioctl_desc::WRITE ||
 574        desc->type == ioctl_desc::READ))
 575     return desc;
 576   return nullptr;
 577 }
 578
 579 static void ioctl_common_pre(void *ctx, const ioctl_desc *desc, int d,
 580                              unsigned request, void *arg) {
 581   if (desc->type == ioctl_desc::READ || desc->type == ioctl_desc::READWRITE) {
 582     unsigned size = desc->size ? desc->size : IOC_SIZE(request);
 583     COMMON_INTERCEPTOR_READ_RANGE(ctx, arg, size);
 584   }
 585   if (desc->type != ioctl_desc::CUSTOM)
 586     return;
 587   if (request == IOCTL_SIOCGIFCONF) {
 588     struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg;
 589     COMMON_INTERCEPTOR_READ_RANGE(ctx, (char*)&ifc->ifc_len,
 590                                   sizeof(ifc->ifc_len));
 591   }
 592 }
 593
 594 static void ioctl_common_post(void *ctx, const ioctl_desc *desc, int res, int d,
 595                               unsigned request, void *arg) {
 596   if (desc->type == ioctl_desc::WRITE || desc->type == ioctl_desc::READWRITE) {
 597     // FIXME: add verbose output
 598     unsigned size = desc->size ? desc->size : IOC_SIZE(request);
 599     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, arg, size);
 600   }
 601   if (desc->type != ioctl_desc::CUSTOM)
 602     return;
 603   if (request == IOCTL_SIOCGIFCONF) {
 604     struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg;
 605     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ifc->ifc_ifcu.ifcu_req, ifc->ifc_len);
 606   }
 607 }
 608
 609 #endif