1//===-- sanitizer_platform_limits_posix.h ---------------------------------===//
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// This file is a part of Sanitizer common code.
10//
11// Sizes and layouts of platform-specific POSIX data structures.
12//===----------------------------------------------------------------------===//
13
14#ifndef SANITIZER_PLATFORM_LIMITS_POSIX_H
15#define SANITIZER_PLATFORM_LIMITS_POSIX_H
16
17#if SANITIZER_LINUX || SANITIZER_APPLE || SANITIZER_HAIKU || SANITIZER_AIX
18
19# include "sanitizer_internal_defs.h"
20# include "sanitizer_mallinfo.h"
21# include "sanitizer_platform.h"
22
23# if SANITIZER_APPLE
24# include <sys/cdefs.h>
25# if !__DARWIN_ONLY_64_BIT_INO_T
26# define SANITIZER_HAS_STAT64 1
27# define SANITIZER_HAS_STATFS64 1
28# else
29# define SANITIZER_HAS_STAT64 0
30# define SANITIZER_HAS_STATFS64 0
31# endif
32# elif SANITIZER_GLIBC || SANITIZER_ANDROID || SANITIZER_AIX
33# define SANITIZER_HAS_STAT64 1
34# define SANITIZER_HAS_STATFS64 1
35# elif SANITIZER_HAIKU
36# include <stdint.h>
37# endif
38
39# if defined(__sparc__)
40// FIXME: This can't be included from tsan which does not support sparc yet.
41# include "sanitizer_glibc_version.h"
42# endif
43
44# define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) ((link_map *)(handle))
45
46namespace __sanitizer {
47extern unsigned struct_utsname_sz;
48extern unsigned struct_stat_sz;
49# if SANITIZER_HAS_STAT64
50extern unsigned struct_stat64_sz;
51# endif
52extern unsigned struct_rusage_sz;
53extern unsigned siginfo_t_sz;
54extern unsigned struct_itimerval_sz;
55extern unsigned pthread_t_sz;
56extern unsigned pthread_mutex_t_sz;
57extern unsigned pthread_cond_t_sz;
58extern unsigned pid_t_sz;
59extern unsigned timeval_sz;
60extern unsigned uid_t_sz;
61extern unsigned gid_t_sz;
62extern unsigned mbstate_t_sz;
63extern unsigned struct_timezone_sz;
64extern unsigned struct_tms_sz;
65extern unsigned struct_itimerspec_sz;
66extern unsigned struct_sigevent_sz;
67extern unsigned struct_stack_t_sz;
68extern unsigned struct_sched_param_sz;
69# if SANITIZER_HAS_STATFS64
70extern unsigned struct_statfs64_sz;
71# endif
72extern unsigned struct_regex_sz;
73extern unsigned struct_regmatch_sz;
74
75# if !SANITIZER_ANDROID
76extern unsigned struct_fstab_sz;
77extern unsigned struct_statfs_sz;
78extern unsigned struct_sockaddr_sz;
79unsigned ucontext_t_sz(void *uctx);
80# endif // !SANITIZER_ANDROID
81
82# if SANITIZER_LINUX
83
84# if defined(__x86_64__)
85const unsigned struct_kernel_stat_sz = 144;
86const unsigned struct_kernel_stat64_sz = 0;
87# elif defined(__i386__)
88const unsigned struct_kernel_stat_sz = 64;
89const unsigned struct_kernel_stat64_sz = 96;
90# elif defined(__arm__)
91const unsigned struct_kernel_stat_sz = 64;
92const unsigned struct_kernel_stat64_sz = 104;
93# elif defined(__aarch64__)
94const unsigned struct_kernel_stat_sz = 128;
95const unsigned struct_kernel_stat64_sz = 104;
96# elif defined(__powerpc__) && !defined(__powerpc64__)
97const unsigned struct_kernel_stat_sz = 72;
98const unsigned struct_kernel_stat64_sz = 104;
99# elif defined(__powerpc64__)
100const unsigned struct_kernel_stat_sz = 144;
101const unsigned struct_kernel_stat64_sz = 104;
102# elif defined(__mips__)
103const unsigned struct_kernel_stat_sz = SANITIZER_ANDROID
104 ? FIRST_32_SECOND_64(104, 128)
105# if defined(_ABIN32) && _MIPS_SIM == _ABIN32
106# if defined(_TIME_BITS) && _TIME_BITS == 64
107 : FIRST_32_SECOND_64(112, 216);
108# else
109 : FIRST_32_SECOND_64(176, 216);
110# endif
111# elif SANITIZER_MUSL
112 : FIRST_32_SECOND_64(160, 208);
113# elif defined(_TIME_BITS) && _TIME_BITS == 64
114 : FIRST_32_SECOND_64(112, 216);
115# else
116 : FIRST_32_SECOND_64(160, 216);
117# endif
118const unsigned struct_kernel_stat64_sz = 104;
119# elif defined(__s390__) && !defined(__s390x__)
120const unsigned struct_kernel_stat_sz = 64;
121const unsigned struct_kernel_stat64_sz = 104;
122# elif defined(__s390x__)
123const unsigned struct_kernel_stat_sz = 144;
124const unsigned struct_kernel_stat64_sz = 0;
125# elif defined(__sparc__) && defined(__arch64__)
126const unsigned struct___old_kernel_stat_sz = 0;
127const unsigned struct_kernel_stat_sz = 104;
128const unsigned struct_kernel_stat64_sz = 144;
129# elif defined(__sparc__) && !defined(__arch64__)
130const unsigned struct___old_kernel_stat_sz = 0;
131const unsigned struct_kernel_stat_sz = 64;
132const unsigned struct_kernel_stat64_sz = 104;
133# elif SANITIZER_RISCV64
134const unsigned struct_kernel_stat_sz = 128;
135const unsigned struct_kernel_stat64_sz = 0; // RISCV64 does not use stat64
136# elif defined(__hexagon__)
137const unsigned struct_kernel_stat_sz = 128;
138const unsigned struct_kernel_stat64_sz = 0;
139# elif defined(__loongarch__)
140const unsigned struct_kernel_stat_sz = 128;
141const unsigned struct_kernel_stat64_sz = 0;
142# elif defined(__alpha__)
143const unsigned struct_kernel_stat_sz = 80;
144const unsigned struct_kernel_stat64_sz = 136;
145# endif
146struct __sanitizer_perf_event_attr {
147 unsigned type;
148 unsigned size;
149 // More fields that vary with the kernel version.
150};
151
152extern unsigned struct_epoll_event_sz;
153extern unsigned struct_sysinfo_sz;
154extern unsigned __user_cap_header_struct_sz;
155extern unsigned __user_cap_data_struct_sz(void *hdrp);
156extern unsigned struct_new_utsname_sz;
157extern unsigned struct_old_utsname_sz;
158extern unsigned struct_oldold_utsname_sz;
159
160const unsigned struct_kexec_segment_sz = 4 * sizeof(unsigned long);
161# endif // SANITIZER_LINUX
162
163# if SANITIZER_LINUX
164
165# if defined(__powerpc64__) || defined(__s390__) || defined(__loongarch__)
166const unsigned struct___old_kernel_stat_sz = 0;
167# elif !defined(__sparc__)
168const unsigned struct___old_kernel_stat_sz = 32;
169# endif
170
171extern unsigned struct_rlimit_sz;
172extern unsigned struct_utimbuf_sz;
173extern unsigned struct_timespec_sz;
174
175struct __sanitizer_iocb {
176 u64 aio_data;
177 u32 aio_key_or_aio_reserved1; // Simply crazy.
178 u32 aio_reserved1_or_aio_key; // Luckily, we don't need these.
179 u16 aio_lio_opcode;
180 s16 aio_reqprio;
181 u32 aio_fildes;
182 u64 aio_buf;
183 u64 aio_nbytes;
184 s64 aio_offset;
185 u64 aio_reserved2;
186 u64 aio_reserved3;
187};
188
189struct __sanitizer_io_event {
190 u64 data;
191 u64 obj;
192 u64 res;
193 u64 res2;
194};
195
196const unsigned iocb_cmd_pread = 0;
197const unsigned iocb_cmd_pwrite = 1;
198const unsigned iocb_cmd_preadv = 7;
199const unsigned iocb_cmd_pwritev = 8;
200
201struct __sanitizer___sysctl_args {
202 int *name;
203 int nlen;
204 void *oldval;
205 uptr *oldlenp;
206 void *newval;
207 uptr newlen;
208 unsigned long ___unused[4];
209};
210
211const unsigned old_sigset_t_sz = sizeof(unsigned long);
212
213struct __sanitizer_sem_t {
214# if SANITIZER_ANDROID && defined(_LP64)
215 int data[4];
216# elif SANITIZER_ANDROID && !defined(_LP64)
217 int data;
218# elif SANITIZER_LINUX
219 uptr data[4];
220# endif
221};
222# endif // SANITIZER_LINUX
223
224# if SANITIZER_LINUX && !SANITIZER_ANDROID
225extern unsigned struct_ustat_sz;
226extern unsigned struct_rlimit64_sz;
227extern unsigned struct_statvfs64_sz;
228
229struct __sanitizer_ipc_perm {
230 int __key;
231 int uid;
232 int gid;
233 int cuid;
234 int cgid;
235# ifdef __powerpc__
236 unsigned mode;
237 unsigned __seq;
238 u64 __unused1;
239 u64 __unused2;
240# elif defined(__sparc__)
241 unsigned mode;
242 unsigned short __pad2;
243 unsigned short __seq;
244 unsigned long long __unused1;
245 unsigned long long __unused2;
246# else
247 unsigned int mode;
248 unsigned short __seq;
249 unsigned short __pad2;
250# if defined(__x86_64__) && !defined(_LP64)
251 u64 __unused1;
252 u64 __unused2;
253# else
254 unsigned long __unused1;
255 unsigned long __unused2;
256# endif
257# endif
258};
259
260struct __sanitizer_shmid_ds {
261 __sanitizer_ipc_perm shm_perm;
262# if defined(__sparc__)
263# if !defined(__arch64__)
264 u32 __pad1;
265# endif
266 long shm_atime;
267# if !defined(__arch64__)
268 u32 __pad2;
269# endif
270 long shm_dtime;
271# if !defined(__arch64__)
272 u32 __pad3;
273# endif
274 long shm_ctime;
275 uptr shm_segsz;
276 int shm_cpid;
277 int shm_lpid;
278 unsigned long shm_nattch;
279 unsigned long __glibc_reserved1;
280 unsigned long __glibc_reserved2;
281# else
282# ifndef __powerpc__
283 uptr shm_segsz;
284# elif !defined(__powerpc64__)
285 uptr __unused0;
286# endif
287# if defined(__x86_64__) && !defined(_LP64)
288 u64 shm_atime;
289 u64 shm_dtime;
290 u64 shm_ctime;
291# else
292 uptr shm_atime;
293# if !defined(_LP64) && !defined(__mips__)
294 uptr __unused1;
295# endif
296 uptr shm_dtime;
297# if !defined(_LP64) && !defined(__mips__)
298 uptr __unused2;
299# endif
300 uptr shm_ctime;
301# if !defined(_LP64) && !defined(__mips__)
302 uptr __unused3;
303# endif
304# endif
305# ifdef __powerpc__
306 uptr shm_segsz;
307# endif
308 int shm_cpid;
309 int shm_lpid;
310# if defined(__x86_64__) && !defined(_LP64)
311 u64 shm_nattch;
312 u64 __unused4;
313 u64 __unused5;
314# else
315 uptr shm_nattch;
316 uptr __unused4;
317 uptr __unused5;
318# endif
319# endif
320};
321# endif
322
323# if SANITIZER_LINUX && !SANITIZER_ANDROID
324extern unsigned struct_msqid_ds_sz;
325extern unsigned struct_mq_attr_sz;
326extern unsigned struct_timex_sz;
327extern unsigned struct_statvfs_sz;
328# endif // SANITIZER_LINUX && !SANITIZER_ANDROID
329
330struct __sanitizer_iovec {
331 void *iov_base;
332 usize iov_len;
333};
334
335# if !SANITIZER_ANDROID && !SANITIZER_AIX
336struct __sanitizer_ifaddrs {
337 struct __sanitizer_ifaddrs *ifa_next;
338 char *ifa_name;
339 unsigned int ifa_flags;
340 void *ifa_addr; // (struct sockaddr *)
341 void *ifa_netmask; // (struct sockaddr *)
342 // This is a union on Linux.
343# ifdef ifa_dstaddr
344# undef ifa_dstaddr
345# endif
346 void *ifa_dstaddr; // (struct sockaddr *)
347 void *ifa_data;
348};
349# endif // !SANITIZER_ANDROID && !SANITIZER_AIX
350
351# if SANITIZER_APPLE
352typedef unsigned long __sanitizer_pthread_key_t;
353# else
354typedef unsigned __sanitizer_pthread_key_t;
355# endif
356
357# if (SANITIZER_LINUX && !SANITIZER_ANDROID) || SANITIZER_AIX
358
359struct __sanitizer_XDR {
360 int x_op;
361 void *x_ops;
362 uptr x_public;
363 uptr x_private;
364 uptr x_base;
365 unsigned x_handy;
366};
367
368const int __sanitizer_XDR_ENCODE = 0;
369const int __sanitizer_XDR_DECODE = 1;
370const int __sanitizer_XDR_FREE = 2;
371# endif
372
373struct __sanitizer_passwd {
374 char *pw_name;
375 char *pw_passwd;
376 int pw_uid;
377 int pw_gid;
378# if SANITIZER_APPLE
379 long pw_change;
380 char *pw_class;
381# endif
382# if !(SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32)) && !SANITIZER_HAIKU
383 char *pw_gecos;
384# endif
385 char *pw_dir;
386 char *pw_shell;
387# if SANITIZER_APPLE
388 long pw_expire;
389# endif
390# if SANITIZER_HAIKU
391 char *pw_gecos;
392# endif
393};
394
395struct __sanitizer_group {
396 char *gr_name;
397 char *gr_passwd;
398 int gr_gid;
399 char **gr_mem;
400};
401
402# if (SANITIZER_LINUX && !SANITIZER_GLIBC && !SANITIZER_ANDROID) || \
403 (defined(__x86_64__) && !defined(_LP64)) || defined(__hexagon__)
404typedef long long __sanitizer_time_t;
405# else
406typedef long __sanitizer_time_t;
407# endif
408
409typedef long __sanitizer_suseconds_t;
410
411struct __sanitizer_timespec {
412 __sanitizer_time_t tv_sec; /* seconds */
413 u64 tv_nsec; /* nanoseconds */
414};
415
416struct __sanitizer_itimerspec {
417 struct __sanitizer_timespec it_interval; /* timer period */
418 struct __sanitizer_timespec it_value; /* timer expiration */
419};
420
421struct __sanitizer_timeval {
422 __sanitizer_time_t tv_sec;
423 __sanitizer_suseconds_t tv_usec;
424};
425
426struct __sanitizer_itimerval {
427 struct __sanitizer_timeval it_interval;
428 struct __sanitizer_timeval it_value;
429};
430
431struct __sanitizer_timeb {
432 __sanitizer_time_t time;
433 unsigned short millitm;
434 short timezone;
435 short dstflag;
436};
437
438struct __sanitizer_ether_addr {
439 u8 octet[6];
440};
441
442struct __sanitizer_tm {
443 int tm_sec;
444 int tm_min;
445 int tm_hour;
446 int tm_mday;
447 int tm_mon;
448 int tm_year;
449 int tm_wday;
450 int tm_yday;
451 int tm_isdst;
452# if !SANITIZER_AIX
453# if SANITIZER_HAIKU
454 int tm_gmtoff;
455# else
456 long int tm_gmtoff;
457# endif
458 const char *tm_zone;
459# endif
460};
461
462# if SANITIZER_LINUX
463struct __sanitizer_mntent {
464 char *mnt_fsname;
465 char *mnt_dir;
466 char *mnt_type;
467 char *mnt_opts;
468 int mnt_freq;
469 int mnt_passno;
470};
471
472struct __sanitizer_file_handle {
473 unsigned int handle_bytes;
474 int handle_type;
475 unsigned char f_handle[1]; // variable sized
476};
477# endif
478
479# if SANITIZER_APPLE || SANITIZER_HAIKU
480struct __sanitizer_msghdr {
481 void *msg_name;
482 unsigned msg_namelen;
483 struct __sanitizer_iovec *msg_iov;
484 unsigned msg_iovlen;
485 void *msg_control;
486 unsigned msg_controllen;
487 int msg_flags;
488};
489struct __sanitizer_cmsghdr {
490 unsigned cmsg_len;
491 int cmsg_level;
492 int cmsg_type;
493};
494# elif SANITIZER_MUSL
495struct __sanitizer_msghdr {
496 void *msg_name;
497 unsigned msg_namelen;
498 struct __sanitizer_iovec *msg_iov;
499 int msg_iovlen;
500# if SANITIZER_WORDSIZE == 64
501 int __pad1;
502# endif
503 void *msg_control;
504 unsigned msg_controllen;
505# if SANITIZER_WORDSIZE == 64
506 int __pad2;
507# endif
508 int msg_flags;
509};
510struct __sanitizer_cmsghdr {
511 unsigned cmsg_len;
512# if SANITIZER_WORDSIZE == 64
513 int __pad1;
514# endif
515 int cmsg_level;
516 int cmsg_type;
517};
518# else
519// In POSIX, int msg_iovlen; socklen_t msg_controllen; socklen_t cmsg_len; but
520// many implementations don't conform to the standard.
521struct __sanitizer_msghdr {
522 void *msg_name;
523 unsigned msg_namelen;
524 struct __sanitizer_iovec *msg_iov;
525 uptr msg_iovlen;
526 void *msg_control;
527# if !SANITIZER_AIX
528 uptr msg_controllen;
529# else
530 unsigned msg_controllen;
531# endif
532 int msg_flags;
533};
534struct __sanitizer_cmsghdr {
535# if !SANITIZER_AIX
536 uptr cmsg_len;
537# else
538 unsigned cmsg_len;
539# endif
540 int cmsg_level;
541 int cmsg_type;
542};
543# endif
544
545# if SANITIZER_LINUX
546struct __sanitizer_mmsghdr {
547 __sanitizer_msghdr msg_hdr;
548 unsigned int msg_len;
549};
550# endif
551
552# if SANITIZER_APPLE
553struct __sanitizer_dirent {
554 unsigned long long d_ino;
555 unsigned long long d_seekoff;
556 unsigned short d_reclen;
557 // more fields that we don't care about
558};
559# elif SANITIZER_HAIKU
560struct __sanitizer_dirent {
561 int d_dev;
562 int d_pdev;
563 unsigned long long d_ino;
564 unsigned long long d_pino;
565 unsigned short d_reclen;
566 // more fields that we don't care about
567};
568# elif (SANITIZER_LINUX && !SANITIZER_GLIBC) || defined(__x86_64__) || \
569 defined(__hexagon__)
570struct __sanitizer_dirent {
571 unsigned long long d_ino;
572 unsigned long long d_off;
573 unsigned short d_reclen;
574 // more fields that we don't care about
575};
576# elif defined(__alpha__)
577struct __sanitizer_dirent {
578 unsigned int d_ino; // ino_t is 32-bit on Alpha
579 int __pad; // explicit padding before d_off
580 unsigned long d_off;
581 unsigned short d_reclen;
582 // more fields that we don't care about
583};
584# else
585struct __sanitizer_dirent {
586# if SANITIZER_AIX
587 uptr d_offset;
588 uptr d_ino;
589# else
590 uptr d_ino;
591 uptr d_off;
592# endif
593 unsigned short d_reclen;
594 // more fields that we don't care about
595};
596# endif
597
598# if SANITIZER_GLIBC
599struct __sanitizer_dirent64 {
600 unsigned long long d_ino;
601 unsigned long long d_off;
602 unsigned short d_reclen;
603 // more fields that we don't care about
604};
605extern unsigned struct_sock_fprog_sz;
606# endif
607
608# if SANITIZER_HAIKU || SANITIZER_AIX
609typedef int __sanitizer_clock_t;
610# elif defined(__x86_64__) && !defined(_LP64)
611typedef long long __sanitizer_clock_t;
612# else
613typedef long __sanitizer_clock_t;
614# endif
615
616# if SANITIZER_LINUX || SANITIZER_HAIKU || SANITIZER_AIX
617typedef int __sanitizer_clockid_t;
618# endif
619# if SANITIZER_LINUX || SANITIZER_HAIKU
620typedef unsigned long long __sanitizer_eventfd_t;
621# endif
622
623# if SANITIZER_LINUX
624# if defined(_LP64) || defined(__x86_64__) || defined(__powerpc__) || \
625 defined(__mips__) || defined(__hexagon__)
626typedef unsigned __sanitizer___kernel_uid_t;
627typedef unsigned __sanitizer___kernel_gid_t;
628# else
629typedef unsigned short __sanitizer___kernel_uid_t;
630typedef unsigned short __sanitizer___kernel_gid_t;
631# endif
632# if defined(__x86_64__) && !defined(_LP64)
633typedef long long __sanitizer___kernel_off_t;
634# else
635typedef long __sanitizer___kernel_off_t;
636# endif
637
638# if defined(__powerpc__) || defined(__mips__)
639typedef unsigned int __sanitizer___kernel_old_uid_t;
640typedef unsigned int __sanitizer___kernel_old_gid_t;
641# else
642typedef unsigned short __sanitizer___kernel_old_uid_t;
643typedef unsigned short __sanitizer___kernel_old_gid_t;
644# endif
645
646typedef long long __sanitizer___kernel_loff_t;
647typedef struct {
648 unsigned long fds_bits[1024 / (8 * sizeof(long))];
649} __sanitizer___kernel_fd_set;
650# endif
651
652// This thing depends on the platform. We are only interested in the upper
653// limit. Verified with a compiler assert in .cpp.
654union __sanitizer_pthread_attr_t {
655 char size[128];
656 void *align;
657};
658
659# if SANITIZER_ANDROID
660# if SANITIZER_MIPS
661typedef unsigned long __sanitizer_sigset_t[16 / sizeof(unsigned long)];
662# else
663typedef unsigned long __sanitizer_sigset_t;
664# endif
665# elif SANITIZER_APPLE
666typedef unsigned __sanitizer_sigset_t;
667# elif SANITIZER_HAIKU
668typedef uint64_t __sanitizer_sigset_t;
669# elif SANITIZER_LINUX
670struct __sanitizer_sigset_t {
671 // The size is determined by looking at sizeof of real sigset_t on linux.
672 uptr val[128 / sizeof(uptr)];
673};
674# elif SANITIZER_AIX
675struct __sanitizer_sigset_t {
676# if SANITIZER_WORDSIZE == 64
677 uptr val[4];
678# else
679 uptr val[2];
680# endif
681};
682# endif
683
684struct __sanitizer_siginfo_pad {
685# if SANITIZER_X32
686 // x32 siginfo_t is aligned to 8 bytes.
687 u64 pad[128 / sizeof(u64)];
688# else
689 // Require uptr, because siginfo_t is always pointer-size aligned on Linux.
690 uptr pad[128 / sizeof(uptr)];
691# endif
692};
693
694# if SANITIZER_LINUX
695# define SANITIZER_HAS_SIGINFO 1
696union __sanitizer_siginfo {
697 __extension__ struct {
698 int si_signo;
699# if SANITIZER_MIPS
700 int si_code;
701 int si_errno;
702# else
703 int si_errno;
704 int si_code;
705# endif
706 };
707 __sanitizer_siginfo_pad pad;
708};
709# else
710# define SANITIZER_HAS_SIGINFO 0
711typedef __sanitizer_siginfo_pad __sanitizer_siginfo;
712# endif
713
714using __sanitizer_sighandler_ptr = void (*)(int sig);
715using __sanitizer_sigactionhandler_ptr = void (*)(int sig,
716 __sanitizer_siginfo *siginfo,
717 void *uctx);
718
719// Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
720# if SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 64)
721struct __sanitizer_sigaction {
722 unsigned sa_flags;
723 union {
724 __sanitizer_sigactionhandler_ptr sigaction;
725 __sanitizer_sighandler_ptr handler;
726 };
727 __sanitizer_sigset_t sa_mask;
728 void (*sa_restorer)();
729};
730# elif SANITIZER_ANDROID && \
731 SANITIZER_MIPS32 // check this before WORDSIZE == 32
732struct __sanitizer_sigaction {
733 unsigned sa_flags;
734 union {
735 __sanitizer_sigactionhandler_ptr sigaction;
736 __sanitizer_sighandler_ptr handler;
737 };
738 __sanitizer_sigset_t sa_mask;
739};
740# elif SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32)
741struct __sanitizer_sigaction {
742 union {
743 __sanitizer_sigactionhandler_ptr sigaction;
744 __sanitizer_sighandler_ptr handler;
745 };
746 __sanitizer_sigset_t sa_mask;
747 uptr sa_flags;
748 void (*sa_restorer)();
749};
750# else // !SANITIZER_ANDROID
751struct __sanitizer_sigaction {
752# if defined(__mips__) && !SANITIZER_FREEBSD && !SANITIZER_MUSL
753 unsigned int sa_flags;
754# endif
755 union {
756 __sanitizer_sigactionhandler_ptr sigaction;
757 __sanitizer_sighandler_ptr handler;
758 };
759# if SANITIZER_FREEBSD
760 int sa_flags;
761 __sanitizer_sigset_t sa_mask;
762# else
763# if defined(__s390x__)
764 int sa_resv;
765# else
766 __sanitizer_sigset_t sa_mask;
767# endif
768# if !defined(__mips__) || SANITIZER_MUSL
769# if defined(__sparc__)
770# if __GLIBC_PREREQ(2, 20)
771 // On sparc glibc 2.19 and earlier sa_flags was unsigned long.
772# if defined(__arch64__)
773 // To maintain ABI compatibility on sparc64 when switching to an int,
774 // __glibc_reserved0 was added.
775 int __glibc_reserved0;
776# endif
777 int sa_flags;
778# else
779 unsigned long sa_flags;
780# endif
781# else
782 int sa_flags;
783# endif
784# endif
785# endif
786# if (SANITIZER_LINUX || SANITIZER_HAIKU) && !defined(__alpha__)
787 void (*sa_restorer)();
788# endif
789# if defined(__mips__) && (SANITIZER_WORDSIZE == 32) && !SANITIZER_MUSL
790 int sa_resv[1];
791# endif
792# if defined(__s390x__)
793 __sanitizer_sigset_t sa_mask;
794# endif
795};
796# endif // !SANITIZER_ANDROID
797
798# if defined(__mips__)
799# define __SANITIZER_KERNEL_NSIG 128
800# else
801# define __SANITIZER_KERNEL_NSIG 64
802# endif
803
804struct __sanitizer_kernel_sigset_t {
805 uptr sig[__SANITIZER_KERNEL_NSIG / (sizeof(uptr) * 8)];
806};
807
808// Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
809# if SANITIZER_MIPS
810struct __sanitizer_kernel_sigaction_t {
811 unsigned int sa_flags;
812 union {
813 void (*handler)(int signo);
814 void (*sigaction)(int signo, __sanitizer_siginfo *info, void *ctx);
815 };
816 __sanitizer_kernel_sigset_t sa_mask;
817 void (*sa_restorer)(void);
818};
819# else
820struct __sanitizer_kernel_sigaction_t {
821 union {
822 void (*handler)(int signo);
823 void (*sigaction)(int signo, __sanitizer_siginfo *info, void *ctx);
824 };
825 unsigned long sa_flags;
826 void (*sa_restorer)(void);
827 __sanitizer_kernel_sigset_t sa_mask;
828};
829# endif
830
831extern const uptr sig_ign;
832extern const uptr sig_dfl;
833extern const uptr sig_err;
834extern const uptr sa_siginfo;
835
836# if SANITIZER_LINUX
837extern int e_tabsz;
838# endif
839
840extern int af_inet;
841extern int af_inet6;
842uptr __sanitizer_in_addr_sz(int af);
843
844# if SANITIZER_LINUX
845struct __sanitizer_dl_phdr_info {
846 uptr dlpi_addr;
847 const char *dlpi_name;
848 const void *dlpi_phdr;
849 short dlpi_phnum;
850};
851
852extern unsigned struct_ElfW_Phdr_sz;
853# endif
854
855struct __sanitizer_protoent {
856 char *p_name;
857 char **p_aliases;
858 int p_proto;
859};
860
861struct __sanitizer_netent {
862 char *n_name;
863 char **n_aliases;
864 int n_addrtype;
865 u32 n_net;
866};
867
868struct __sanitizer_addrinfo {
869 int ai_flags;
870 int ai_family;
871 int ai_socktype;
872 int ai_protocol;
873# if SANITIZER_ANDROID || SANITIZER_APPLE || SANITIZER_HAIKU || SANITIZER_AIX
874# if SANITIZER_AIX // AIX ai_addrlen type is size_t
875 uptr ai_addrlen;
876# else
877 unsigned ai_addrlen;
878# endif
879 char *ai_canonname;
880 void *ai_addr;
881# else // LINUX
882 unsigned ai_addrlen;
883 void *ai_addr;
884 char *ai_canonname;
885# endif
886 struct __sanitizer_addrinfo *ai_next;
887# if SANITIZER_AIX
888 int ai_eflags;
889# endif
890};
891
892struct __sanitizer_hostent {
893 char *h_name;
894 char **h_aliases;
895 int h_addrtype;
896 int h_length;
897 char **h_addr_list;
898};
899
900struct __sanitizer_pollfd {
901 int fd;
902 short events;
903 short revents;
904};
905
906# if SANITIZER_ANDROID || SANITIZER_APPLE || SANITIZER_AIX
907typedef unsigned __sanitizer_nfds_t;
908# else
909typedef unsigned long __sanitizer_nfds_t;
910# endif
911
912# if !SANITIZER_ANDROID
913# if SANITIZER_LINUX
914struct __sanitizer_glob_t {
915 uptr gl_pathc;
916 char **gl_pathv;
917 uptr gl_offs;
918 int gl_flags;
919
920 void (*gl_closedir)(void *dirp);
921 void *(*gl_readdir)(void *dirp);
922 void *(*gl_opendir)(const char *);
923 int (*gl_lstat)(const char *, void *);
924 int (*gl_stat)(const char *, void *);
925};
926# endif // SANITIZER_LINUX
927
928# if SANITIZER_LINUX
929extern int glob_nomatch;
930extern int glob_altdirfunc;
931# endif
932# endif // !SANITIZER_ANDROID
933
934extern unsigned path_max;
935
936# if !SANITIZER_ANDROID
937extern const int wordexp_wrde_dooffs;
938# endif // !SANITIZER_ANDROID
939
940struct __sanitizer_wordexp_t {
941 uptr we_wordc;
942 char **we_wordv;
943 uptr we_offs;
944# if SANITIZER_AIX
945 int we_sflags;
946 uptr we_soffs;
947# endif
948};
949
950# if SANITIZER_LINUX && !SANITIZER_ANDROID
951struct __sanitizer_FILE {
952 int _flags;
953 char *_IO_read_ptr;
954 char *_IO_read_end;
955 char *_IO_read_base;
956 char *_IO_write_base;
957 char *_IO_write_ptr;
958 char *_IO_write_end;
959 char *_IO_buf_base;
960 char *_IO_buf_end;
961 char *_IO_save_base;
962 char *_IO_backup_base;
963 char *_IO_save_end;
964 void *_markers;
965 __sanitizer_FILE *_chain;
966 int _fileno;
967};
968# define SANITIZER_HAS_STRUCT_FILE 1
969# else
970typedef void __sanitizer_FILE;
971# define SANITIZER_HAS_STRUCT_FILE 0
972# endif
973
974# if SANITIZER_LINUX && !SANITIZER_ANDROID && \
975 (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
976 defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
977 defined(__s390__) || defined(__loongarch__) || SANITIZER_RISCV64 || \
978 defined(__sparc__))
979extern unsigned struct_user_regs_struct_sz;
980extern unsigned struct_user_fpregs_struct_sz;
981extern unsigned struct_user_fpxregs_struct_sz;
982extern unsigned struct_user_vfpregs_struct_sz;
983
984extern int ptrace_peektext;
985extern int ptrace_peekdata;
986extern int ptrace_peekuser;
987extern int ptrace_getregs;
988extern int ptrace_setregs;
989extern int ptrace_getfpregs;
990extern int ptrace_setfpregs;
991extern int ptrace_getfpxregs;
992extern int ptrace_setfpxregs;
993extern int ptrace_getvfpregs;
994extern int ptrace_setvfpregs;
995extern int ptrace_getsiginfo;
996extern int ptrace_setsiginfo;
997extern int ptrace_getregset;
998extern int ptrace_setregset;
999extern int ptrace_geteventmsg;
1000
1001// Helper for the ptrace interceptor.
1002template <class T>
1003inline T ptrace_data_arg(int request, T addr, T data) {
1004# if SANITIZER_LINUX && SANITIZER_SPARC
1005 // As described in ptrace(2), the meanings of addr and data are reversed
1006 // for the PTRACE_GETREGS, PTRACE_GETFPREGS, PTRACE_GETREGS, and
1007 // PTRACE_GETFPREGS requests on Linux/sparc64.
1008 if (request == ptrace_getregs || request == ptrace_getfpregs ||
1009 request == ptrace_setregs || request == ptrace_setfpregs)
1010 return addr;
1011 else
1012# endif
1013 return data;
1014}
1015# endif
1016
1017# if SANITIZER_LINUX && !SANITIZER_ANDROID
1018extern unsigned struct_shminfo_sz;
1019extern unsigned struct_shm_info_sz;
1020extern int shmctl_ipc_stat;
1021extern int shmctl_ipc_info;
1022extern int shmctl_shm_info;
1023extern int shmctl_shm_stat;
1024# endif
1025
1026# if !SANITIZER_APPLE && !SANITIZER_FREEBSD
1027extern unsigned struct_utmp_sz;
1028# endif
1029# if !SANITIZER_ANDROID
1030extern unsigned struct_utmpx_sz;
1031# endif
1032
1033extern int map_fixed;
1034
1035// ioctl arguments
1036struct __sanitizer_ifconf {
1037 int ifc_len;
1038 union {
1039 void *ifcu_req;
1040 } ifc_ifcu;
1041# if SANITIZER_APPLE
1042} __attribute__((packed));
1043# else
1044};
1045# endif
1046
1047# if SANITIZER_LINUX && !SANITIZER_ANDROID
1048struct __sanitizer__obstack_chunk {
1049 char *limit;
1050 struct __sanitizer__obstack_chunk *prev;
1051};
1052
1053struct __sanitizer_obstack {
1054 long chunk_size;
1055 struct __sanitizer__obstack_chunk *chunk;
1056 char *object_base;
1057 char *next_free;
1058 uptr more_fields[7];
1059};
1060
1061typedef uptr (*__sanitizer_cookie_io_read)(void *cookie, char *buf, uptr size);
1062typedef uptr (*__sanitizer_cookie_io_write)(void *cookie, const char *buf,
1063 uptr size);
1064typedef int (*__sanitizer_cookie_io_seek)(void *cookie, u64 *offset,
1065 int whence);
1066typedef int (*__sanitizer_cookie_io_close)(void *cookie);
1067
1068struct __sanitizer_cookie_io_functions_t {
1069 __sanitizer_cookie_io_read read;
1070 __sanitizer_cookie_io_write write;
1071 __sanitizer_cookie_io_seek seek;
1072 __sanitizer_cookie_io_close close;
1073};
1074# endif
1075
1076# define IOC_NRBITS 8
1077# define IOC_TYPEBITS 8
1078# if defined(__powerpc__) || defined(__powerpc64__) || defined(__mips__) || \
1079 defined(__sparc__) || defined(__alpha__)
1080# define IOC_SIZEBITS 13
1081# define IOC_DIRBITS 3
1082# define IOC_NONE 1U
1083# define IOC_WRITE 4U
1084# define IOC_READ 2U
1085# else
1086# define IOC_SIZEBITS 14
1087# define IOC_DIRBITS 2
1088# define IOC_NONE 0U
1089# define IOC_WRITE 1U
1090# define IOC_READ 2U
1091# endif
1092# define IOC_NRMASK ((1 << IOC_NRBITS) - 1)
1093# define IOC_TYPEMASK ((1 << IOC_TYPEBITS) - 1)
1094# define IOC_SIZEMASK ((1 << IOC_SIZEBITS) - 1)
1095# if defined(IOC_DIRMASK)
1096# undef IOC_DIRMASK
1097# endif
1098# define IOC_DIRMASK ((1 << IOC_DIRBITS) - 1)
1099# define IOC_NRSHIFT 0
1100# define IOC_TYPESHIFT (IOC_NRSHIFT + IOC_NRBITS)
1101# define IOC_SIZESHIFT (IOC_TYPESHIFT + IOC_TYPEBITS)
1102# define IOC_DIRSHIFT (IOC_SIZESHIFT + IOC_SIZEBITS)
1103# define EVIOC_EV_MAX 0x1f
1104# define EVIOC_ABS_MAX 0x3f
1105
1106# define IOC_DIR(nr) (((nr) >> IOC_DIRSHIFT) & IOC_DIRMASK)
1107# define IOC_TYPE(nr) (((nr) >> IOC_TYPESHIFT) & IOC_TYPEMASK)
1108# define IOC_NR(nr) (((nr) >> IOC_NRSHIFT) & IOC_NRMASK)
1109
1110# if defined(__sparc__)
1111// In sparc the 14 bits SIZE field overlaps with the
1112// least significant bit of DIR, so either IOC_READ or
1113// IOC_WRITE shall be 1 in order to get a non-zero SIZE.
1114# define IOC_SIZE(nr) \
1115 ((((((nr) >> 29) & 0x7) & (4U | 2U)) == 0) ? 0 : (((nr) >> 16) & 0x3fff))
1116# else
1117# define IOC_SIZE(nr) (((nr) >> IOC_SIZESHIFT) & IOC_SIZEMASK)
1118# endif
1119
1120extern unsigned struct_ifreq_sz;
1121extern unsigned struct_termios_sz;
1122extern unsigned struct_winsize_sz;
1123
1124# if SANITIZER_LINUX
1125extern unsigned struct_arpreq_sz;
1126extern unsigned struct_cdrom_msf_sz;
1127extern unsigned struct_cdrom_multisession_sz;
1128extern unsigned struct_cdrom_read_audio_sz;
1129extern unsigned struct_cdrom_subchnl_sz;
1130extern unsigned struct_cdrom_ti_sz;
1131extern unsigned struct_cdrom_tocentry_sz;
1132extern unsigned struct_cdrom_tochdr_sz;
1133extern unsigned struct_cdrom_volctrl_sz;
1134extern unsigned struct_ff_effect_sz;
1135extern unsigned struct_floppy_drive_params_sz;
1136extern unsigned struct_floppy_drive_struct_sz;
1137extern unsigned struct_floppy_fdc_state_sz;
1138extern unsigned struct_floppy_max_errors_sz;
1139extern unsigned struct_floppy_raw_cmd_sz;
1140extern unsigned struct_floppy_struct_sz;
1141extern unsigned struct_floppy_write_errors_sz;
1142extern unsigned struct_format_descr_sz;
1143extern unsigned struct_hd_driveid_sz;
1144extern unsigned struct_hd_geometry_sz;
1145extern unsigned struct_input_absinfo_sz;
1146extern unsigned struct_input_id_sz;
1147extern unsigned struct_mtpos_sz;
1148extern unsigned struct_vt_consize_sz;
1149extern unsigned struct_vt_sizes_sz;
1150extern unsigned struct_vt_stat_sz;
1151# endif // SANITIZER_LINUX
1152
1153# if SANITIZER_LINUX
1154extern unsigned struct_copr_buffer_sz;
1155extern unsigned struct_copr_debug_buf_sz;
1156extern unsigned struct_copr_msg_sz;
1157extern unsigned struct_midi_info_sz;
1158extern unsigned struct_mtget_sz;
1159extern unsigned struct_mtop_sz;
1160extern unsigned struct_rtentry_sz;
1161extern unsigned struct_sbi_instrument_sz;
1162extern unsigned struct_seq_event_rec_sz;
1163extern unsigned struct_synth_info_sz;
1164extern unsigned struct_vt_mode_sz;
1165# endif // SANITIZER_LINUX
1166
1167# if SANITIZER_LINUX && !SANITIZER_ANDROID
1168extern unsigned struct_ax25_parms_struct_sz;
1169extern unsigned struct_input_keymap_entry_sz;
1170extern unsigned struct_ipx_config_data_sz;
1171extern unsigned struct_kbdiacrs_sz;
1172extern unsigned struct_kbentry_sz;
1173extern unsigned struct_kbkeycode_sz;
1174extern unsigned struct_kbsentry_sz;
1175extern unsigned struct_mtconfiginfo_sz;
1176extern unsigned struct_nr_parms_struct_sz;
1177extern unsigned struct_scc_modem_sz;
1178extern unsigned struct_scc_stat_sz;
1179extern unsigned struct_serial_multiport_struct_sz;
1180extern unsigned struct_serial_struct_sz;
1181extern unsigned struct_sockaddr_ax25_sz;
1182extern unsigned struct_unimapdesc_sz;
1183extern unsigned struct_unimapinit_sz;
1184# endif // SANITIZER_LINUX && !SANITIZER_ANDROID
1185
1186extern const unsigned long __sanitizer_bufsiz;
1187
1188# if SANITIZER_LINUX && !SANITIZER_ANDROID
1189extern unsigned struct_audio_buf_info_sz;
1190extern unsigned struct_ppp_stats_sz;
1191# endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
1192
1193# if !SANITIZER_ANDROID && !SANITIZER_APPLE
1194extern unsigned struct_sioc_sg_req_sz;
1195extern unsigned struct_sioc_vif_req_sz;
1196# endif
1197
1198extern unsigned fpos_t_sz;
1199
1200// ioctl request identifiers
1201
1202// A special value to mark ioctls that are not present on the target platform,
1203// when it can not be determined without including any system headers.
1204extern const unsigned IOCTL_NOT_PRESENT;
1205
1206extern unsigned IOCTL_FIOASYNC;
1207extern unsigned IOCTL_FIOCLEX;
1208extern unsigned IOCTL_FIOGETOWN;
1209extern unsigned IOCTL_FIONBIO;
1210extern unsigned IOCTL_FIONCLEX;
1211extern unsigned IOCTL_FIOSETOWN;
1212extern unsigned IOCTL_SIOCADDMULTI;
1213extern unsigned IOCTL_SIOCATMARK;
1214extern unsigned IOCTL_SIOCDELMULTI;
1215extern unsigned IOCTL_SIOCGIFADDR;
1216extern unsigned IOCTL_SIOCGIFBRDADDR;
1217extern unsigned IOCTL_SIOCGIFCONF;
1218extern unsigned IOCTL_SIOCGIFDSTADDR;
1219extern unsigned IOCTL_SIOCGIFFLAGS;
1220extern unsigned IOCTL_SIOCGIFMETRIC;
1221extern unsigned IOCTL_SIOCGIFMTU;
1222extern unsigned IOCTL_SIOCGIFNETMASK;
1223extern unsigned IOCTL_SIOCGPGRP;
1224extern unsigned IOCTL_SIOCSIFADDR;
1225extern unsigned IOCTL_SIOCSIFBRDADDR;
1226extern unsigned IOCTL_SIOCSIFDSTADDR;
1227extern unsigned IOCTL_SIOCSIFFLAGS;
1228extern unsigned IOCTL_SIOCSIFMETRIC;
1229extern unsigned IOCTL_SIOCSIFMTU;
1230extern unsigned IOCTL_SIOCSIFNETMASK;
1231extern unsigned IOCTL_SIOCSPGRP;
1232# if !SANITIZER_HAIKU
1233extern unsigned IOCTL_TIOCCONS;
1234extern unsigned IOCTL_TIOCGETD;
1235extern unsigned IOCTL_TIOCNOTTY;
1236extern unsigned IOCTL_TIOCPKT;
1237extern unsigned IOCTL_TIOCSETD;
1238extern unsigned IOCTL_TIOCSTI;
1239# endif
1240extern unsigned IOCTL_TIOCEXCL;
1241extern unsigned IOCTL_TIOCGPGRP;
1242extern unsigned IOCTL_TIOCGWINSZ;
1243extern unsigned IOCTL_TIOCMBIC;
1244extern unsigned IOCTL_TIOCMBIS;
1245extern unsigned IOCTL_TIOCMGET;
1246extern unsigned IOCTL_TIOCMSET;
1247extern unsigned IOCTL_TIOCNXCL;
1248extern unsigned IOCTL_TIOCOUTQ;
1249# if !SANITIZER_AIX
1250extern unsigned IOCTL_TIOCSCTTY;
1251# endif
1252extern unsigned IOCTL_TIOCSPGRP;
1253extern unsigned IOCTL_TIOCSWINSZ;
1254# if SANITIZER_LINUX && !SANITIZER_ANDROID
1255extern unsigned IOCTL_SIOCGETSGCNT;
1256extern unsigned IOCTL_SIOCGETVIFCNT;
1257# endif
1258# if SANITIZER_LINUX
1259extern unsigned IOCTL_EVIOCGABS;
1260extern unsigned IOCTL_EVIOCGBIT;
1261extern unsigned IOCTL_EVIOCGEFFECTS;
1262extern unsigned IOCTL_EVIOCGID;
1263extern unsigned IOCTL_EVIOCGKEY;
1264extern unsigned IOCTL_EVIOCGKEYCODE;
1265extern unsigned IOCTL_EVIOCGLED;
1266extern unsigned IOCTL_EVIOCGNAME;
1267extern unsigned IOCTL_EVIOCGPHYS;
1268extern unsigned IOCTL_EVIOCGRAB;
1269extern unsigned IOCTL_EVIOCGREP;
1270extern unsigned IOCTL_EVIOCGSND;
1271extern unsigned IOCTL_EVIOCGSW;
1272extern unsigned IOCTL_EVIOCGUNIQ;
1273extern unsigned IOCTL_EVIOCGVERSION;
1274extern unsigned IOCTL_EVIOCRMFF;
1275extern unsigned IOCTL_EVIOCSABS;
1276extern unsigned IOCTL_EVIOCSFF;
1277extern unsigned IOCTL_EVIOCSKEYCODE;
1278extern unsigned IOCTL_EVIOCSREP;
1279extern unsigned IOCTL_BLKFLSBUF;
1280extern unsigned IOCTL_BLKGETSIZE;
1281extern unsigned IOCTL_BLKRAGET;
1282extern unsigned IOCTL_BLKRASET;
1283extern unsigned IOCTL_BLKROGET;
1284extern unsigned IOCTL_BLKROSET;
1285extern unsigned IOCTL_BLKRRPART;
1286extern unsigned IOCTL_BLKFRASET;
1287extern unsigned IOCTL_BLKFRAGET;
1288extern unsigned IOCTL_BLKSECTSET;
1289extern unsigned IOCTL_BLKSECTGET;
1290extern unsigned IOCTL_BLKSSZGET;
1291extern unsigned IOCTL_BLKBSZGET;
1292extern unsigned IOCTL_BLKBSZSET;
1293extern unsigned IOCTL_BLKGETSIZE64;
1294extern unsigned IOCTL_CDROMAUDIOBUFSIZ;
1295extern unsigned IOCTL_CDROMEJECT;
1296extern unsigned IOCTL_CDROMEJECT_SW;
1297extern unsigned IOCTL_CDROMMULTISESSION;
1298extern unsigned IOCTL_CDROMPAUSE;
1299extern unsigned IOCTL_CDROMPLAYMSF;
1300extern unsigned IOCTL_CDROMPLAYTRKIND;
1301extern unsigned IOCTL_CDROMREADAUDIO;
1302extern unsigned IOCTL_CDROMREADCOOKED;
1303extern unsigned IOCTL_CDROMREADMODE1;
1304extern unsigned IOCTL_CDROMREADMODE2;
1305extern unsigned IOCTL_CDROMREADRAW;
1306extern unsigned IOCTL_CDROMREADTOCENTRY;
1307extern unsigned IOCTL_CDROMREADTOCHDR;
1308extern unsigned IOCTL_CDROMRESET;
1309extern unsigned IOCTL_CDROMRESUME;
1310extern unsigned IOCTL_CDROMSEEK;
1311extern unsigned IOCTL_CDROMSTART;
1312extern unsigned IOCTL_CDROMSTOP;
1313extern unsigned IOCTL_CDROMSUBCHNL;
1314extern unsigned IOCTL_CDROMVOLCTRL;
1315extern unsigned IOCTL_CDROMVOLREAD;
1316extern unsigned IOCTL_CDROM_GET_UPC;
1317extern unsigned IOCTL_FDCLRPRM;
1318extern unsigned IOCTL_FDDEFPRM;
1319extern unsigned IOCTL_FDFLUSH;
1320extern unsigned IOCTL_FDFMTBEG;
1321extern unsigned IOCTL_FDFMTEND;
1322extern unsigned IOCTL_FDFMTTRK;
1323extern unsigned IOCTL_FDGETDRVPRM;
1324extern unsigned IOCTL_FDGETDRVSTAT;
1325extern unsigned IOCTL_FDGETDRVTYP;
1326extern unsigned IOCTL_FDGETFDCSTAT;
1327extern unsigned IOCTL_FDGETMAXERRS;
1328extern unsigned IOCTL_FDGETPRM;
1329extern unsigned IOCTL_FDMSGOFF;
1330extern unsigned IOCTL_FDMSGON;
1331extern unsigned IOCTL_FDPOLLDRVSTAT;
1332extern unsigned IOCTL_FDRAWCMD;
1333extern unsigned IOCTL_FDRESET;
1334extern unsigned IOCTL_FDSETDRVPRM;
1335extern unsigned IOCTL_FDSETEMSGTRESH;
1336extern unsigned IOCTL_FDSETMAXERRS;
1337extern unsigned IOCTL_FDSETPRM;
1338extern unsigned IOCTL_FDTWADDLE;
1339extern unsigned IOCTL_FDWERRORCLR;
1340extern unsigned IOCTL_FDWERRORGET;
1341extern unsigned IOCTL_HDIO_DRIVE_CMD;
1342extern unsigned IOCTL_HDIO_GETGEO;
1343extern unsigned IOCTL_HDIO_GET_32BIT;
1344extern unsigned IOCTL_HDIO_GET_DMA;
1345extern unsigned IOCTL_HDIO_GET_IDENTITY;
1346extern unsigned IOCTL_HDIO_GET_KEEPSETTINGS;
1347extern unsigned IOCTL_HDIO_GET_MULTCOUNT;
1348extern unsigned IOCTL_HDIO_GET_NOWERR;
1349extern unsigned IOCTL_HDIO_GET_UNMASKINTR;
1350extern unsigned IOCTL_HDIO_SET_32BIT;
1351extern unsigned IOCTL_HDIO_SET_DMA;
1352extern unsigned IOCTL_HDIO_SET_KEEPSETTINGS;
1353extern unsigned IOCTL_HDIO_SET_MULTCOUNT;
1354extern unsigned IOCTL_HDIO_SET_NOWERR;
1355extern unsigned IOCTL_HDIO_SET_UNMASKINTR;
1356extern unsigned IOCTL_MTIOCPOS;
1357extern unsigned IOCTL_PPPIOCGASYNCMAP;
1358extern unsigned IOCTL_PPPIOCGDEBUG;
1359extern unsigned IOCTL_PPPIOCGFLAGS;
1360extern unsigned IOCTL_PPPIOCGUNIT;
1361extern unsigned IOCTL_PPPIOCGXASYNCMAP;
1362extern unsigned IOCTL_PPPIOCSASYNCMAP;
1363extern unsigned IOCTL_PPPIOCSDEBUG;
1364extern unsigned IOCTL_PPPIOCSFLAGS;
1365extern unsigned IOCTL_PPPIOCSMAXCID;
1366extern unsigned IOCTL_PPPIOCSMRU;
1367extern unsigned IOCTL_PPPIOCSXASYNCMAP;
1368extern unsigned IOCTL_SIOCDARP;
1369extern unsigned IOCTL_SIOCDRARP;
1370extern unsigned IOCTL_SIOCGARP;
1371extern unsigned IOCTL_SIOCGIFENCAP;
1372extern unsigned IOCTL_SIOCGIFHWADDR;
1373extern unsigned IOCTL_SIOCGIFMAP;
1374extern unsigned IOCTL_SIOCGIFMEM;
1375extern unsigned IOCTL_SIOCGIFNAME;
1376extern unsigned IOCTL_SIOCGIFSLAVE;
1377extern unsigned IOCTL_SIOCGRARP;
1378extern unsigned IOCTL_SIOCGSTAMP;
1379extern unsigned IOCTL_SIOCSARP;
1380extern unsigned IOCTL_SIOCSIFENCAP;
1381extern unsigned IOCTL_SIOCSIFHWADDR;
1382extern unsigned IOCTL_SIOCSIFLINK;
1383extern unsigned IOCTL_SIOCSIFMAP;
1384extern unsigned IOCTL_SIOCSIFMEM;
1385extern unsigned IOCTL_SIOCSIFSLAVE;
1386extern unsigned IOCTL_SIOCSRARP;
1387extern unsigned IOCTL_SNDCTL_COPR_HALT;
1388extern unsigned IOCTL_SNDCTL_COPR_LOAD;
1389extern unsigned IOCTL_SNDCTL_COPR_RCODE;
1390extern unsigned IOCTL_SNDCTL_COPR_RCVMSG;
1391extern unsigned IOCTL_SNDCTL_COPR_RDATA;
1392extern unsigned IOCTL_SNDCTL_COPR_RESET;
1393extern unsigned IOCTL_SNDCTL_COPR_RUN;
1394extern unsigned IOCTL_SNDCTL_COPR_SENDMSG;
1395extern unsigned IOCTL_SNDCTL_COPR_WCODE;
1396extern unsigned IOCTL_SNDCTL_COPR_WDATA;
1397extern unsigned IOCTL_TCFLSH;
1398extern unsigned IOCTL_TCSBRK;
1399extern unsigned IOCTL_TCSBRKP;
1400# if SANITIZER_TERMIOS_IOCTL_CONSTANTS
1401extern unsigned IOCTL_TCGETS;
1402extern unsigned IOCTL_TCSETS;
1403extern unsigned IOCTL_TCSETSF;
1404extern unsigned IOCTL_TCSETSW;
1405# endif
1406extern unsigned IOCTL_TCXONC;
1407extern unsigned IOCTL_TIOCGLCKTRMIOS;
1408extern unsigned IOCTL_TIOCGSOFTCAR;
1409extern unsigned IOCTL_TIOCINQ;
1410extern unsigned IOCTL_TIOCLINUX;
1411extern unsigned IOCTL_TIOCSERCONFIG;
1412extern unsigned IOCTL_TIOCSERGETLSR;
1413extern unsigned IOCTL_TIOCSERGWILD;
1414extern unsigned IOCTL_TIOCSERSWILD;
1415extern unsigned IOCTL_TIOCSLCKTRMIOS;
1416extern unsigned IOCTL_TIOCSSOFTCAR;
1417extern unsigned IOCTL_VT_DISALLOCATE;
1418extern unsigned IOCTL_VT_GETSTATE;
1419extern unsigned IOCTL_VT_RESIZE;
1420extern unsigned IOCTL_VT_RESIZEX;
1421extern unsigned IOCTL_VT_SENDSIG;
1422extern unsigned IOCTL_MTIOCGET;
1423extern unsigned IOCTL_MTIOCTOP;
1424extern unsigned IOCTL_SIOCADDRT;
1425extern unsigned IOCTL_SIOCDELRT;
1426extern unsigned IOCTL_SNDCTL_DSP_GETBLKSIZE;
1427extern unsigned IOCTL_SNDCTL_DSP_GETFMTS;
1428extern unsigned IOCTL_SNDCTL_DSP_NONBLOCK;
1429extern unsigned IOCTL_SNDCTL_DSP_POST;
1430extern unsigned IOCTL_SNDCTL_DSP_RESET;
1431extern unsigned IOCTL_SNDCTL_DSP_SETFMT;
1432extern unsigned IOCTL_SNDCTL_DSP_SETFRAGMENT;
1433extern unsigned IOCTL_SNDCTL_DSP_SPEED;
1434extern unsigned IOCTL_SNDCTL_DSP_STEREO;
1435extern unsigned IOCTL_SNDCTL_DSP_SUBDIVIDE;
1436extern unsigned IOCTL_SNDCTL_DSP_SYNC;
1437extern unsigned IOCTL_SNDCTL_FM_4OP_ENABLE;
1438extern unsigned IOCTL_SNDCTL_FM_LOAD_INSTR;
1439extern unsigned IOCTL_SNDCTL_MIDI_INFO;
1440extern unsigned IOCTL_SNDCTL_MIDI_PRETIME;
1441extern unsigned IOCTL_SNDCTL_SEQ_CTRLRATE;
1442extern unsigned IOCTL_SNDCTL_SEQ_GETINCOUNT;
1443extern unsigned IOCTL_SNDCTL_SEQ_GETOUTCOUNT;
1444extern unsigned IOCTL_SNDCTL_SEQ_NRMIDIS;
1445extern unsigned IOCTL_SNDCTL_SEQ_NRSYNTHS;
1446extern unsigned IOCTL_SNDCTL_SEQ_OUTOFBAND;
1447extern unsigned IOCTL_SNDCTL_SEQ_PANIC;
1448extern unsigned IOCTL_SNDCTL_SEQ_PERCMODE;
1449extern unsigned IOCTL_SNDCTL_SEQ_RESET;
1450extern unsigned IOCTL_SNDCTL_SEQ_RESETSAMPLES;
1451extern unsigned IOCTL_SNDCTL_SEQ_SYNC;
1452extern unsigned IOCTL_SNDCTL_SEQ_TESTMIDI;
1453extern unsigned IOCTL_SNDCTL_SEQ_THRESHOLD;
1454extern unsigned IOCTL_SNDCTL_SYNTH_INFO;
1455extern unsigned IOCTL_SNDCTL_SYNTH_MEMAVL;
1456extern unsigned IOCTL_SNDCTL_TMR_CONTINUE;
1457extern unsigned IOCTL_SNDCTL_TMR_METRONOME;
1458extern unsigned IOCTL_SNDCTL_TMR_SELECT;
1459extern unsigned IOCTL_SNDCTL_TMR_SOURCE;
1460extern unsigned IOCTL_SNDCTL_TMR_START;
1461extern unsigned IOCTL_SNDCTL_TMR_STOP;
1462extern unsigned IOCTL_SNDCTL_TMR_TEMPO;
1463extern unsigned IOCTL_SNDCTL_TMR_TIMEBASE;
1464extern unsigned IOCTL_SOUND_MIXER_READ_ALTPCM;
1465extern unsigned IOCTL_SOUND_MIXER_READ_BASS;
1466extern unsigned IOCTL_SOUND_MIXER_READ_CAPS;
1467extern unsigned IOCTL_SOUND_MIXER_READ_CD;
1468extern unsigned IOCTL_SOUND_MIXER_READ_DEVMASK;
1469extern unsigned IOCTL_SOUND_MIXER_READ_ENHANCE;
1470extern unsigned IOCTL_SOUND_MIXER_READ_IGAIN;
1471extern unsigned IOCTL_SOUND_MIXER_READ_IMIX;
1472extern unsigned IOCTL_SOUND_MIXER_READ_LINE1;
1473extern unsigned IOCTL_SOUND_MIXER_READ_LINE2;
1474extern unsigned IOCTL_SOUND_MIXER_READ_LINE3;
1475extern unsigned IOCTL_SOUND_MIXER_READ_LINE;
1476extern unsigned IOCTL_SOUND_MIXER_READ_LOUD;
1477extern unsigned IOCTL_SOUND_MIXER_READ_MIC;
1478extern unsigned IOCTL_SOUND_MIXER_READ_MUTE;
1479extern unsigned IOCTL_SOUND_MIXER_READ_OGAIN;
1480extern unsigned IOCTL_SOUND_MIXER_READ_PCM;
1481extern unsigned IOCTL_SOUND_MIXER_READ_RECLEV;
1482extern unsigned IOCTL_SOUND_MIXER_READ_RECMASK;
1483extern unsigned IOCTL_SOUND_MIXER_READ_RECSRC;
1484extern unsigned IOCTL_SOUND_MIXER_READ_SPEAKER;
1485extern unsigned IOCTL_SOUND_MIXER_READ_STEREODEVS;
1486extern unsigned IOCTL_SOUND_MIXER_READ_SYNTH;
1487extern unsigned IOCTL_SOUND_MIXER_READ_TREBLE;
1488extern unsigned IOCTL_SOUND_MIXER_READ_VOLUME;
1489extern unsigned IOCTL_SOUND_MIXER_WRITE_ALTPCM;
1490extern unsigned IOCTL_SOUND_MIXER_WRITE_BASS;
1491extern unsigned IOCTL_SOUND_MIXER_WRITE_CD;
1492extern unsigned IOCTL_SOUND_MIXER_WRITE_ENHANCE;
1493extern unsigned IOCTL_SOUND_MIXER_WRITE_IGAIN;
1494extern unsigned IOCTL_SOUND_MIXER_WRITE_IMIX;
1495extern unsigned IOCTL_SOUND_MIXER_WRITE_LINE1;
1496extern unsigned IOCTL_SOUND_MIXER_WRITE_LINE2;
1497extern unsigned IOCTL_SOUND_MIXER_WRITE_LINE3;
1498extern unsigned IOCTL_SOUND_MIXER_WRITE_LINE;
1499extern unsigned IOCTL_SOUND_MIXER_WRITE_LOUD;
1500extern unsigned IOCTL_SOUND_MIXER_WRITE_MIC;
1501extern unsigned IOCTL_SOUND_MIXER_WRITE_MUTE;
1502extern unsigned IOCTL_SOUND_MIXER_WRITE_OGAIN;
1503extern unsigned IOCTL_SOUND_MIXER_WRITE_PCM;
1504extern unsigned IOCTL_SOUND_MIXER_WRITE_RECLEV;
1505extern unsigned IOCTL_SOUND_MIXER_WRITE_RECSRC;
1506extern unsigned IOCTL_SOUND_MIXER_WRITE_SPEAKER;
1507extern unsigned IOCTL_SOUND_MIXER_WRITE_SYNTH;
1508extern unsigned IOCTL_SOUND_MIXER_WRITE_TREBLE;
1509extern unsigned IOCTL_SOUND_MIXER_WRITE_VOLUME;
1510extern unsigned IOCTL_SOUND_PCM_READ_BITS;
1511extern unsigned IOCTL_SOUND_PCM_READ_CHANNELS;
1512extern unsigned IOCTL_SOUND_PCM_READ_FILTER;
1513extern unsigned IOCTL_SOUND_PCM_READ_RATE;
1514extern unsigned IOCTL_SOUND_PCM_WRITE_CHANNELS;
1515extern unsigned IOCTL_SOUND_PCM_WRITE_FILTER;
1516extern unsigned IOCTL_VT_ACTIVATE;
1517extern unsigned IOCTL_VT_GETMODE;
1518extern unsigned IOCTL_VT_OPENQRY;
1519extern unsigned IOCTL_VT_RELDISP;
1520extern unsigned IOCTL_VT_SETMODE;
1521extern unsigned IOCTL_VT_WAITACTIVE;
1522# endif // SANITIZER_LINUX
1523
1524# if SANITIZER_LINUX && !SANITIZER_ANDROID
1525extern unsigned IOCTL_EQL_EMANCIPATE;
1526extern unsigned IOCTL_EQL_ENSLAVE;
1527extern unsigned IOCTL_EQL_GETMASTRCFG;
1528extern unsigned IOCTL_EQL_GETSLAVECFG;
1529extern unsigned IOCTL_EQL_SETMASTRCFG;
1530extern unsigned IOCTL_EQL_SETSLAVECFG;
1531extern unsigned IOCTL_EVIOCGKEYCODE_V2;
1532extern unsigned IOCTL_EVIOCGPROP;
1533extern unsigned IOCTL_EVIOCSKEYCODE_V2;
1534extern unsigned IOCTL_FS_IOC_GETFLAGS;
1535extern unsigned IOCTL_FS_IOC_GETVERSION;
1536extern unsigned IOCTL_FS_IOC_SETFLAGS;
1537extern unsigned IOCTL_FS_IOC_SETVERSION;
1538extern unsigned IOCTL_GIO_CMAP;
1539extern unsigned IOCTL_GIO_FONT;
1540extern unsigned IOCTL_GIO_UNIMAP;
1541extern unsigned IOCTL_GIO_UNISCRNMAP;
1542extern unsigned IOCTL_KDADDIO;
1543extern unsigned IOCTL_KDDELIO;
1544extern unsigned IOCTL_KDGETKEYCODE;
1545extern unsigned IOCTL_KDGKBDIACR;
1546extern unsigned IOCTL_KDGKBENT;
1547extern unsigned IOCTL_KDGKBLED;
1548extern unsigned IOCTL_KDGKBMETA;
1549extern unsigned IOCTL_KDGKBSENT;
1550extern unsigned IOCTL_KDMAPDISP;
1551extern unsigned IOCTL_KDSETKEYCODE;
1552extern unsigned IOCTL_KDSIGACCEPT;
1553extern unsigned IOCTL_KDSKBDIACR;
1554extern unsigned IOCTL_KDSKBENT;
1555extern unsigned IOCTL_KDSKBLED;
1556extern unsigned IOCTL_KDSKBMETA;
1557extern unsigned IOCTL_KDSKBSENT;
1558extern unsigned IOCTL_KDUNMAPDISP;
1559extern unsigned IOCTL_LPABORT;
1560extern unsigned IOCTL_LPABORTOPEN;
1561extern unsigned IOCTL_LPCAREFUL;
1562extern unsigned IOCTL_LPCHAR;
1563extern unsigned IOCTL_LPGETIRQ;
1564extern unsigned IOCTL_LPGETSTATUS;
1565extern unsigned IOCTL_LPRESET;
1566extern unsigned IOCTL_LPSETIRQ;
1567extern unsigned IOCTL_LPTIME;
1568extern unsigned IOCTL_LPWAIT;
1569extern unsigned IOCTL_MTIOCGETCONFIG;
1570extern unsigned IOCTL_MTIOCSETCONFIG;
1571extern unsigned IOCTL_PIO_CMAP;
1572extern unsigned IOCTL_PIO_FONT;
1573extern unsigned IOCTL_PIO_UNIMAP;
1574extern unsigned IOCTL_PIO_UNIMAPCLR;
1575extern unsigned IOCTL_PIO_UNISCRNMAP;
1576extern unsigned IOCTL_SCSI_IOCTL_GET_IDLUN;
1577extern unsigned IOCTL_SCSI_IOCTL_PROBE_HOST;
1578extern unsigned IOCTL_SCSI_IOCTL_TAGGED_DISABLE;
1579extern unsigned IOCTL_SCSI_IOCTL_TAGGED_ENABLE;
1580extern unsigned IOCTL_SIOCAIPXITFCRT;
1581extern unsigned IOCTL_SIOCAIPXPRISLT;
1582extern unsigned IOCTL_SIOCAX25ADDUID;
1583extern unsigned IOCTL_SIOCAX25DELUID;
1584extern unsigned IOCTL_SIOCAX25GETPARMS;
1585extern unsigned IOCTL_SIOCAX25GETUID;
1586extern unsigned IOCTL_SIOCAX25NOUID;
1587extern unsigned IOCTL_SIOCAX25SETPARMS;
1588extern unsigned IOCTL_SIOCDEVPLIP;
1589extern unsigned IOCTL_SIOCIPXCFGDATA;
1590extern unsigned IOCTL_SIOCNRDECOBS;
1591extern unsigned IOCTL_SIOCNRGETPARMS;
1592extern unsigned IOCTL_SIOCNRRTCTL;
1593extern unsigned IOCTL_SIOCNRSETPARMS;
1594extern unsigned IOCTL_SNDCTL_DSP_GETISPACE;
1595extern unsigned IOCTL_SNDCTL_DSP_GETOSPACE;
1596extern unsigned IOCTL_TIOCGSERIAL;
1597extern unsigned IOCTL_TIOCSERGETMULTI;
1598extern unsigned IOCTL_TIOCSERSETMULTI;
1599extern unsigned IOCTL_TIOCSSERIAL;
1600extern unsigned IOCTL_GIO_SCRNMAP;
1601extern unsigned IOCTL_KDDISABIO;
1602extern unsigned IOCTL_KDENABIO;
1603extern unsigned IOCTL_KDGETLED;
1604extern unsigned IOCTL_KDGETMODE;
1605extern unsigned IOCTL_KDGKBMODE;
1606extern unsigned IOCTL_KDGKBTYPE;
1607extern unsigned IOCTL_KDMKTONE;
1608extern unsigned IOCTL_KDSETLED;
1609extern unsigned IOCTL_KDSETMODE;
1610extern unsigned IOCTL_KDSKBMODE;
1611extern unsigned IOCTL_KIOCSOUND;
1612extern unsigned IOCTL_PIO_SCRNMAP;
1613# endif
1614
1615# if SANITIZER_GLIBC
1616struct __sanitizer_servent {
1617 char *s_name;
1618 char **s_aliases;
1619 int s_port;
1620 char *s_proto;
1621};
1622# endif
1623
1624extern const int si_SEGV_MAPERR;
1625extern const int si_SEGV_ACCERR;
1626} // namespace __sanitizer
1627
1628# define CHECK_TYPE_SIZE(TYPE) \
1629 COMPILER_CHECK(sizeof(__sanitizer_##TYPE) == sizeof(TYPE))
1630
1631# define CHECK_SIZE_AND_OFFSET(CLASS, MEMBER) \
1632 COMPILER_CHECK(sizeof(((__sanitizer_##CLASS *)NULL)->MEMBER) == \
1633 sizeof(((CLASS *)NULL)->MEMBER)); \
1634 COMPILER_CHECK(offsetof(__sanitizer_##CLASS, MEMBER) == \
1635 offsetof(CLASS, MEMBER))
1636
1637// For sigaction, which is a function and struct at the same time,
1638// and thus requires explicit "struct" in sizeof() expression.
1639# define CHECK_STRUCT_SIZE_AND_OFFSET(CLASS, MEMBER) \
1640 COMPILER_CHECK(sizeof(((struct __sanitizer_##CLASS *)NULL)->MEMBER) == \
1641 sizeof(((struct CLASS *)NULL)->MEMBER)); \
1642 COMPILER_CHECK(offsetof(struct __sanitizer_##CLASS, MEMBER) == \
1643 offsetof(struct CLASS, MEMBER))
1644
1645# define SIGACTION_SYMNAME sigaction
1646
1647# if SANITIZER_LINUX
1648typedef void *__sanitizer_timer_t;
1649# endif
1650
1651#endif // SANITIZER_LINUX || SANITIZER_APPLE || SANITIZER_HAIKU ||
1652 // SANITIZER_AIX
1653
1654#endif
1655