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