| 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(uptr)); |
| 119 |
_(BLKRASET, NONE, 0); |
| 120 |
_(BLKROGET, WRITE, sizeof(int)); |
| 121 |
_(BLKROSET, READ, sizeof(int)); |
| 122 |
_(BLKRRPART, NONE, 0); |
| 123 |
_(BLKFRASET, NONE, 0); |
| 124 |
_(BLKFRAGET, WRITE, sizeof(uptr)); |
| 125 |
_(BLKSECTSET, READ, sizeof(short)); |
| 126 |
_(BLKSECTGET, WRITE, sizeof(short)); |
| 127 |
_(BLKSSZGET, WRITE, sizeof(int)); |
| 128 |
_(BLKBSZGET, WRITE, sizeof(int)); |
| 129 |
_(BLKBSZSET, READ, sizeof(uptr)); |
| 130 |
_(BLKGETSIZE64, WRITE, sizeof(u64)); |
| 131 |
_(CDROMEJECT, NONE, 0); |
| 132 |
_(CDROMEJECT_SW, NONE, 0); |
| 133 |
_(CDROMMULTISESSION, WRITE, struct_cdrom_multisession_sz); |
| 134 |
_(CDROMPAUSE, NONE, 0); |
| 135 |
_(CDROMPLAYMSF, READ, struct_cdrom_msf_sz); |
| 136 |
_(CDROMPLAYTRKIND, READ, struct_cdrom_ti_sz); |
| 137 |
_(CDROMREADAUDIO, READ, struct_cdrom_read_audio_sz); |
| 138 |
_(CDROMREADCOOKED, READ, struct_cdrom_msf_sz); |
| 139 |
_(CDROMREADMODE1, READ, struct_cdrom_msf_sz); |
| 140 |
_(CDROMREADMODE2, READ, struct_cdrom_msf_sz); |
| 141 |
_(CDROMREADRAW, READ, struct_cdrom_msf_sz); |
| 142 |
_(CDROMREADTOCENTRY, WRITE, struct_cdrom_tocentry_sz); |
| 143 |
_(CDROMREADTOCHDR, WRITE, struct_cdrom_tochdr_sz); |
| 144 |
_(CDROMRESET, NONE, 0); |
| 145 |
_(CDROMRESUME, NONE, 0); |
| 146 |
_(CDROMSEEK, READ, struct_cdrom_msf_sz); |
| 147 |
_(CDROMSTART, NONE, 0); |
| 148 |
_(CDROMSTOP, NONE, 0); |
| 149 |
_(CDROMSUBCHNL, WRITE, struct_cdrom_subchnl_sz); |
| 150 |
_(CDROMVOLCTRL, READ, struct_cdrom_volctrl_sz); |
| 151 |
_(CDROMVOLREAD, WRITE, struct_cdrom_volctrl_sz); |
| 152 |
_(CDROM_GET_UPC, WRITE, 8); |
| 153 |
_(EVIOCGABS, WRITE, struct_input_absinfo_sz); // fixup |
| 154 |
_(EVIOCGBIT, WRITE, struct_input_id_sz); // fixup |
| 155 |
_(EVIOCGEFFECTS, WRITE, sizeof(int)); |
| 156 |
_(EVIOCGID, WRITE, struct_input_id_sz); |
| 157 |
_(EVIOCGKEY, WRITE, 0); |
| 158 |
_(EVIOCGKEYCODE, WRITE, sizeof(int) * 2); |
| 159 |
_(EVIOCGLED, WRITE, 0); |
| 160 |
_(EVIOCGNAME, WRITE, 0); |
| 161 |
_(EVIOCGPHYS, WRITE, 0); |
| 162 |
_(EVIOCGRAB, READ, sizeof(int)); |
| 163 |
_(EVIOCGREP, WRITE, sizeof(int) * 2); |
| 164 |
_(EVIOCGSND, WRITE, 0); |
| 165 |
_(EVIOCGSW, WRITE, 0); |
| 166 |
_(EVIOCGUNIQ, WRITE, 0); |
| 167 |
_(EVIOCGVERSION, WRITE, sizeof(int)); |
| 168 |
_(EVIOCRMFF, READ, sizeof(int)); |
| 169 |
_(EVIOCSABS, READ, struct_input_absinfo_sz); // fixup |
| 170 |
_(EVIOCSFF, READ, struct_ff_effect_sz); |
| 171 |
_(EVIOCSKEYCODE, READ, sizeof(int) * 2); |
| 172 |
_(EVIOCSREP, READ, sizeof(int) * 2); |
| 173 |
_(FDCLRPRM, NONE, 0); |
| 174 |
_(FDDEFPRM, READ, struct_floppy_struct_sz); |
| 175 |
_(FDFLUSH, NONE, 0); |
| 176 |
_(FDFMTBEG, NONE, 0); |
| 177 |
_(FDFMTEND, NONE, 0); |
| 178 |
_(FDFMTTRK, READ, struct_format_descr_sz); |
| 179 |
_(FDGETDRVPRM, WRITE, struct_floppy_drive_params_sz); |
| 180 |
_(FDGETDRVSTAT, WRITE, struct_floppy_drive_struct_sz); |
| 181 |
_(FDGETDRVTYP, WRITE, 16); |
| 182 |
_(FDGETFDCSTAT, WRITE, struct_floppy_fdc_state_sz); |
| 183 |
_(FDGETMAXERRS, WRITE, struct_floppy_max_errors_sz); |
| 184 |
_(FDGETPRM, WRITE, struct_floppy_struct_sz); |
| 185 |
_(FDMSGOFF, NONE, 0); |
| 186 |
_(FDMSGON, NONE, 0); |
| 187 |
_(FDPOLLDRVSTAT, WRITE, struct_floppy_drive_struct_sz); |
| 188 |
_(FDRAWCMD, WRITE, struct_floppy_raw_cmd_sz); |
| 189 |
_(FDRESET, NONE, 0); |
| 190 |
_(FDSETDRVPRM, READ, struct_floppy_drive_params_sz); |
| 191 |
_(FDSETEMSGTRESH, NONE, 0); |
| 192 |
_(FDSETMAXERRS, READ, struct_floppy_max_errors_sz); |
| 193 |
_(FDSETPRM, READ, struct_floppy_struct_sz); |
| 194 |
_(FDTWADDLE, NONE, 0); |
| 195 |
_(FDWERRORCLR, NONE, 0); |
| 196 |
_(FDWERRORGET, WRITE, struct_floppy_write_errors_sz); |
| 197 |
_(HDIO_DRIVE_CMD, WRITE, sizeof(int)); |
| 198 |
_(HDIO_GETGEO, WRITE, struct_hd_geometry_sz); |
| 199 |
_(HDIO_GET_32BIT, WRITE, sizeof(int)); |
| 200 |
_(HDIO_GET_DMA, WRITE, sizeof(int)); |
| 201 |
_(HDIO_GET_IDENTITY, WRITE, struct_hd_driveid_sz); |
| 202 |
_(HDIO_GET_KEEPSETTINGS, WRITE, sizeof(int)); |
| 203 |
_(HDIO_GET_MULTCOUNT, WRITE, sizeof(int)); |
| 204 |
_(HDIO_GET_NOWERR, WRITE, sizeof(int)); |
| 205 |
_(HDIO_GET_UNMASKINTR, WRITE, sizeof(int)); |
| 206 |
_(HDIO_SET_32BIT, NONE, 0); |
| 207 |
_(HDIO_SET_DMA, NONE, 0); |
| 208 |
_(HDIO_SET_KEEPSETTINGS, NONE, 0); |
| 209 |
_(HDIO_SET_MULTCOUNT, NONE, 0); |
| 210 |
_(HDIO_SET_NOWERR, NONE, 0); |
| 211 |
_(HDIO_SET_UNMASKINTR, NONE, 0); |
| 212 |
_(MTIOCGET, WRITE, struct_mtget_sz); |
| 213 |
_(MTIOCPOS, WRITE, struct_mtpos_sz); |
| 214 |
_(MTIOCTOP, READ, struct_mtop_sz); |
| 215 |
_(PPPIOCGASYNCMAP, WRITE, sizeof(int)); |
| 216 |
_(PPPIOCGDEBUG, WRITE, sizeof(int)); |
| 217 |
_(PPPIOCGFLAGS, WRITE, sizeof(int)); |
| 218 |
_(PPPIOCGUNIT, WRITE, sizeof(int)); |
| 219 |
_(PPPIOCGXASYNCMAP, WRITE, sizeof(int) * 8); |
| 220 |
_(PPPIOCSASYNCMAP, READ, sizeof(int)); |
| 221 |
_(PPPIOCSDEBUG, READ, sizeof(int)); |
| 222 |
_(PPPIOCSFLAGS, READ, sizeof(int)); |
| 223 |
_(PPPIOCSMAXCID, READ, sizeof(int)); |
| 224 |
_(PPPIOCSMRU, READ, sizeof(int)); |
| 225 |
_(PPPIOCSXASYNCMAP, READ, sizeof(int) * 8); |
| 226 |
_(SIOCADDRT, READ, struct_rtentry_sz); |
| 227 |
_(SIOCDARP, READ, struct_arpreq_sz); |
| 228 |
_(SIOCDELRT, READ, struct_rtentry_sz); |
| 229 |
_(SIOCDRARP, READ, struct_arpreq_sz); |
| 230 |
_(SIOCGARP, WRITE, struct_arpreq_sz); |
| 231 |
_(SIOCGIFENCAP, WRITE, sizeof(int)); |
| 232 |
_(SIOCGIFHWADDR, WRITE, struct_ifreq_sz); |
| 233 |
_(SIOCGIFMAP, WRITE, struct_ifreq_sz); |
| 234 |
_(SIOCGIFMEM, WRITE, struct_ifreq_sz); |
| 235 |
_(SIOCGIFNAME, NONE, 0); |
| 236 |
_(SIOCGIFSLAVE, NONE, 0); |
| 237 |
_(SIOCGRARP, WRITE, struct_arpreq_sz); |
| 238 |
_(SIOCGSTAMP, WRITE, timeval_sz); |
| 239 |
_(SIOCSARP, READ, struct_arpreq_sz); |
| 240 |
_(SIOCSIFENCAP, READ, sizeof(int)); |
| 241 |
_(SIOCSIFHWADDR, READ, struct_ifreq_sz); |
| 242 |
_(SIOCSIFLINK, NONE, 0); |
| 243 |
_(SIOCSIFMAP, READ, struct_ifreq_sz); |
| 244 |
_(SIOCSIFMEM, READ, struct_ifreq_sz); |
| 245 |
_(SIOCSIFSLAVE, NONE, 0); |
| 246 |
_(SIOCSRARP, READ, struct_arpreq_sz); |
| 247 |
_(SNDCTL_COPR_HALT, WRITE, struct_copr_debug_buf_sz); |
| 248 |
_(SNDCTL_COPR_LOAD, READ, struct_copr_buffer_sz); |
| 249 |
_(SNDCTL_COPR_RCODE, WRITE, struct_copr_debug_buf_sz); |
| 250 |
_(SNDCTL_COPR_RCVMSG, WRITE, struct_copr_msg_sz); |
| 251 |
_(SNDCTL_COPR_RDATA, WRITE, struct_copr_debug_buf_sz); |
| 252 |
_(SNDCTL_COPR_RESET, NONE, 0); |
| 253 |
_(SNDCTL_COPR_RUN, WRITE, struct_copr_debug_buf_sz); |
| 254 |
_(SNDCTL_COPR_SENDMSG, READ, struct_copr_msg_sz); |
| 255 |
_(SNDCTL_COPR_WCODE, READ, struct_copr_debug_buf_sz); |
| 256 |
_(SNDCTL_COPR_WDATA, READ, struct_copr_debug_buf_sz); |
| 257 |
_(SNDCTL_DSP_GETBLKSIZE, WRITE, sizeof(int)); |
| 258 |
_(SNDCTL_DSP_GETFMTS, WRITE, sizeof(int)); |
| 259 |
_(SNDCTL_DSP_NONBLOCK, NONE, 0); |
| 260 |
_(SNDCTL_DSP_POST, NONE, 0); |
| 261 |
_(SNDCTL_DSP_RESET, NONE, 0); |
| 262 |
_(SNDCTL_DSP_SETFMT, WRITE, sizeof(int)); |
| 263 |
_(SNDCTL_DSP_SETFRAGMENT, WRITE, sizeof(int)); |
| 264 |
_(SNDCTL_DSP_SPEED, WRITE, sizeof(int)); |
| 265 |
_(SNDCTL_DSP_STEREO, WRITE, sizeof(int)); |
| 266 |
_(SNDCTL_DSP_SUBDIVIDE, WRITE, sizeof(int)); |
| 267 |
_(SNDCTL_DSP_SYNC, NONE, 0); |
| 268 |
_(SNDCTL_FM_4OP_ENABLE, READ, sizeof(int)); |
| 269 |
_(SNDCTL_FM_LOAD_INSTR, READ, struct_sbi_instrument_sz); |
| 270 |
_(SNDCTL_MIDI_INFO, WRITE, struct_midi_info_sz); |
| 271 |
_(SNDCTL_MIDI_PRETIME, WRITE, sizeof(int)); |
| 272 |
_(SNDCTL_SEQ_CTRLRATE, WRITE, sizeof(int)); |
| 273 |
_(SNDCTL_SEQ_GETINCOUNT, WRITE, sizeof(int)); |
| 274 |
_(SNDCTL_SEQ_GETOUTCOUNT, WRITE, sizeof(int)); |
| 275 |
_(SNDCTL_SEQ_NRMIDIS, WRITE, sizeof(int)); |
| 276 |
_(SNDCTL_SEQ_NRSYNTHS, WRITE, sizeof(int)); |
| 277 |
_(SNDCTL_SEQ_OUTOFBAND, READ, struct_seq_event_rec_sz); |
| 278 |
_(SNDCTL_SEQ_PANIC, NONE, 0); |
| 279 |
_(SNDCTL_SEQ_PERCMODE, NONE, 0); |
| 280 |
_(SNDCTL_SEQ_RESET, NONE, 0); |
| 281 |
_(SNDCTL_SEQ_RESETSAMPLES, READ, sizeof(int)); |
| 282 |
_(SNDCTL_SEQ_SYNC, NONE, 0); |
| 283 |
_(SNDCTL_SEQ_TESTMIDI, READ, sizeof(int)); |
| 284 |
_(SNDCTL_SEQ_THRESHOLD, READ, sizeof(int)); |
| 285 |
_(SNDCTL_SYNTH_INFO, WRITE, struct_synth_info_sz); |
| 286 |
_(SNDCTL_SYNTH_MEMAVL, WRITE, sizeof(int)); |
| 287 |
_(SNDCTL_TMR_METRONOME, READ, sizeof(int)); |
| 288 |
_(SNDCTL_TMR_SELECT, WRITE, sizeof(int)); |
| 289 |
_(SNDCTL_TMR_SOURCE, WRITE, sizeof(int)); |
| 290 |
_(SNDCTL_TMR_TEMPO, WRITE, sizeof(int)); |
| 291 |
_(SNDCTL_TMR_TIMEBASE, WRITE, sizeof(int)); |
| 292 |
_(SOUND_MIXER_READ_ALTPCM, WRITE, sizeof(int)); |
| 293 |
_(SOUND_MIXER_READ_BASS, WRITE, sizeof(int)); |
| 294 |
_(SOUND_MIXER_READ_CAPS, WRITE, sizeof(int)); |
| 295 |
_(SOUND_MIXER_READ_CD, WRITE, sizeof(int)); |
| 296 |
_(SOUND_MIXER_READ_DEVMASK, WRITE, sizeof(int)); |
| 297 |
_(SOUND_MIXER_READ_ENHANCE, WRITE, sizeof(int)); |
| 298 |
_(SOUND_MIXER_READ_IGAIN, WRITE, sizeof(int)); |
| 299 |
_(SOUND_MIXER_READ_IMIX, WRITE, sizeof(int)); |
| 300 |
_(SOUND_MIXER_READ_LINE, WRITE, sizeof(int)); |
| 301 |
_(SOUND_MIXER_READ_LINE1, WRITE, sizeof(int)); |
| 302 |
_(SOUND_MIXER_READ_LINE2, WRITE, sizeof(int)); |
| 303 |
_(SOUND_MIXER_READ_LINE3, WRITE, sizeof(int)); |
| 304 |
_(SOUND_MIXER_READ_MIC, WRITE, sizeof(int)); |
| 305 |
_(SOUND_MIXER_READ_OGAIN, WRITE, sizeof(int)); |
| 306 |
_(SOUND_MIXER_READ_PCM, WRITE, sizeof(int)); |
| 307 |
_(SOUND_MIXER_READ_RECLEV, WRITE, sizeof(int)); |
| 308 |
_(SOUND_MIXER_READ_RECMASK, WRITE, sizeof(int)); |
| 309 |
_(SOUND_MIXER_READ_RECSRC, WRITE, sizeof(int)); |
| 310 |
_(SOUND_MIXER_READ_SPEAKER, WRITE, sizeof(int)); |
| 311 |
_(SOUND_MIXER_READ_STEREODEVS, WRITE, sizeof(int)); |
| 312 |
_(SOUND_MIXER_READ_SYNTH, WRITE, sizeof(int)); |
| 313 |
_(SOUND_MIXER_READ_TREBLE, WRITE, sizeof(int)); |
| 314 |
_(SOUND_MIXER_READ_VOLUME, WRITE, sizeof(int)); |
| 315 |
_(SOUND_MIXER_WRITE_ALTPCM, WRITE, sizeof(int)); |
| 316 |
_(SOUND_MIXER_WRITE_BASS, WRITE, sizeof(int)); |
| 317 |
_(SOUND_MIXER_WRITE_CD, WRITE, sizeof(int)); |
| 318 |
_(SOUND_MIXER_WRITE_ENHANCE, WRITE, sizeof(int)); |
| 319 |
_(SOUND_MIXER_WRITE_IGAIN, WRITE, sizeof(int)); |
| 320 |
_(SOUND_MIXER_WRITE_IMIX, WRITE, sizeof(int)); |
| 321 |
_(SOUND_MIXER_WRITE_LINE, WRITE, sizeof(int)); |
| 322 |
_(SOUND_MIXER_WRITE_LINE1, WRITE, sizeof(int)); |
| 323 |
_(SOUND_MIXER_WRITE_LINE2, WRITE, sizeof(int)); |
| 324 |
_(SOUND_MIXER_WRITE_LINE3, WRITE, sizeof(int)); |
| 325 |
_(SOUND_MIXER_WRITE_MIC, WRITE, sizeof(int)); |
| 326 |
_(SOUND_MIXER_WRITE_OGAIN, WRITE, sizeof(int)); |
| 327 |
_(SOUND_MIXER_WRITE_PCM, WRITE, sizeof(int)); |
| 328 |
_(SOUND_MIXER_WRITE_RECLEV, WRITE, sizeof(int)); |
| 329 |
_(SOUND_MIXER_WRITE_RECSRC, WRITE, sizeof(int)); |
| 330 |
_(SOUND_MIXER_WRITE_SPEAKER, WRITE, sizeof(int)); |
| 331 |
_(SOUND_MIXER_WRITE_SYNTH, WRITE, sizeof(int)); |
| 332 |
_(SOUND_MIXER_WRITE_TREBLE, WRITE, sizeof(int)); |
| 333 |
_(SOUND_MIXER_WRITE_VOLUME, WRITE, sizeof(int)); |
| 334 |
_(SOUND_PCM_READ_BITS, WRITE, sizeof(int)); |
| 335 |
_(SOUND_PCM_READ_CHANNELS, WRITE, sizeof(int)); |
| 336 |
_(SOUND_PCM_READ_FILTER, WRITE, sizeof(int)); |
| 337 |
_(SOUND_PCM_READ_RATE, WRITE, sizeof(int)); |
| 338 |
_(SOUND_PCM_WRITE_CHANNELS, WRITE, sizeof(int)); |
| 339 |
_(SOUND_PCM_WRITE_FILTER, WRITE, sizeof(int)); |
| 340 |
_(TCFLSH, NONE, 0); |
| 341 |
_(TCGETS, WRITE, struct_termios_sz); |
| 342 |
_(TCSBRK, NONE, 0); |
| 343 |
_(TCSBRKP, NONE, 0); |
| 344 |
_(TCSETS, READ, struct_termios_sz); |
| 345 |
_(TCSETSF, READ, struct_termios_sz); |
| 346 |
_(TCSETSW, READ, struct_termios_sz); |
| 347 |
_(TCXONC, NONE, 0); |
| 348 |
_(TIOCGLCKTRMIOS, WRITE, struct_termios_sz); |
| 349 |
_(TIOCGSOFTCAR, WRITE, sizeof(int)); |
| 350 |
_(TIOCINQ, WRITE, sizeof(int)); |
| 351 |
_(TIOCLINUX, READ, sizeof(char)); |
| 352 |
_(TIOCSERCONFIG, NONE, 0); |
| 353 |
_(TIOCSERGETLSR, WRITE, sizeof(int)); |
| 354 |
_(TIOCSERGWILD, WRITE, sizeof(int)); |
| 355 |
_(TIOCSERSWILD, READ, sizeof(int)); |
| 356 |
_(TIOCSLCKTRMIOS, READ, struct_termios_sz); |
| 357 |
_(TIOCSSOFTCAR, READ, sizeof(int)); |
| 358 |
_(VT_ACTIVATE, NONE, 0); |
| 359 |
_(VT_DISALLOCATE, NONE, 0); |
| 360 |
_(VT_GETMODE, WRITE, struct_vt_mode_sz); |
| 361 |
_(VT_GETSTATE, WRITE, struct_vt_stat_sz); |
| 362 |
_(VT_OPENQRY, WRITE, sizeof(int)); |
| 363 |
_(VT_RELDISP, NONE, 0); |
| 364 |
_(VT_RESIZE, READ, struct_vt_sizes_sz); |
| 365 |
_(VT_RESIZEX, READ, struct_vt_consize_sz); |
| 366 |
_(VT_SENDSIG, NONE, 0); |
| 367 |
_(VT_SETMODE, READ, struct_vt_mode_sz); |
| 368 |
_(VT_WAITACTIVE, NONE, 0); |
| 369 |
#endif |
| 370 |
|
| 371 |
#if SANITIZER_GLIBC |
| 372 |
// _(SIOCDEVPLIP, WRITE, struct_ifreq_sz); // the same as EQL_ENSLAVE |
| 373 |
_(EQL_EMANCIPATE, WRITE, struct_ifreq_sz); |
| 374 |
_(EQL_ENSLAVE, WRITE, struct_ifreq_sz); |
| 375 |
_(EQL_GETMASTRCFG, WRITE, struct_ifreq_sz); |
| 376 |
_(EQL_GETSLAVECFG, WRITE, struct_ifreq_sz); |
| 377 |
_(EQL_SETMASTRCFG, WRITE, struct_ifreq_sz); |
| 378 |
_(EQL_SETSLAVECFG, WRITE, struct_ifreq_sz); |
| 379 |
_(EVIOCGKEYCODE_V2, WRITE, struct_input_keymap_entry_sz); |
| 380 |
_(EVIOCGPROP, WRITE, 0); |
| 381 |
_(EVIOCSKEYCODE_V2, READ, struct_input_keymap_entry_sz); |
| 382 |
_(FS_IOC_GETFLAGS, WRITE, sizeof(int)); |
| 383 |
_(FS_IOC_GETVERSION, WRITE, sizeof(int)); |
| 384 |
_(FS_IOC_SETFLAGS, READ, sizeof(int)); |
| 385 |
_(FS_IOC_SETVERSION, READ, sizeof(int)); |
| 386 |
_(GIO_CMAP, WRITE, 48); |
| 387 |
_(GIO_FONT, WRITE, 8192); |
| 388 |
_(GIO_SCRNMAP, WRITE, e_tabsz); |
| 389 |
_(GIO_UNIMAP, WRITE, struct_unimapdesc_sz); |
| 390 |
_(GIO_UNISCRNMAP, WRITE, sizeof(short) * e_tabsz); |
| 391 |
_(KDADDIO, NONE, 0); |
| 392 |
_(KDDELIO, NONE, 0); |
| 393 |
_(KDDISABIO, NONE, 0); |
| 394 |
_(KDENABIO, NONE, 0); |
| 395 |
_(KDGETKEYCODE, WRITE, struct_kbkeycode_sz); |
| 396 |
_(KDGETLED, WRITE, 1); |
| 397 |
_(KDGETMODE, WRITE, sizeof(int)); |
| 398 |
_(KDGKBDIACR, WRITE, struct_kbdiacrs_sz); |
| 399 |
_(KDGKBENT, WRITE, struct_kbentry_sz); |
| 400 |
_(KDGKBLED, WRITE, sizeof(int)); |
| 401 |
_(KDGKBMETA, WRITE, sizeof(int)); |
| 402 |
_(KDGKBMODE, WRITE, sizeof(int)); |
| 403 |
_(KDGKBSENT, WRITE, struct_kbsentry_sz); |
| 404 |
_(KDGKBTYPE, WRITE, 1); |
| 405 |
_(KDMAPDISP, NONE, 0); |
| 406 |
_(KDMKTONE, NONE, 0); |
| 407 |
_(KDSETKEYCODE, READ, struct_kbkeycode_sz); |
| 408 |
_(KDSETLED, NONE, 0); |
| 409 |
_(KDSETMODE, NONE, 0); |
| 410 |
_(KDSIGACCEPT, NONE, 0); |
| 411 |
_(KDSKBDIACR, READ, struct_kbdiacrs_sz); |
| 412 |
_(KDSKBENT, READ, struct_kbentry_sz); |
| 413 |
_(KDSKBLED, NONE, 0); |
| 414 |
_(KDSKBMETA, NONE, 0); |
| 415 |
_(KDSKBMODE, NONE, 0); |
| 416 |
_(KDSKBSENT, READ, struct_kbsentry_sz); |
| 417 |
_(KDUNMAPDISP, NONE, 0); |
| 418 |
_(KIOCSOUND, NONE, 0); |
| 419 |
_(LPABORT, NONE, 0); |
| 420 |
_(LPABORTOPEN, NONE, 0); |
| 421 |
_(LPCAREFUL, NONE, 0); |
| 422 |
_(LPCHAR, NONE, 0); |
| 423 |
_(LPGETIRQ, WRITE, sizeof(int)); |
| 424 |
_(LPGETSTATUS, WRITE, sizeof(int)); |
| 425 |
_(LPRESET, NONE, 0); |
| 426 |
_(LPSETIRQ, NONE, 0); |
| 427 |
_(LPTIME, NONE, 0); |
| 428 |
_(LPWAIT, NONE, 0); |
| 429 |
_(MTIOCGETCONFIG, WRITE, struct_mtconfiginfo_sz); |
| 430 |
_(MTIOCSETCONFIG, READ, struct_mtconfiginfo_sz); |
| 431 |
_(PIO_CMAP, NONE, 0); |
| 432 |
_(PIO_FONT, READ, 8192); |
| 433 |
_(PIO_SCRNMAP, READ, e_tabsz); |
| 434 |
_(PIO_UNIMAP, READ, struct_unimapdesc_sz); |
| 435 |
_(PIO_UNIMAPCLR, READ, struct_unimapinit_sz); |
| 436 |
_(PIO_UNISCRNMAP, READ, sizeof(short) * e_tabsz); |
| 437 |
_(SCSI_IOCTL_PROBE_HOST, READ, sizeof(int)); |
| 438 |
_(SCSI_IOCTL_TAGGED_DISABLE, NONE, 0); |
| 439 |
_(SCSI_IOCTL_TAGGED_ENABLE, NONE, 0); |
| 440 |
_(SNDCTL_DSP_GETISPACE, WRITE, struct_audio_buf_info_sz); |
| 441 |
_(SNDCTL_DSP_GETOSPACE, WRITE, struct_audio_buf_info_sz); |
| 442 |
_(TIOCGSERIAL, WRITE, struct_serial_struct_sz); |
| 443 |
_(TIOCSERGETMULTI, WRITE, struct_serial_multiport_struct_sz); |
| 444 |
_(TIOCSERSETMULTI, READ, struct_serial_multiport_struct_sz); |
| 445 |
_(TIOCSSERIAL, READ, struct_serial_struct_sz); |
| 446 |
|
| 447 |
// The following ioctl requests are shared between AX25, IPX, netrom and |
| 448 |
// mrouted. |
| 449 |
// _(SIOCAIPXITFCRT, READ, sizeof(char)); |
| 450 |
// _(SIOCAX25GETUID, READ, struct_sockaddr_ax25_sz); |
| 451 |
// _(SIOCNRGETPARMS, WRITE, struct_nr_parms_struct_sz); |
| 452 |
// _(SIOCAIPXPRISLT, READ, sizeof(char)); |
| 453 |
// _(SIOCNRSETPARMS, READ, struct_nr_parms_struct_sz); |
| 454 |
// _(SIOCAX25ADDUID, READ, struct_sockaddr_ax25_sz); |
| 455 |
// _(SIOCNRDECOBS, NONE, 0); |
| 456 |
// _(SIOCAX25DELUID, READ, struct_sockaddr_ax25_sz); |
| 457 |
// _(SIOCIPXCFGDATA, WRITE, struct_ipx_config_data_sz); |
| 458 |
// _(SIOCAX25NOUID, READ, sizeof(int)); |
| 459 |
// _(SIOCNRRTCTL, READ, sizeof(int)); |
| 460 |
// _(SIOCAX25DIGCTL, READ, sizeof(int)); |
| 461 |
// _(SIOCAX25GETPARMS, WRITE, struct_ax25_parms_struct_sz); |
| 462 |
// _(SIOCAX25SETPARMS, READ, struct_ax25_parms_struct_sz); |
| 463 |
#endif |
| 464 |
#undef _ |
| 465 |
} |
| 466 |
|
| 467 |
static bool ioctl_initialized = false; |
| 468 |
|
| 469 |
struct ioctl_desc_compare { |
| 470 |
bool operator()(const ioctl_desc& left, const ioctl_desc& right) const { |
| 471 |
return left.req < right.req; |
| 472 |
} |
| 473 |
}; |
| 474 |
|
| 475 |
static void ioctl_init() { |
| 476 |
ioctl_table_fill(); |
| 477 |
Sort(ioctl_table, ioctl_table_size, ioctl_desc_compare()); |
| 478 |
|
| 479 |
bool bad = false; |
| 480 |
for (unsigned i = 0; i < ioctl_table_size - 1; ++i) { |
| 481 |
if (ioctl_table[i].req >= ioctl_table[i + 1].req) { |
| 482 |
Printf("Duplicate or unsorted ioctl request id %x >= %x (%s vs %s)\n", |
| 483 |
ioctl_table[i].req, ioctl_table[i + 1].req, ioctl_table[i].name, |
| 484 |
ioctl_table[i + 1].name); |
| 485 |
bad = true; |
| 486 |
} |
| 487 |
} |
| 488 |
|
| 489 |
if (bad) Die(); |
| 490 |
|
| 491 |
ioctl_initialized = true; |
| 492 |
} |
| 493 |
|
| 494 |
// Handle the most evil ioctls that encode argument value as part of request id. |
| 495 |
static unsigned ioctl_request_fixup(unsigned req) { |
| 496 |
#if SANITIZER_LINUX |
| 497 |
// Strip size and event number. |
| 498 |
const unsigned kEviocgbitMask = |
| 499 |
(IOC_SIZEMASK << IOC_SIZESHIFT) | EVIOC_EV_MAX; |
| 500 |
if ((req & ~kEviocgbitMask) == IOCTL_EVIOCGBIT) |
| 501 |
return IOCTL_EVIOCGBIT; |
| 502 |
// Strip absolute axis number. |
| 503 |
if ((req & ~EVIOC_ABS_MAX) == IOCTL_EVIOCGABS) |
| 504 |
return IOCTL_EVIOCGABS; |
| 505 |
if ((req & ~EVIOC_ABS_MAX) == IOCTL_EVIOCSABS) |
| 506 |
return IOCTL_EVIOCSABS; |
| 507 |
#endif |
| 508 |
return req; |
| 509 |
} |
| 510 |
|
| 511 |
static const ioctl_desc *ioctl_table_lookup(unsigned req) { |
| 512 |
int left = 0; |
| 513 |
int right = ioctl_table_size; |
| 514 |
while (left < right) { |
| 515 |
int mid = (left + right) / 2; |
| 516 |
if (ioctl_table[mid].req < req) |
| 517 |
left = mid + 1; |
| 518 |
else |
| 519 |
right = mid; |
| 520 |
} |
| 521 |
if (left == right && ioctl_table[left].req == req) |
| 522 |
return ioctl_table + left; |
| 523 |
else |
| 524 |
return nullptr; |
| 525 |
} |
| 526 |
|
| 527 |
static bool ioctl_decode(unsigned req, ioctl_desc *desc) { |
| 528 |
CHECK(desc); |
| 529 |
desc->req = req; |
| 530 |
desc->name = "<DECODED_IOCTL>"; |
| 531 |
desc->size = IOC_SIZE(req); |
| 532 |
// Sanity check. |
| 533 |
if (desc->size > 0xFFFF) return false; |
| 534 |
unsigned dir = IOC_DIR(req); |
| 535 |
switch (dir) { |
| 536 |
case IOC_NONE: |
| 537 |
desc->type = ioctl_desc::NONE; |
| 538 |
break; |
| 539 |
case IOC_READ | IOC_WRITE: |
| 540 |
desc->type = ioctl_desc::READWRITE; |
| 541 |
break; |
| 542 |
case IOC_READ: |
| 543 |
desc->type = ioctl_desc::WRITE; |
| 544 |
break; |
| 545 |
case IOC_WRITE: |
| 546 |
desc->type = ioctl_desc::READ; |
| 547 |
break; |
| 548 |
default: |
| 549 |
return false; |
| 550 |
} |
| 551 |
// Size can be 0 iff type is NONE. |
| 552 |
if ((desc->type == IOC_NONE) != (desc->size == 0)) return false; |
| 553 |
// Sanity check. |
| 554 |
if (IOC_TYPE(req) == 0) return false; |
| 555 |
return true; |
| 556 |
} |
| 557 |
|
| 558 |
static const ioctl_desc *ioctl_lookup(unsigned req) { |
| 559 |
req = ioctl_request_fixup(req); |
| 560 |
const ioctl_desc *desc = ioctl_table_lookup(req); |
| 561 |
if (desc) return desc; |
| 562 |
|
| 563 |
// Try stripping access size from the request id. |
| 564 |
desc = ioctl_table_lookup(req & ~(IOC_SIZEMASK << IOC_SIZESHIFT)); |
| 565 |
// Sanity check: requests that encode access size are either read or write and |
| 566 |
// have size of 0 in the table. |
| 567 |
if (desc && desc->size == 0 && |
| 568 |
(desc->type == ioctl_desc::READWRITE || desc->type == ioctl_desc::WRITE || |
| 569 |
desc->type == ioctl_desc::READ)) |
| 570 |
return desc; |
| 571 |
return nullptr; |
| 572 |
} |
| 573 |
|
| 574 |
static void ioctl_common_pre(void *ctx, const ioctl_desc *desc, int d, |
| 575 |
unsigned request, void *arg) { |
| 576 |
if (desc->type == ioctl_desc::READ || desc->type == ioctl_desc::READWRITE) { |
| 577 |
unsigned size = desc->size ? desc->size : IOC_SIZE(request); |
| 578 |
COMMON_INTERCEPTOR_READ_RANGE(ctx, arg, size); |
| 579 |
} |
| 580 |
if (desc->type != ioctl_desc::CUSTOM) |
| 581 |
return; |
| 582 |
if (request == IOCTL_SIOCGIFCONF) { |
| 583 |
struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg; |
| 584 |
COMMON_INTERCEPTOR_READ_RANGE(ctx, (char*)&ifc->ifc_len, |
| 585 |
sizeof(ifc->ifc_len)); |
| 586 |
} |
| 587 |
} |
| 588 |
|
| 589 |
static void ioctl_common_post(void *ctx, const ioctl_desc *desc, int res, int d, |
| 590 |
unsigned request, void *arg) { |
| 591 |
if (desc->type == ioctl_desc::WRITE || desc->type == ioctl_desc::READWRITE) { |
| 592 |
// FIXME: add verbose output |
| 593 |
unsigned size = desc->size ? desc->size : IOC_SIZE(request); |
| 594 |
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, arg, size); |
| 595 |
} |
| 596 |
if (desc->type != ioctl_desc::CUSTOM) |
| 597 |
return; |
| 598 |
if (request == IOCTL_SIOCGIFCONF) { |
| 599 |
struct __sanitizer_ifconf *ifc = (__sanitizer_ifconf *)arg; |
| 600 |
COMMON_INTERCEPTOR_WRITE_RANGE(ctx, ifc->ifc_ifcu.ifcu_req, ifc->ifc_len); |
| 601 |
} |
| 602 |
} |
| 603 |
|
| 604 |
#endif |