include/vki/vki-freebsd.h

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- FreeBSD-specific kernel interface.             vki-freebsd.h ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2000-2005 Julian Seward
  11       jseward@acm.org
  12    Copyright (C) 2018-2021 Paul Floyd
  13       pjfloyd@wanadoo.fr
  14
  15    This program is free software; you can redistribute it and/or
  16    modify it under the terms of the GNU General Public License as
  17    published by the Free Software Foundation; either version 2 of the
  18    License, or (at your option) any later version.
  19
  20    This program is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23    General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program; if not, see <http://www.gnu.org/licenses/>.
  27
  28    The GNU General Public License is contained in the file COPYING.
  29 */
  30
  31 /* This file defines types and constants for the kernel interface, and to
  32    make that clear everything is prefixed VKI_/vki_.
  33
  34    All code is copied verbatim from kernel source files, except that:
  35    - VKI_/vki_ prefixes are added
  36    - some extra explanatory comments are included;  they are all within
  37      "[[ ]]"
  38    - for some types, we only care about the size;  for a few of them (big
  39      ones that are painful to fully drag in here), a VKI_SIZEOF_* constant
  40      is used.
  41
  42    The files the code is taken from is indicated.
  43 */
  44
  45 #ifndef VKI_FREEBSD_H
  46 #define VKI_FREEBSD_H
  47
  48 //----------------------------------------------------------------------
  49 // Arch-specific POSIX types
  50 //----------------------------------------------------------------------
  51
  52 #if defined(VGA_x86)
  53 #  include "vki-machine-types-x86-freebsd.h"
  54 #elif defined(VGA_amd64)
  55 #  include "vki-machine-types-amd64-freebsd.h"
  56 #elif defined(VGA_arm64)
  57 #  include "vki-machine-types-arm64-freebsd.h"
  58 #else
  59 #  error Unknown platform
  60 #endif
  61
  62 #include <sys/fcntl.h>
  63 #include <sys/param.h>
  64
  65
  66 //----------------------------------------------------------------------
  67 // From sys/select.h
  68 //----------------------------------------------------------------------
  69
  70 typedef unsigned long __vki_fd_mask;
  71
  72 #undef __VKI_NFDBITS
  73 #define __VKI_NFDBITS   (8 * sizeof(__vki_fd_mask))
  74
  75 #undef __VKI_FD_SETSIZE
  76 #define __VKI_FD_SETSIZE   1024U
  77
  78 #undef __VKI_FDSET_LONGS
  79 #define __VKI_FDSET_LONGS  (__VKI_FD_SETSIZE/__VKI_NFDBITS)
  80
  81 #undef __VKI_FDELT
  82 #define  __VKI_FDELT(d) ((d) / __VKI_NFDBITS)
  83
  84 #undef __VKI_FDMASK
  85 #define  __VKI_FDMASK(d)   (1UL << ((d) % __VKI_NFDBITS))
  86
  87 typedef struct {
  88    unsigned long fds_bits [__VKI_FDSET_LONGS];
  89 } __vki_fd_set;
  90
  91 //----------------------------------------------------------------------
  92 // sys/_types.h
  93 //----------------------------------------------------------------------
  94 /* MD QQQ 32 on 64 */
  95 typedef  long     __vki_key_t;
  96 typedef  long     __vki_suseconds_t;
  97 typedef  struct __timer *__vki_timer_t;
  98 typedef  struct __mq *__vki_mqd_t;
  99
 100 /* MI */
 101 typedef  vki_uint32_t   __vki_blksize_t;
 102 typedef  vki_int64_t __vki_blkcnt_t;
 103 typedef  vki_int32_t __vki_clockid_t;
 104 typedef  vki_int32_t __vki_ct_rune_t;
 105 typedef  vki_uint32_t   __vki_fflags_t;
 106 typedef  vki_uint64_t   __vki_fsblkcnt_t;
 107 typedef  vki_uint64_t   __vki_fsfilcnt_t;
 108 typedef  vki_uint32_t   __vki_gid_t;
 109 typedef  vki_int64_t __vki_id_t;
 110 typedef  vki_uint64_t   __vki_ino_t;
 111 typedef  vki_int32_t __vki_lwpid_t;
 112 typedef  vki_uint16_t   __vki_mode_t;
 113 typedef  vki_uint64_t   __vki_nlink_t;
 114 typedef  vki_int64_t __vki_off_t;
 115 typedef  vki_int32_t __vki_pid_t;
 116 typedef  vki_int64_t __vki_rlim_t;
 117 typedef  vki_uint8_t __vki_sa_family_t;
 118 typedef  vki_uint32_t   __vki_socklen_t;
 119 typedef  vki_uint32_t   __vki_uid_t;
 120 typedef  vki_int32_t __vki_useconds_t;
 121 typedef  __vki_ct_rune_t   __vki_rune_t;
 122 typedef  __vki_ct_rune_t   __vki_wchar_t;
 123 typedef  __vki_ct_rune_t   __vki_wint_t;
 124 typedef  vki_uint64_t   __vki_dev_t;
 125 typedef  vki_uint32_t   __vki_fixpt_t;
 126
 127
 128 //----------------------------------------------------------------------
 129 // sys/types.h
 130 //----------------------------------------------------------------------
 131
 132 typedef  vki_uint8_t    vki_u_int8_t;
 133 typedef  vki_uint16_t      vki_u_int16_t;
 134 typedef  vki_uint32_t      vki_u_int32_t;
 135 typedef  vki_uint64_t      vki_u_int64_t;
 136
 137 typedef  vki_uint64_t      vki_u_quad_t;
 138 typedef  vki_int64_t    vki_quad_t;
 139 typedef  __vki_caddr_t     vki_caddr_t;
 140 typedef __const __vki_caddr_t vki_c_caddr_t;
 141 typedef __volatile __vki_caddr_t vki_v_caddr_t;
 142
 143 typedef __vki_blksize_t    vki_blksize_t;
 144 typedef __vki_blkcnt_t     vki_blkcnt_t;
 145 typedef __vki_clock_t      vki_clock_t;
 146 typedef __vki_clockid_t    vki_clockid_t;
 147 typedef __vki_dev_t     vki_dev_t;
 148 typedef __vki_fflags_t     vki_fflags_t;
 149 typedef __vki_fixpt_t      vki_fixpt_t;
 150 typedef __vki_fsblkcnt_t   vki_fsblkcnt_t;
 151 typedef __vki_fsfilcnt_t   vki_fsfilcnt_t;
 152 typedef __vki_gid_t     vki_gid_t;
 153 typedef vki_uint32_t    vki_in_addr_t;
 154 typedef vki_uint16_t    vki_in_port_t;
 155 typedef __vki_id_t      vki_id_t;
 156 typedef __vki_ino_t     vki_ino_t;
 157 typedef __vki_key_t     vki_key_t;
 158 typedef __vki_lwpid_t      vki_lwpid_t;
 159 typedef __vki_mode_t    vki_mode_t;
 160 typedef __vki_nlink_t      vki_nlink_t;
 161 typedef __vki_off_t     vki_off_t;
 162 typedef __vki_pid_t     vki_pid_t;
 163 typedef __vki_register_t   vki_register_t;
 164 typedef __vki_rlim_t    vki_rlim_t;
 165 typedef __vki_segsz_t      vki_segsz_t;
 166 typedef __vki_size_t    vki_size_t;
 167 typedef __vki_ssize_t      vki_ssize_t;
 168 typedef __vki_suseconds_t  vki_suseconds_t;
 169 typedef __vki_time_t    vki_time_t;
 170 typedef __vki_timer_t      vki_timer_t;
 171 typedef __vki_mqd_t     vki_mqd_t;
 172 typedef __vki_u_register_t vki_u_register_t;
 173 typedef __vki_uid_t     vki_uid_t;
 174 typedef __vki_useconds_t   vki_useconds_t;
 175 typedef int             vki_cpuwhich_t;
 176 typedef int             vki_cpulevel_t;
 177 typedef int             vki_cpusetid_t;
 178
 179
 180 typedef __vki_vm_offset_t  vki_vm_offset_t;
 181 typedef __vki_vm_ooffset_t vki_vm_ooffset_t;
 182 typedef __vki_vm_paddr_t   vki_vm_paddr_t;
 183 typedef __vki_vm_pindex_t  vki_vm_pindex_t;
 184 typedef __vki_vm_size_t    vki_vm_size_t;
 185
 186 //----------------------------------------------------------------------
 187 // sys/select.h
 188 //----------------------------------------------------------------------
 189
 190 typedef __vki_fd_set    vki_fd_set;
 191
 192 //----------------------------------------------------------------------
 193 // Now the rest of the arch-specific stuff
 194 //----------------------------------------------------------------------
 195
 196 #if defined(VGA_x86)
 197 #  include "vki-x86-freebsd.h"
 198 #elif defined(VGA_amd64)
 199 #  include "vki-amd64-freebsd.h"
 200 #elif defined(VGA_arm64)
 201 #  include "vki-arm64-freebsd.h"
 202 #else
 203 #  error Unknown platform
 204 #endif
 205
 206 //----------------------------------------------------------------------
 207 // freebsd version hacks
 208 //----------------------------------------------------------------------
 209 #ifndef ELFMAG
 210 #define ELFMAG "\177ELF"   /* magic string */
 211 #endif
 212 #ifndef SELFMAG
 213 #define SELFMAG   4     /* magic string size */
 214 #endif
 215
 216 // see http://bugs.freebsd.org/bugzilla/show_bug.cgi?id=239669
 217 #if !defined(ELF_NOTE_GNU)
 218 #define ELF_NOTE_GNU "GNU"
 219 #endif
 220
 221
 222 #define VKI_ELF_NOTE_ROUNDSIZE 4
 223
 224
 225 //----------------------------------------------------------------------
 226 // From sys/syslimits.h
 227 //----------------------------------------------------------------------
 228
 229 #define VKI_PATH_MAX       1024
 230
 231
 232 //----------------------------------------------------------------------
 233 // From sys/timespec.h
 234 //----------------------------------------------------------------------
 235
 236 struct vki_timespec {
 237    vki_time_t  tv_sec;     /* seconds */
 238    long     tv_nsec; /* nanoseconds */
 239 };
 240
 241 struct  vki_itimerspec {
 242    struct  vki_timespec it_interval;    /* timer period */
 243    struct  vki_timespec it_value;       /* timer expiration */
 244 };
 245
 246 //----------------------------------------------------------------------
 247 // From sys/_time.h
 248 //----------------------------------------------------------------------
 249
 250 struct vki_timeval {
 251    vki_time_t  tv_sec;     /* seconds */
 252    vki_suseconds_t   tv_usec; /* microseconds */
 253 };
 254
 255 //----------------------------------------------------------------------
 256 // From sys/time.h
 257 //----------------------------------------------------------------------
 258
 259 #define VKI_CLOCK_REALTIME            0
 260 #define VKI_CLOCK_MONOTONIC           1
 261 #define VKI_CLOCK_PROCESS_CPUTIME_ID  2
 262 #define VKI_CLOCK_THREAD_CPUTIME_ID   3
 263
 264 struct vki_timezone {
 265    int   tz_minuteswest;   /* minutes west of Greenwich */
 266    int   tz_dsttime; /* type of dst correction */
 267 };
 268
 269 struct   vki_itimerval {
 270    struct   vki_timeval it_interval;   /* timer interval */
 271    struct   vki_timeval it_value;   /* current value */
 272 };
 273
 274 //----------------------------------------------------------------------
 275 // From sys/timex.h
 276 //----------------------------------------------------------------------
 277
 278 struct vki_ntptimeval {
 279    struct vki_timespec time;
 280    long maxerror;
 281    long esterror;
 282    long tai;
 283    int time_state;
 284 };
 285
 286 struct vki_timex {
 287    unsigned int modes;  /* mode selector */
 288    long offset;      /* time offset (usec) */
 289    long freq;     /* frequency offset (scaled ppm) */
 290    long maxerror;    /* maximum error (usec) */
 291    long esterror;    /* estimated error (usec) */
 292    int status;    /* clock command/status */
 293    long constant;    /* pll time constant */
 294    long precision;      /* clock precision (usec) (read only) */
 295    long tolerance;      /* clock frequency tolerance (ppm)
 296              * (read only)
 297              */
 298    long ppsfreq;           /* pps frequency (scaled ppm) (ro) */
 299    long jitter;            /* pps jitter (us) (ro) */
 300    int shift;              /* interval duration (s) (shift) (ro) */
 301    long stabil;            /* pps stability (scaled ppm) (ro) */
 302    long jitcnt;            /* jitter limit exceeded (ro) */
 303    long calcnt;            /* calibration intervals (ro) */
 304    long errcnt;            /* calibration errors (ro) */
 305    long stbcnt;            /* stability limit exceeded (ro) */
 306 };
 307
 308 #define MOD_OFFSET      0x0001   /* time offset */
 309 #define MOD_FREQUENCY      0x0002   /* frequency offset */
 310 #define MOD_MAXERROR    0x0004   /* maximum time error */
 311 #define MOD_ESTERROR    0x0008   /* estimated time error */
 312 #define MOD_STATUS      0x0010   /* clock status */
 313 #define MOD_TIMECONST      0x0020   /* pll time constant */
 314 #define MOD_PPSMAX      0x0040
 315 #define MOD_TAI         0x0080
 316 #define MOD_MICRO    0x1000
 317 #define MOD_NANO     0x2000
 318 #define MOD_CLKB     0x4000
 319 #define MOD_CLKA     0x8000
 320
 321 //----------------------------------------------------------------------
 322 // From sys/times.h
 323 //----------------------------------------------------------------------
 324
 325 struct vki_tms {
 326    vki_clock_t tms_utime;
 327    vki_clock_t tms_stime;
 328    vki_clock_t tms_cutime;
 329    vki_clock_t tms_cstime;
 330 };
 331
 332 //----------------------------------------------------------------------
 333 // From sys/stat.h
 334 //----------------------------------------------------------------------
 335
 336 /* QQQ 4.x stat layout */
 337 struct vki_freebsd11_stat {
 338    vki_uint32_t   st_dev;
 339    vki_uint32_t   st_ino;
 340    vki_mode_t  st_mode;
 341    vki_uint16_t st_nlink;
 342    vki_uid_t   st_uid;
 343    vki_gid_t   st_gid;
 344    vki_uint32_t   st_rdev;
 345 #if 0
 346    struct vki_timespec  st_atimespec;
 347    struct vki_timespec  st_mtimespec;
 348    struct vki_timespec  st_ctimespec;
 349 #else
 350    vki_time_t  st_atime;
 351    long     st_atime_nsec;
 352    vki_time_t  st_mtime;
 353    long     st_mtime_nsec;
 354    vki_time_t  st_ctime;
 355    long     st_ctime_nsec;
 356 #endif
 357    vki_off_t   st_size;
 358    vki_blkcnt_t   st_blocks;
 359    vki_blksize_t  st_blksize;
 360    vki_fflags_t   st_flags;
 361    vki_uint32_t   st_gen;
 362    vki_int32_t st_lspare;
 363    struct vki_timespec  st_birthtimespec;
 364 unsigned int :
 365    (8 / 2) * (16 - (int)sizeof(struct vki_timespec));
 366 unsigned int :
 367    (8 / 2) * (16 - (int)sizeof(struct vki_timespec));
 368 };
 369
 370 #if defined(VGP_x86_freebsd)
 371 #define  VKI_STAT_TIME_T_EXT  1
 372 #endif
 373
 374 /*
 375  * FreeBSD 12 has two versions of the stat struct
 376  * freebsd11_stat, which is the same as vki_stat above
 377  * and just stat, which is the same as vki_stat below
 378  * Since vki_stat is used by other OSes, it's best not to
 379  * use the same naming
 380  */
 381
 382 struct vki_stat {
 383    vki_dev_t     st_dev;
 384    vki_ino_t     st_ino;
 385    vki_nlink_t   st_nlink;
 386    vki_mode_t   st_mode;
 387    vki_int16_t st_padding0;
 388    vki_uid_t    st_uid;
 389    vki_gid_t    st_gid;
 390    vki_int32_t st_padding1;
 391    vki_dev_t     st_rdev;
 392 #ifdef   VKI_STAT_TIME_T_EXT
 393    vki_int32_t st_atim_ext;
 394 #endif
 395    //struct   vki_timespec st_atim;
 396    vki_time_t st_atime;
 397    long    st_atime_nsec;
 398 #ifdef   VKI_STAT_TIME_T_EXT
 399    vki_int32_t st_mtim_ext;
 400 #endif
 401    //struct   vki_timespec st_mtim;
 402    vki_time_t st_mtime;
 403    long    st_mtime_nsec;
 404 #ifdef   VKI_STAT_TIME_T_EXT
 405    vki_int32_t st_ctim_ext;
 406 #endif
 407    //struct   vki_timespec st_ctim;
 408    vki_time_t st_ctime;
 409    long    st_ctime_nsec;
 410 #ifdef   VKI_STAT_TIME_T_EXT
 411    vki_int32_t st_btim_ext;
 412 #endif
 413    //struct   vki_timespec st_birthtim;
 414    vki_time_t st_btime;
 415    long    st_btime_nsec;
 416    vki_off_t    st_size;
 417    vki_blkcnt_t st_blocks;
 418    vki_blksize_t st_blksize;
 419    vki_fflags_t  st_flags;
 420    vki_uint64_t st_gen;
 421    vki_uint64_t st_spare[10];
 422 };
 423
 424
 425
 426 //----------------------------------------------------------------------
 427 // From linux-2.6.8.1/include/linux/sched.h
 428 //----------------------------------------------------------------------
 429
 430 struct vki_sched_param {
 431    int sched_priority;
 432 };
 433
 434 //----------------------------------------------------------------------
 435 // From sys/signal.h
 436 //----------------------------------------------------------------------
 437
 438 #define  VKI_SIG_BLOCK  1  /*  block specified signal set */
 439 #define  VKI_SIG_UNBLOCK   2  /*  unblock specified signal set */
 440 #define  VKI_SIG_SETMASK   3  /*  set specified signal set */
 441
 442 #define  VKI_SIG_DFL ((__vki_sighandler_t)0)
 443 #define  VKI_SIG_IGN ((__vki_sighandler_t)1)
 444 #define  VKI_SIG_ERR ((__vki_sighandler_t)-1)
 445
 446 typedef void __vki_signalfn_t(int);
 447 typedef __vki_signalfn_t *__vki_sighandler_t;
 448
 449 #define  VKI_SIGHUP     1
 450 #define  VKI_SIGINT     2
 451 #define  VKI_SIGQUIT    3
 452 #define  VKI_SIGILL     4
 453 #define  VKI_SIGTRAP    5
 454 #define  VKI_SIGABRT    6
 455 #define  VKI_SIGEMT     7
 456 #define  VKI_SIGFPE     8
 457 #define  VKI_SIGKILL    9
 458 #define  VKI_SIGBUS     10
 459 #define  VKI_SIGSEGV    11
 460 #define  VKI_SIGSYS     12
 461 #define  VKI_SIGPIPE    13
 462 #define  VKI_SIGALRM    14
 463 #define  VKI_SIGTERM    15
 464 #define  VKI_SIGURG     16
 465 #define  VKI_SIGSTOP    17
 466 #define  VKI_SIGTSTP    18
 467 #define  VKI_SIGCONT    19
 468 #define  VKI_SIGCHLD    20
 469 #define  VKI_SIGTTIN    21
 470 #define  VKI_SIGTTOU    22
 471 #define  VKI_SIGIO      23
 472 #define  VKI_SIGXCPU    24
 473 #define  VKI_SIGXFSZ    25
 474 #define  VKI_SIGVTALRM  26
 475 #define  VKI_SIGPROF    27
 476 #define  VKI_SIGWINCH   28
 477 #define  VKI_SIGINFO    29
 478 #define  VKI_SIGUSR1    30
 479 #define  VKI_SIGUSR2    31
 480 #define  VKI_SIGTHR     32
 481 #define  VKI_SIGLIBRT   33
 482
 483 #define  VKI_SIGRTMIN      65
 484 #define  VKI_SIGRTMAX      126
 485
 486 #define  VKI_SA_ONSTACK    0x0001
 487 #define  VKI_SA_RESTART    0x0002
 488 #define  VKI_SA_RESETHAND  0x0004
 489 #define  VKI_SA_NOCLDSTOP  0x0008
 490 #define  VKI_SA_NODEFER    0x0010
 491 #define  VKI_SA_NOCLDWAIT  0x0020
 492 #define  VKI_SA_SIGINFO    0x0040
 493 #define VKI_SA_RESTORER         0 /* FreeBSD doesn't have this */
 494
 495 #define  VKI_SS_ONSTACK    0x0001
 496 #define  VKI_SS_DISABLE    0x0004
 497
 498 #define  VKI_SA_ONESHOT    VKI_SA_RESETHAND
 499 #define  VKI_SA_NOMASK     VKI_SA_NODEFER
 500
 501 struct vki_sigaction {
 502    __vki_sighandler_t ksa_handler;
 503    int      sa_flags;
 504    vki_sigset_t   sa_mask;
 505 };
 506
 507 typedef struct vki_sigaltstack {
 508    void     *ss_sp;
 509    vki_size_t  ss_size;
 510    int      ss_flags;
 511 } vki_stack_t;
 512
 513 typedef union vki_sigval {
 514    int sival_int;
 515    void *sival_ptr;
 516 } vki_sigval_t;
 517
 518 typedef struct vki_siginfo {
 519    int si_signo;
 520    int si_errno;
 521    int si_code;
 522    vki_pid_t si_pid;
 523    vki_uid_t si_uid;
 524    int si_status;
 525    void *si_addr;
 526    vki_sigval_t si_value;
 527 // 666: not valid. switch to above def
 528 #ifdef si_band
 529 #undef si_band
 530 #endif
 531    long si_band;
 532    int __spare__[7];
 533 } vki_siginfo_t;
 534
 535 /*
 536  * si_code values
 537  */
 538 #define VKI_SI_USER  0x10001     /* sent by kill, sigsend, raise */
 539 #define VKI_SI_QUEUE 0x10002
 540 #define VKI_SI_TIMER 0x10003
 541 #define VKI_SI_ASYNCIO  0x10004
 542 #define VKI_SI_MESGQ 0x10005
 543 #define VKI_SI_KERNEL   0x10006
 544 #define VKI_SI_LWP      0x10007
 545 /*
 546  * SIGILL si_codes
 547  */
 548 #define VKI_ILL_ILLOPC  1  /* illegal opcode */
 549 #define VKI_ILL_ILLOPN  2  /* illegal operand */
 550 #define VKI_ILL_ILLADR  3  /* illegal addressing mode */
 551 #define VKI_ILL_ILLTRP  4  /* illegal trap */
 552 #define VKI_ILL_PRVOPC  5  /* privileged opcode */
 553 #define VKI_ILL_PRVREG  6  /* privileged register */
 554 #define VKI_ILL_COPROC  7  /* coprocessor error */
 555 #define VKI_ILL_BADSTK  8  /* internal stack error */
 556
 557 /*
 558  * SIGFPE si_codes
 559  */
 560 #define VKI_FPE_INTOVF  1  /* integer overflow */
 561 #define VKI_FPE_INTDIV  2  /* integer divide by zero */
 562 #define VKI_FPE_FLTDIV  3  /* floating point divide by zero */
 563 #define VKI_FPE_FLTOVF  4  /* floating point overflow */
 564 #define VKI_FPE_FLTUND  5  /* floating point underflow */
 565 #define VKI_FPE_FLTRES  6  /* floating point inexact result */
 566 #define VKI_FPE_FLTINV  7  /* floating point invalid operation */
 567 #define VKI_FPE_FLTSUB  8  /* subscript out of range */
 568
 569 /*
 570  * SIGSEGV si_codes
 571  */
 572 #define VKI_SEGV_MAPERR 1  /* address not mapped to object */
 573 #define VKI_SEGV_ACCERR 2  /* invalid permissions for mapped object */
 574 /* XXX i386 and amd64 specific */
 575 #define  VKI_SEGV_PAGE_FAULT  12
 576
 577 /*
 578  * SIGBUS si_codes
 579  */
 580 #define VKI_BUS_ADRALN  1  /* invalid address alignment */
 581 #define VKI_BUS_ADRERR  2  /* non-existant physical address */
 582 #define VKI_BUS_OBJERR  3  /* object specific hardware error */
 583 #define VKI_BUS_OOMERR  100   /* Non-standard: No memory.  */
 584
 585 /*
 586  * SIGTRAP si_codes
 587  */
 588 #define VKI_TRAP_BRKPT  1  /* process breakpoint */
 589 #define VKI_TRAP_TRACE  2  /* process trace trap */
 590 #define VKI_TRAP_DTRACE 3   /* DTrace induced trap.                 */
 591 #define VKI_TRAP_CAP    4   /* Capabilities protective trap.        */
 592
 593 /*
 594  * SIGCHLD si_codes
 595  */
 596 #define VKI_CLD_EXITED    1  /* child has exited */
 597 #define VKI_CLD_KILLED    2  /* child was killed */
 598 #define VKI_CLD_DUMPED    3  /* child terminated abnormally */
 599 #define VKI_CLD_TRAPPED   4  /* traced child has trapped */
 600 #define VKI_CLD_STOPPED   5  /* child has stopped */
 601 #define VKI_CLD_CONTINUED 6  /* stopped child has continued */
 602
 603 #if 0 /* freebsd-6 */
 604 typedef struct vki_sigevent {
 605    int sigev_notify;
 606    int sigev_signo;
 607    vki_sigval_t sigev_value;
 608    union {
 609       int _threadid;
 610
 611       struct {
 612          void (*_function)(vki_sigval_t);
 613          void *_attribute; /* really pthread_attr_t */
 614       } _sigev_thread;
 615       long __spare__[8];
 616    } _sigev_un;
 617 } vki_sigevent_t;
 618 #endif
 619
 620 struct vki_sigevent {
 621    int     sigev_notify;           /* Notification type */
 622    union {
 623       int   __sigev_signo;  /* Signal number */
 624       int   __sigev_notify_kqueue;
 625    } __sigev_u;
 626    vki_sigval_t sigev_value;       /* Signal value */
 627 };
 628 #if 0
 629 #define sigev_signo             __sigev_u.__sigev_signo
 630 #define sigev_notify_kqueue     __sigev_u.__sigev_notify_kqueue
 631 #endif
 632
 633 //----------------------------------------------------------------------
 634 // From sys/_iovec.h
 635 //----------------------------------------------------------------------
 636
 637 struct vki_iovec {
 638    void *iov_base;
 639    __vki_size_t iov_len;
 640 };
 641
 642 //----------------------------------------------------------------------
 643 // From sys/socket.h
 644 //----------------------------------------------------------------------
 645
 646 typedef __vki_sa_family_t  vki_sa_family_t;
 647 typedef __vki_socklen_t    vki_socklen_t;
 648
 649 struct vki_sockaddr {
 650    vki_uint8_t sa_len;
 651    vki_sa_family_t   sa_family;  /* address family, AF_xxx  */
 652    char     sa_data[14];   /* 14 bytes of protocol address  */
 653 };
 654
 655 struct vki_msghdr {
 656    void  *  msg_name;   /* Socket name       */
 657    vki_socklen_t  msg_namelen;   /* Length of name    */
 658    struct vki_iovec *   msg_iov; /* Data blocks       */
 659    int      msg_iovlen; /* Number of blocks     */
 660    void  *  msg_control;   /* Per protocol magic (eg BSD file descriptor passing) */
 661    vki_socklen_t  msg_controllen;   /* Length of cmsg list */
 662    int      msg_flags;
 663 };
 664
 665 struct vki_cmsghdr {
 666    vki_socklen_t  cmsg_len;   /* data byte count, including hdr */
 667    int    cmsg_level; /* originating protocol */
 668    int    cmsg_type;  /* protocol-specific type */
 669 };
 670
 671 #define __VKI_CMSG_NXTHDR(ctl, len, cmsg) __vki_cmsg_nxthdr((ctl),(len),(cmsg))
 672 #define VKI_CMSG_NXTHDR(mhdr, cmsg) vki_cmsg_nxthdr((mhdr), (cmsg))
 673
 674 #define VKI_CMSG_ALIGN(len) ( ((len)+sizeof(long)-1) & ~(sizeof(long)-1) )
 675
 676 #define VKI_CMSG_DATA(cmsg)   ((void *)((char *)(cmsg) + VKI_CMSG_ALIGN(sizeof(struct vki_cmsghdr))))
 677
 678 #define __VKI_CMSG_FIRSTHDR(ctl,len) ((len) >= sizeof(struct vki_cmsghdr) ? \
 679               (struct vki_cmsghdr *)(ctl) : \
 680               (struct vki_cmsghdr *)NULL)
 681 #define VKI_CMSG_FIRSTHDR(msg)   __VKI_CMSG_FIRSTHDR((msg)->msg_control, (msg)->msg_controllen)
 682
 683 // [[Urgh, this is revolting...]
 684 // QQQ check
 685 static __inline struct vki_cmsghdr * __vki_cmsg_nxthdr(void *__ctl, vki_socklen_t __size,
 686       struct vki_cmsghdr *__cmsg)
 687 {
 688    struct vki_cmsghdr * __ptr;
 689
 690    __ptr = (struct vki_cmsghdr*)(((unsigned char *) __cmsg) +  VKI_CMSG_ALIGN(__cmsg->cmsg_len));
 691    if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
 692       return (struct vki_cmsghdr *)0;
 693
 694    return __ptr;
 695 }
 696
 697 static __inline struct vki_cmsghdr * vki_cmsg_nxthdr (struct vki_msghdr *__msg, struct vki_cmsghdr *__cmsg)
 698 {
 699    return __vki_cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
 700 }
 701
 702 #define  VKI_SCM_RIGHTS 0x01     /* rw: access rights (array of int) */
 703
 704 #define VKI_AF_UNIX  1  /* Unix domain sockets     */
 705 #define VKI_AF_INET  2  /* Internet IP Protocol    */
 706 #define VKI_AF_INET6 28 /* IP version 6         */
 707
 708 #define VKI_MSG_NOSIGNAL   0x20000  /* Do not generate SIGPIPE */
 709
 710 #define VKI_SOL_SOCKET  0xffff
 711
 712 #define VKI_SO_TYPE  0x1008
 713
 714 #define VKI_SOCK_STREAM 1
 715
 716 #include <netinet/tcp.h>
 717
 718 #define VKI_TCP_NODELAY  TCP_NODELAY
 719
 720 #include <netinet/in.h>
 721
 722 #define VKI_IPPROTO_TCP  IPPROTO_TCP
 723
 724 struct vki_sf_hdtr {
 725    struct iovec *headers;
 726    int hdr_cnt;
 727    struct iovec *trailers;
 728    int trl_cnt;
 729 };
 730
 731
 732 //----------------------------------------------------------------------
 733 // From netinet/in.h
 734 //----------------------------------------------------------------------
 735
 736 struct vki_in_addr {
 737    vki_in_addr_t  s_addr;
 738 };
 739
 740 /* Structure describing an Internet (IP) socket address. */
 741 #define __VKI_SOCK_SIZE__  16 /* sizeof(struct sockaddr) */
 742 struct vki_sockaddr_in {
 743    vki_uint8_t     sin_len;
 744    vki_sa_family_t sin_family; /* Address family    */
 745    vki_in_port_t      sin_port;   /* Port number       */
 746    struct vki_in_addr sin_addr;   /* Internet address     */
 747    char         sin_zero[8];
 748 };
 749
 750 //----------------------------------------------------------------------
 751 // From netinet6/in6.h
 752 //----------------------------------------------------------------------
 753
 754 struct vki_in6_addr {
 755    union {
 756       vki_uint8_t u6_addr8[16];
 757       vki_uint16_t   u6_addr16[8];
 758       vki_uint32_t   u6_addr32[4];
 759    } vki_in6_u;
 760 #define vki_s6_addr     vki_in6_u.u6_addr8
 761 #define vki_s6_addr16      vki_in6_u.u6_addr16
 762 #define vki_s6_addr32      vki_in6_u.u6_addr32
 763 };
 764
 765 struct vki_sockaddr_in6 {
 766    vki_uint8_t    sin6_len;
 767    vki_sa_family_t      sin6_family;    /* AF_INET6 */
 768    vki_uint16_t      sin6_port;      /* Transport layer port # */
 769    vki_uint32_t      sin6_flowinfo;  /* IPv6 flow information */
 770    struct vki_in6_addr  sin6_addr;      /* IPv6 address */
 771    vki_uint32_t      sin6_scope_id;  /* scope id (new in RFC2553) */
 772 };
 773
 774 //----------------------------------------------------------------------
 775 // From netinet/sctp_uio.h
 776 //----------------------------------------------------------------------
 777 #define VKI_SCTP_ALIGN_RESV_PAD 92
 778
 779 typedef vki_uint32_t vki_sctp_assoc_t;
 780
 781 struct vki_sctp_sndrcvinfo {
 782    vki_uint16_t sinfo_stream;
 783    vki_uint16_t sinfo_ssn;
 784    vki_uint16_t sinfo_flags;
 785    vki_uint32_t sinfo_ppid;
 786    vki_uint32_t sinfo_context;
 787    vki_uint32_t sinfo_timetolive;
 788    vki_uint32_t sinfo_tsn;
 789    vki_uint32_t sinfo_cumtsn;
 790    vki_sctp_assoc_t sinfo_assoc_id;
 791    vki_uint16_t sinfo_keynumber;
 792    vki_uint16_t sinfo_keynumber_valid;
 793    vki_uint8_t __reserve_pad[VKI_SCTP_ALIGN_RESV_PAD];
 794 };
 795
 796 //----------------------------------------------------------------------
 797 // From sys/un.h
 798 //----------------------------------------------------------------------
 799
 800 #define VKI_UNIX_PATH_MAX  104   /* QQQ overridden by sun_len */
 801
 802 struct vki_sockaddr_un {
 803    unsigned char sun_len;
 804    vki_sa_family_t sun_family;   /* AF_UNIX */
 805    char sun_path[VKI_UNIX_PATH_MAX];   /* pathname */
 806 };
 807
 808 //----------------------------------------------------------------------
 809 // From aio.h
 810 //----------------------------------------------------------------------
 811
 812 struct vki___aiocb_private {
 813    long    status;
 814    long    error;
 815    void    *kernelinfo;
 816 };
 817
 818 typedef struct vki_aiocb {
 819    int     aio_fildes;
 820    vki_off_t   aio_offset;
 821    volatile void *aio_buf;
 822    vki_size_t  aio_nbytes;
 823    int     __spare__[2];
 824    void    *__spare2__;
 825    int     aio_lio_opcode;
 826    int     aio_reqprio;
 827    struct  vki___aiocb_private _aiocb_private;
 828    struct  vki_sigevent aio_sigevent;
 829 } aiocb_t;
 830
 831 #define VKI_LIO_NOP                 0x0
 832 #define VKI_LIO_WRITE               0x1
 833 #define VKI_LIO_READ                0x2
 834
 835 #define VKI_LIO_NOWAIT              0x0
 836 #define VKI_LIO_WAIT                0x1
 837
 838
 839 #define VKI_LIO_NOWAIT 0x0
 840
 841 //----------------------------------------------------------------------
 842 // From sys/mount.h
 843 //----------------------------------------------------------------------
 844
 845 typedef struct vki_fsid {
 846    vki_int32_t val[2];
 847 } vki_fsid_t;
 848 #define VKI_OMFSNAMELEN 16
 849 #define VKI_OMNAMELEN   (88 - 2 * sizeof(long))
 850 #define VKI_MFSNAMELEN  16
 851 #define VKI_FREEBSD11_MNAMELEN   88
 852
 853 struct vki_freebsd11_statfs {
 854    vki_uint32_t f_version;
 855    vki_uint32_t f_type;
 856    vki_uint64_t f_flags;
 857    vki_uint64_t f_bsize;
 858    vki_uint64_t f_iosize;
 859    vki_uint64_t f_blocks;
 860    vki_uint64_t f_bfree;
 861    vki_int64_t  f_bavail;
 862    vki_uint64_t f_files;
 863    vki_int64_t  f_ffree;
 864    vki_uint64_t f_syncwrites;
 865    vki_uint64_t f_asyncwrites;
 866    vki_uint64_t f_syncreads;
 867    vki_uint64_t f_asyncreads;
 868    vki_uint64_t f_spare[10];
 869    vki_uint32_t f_namemax;
 870    vki_uid_t     f_owner;
 871    vki_fsid_t    f_fsid;
 872    char      f_charspare[80];
 873    char      f_fstypename[VKI_OMFSNAMELEN];
 874    char      f_mntfromname[VKI_FREEBSD11_MNAMELEN];
 875    char      f_mntonname[VKI_FREEBSD11_MNAMELEN];
 876 };
 877
 878
 879 #define MAXFIDSZ        16
 880
 881 struct vki_fid {
 882    vki_uint16_t    fid_len;
 883    vki_uint16_t    fid_reserved;
 884    char            fid_data[MAXFIDSZ];
 885 };
 886
 887 struct vki_fhandle {
 888    vki_fsid_t  fh_fsid;
 889    struct vki_fid fh_fid;
 890 };
 891
 892
 893 #define VKI_MNAMELEN        1024
 894 struct vki_statfs {
 895    vki_uint32_t f_version;
 896    vki_uint32_t f_type;
 897    vki_uint64_t f_flags;
 898    vki_uint64_t f_bsize;
 899    vki_uint64_t f_iosize;
 900    vki_uint64_t f_blocks;
 901    vki_uint64_t f_bfree;
 902    vki_int64_t  f_bavail;
 903    vki_uint64_t f_files;
 904    vki_int64_t  f_ffree;
 905    vki_uint64_t f_syncwrites;
 906    vki_uint64_t f_asyncwrites;
 907    vki_uint64_t f_syncreads;
 908    vki_uint64_t f_asyncreads;
 909    vki_uint64_t f_spare[10];
 910    vki_uint32_t f_namemax;
 911    vki_uid_t     f_owner;
 912    vki_fsid_t    f_fsid;
 913    char      f_charspare[80];
 914    char      f_fstypename[VKI_MFSNAMELEN];
 915    char      f_mntfromname[VKI_MNAMELEN];
 916    char      f_mntonname[VKI_MNAMELEN];
 917 };
 918
 919 typedef struct vki_fhandle  vki_fhandle_t;
 920
 921 //----------------------------------------------------------------------
 922 // From sys/ttycom.h
 923 //----------------------------------------------------------------------
 924
 925 struct vki_winsize {
 926    unsigned short ws_row;
 927    unsigned short ws_col;
 928    unsigned short ws_xpixel;
 929    unsigned short ws_ypixel;
 930 };
 931
 932
 933 //----------------------------------------------------------------------
 934 // From sys/termios.h
 935 //----------------------------------------------------------------------
 936
 937 typedef unsigned int    vki_tcflag_t;
 938 typedef unsigned char   vki_cc_t;
 939 typedef unsigned int    vki_speed_t;
 940
 941 #define VKI_NCCS 20
 942 struct vki_termios {
 943    vki_tcflag_t c_iflag;      /* input mode flags */
 944    vki_tcflag_t c_oflag;      /* output mode flags */
 945    vki_tcflag_t c_cflag;      /* control mode flags */
 946    vki_tcflag_t c_lflag;      /* local mode flags */
 947    vki_cc_t c_cc[VKI_NCCS];   /* control characters */
 948    vki_speed_t c_ispeed;
 949    vki_speed_t c_ospeed;
 950 };
 951
 952 //----------------------------------------------------------------------
 953 // From sys/ioccom.h
 954 //----------------------------------------------------------------------
 955
 956 /* QQQ keep linux's naming, but use our layout */
 957
 958 /*
 959  * We actually have a 16 bit "base" ioctl, which may or may not be decoded
 960  * into number/group
 961  */
 962 #define _VKI_IOC_BASEBITS  16U
 963 #define _VKI_IOC_NRBITS    8U  /* "num" on freebsd */
 964 #define _VKI_IOC_TYPEBITS  8U  /* "group" on freebsd */
 965
 966 #define _VKI_IOC_SIZEBITS  13U
 967 #define _VKI_IOC_DIRBITS   3U
 968
 969 #define _VKI_IOC_BASEMASK  ((1ul << _VKI_IOC_BASEBITS)-1)
 970 #define _VKI_IOC_NRMASK    ((1ul << _VKI_IOC_NRBITS)-1)
 971 #define _VKI_IOC_TYPEMASK  ((1ul << _VKI_IOC_TYPEBITS)-1)
 972 #define _VKI_IOC_SIZEMASK  ((1ul << _VKI_IOC_SIZEBITS)-1)
 973 #define _VKI_IOC_DIRMASK   ((1ul << _VKI_IOC_DIRBITS)-1)
 974
 975 #define  _VKI_IOC_BASESHIFT   0U
 976 #define _VKI_IOC_NRSHIFT   0U
 977 #define _VKI_IOC_TYPESHIFT (_VKI_IOC_NRSHIFT+_VKI_IOC_NRBITS)
 978 #define _VKI_IOC_SIZESHIFT (_VKI_IOC_TYPESHIFT+_VKI_IOC_TYPEBITS)
 979 #define _VKI_IOC_DIRSHIFT  (_VKI_IOC_SIZESHIFT+_VKI_IOC_SIZEBITS)
 980
 981 #define _VKI_IOC_NONE   1U /* "void" on freebsd, as a specific mode */
 982 #define _VKI_IOC_READ   2U /* "out", copyout in reversed linux terminology */
 983 #define _VKI_IOC_WRITE  4U /* "in", copyin in reversed linux terminology */
 984 #define _VKI_IOC_RDWR   6U /* "inout", copyin and copyout */
 985
 986 #define _VKI_IOC(dir,type,nr,size) \
 987    (((dir)  << _VKI_IOC_DIRSHIFT) | \
 988     ((type) << _VKI_IOC_TYPESHIFT) | \
 989     ((nr)   << _VKI_IOC_NRSHIFT) | \
 990     ((size) << _VKI_IOC_SIZESHIFT))
 991
 992 /* provoke compile error for invalid uses of size argument */
 993 extern unsigned int __vki_invalid_size_argument_for_IOC;
 994 #define _VKI_IOC_TYPECHECK(t) \
 995    ((sizeof(t) == sizeof(t[1]) && \
 996      sizeof(t) < (1 << _VKI_IOC_SIZEBITS)) ? \
 997      sizeof(t) : __vki_invalid_size_argument_for_IOC)
 998
 999 /* used to create numbers */
1000 #define _VKI_IO(type,nr)   _VKI_IOC(_VKI_IOC_NONE,(type),(nr),0)
1001 #define _VKI_IOR(type,nr,size)   _VKI_IOC(_VKI_IOC_READ,(type),(nr),(_VKI_IOC_TYPECHECK(size)))
1002 #define _VKI_IOW(type,nr,size)   _VKI_IOC(_VKI_IOC_WRITE,(type),(nr),(_VKI_IOC_TYPECHECK(size)))
1003 #define _VKI_IOWR(type,nr,size)  _VKI_IOC(_VKI_IOC_READ|_VKI_IOC_WRITE,(type),(nr),(_VKI_IOC_TYPECHECK(size)))
1004
1005 /* used to decode ioctl numbers.. */
1006 #define _VKI_IOC_DIR(nr)   (((nr) >> _VKI_IOC_DIRSHIFT) & _VKI_IOC_DIRMASK)
1007 #define _VKI_IOC_TYPE(nr)  (((nr) >> _VKI_IOC_TYPESHIFT) & _VKI_IOC_TYPEMASK)
1008 #define _VKI_IOC_NR(nr)    (((nr) >> _VKI_IOC_NRSHIFT) & _VKI_IOC_NRMASK)
1009 #define _VKI_IOC_SIZE(nr)  (((nr) >> _VKI_IOC_SIZESHIFT) & _VKI_IOC_SIZEMASK)
1010 #define _VKI_IOC_BASE(nr)  (((nr) >> _VKI_IOC_BASESHIFT) & _VKI_IOC_BASEMASK)
1011
1012 //----------------------------------------------------------------------
1013 // From sys/random.h
1014 //----------------------------------------------------------------------
1015
1016 #define VKI_GRND_NONBLOCK 0x1U
1017
1018 //----------------------------------------------------------------------
1019 // From sys/termios.h
1020 //----------------------------------------------------------------------
1021
1022 #if 0
1023 #define VKI_TCGETS   0x5401
1024 #define VKI_TCSETS   0x5402 /* Clashes with SNDCTL_TMR_START sound ioctl */
1025 #define VKI_TCSETSW  0x5403
1026 #define VKI_TCSETSF  0x5404
1027 #define VKI_TCGETA   0x5405   y
1028 #define VKI_TCSETA   0x5406   y
1029 #define VKI_TCSETAW  0x5407   y
1030 #define VKI_TCSETAF  0x5408   y
1031 #define VKI_TCSBRK   0x5409
1032 #define VKI_TCXONC   0x540A
1033 #define VKI_TCFLSH   0x540B   y
1034 #define VKI_TIOCSCTTY   0x540E
1035 #define VKI_TIOCGPGRP   0x540F   y
1036 #define VKI_TIOCSPGRP   0x5410   y
1037 #define VKI_TIOCOUTQ 0x5411
1038 #define VKI_TIOCGWINSZ  0x5413   y
1039 #define VKI_TIOCSWINSZ  0x5414   y
1040 #define VKI_TIOCMGET 0x5415   y
1041 #define VKI_TIOCMBIS 0x5416   y
1042 #define VKI_TIOCMBIC 0x5417   y
1043 #define VKI_TIOCMSET 0x5418   y
1044 #define VKI_FIONREAD 0x541B
1045 #define VKI_TIOCLINUX   0x541C
1046 #define VKI_FIONBIO  0x5421
1047 #define VKI_TCSBRKP  0x5425   /* Needed for POSIX tcsendbreak() */
1048 #define VKI_TIOCGPTN _VKI_IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
1049 #define VKI_TIOCSPTLCK  _VKI_IOW('T',0x31, int)  /* Lock/unlock Pty */
1050
1051 #define VKI_FIOASYNC 0x5452
1052 #define VKI_TIOCSERGETLSR   0x5459 /* Get line status register */
1053
1054 #define VKI_TIOCGICOUNT 0x545D   /* read serial port inline interrupt counts */
1055 #endif
1056
1057 #define  VKI_TIOCFLUSH  _VKI_IOW('t', 16, int);
1058 #define  VKI_TIOCGETA   _VKI_IOR('t', 19, struct vki_termios)  /* get termios */
1059 #define  VKI_TIOCSETA   _VKI_IOR('t', 20, struct vki_termios)  /* set termios */
1060 #define  VKI_TIOCSETAW  _VKI_IOR('t', 21, struct vki_termios)  /* drain,set */
1061 #define  VKI_TIOCSETAF  _VKI_IOR('t', 22, struct vki_termios)  /* flush,set */
1062
1063 #define  _VKI_TIOCPTMASTER  _VKI_IO('t', 28)    /* pts master validation */
1064
1065 #define VKI_TIOCSWINSZ  _VKI_IOW('t', 103, struct vki_winsize)  /* set window size */
1066 #define VKI_TIOCGWINSZ  _VKI_IOR('t', 104, struct vki_winsize)  /* get window size */
1067
1068 #define VKI_TIOCMGET _VKI_IOR('t', 106, int) /* get all modem bits */
1069 #define VKI_TIOCMBIC _VKI_IOW('t', 107, int) /* bic modem bits */
1070 #define VKI_TIOCMBIS _VKI_IOW('t', 108, int) /* bis modem bits */
1071 #define VKI_TIOCMSET _VKI_IOW('t', 109, int) /* set all modem bits */
1072 #define  VKI_TIOCSTART  _VKI_IO('t', 110)    /* start output, like ^Q */
1073 #define  VKI_TIOCSTOP   _VKI_IO('t', 111)    /* stop output, like ^S */
1074 #define  VKI_TIOCPKT    _VKI_IOW('t', 112, int) /* pty: set/clear packet mode */
1075
1076 #define  VKI_TIOCSPGRP  _VKI_IOW('t', 118, int)    /* set pgrp */
1077 #define  VKI_TIOCGPGRP  _VKI_IOR('t', 119, int)    /* get pgrp */
1078 #define  VKI_TIOCCBRK   _VKI_IO('t', 122)
1079 #define  VKI_TIOCSBRK   _VKI_IO('t', 123)
1080
1081
1082 //----------------------------------------------------------------------
1083 // From sys/filio.h
1084 //----------------------------------------------------------------------
1085
1086 #define VKI_FIOCLEX  _VKI_IO('f', 1)      /* close on exec */
1087 #define VKI_FIONCLEX _VKI_IO('f', 2)      /* no close on exec */
1088 #define VKI_FIONREAD _VKI_IOR('f', 127, int)
1089 #define VKI_FIONBIO  _VKI_IOW('f', 126, int)
1090 #define VKI_FIOASYNC _VKI_IOW('f', 125, int)
1091 #define VKI_FIOSETOWN   _VKI_IOW('f', 124, int)
1092 #define VKI_FIOGETOWN   _VKI_IOW('f', 123, int)
1093 struct vki_fiodgname_arg {
1094    int     len;
1095    void    *buf;
1096 };
1097 #define VKI_FIODGNAME   _VKI_IOW('f', 120, struct vki_fiodgname_arg) /* get dev. name */
1098
1099 // See syswrap-freebsd.c PRE/POST(sys_ioctl)
1100 #if 0
1101 //----------------------------------------------------------------------
1102 // From net/if.h
1103 //----------------------------------------------------------------------
1104 #define  VKI_IFNAMSIZ   16
1105
1106 struct vki_ifmediareq {
1107    char    ifm_name[VKI_IFNAMSIZ];
1108    int     ifm_current;
1109    int     ifm_mask;
1110    int     ifm_status;
1111    int     ifm_active;
1112    int     ifm_count;
1113    int     *ifm_ulist;
1114 };
1115
1116
1117 //----------------------------------------------------------------------
1118 // From sys/sockio.h
1119 //----------------------------------------------------------------------
1120 #define VKI_SIOCGIFMEDIA  _VKI_IOWR('i', 56, struct vki_ifmediareq)
1121 #endif
1122
1123 //----------------------------------------------------------------------
1124 // From sys/poll.h
1125 //----------------------------------------------------------------------
1126
1127 #define VKI_POLLIN      0x0001
1128
1129 struct vki_pollfd {
1130    int fd;
1131    short events;
1132    short revents;
1133 };
1134
1135 //----------------------------------------------------------------------
1136 // From sys/event.h
1137 //----------------------------------------------------------------------
1138 struct vki_kevent_freebsd11 {
1139    vki_uintptr_t  ident;
1140    vki_int16_t    filter;
1141    vki_uint16_t   flags;
1142    vki_uint32_t   fflags;
1143    vki_intptr_t   data;
1144    void           *udata;
1145 };
1146
1147 struct vki_kevent {
1148    vki_uintptr_t  ident;
1149    vki_int16_t    filter;
1150    vki_uint16_t   flags;
1151    vki_uint32_t   fflags;
1152    vki_int64_t    data;
1153    void           *udata;
1154    vki_uint64_t   ext[4];
1155 };
1156
1157
1158 // QQQ sort
1159
1160 //----------------------------------------------------------------------
1161 // From sys/resource.h
1162 //----------------------------------------------------------------------
1163
1164 #define VKI_RUSAGE_SELF     0
1165 #define VKI_RUSAGE_CHILDREN -1
1166 #define VKI_RUSAGE_THREAD   1
1167
1168 struct   vki_rusage {
1169    struct vki_timeval ru_utime;  /* user time used */
1170    struct vki_timeval ru_stime;  /* system time used */
1171    long  ru_maxrss;     /* maximum resident set size */
1172    long  ru_ixrss;      /* integral shared memory size */
1173    long  ru_idrss;      /* integral unshared data size */
1174    long  ru_isrss;      /* integral unshared stack size */
1175    long  ru_minflt;     /* page reclaims */
1176    long  ru_majflt;     /* page faults */
1177    long  ru_nswap;      /* swaps */
1178    long  ru_inblock;    /* block input operations */
1179    long  ru_oublock;    /* block output operations */
1180    long  ru_msgsnd;     /* messages sent */
1181    long  ru_msgrcv;     /* messages received */
1182    long  ru_nsignals;      /* signals received */
1183    long  ru_nvcsw;      /* voluntary context switches */
1184    long  ru_nivcsw;     /* involuntary " */
1185 };
1186
1187 struct vki_rlimit {
1188    vki_rlim_t  rlim_cur;
1189    vki_rlim_t  rlim_max;
1190 };
1191
1192 #define VKI_RLIMIT_DATA    2  /* max data size */
1193 #define VKI_RLIMIT_STACK   3  /* max stack size */
1194 #define VKI_RLIMIT_CORE    4  /* max core file size */
1195 #define VKI_RLIMIT_NOFILE  8  /* max number of open files */
1196
1197 struct vki___wrusage {
1198    struct vki_rusage   wru_self;
1199    struct vki_rusage   wru_children;
1200 };
1201
1202
1203 //----------------------------------------------------------------------
1204 // From sys/procfs.h
1205 //----------------------------------------------------------------------
1206
1207 #define VKI_PRSTATUS_VERSION  1
1208 struct vki_elf_prstatus {
1209    int      pr_version; /* version of struct - PRSTATUS_VERSION */
1210    vki_size_t  pr_statussz;
1211    vki_size_t  pr_gregsetsz;
1212    vki_size_t  pr_fpregsetsz;
1213    int      pr_osreldate;
1214    int      pr_cursig;  /* Current signal */
1215    vki_pid_t   pr_pid;
1216    vki_elf_gregset_t pr_reg;  /* GP registers */
1217 };
1218
1219 #define VKI_ELF_PRARGSZ (80)  /* Number of chars for args */
1220 #define VKI_MAXCOMLEN   (16)
1221
1222 #define  VKI_PRPSINFO_VERSION 1
1223 struct vki_elf_prpsinfo {
1224    int   pr_version; /* version of struct - PRPSINFO_VERSION */
1225    vki_size_t  pr_psinfosz;
1226    char  pr_fname[VKI_MAXCOMLEN+1];    /* filename of executable */
1227    char  pr_psargs[VKI_ELF_PRARGSZ];   /* initial part of arg list */
1228 };
1229
1230 //----------------------------------------------------------------------
1231 // From posix4/mqueue.h
1232 //----------------------------------------------------------------------
1233
1234 struct vki_mq_attr {
1235    long  mq_flags;   /* message queue flags        */
1236    long  mq_maxmsg;  /* maximum number of messages    */
1237    long  mq_msgsize; /* maximum message size       */
1238    long  mq_curmsgs; /* number of messages currently queued */
1239 };
1240
1241 //----------------------------------------------------------------------
1242 // From sys/ucontext.h
1243 //----------------------------------------------------------------------
1244
1245 #define  VKI_UCF_SWAPPED   1
1246
1247 struct vki_ucontext {
1248    vki_sigset_t         uc_sigmask;
1249    struct vki_mcontext  uc_mcontext;
1250    struct vki_ucontext* uc_link;
1251    vki_stack_t          uc_stack;
1252    int                  uc_flags;
1253    unsigned int         __spare__[4];
1254 };
1255
1256 //----------------------------------------------------------------------
1257 // From sys/utsname.h
1258 //----------------------------------------------------------------------
1259
1260 #define VKI_SYS_NMLN        32
1261
1262 struct vki_utsname {
1263    char    sysname[VKI_SYS_NMLN];      /* Name of this OS. */
1264    char    nodename[VKI_SYS_NMLN];     /* Name of this network node. */
1265    char    release[VKI_SYS_NMLN];      /* Release level. */
1266    char    version[VKI_SYS_NMLN];      /* Version level. */
1267    char    machine[VKI_SYS_NMLN];      /* Hardware type. */
1268 };
1269
1270 #define VKI_IPC_CREAT  00001000   /* create if key is nonexistent */
1271 #define VKI_IPC_EXCL   00002000   /* fail if key exists */
1272 #define VKI_IPC_NOWAIT 00004000   /* return error on wait */
1273
1274 #define VKI_IPC_RMID 0     /* remove resource */
1275 #define VKI_IPC_SET  1     /* set ipc_perm options */
1276 #define VKI_IPC_STAT 2     /* get ipc_perm options */
1277 #define VKI_IPC_INFO 3     /* only used by Linux compatibilty shm_ctl */
1278
1279 //----------------------------------------------------------------------
1280 // From sys/ipc.h
1281 //----------------------------------------------------------------------
1282
1283 struct vki_ipc_perm_old {
1284    unsigned short cuid;
1285    unsigned short cgid;
1286    unsigned short uid;
1287    unsigned short gid;
1288    unsigned short mode;
1289    unsigned short seq;
1290    vki_key_t   key;
1291 };
1292
1293 struct vki_ipc_perm {
1294    vki_uid_t   cuid;
1295    vki_gid_t   cgid;
1296    vki_uid_t   uid;
1297    vki_gid_t   gid;
1298    vki_mode_t  mode;
1299    unsigned short seq;
1300    vki_key_t   key;
1301 };
1302
1303 //----------------------------------------------------------------------
1304 // From sys/sem.h
1305 //----------------------------------------------------------------------
1306
1307 #define VKI_GETALL  6       /* get all semval's */
1308 #define VKI_SETVAL  8       /* set semval */
1309 #define VKI_SETALL  9       /* set all semval's */
1310 #define VKI_SEM_STAT 10
1311 #define VKI_SEM_INFO 11
1312
1313 struct vki_semid_ds_old {
1314    struct vki_ipc_perm_old sem_perm;
1315    struct sem      *__sem_base;
1316    unsigned short  sem_nsems;
1317    vki_time_t      sem_otime;
1318    long            sem_pad1;
1319    vki_time_t      sem_ctime;
1320    long            sem_pad2;
1321    long            sem_pad3[4];
1322 };
1323
1324
1325 /* Obsolete, used only for backwards compatibility and libc5 compiles */
1326 struct vki_semid_ds {
1327    struct vki_ipc_perm  sem_perm;      /* permissions .. see ipc.h */
1328    // [[Use void* to avoid excess header copying]]
1329    void/*struct sem  */*sem_base;      /* ptr to first semaphore in array */
1330    unsigned short    sem_nsems;     /* no. of semaphores in array */
1331    vki_time_t     sem_otime;     /* last semop time */
1332    vki_time_t     sem_ctime;     /* last change time */
1333 };
1334
1335 struct vki_sembuf {
1336    vki_uint16_t   sem_num; /* semaphore index in array */
1337    vki_int16_t sem_op;     /* semaphore operation */
1338    vki_int16_t sem_flg; /* operation flags */
1339 };
1340
1341 union vki_semun {
1342    int val;       /* value for SETVAL */
1343    struct vki_semid_ds *buf;  /* buffer for IPC_STAT & IPC_SET */
1344    vki_uint16_t *array; /* array for GETALL & SETALL */
1345 };
1346
1347
1348 //----------------------------------------------------------------------
1349 // From sys/errno.h
1350 //----------------------------------------------------------------------
1351
1352 #define VKI_ERESTART -1
1353 #define VKI_EPERM           1               /* Operation not permitted */
1354 #define VKI_ENOENT          2               /* No such file or directory */
1355 #define VKI_ESRCH           3               /* No such process */
1356 #define VKI_EINTR           4               /* Interrupted system call */
1357 #define VKI_EIO             5               /* Input/output error */
1358 #define VKI_ENXIO           6               /* Device not configured */
1359 #define VKI_E2BIG           7               /* Argument list too long */
1360 #define VKI_ENOEXEC         8               /* Exec format error */
1361 #define VKI_EBADF           9               /* Bad file descriptor */
1362 #define VKI_ECHILD          10              /* No child processes */
1363 #define VKI_EDEADLK         11              /* Resource deadlock avoided */
1364 #define VKI_ENOMEM          12              /* Cannot allocate memory */
1365 #define VKI_EACCES          13              /* Permission denied */
1366 #define VKI_EFAULT          14              /* Bad address */
1367 #define VKI_ENOTBLK         15              /* Block device required */
1368 #define VKI_EBUSY           16              /* Device busy */
1369 #define VKI_EEXIST          17              /* File exists */
1370 #define VKI_EXDEV           18              /* Cross-device link */
1371 #define VKI_ENODEV          19              /* Operation not supported by device */
1372 #define VKI_ENOTDIR         20              /* Not a directory */
1373 #define VKI_EISDIR          21              /* Is a directory */
1374 #define VKI_EINVAL          22              /* Invalid argument */
1375 #define VKI_ENFILE          23              /* Too many open files in system */
1376 #define VKI_EMFILE          24              /* Too many open files */
1377 #define VKI_ENOTTY          25              /* Inappropriate ioctl for device */
1378 #define VKI_ETXTBSY         26              /* Text file busy */
1379 #define VKI_EFBIG           27              /* File too large */
1380 #define VKI_ENOSPC          28              /* No space left on device */
1381 #define VKI_ESPIPE          29              /* Illegal seek */
1382 #define VKI_EROFS           30              /* Read-only filesystem */
1383 #define VKI_EMLINK          31              /* Too many links */
1384 #define VKI_EPIPE           32              /* Broken pipe */
1385 #define VKI_EDOM            33              /* Numerical argument out of domain */
1386 #define VKI_ERANGE          34              /* Result too large */
1387 #define VKI_EAGAIN          35              /* Resource temporarily unavailable */
1388 #define VKI_EWOULDBLOCK     VKI_EAGAIN          /* Operation would block */
1389 #define VKI_EINPROGRESS     36              /* Operation now in progress */
1390 #define VKI_EALREADY        37              /* Operation already in progress */
1391 #define VKI_ENOTSOCK        38              /* Socket operation on non-socket */
1392 #define VKI_EDESTADDRREQ    39              /* Destination address required */
1393 #define VKI_EMSGSIZE        40              /* Message too long */
1394 #define VKI_EPROTOTYPE      41              /* Protocol wrong type for socket */
1395 #define VKI_ENOPROTOOPT     42              /* Protocol not available */
1396 #define VKI_EPROTONOSUPPORT 43              /* Protocol not supported */
1397 #define VKI_ESOCKTNOSUPPORT 44              /* Socket type not supported */
1398 #define VKI_EOPNOTSUPP      45              /* Operation not supported */
1399 #define VKI_ENOTSUP         VKI_EOPNOTSUPP      /* Operation not supported */
1400 #define VKI_EPFNOSUPPORT    46              /* Protocol family not supported */
1401 #define VKI_EAFNOSUPPORT    47              /* Address family not supported by protocol family */
1402 #define VKI_EADDRINUSE      48              /* Address already in use */
1403 #define VKI_EADDRNOTAVAIL   49
1404 #define VKI_ENETDOWN        50              /* Network is down */
1405 #define VKI_ENETUNREACH     51              /* Network is unreachable */
1406 #define VKI_ENETRESET       52              /* Network dropped connection on reset */
1407 #define VKI_ECONNABORTED    53              /* Software caused connection abort */
1408 #define VKI_ECONNRESET      54              /* Connection reset by peer */
1409 #define VKI_ENOBUFS         55              /* No buffer space available */
1410 #define VKI_EISCONN         56              /* Socket is already connected */
1411 #define VKI_ENOTCONN        57              /* Socket is not connected */
1412 #define VKI_ESHUTDOWN       58              /* Can't send after socket shutdown */
1413 #define VKI_ETOOMANYREFS    59              /* Too many references: can't splice */
1414 #define VKI_ETIMEDOUT       60              /* Operation timed out */
1415 #define VKI_ECONNREFUSED    61              /* Connection refused */
1416 #define VKI_ELOOP           62              /* Too many levels of symbolic links */
1417 #define VKI_ENAMETOOLONG    63              /* File name too long */
1418 #define VKI_EHOSTDOWN       64              /* Host is down */
1419 #define VKI_EHOSTUNREACH    65              /* No route to host */
1420 #define VKI_ENOTEMPTY       66              /* Directory not empty */
1421 #define VKI_EPROCLIM        67              /* Too many processes */
1422 #define VKI_EUSERS          68              /* Too many users */
1423 #define VKI_EDQUOT          69              /* Disc quota exceeded */
1424 #define VKI_ESTALE          70              /* Stale NFS file handle */
1425 #define VKI_EREMOTE         71              /* Too many levels of remote in path */
1426 #define VKI_EBADRPC         72              /* RPC struct is bad */
1427 #define VKI_ERPCMISMATCH    73              /* RPC version wrong */
1428 #define VKI_EPROGUNAVAIL    74              /* RPC prog. not avail */
1429 #define VKI_EPROGMISMATCH   75              /* Program version wrong */
1430 #define VKI_EPROCUNAVAIL    76              /* Bad procedure for program */
1431 #define VKI_ENOLCK          77              /* No locks available */
1432 #define VKI_ENOSYS          78              /* Function not implemented */
1433 #define VKI_EFTYPE          79              /* Inappropriate file type or format */
1434 #define VKI_EAUTH           80              /* Authentication error */
1435 #define VKI_ENEEDAUTH       81              /* Need authenticator */
1436 #define VKI_EIDRM           82              /* Identifier removed */
1437 #define VKI_ENOMSG          83              /* No message of desired type */
1438 #define VKI_EOVERFLOW       84              /* Value too large to be stored in data type */
1439 #define VKI_ECANCELED       85              /* Operation canceled */
1440 #define VKI_EILSEQ          86              /* Illegal byte sequence */
1441 #define VKI_ENOATTR         87              /* Attribute not found */
1442 #define VKI_EDOOFUS         88              /* Programming error */
1443 #define VKI_EBADMSG         89              /* Bad message */
1444 #define VKI_EMULTIHOP       90              /* Multihop attempted */
1445 #define VKI_ENOLINK         91              /* Link has been severed */
1446 #define VKI_EPROTO          92              /* Protocol error */
1447 #define VKI_ENOTCAPABLE     93              /* Capabilities insufficient */
1448 #define VKI_ECAPMODE        94              /* Not permitted in capability mode */
1449
1450 //----------------------------------------------------------------------
1451 // From sys/wait.h
1452 //----------------------------------------------------------------------
1453
1454 #define VKI_WNOHANG  0x00000001
1455
1456 typedef enum vki_idtype {
1457    VKI_P_PID,
1458    VKI_P_PPID,
1459    VKI_P_PGID,
1460    VKI_P_SID,
1461    VKI_P_CID,
1462    VKI_P_UID,
1463    VKI_P_GID,
1464    VKI_P_ALL,
1465    VKI_P_LWPID,
1466    VKI_P_TASKID,
1467    VKI_P_PROJID,
1468    VLI_P_POOLID,
1469    VKI_P_JAILID,
1470    VKI_P_CTID,
1471    VKI_P_CPUID,
1472    VKI_P_PSETID
1473 } vki_idtype_t;
1474
1475 //----------------------------------------------------------------------
1476 // From sys/mman.h
1477 //----------------------------------------------------------------------
1478
1479 #define VKI_PROT_NONE   0x00     /* No page permissions */
1480 #define VKI_PROT_READ   0x01     /* page can be read */
1481 #define VKI_PROT_WRITE  0x02     /* page can be written */
1482 #define VKI_PROT_EXEC   0x04     /* page can be executed */
1483
1484 #define VKI_MAP_SHARED  0x01     /* Share changes */
1485 #define VKI_MAP_PRIVATE 0x02     /* Changes are private */
1486 #define VKI_MAP_FIXED   0x10     /* Interpret addr exactly */
1487 #define VKI_MAP_NORESERVE  0x0040      /* don't check for reservations */
1488 #define  VKI_MAP_STACK  0x400
1489 #define VKI_MAP_ANON 0x1000   /* don't use a file */
1490 #define  VKI_MAP_ANONYMOUS VKI_MAP_ANON
1491
1492 //----------------------------------------------------------------------
1493 // From sys/stat.h
1494 //----------------------------------------------------------------------
1495
1496 #define VKI_S_IFMT  00170000
1497
1498 #define VKI_S_IFWHT  0160000
1499 #define VKI_S_IFSOCK 0140000
1500 #define VKI_S_IFLNK  0120000
1501 #define VKI_S_IFREG  0100000
1502 #define VKI_S_IFBLK  0060000
1503 #define VKI_S_IFDIR  0040000
1504 #define VKI_S_IFCHR  0020000
1505 #define VKI_S_IFIFO  0010000
1506 #define VKI_S_ISUID  0004000
1507 #define VKI_S_ISGID  0002000
1508 #define VKI_S_ISTXT  0001000
1509
1510 #define VKI_S_ISLNK(m)  (((m) & VKI_S_IFMT) == VKI_S_IFLNK)
1511 #define VKI_S_ISREG(m)  (((m) & VKI_S_IFMT) == VKI_S_IFREG)
1512 #define VKI_S_ISDIR(m)  (((m) & VKI_S_IFMT) == VKI_S_IFDIR)
1513 #define VKI_S_ISCHR(m)  (((m) & VKI_S_IFMT) == VKI_S_IFCHR)
1514 #define VKI_S_ISBLK(m)  (((m) & VKI_S_IFMT) == VKI_S_IFBLK)
1515 #define VKI_S_ISFIFO(m) (((m) & VKI_S_IFMT) == VKI_S_IFIFO)
1516 #define VKI_S_ISSOCK(m) (((m) & VKI_S_IFMT) == VKI_S_IFSOCK)
1517 #define VKI_S_ISWHT(m)  (((m) & VKI_S_IFMT) == VKI_S_IFWHT)
1518
1519 #define VKI_S_IRWXU 00700
1520 #define VKI_S_IRUSR 00400
1521 #define VKI_S_IWUSR 00200
1522 #define VKI_S_IXUSR 00100
1523
1524 #define VKI_S_IRWXG 00070
1525 #define VKI_S_IRGRP 00040
1526 #define VKI_S_IWGRP 00020
1527 #define VKI_S_IXGRP 00010
1528
1529 #define VKI_S_IRWXO 00007
1530 #define VKI_S_IROTH 00004
1531 #define VKI_S_IWOTH 00002
1532 #define VKI_S_IXOTH 00001
1533
1534
1535 //----------------------------------------------------------------------
1536 // From sys/dirent.h
1537 //----------------------------------------------------------------------
1538
1539 struct vki_dirent {
1540    vki_uint32_t   d_fileno;
1541    vki_uint16_t   d_reclen;
1542    vki_uint8_t d_type;
1543    vki_uint8_t d_namelen;
1544    char     vki_d_name[256]; /* We must not include limits.h! */
1545 };
1546
1547 //----------------------------------------------------------------------
1548 // From sys/fcntl.h
1549 //----------------------------------------------------------------------
1550
1551 #define VKI_O_RDONLY   O_RDONLY
1552 #define VKI_O_WRONLY   O_WRONLY
1553 #define VKI_O_RDWR     O_RDWR
1554
1555 #define VKI_FREAD FREAD
1556 #define VKI_WRITE WRITE
1557
1558 #define VKI_O_NONBLOCK    O_NONBLOCK
1559 #define VKI_O_APPEND   O_APPEND
1560 #define VKI_O_CREAT    O_CREAT
1561 #define VKI_O_TRUNC    O_TRUNC
1562 #define VKI_O_EXCL     O_EXCL
1563 #define VKI_O_DIRECTORY O_DIRECTORY
1564 #define VKI_O_EXEC      O_EXEC
1565 #define VKI_O_SEARCH    O_EXEC
1566
1567 #define VKI_AT_FDCWD            AT_FDCWD
1568 #define VKI_AT_SYMLINK_NOFOLLOW 0x0200
1569
1570
1571 #define VKI_F_DUPFD     0  /* dup */
1572 #define VKI_F_GETFD     1  /* get close_on_exec */
1573 #define VKI_F_SETFD     2  /* set/clear close_on_exec */
1574 #define VKI_F_GETFL     3  /* get file->f_flags */
1575 #define VKI_F_SETFL     4  /* set file->f_flags */
1576 #define VKI_F_SETOWN    5  /*  for sockets. */
1577 #define VKI_F_GETOWN    6  /*  for sockets. */
1578 #define VKI_F_OGETLK    7  /* get record locking information */
1579 #define VKI_F_OSETLK    8  /* set record locking information */
1580 #define VKI_F_OSETLKW   9  /* F_SETLK; wait if blocked */
1581 #define VKI_F_DUP2FD    10 /* duplicate file descriptor to arg */
1582 #define VKI_F_GETLK     11 /* get record locking information */
1583 #define VKI_F_SETLK     12 /* set record locking information */
1584 #define VKI_F_SETLKW    13 /* F_SETLK; wait if blocked */
1585 #define VKI_F_SETLK_REMOTE 14 /* debugging support for remote locks */
1586 #define VKI_F_READAHEAD    15 /* read ahead */
1587 #define VKI_F_RDAHEAD      16 /* Darwin compatible read ahead */
1588 #define VKI_F_DUPFD_CLOEXEC  17 /* dup close_on_exec */
1589 #define VKI_F_DUP2FD_CLOEXEC 18 /* Like F_DUP2FD, but FD_CLOEXEC is set */
1590 #define VKI_F_ADD_SEALS    19 /* apply seals to underlying file */
1591 #define VKI_F_GET_SEALS    20 /* get seals to underlying file */
1592 #define VKI_F_ISUNIONSTACK 21 /* kludge for libc (part of a union stack?) */
1593 /* FreeBSD 13.1 and later */
1594 #define VKI_F_KINFO        22 /* Return kinfo_file for this fd */
1595
1596 /* for F_[GET|SET]FL */
1597 #define VKI_FD_CLOEXEC  1  /* actually anything with low bit set goes */
1598
1599 /* for F_[ADD|GET]_SEALS */
1600 #define VKI_F_SEAL_SEAL    0x0001
1601 #define VKI_F_SEAL_SHRINK  0x0002
1602 #define VKI_F_SEAL_GROW    0x0004
1603 #define VKI_F_SEAL_WRITE   0x0008
1604
1605 struct vki_spacectl_range {
1606    vki_off_t   r_offset;
1607    vki_off_t   r_len;
1608 };
1609
1610
1611 //----------------------------------------------------------------------
1612 // From sys/unistd.h
1613 //----------------------------------------------------------------------
1614
1615 #define VKI_SEEK_SET              0
1616 #define VKI_SEEK_CUR              1
1617 #define VKI_SEEK_END              2
1618
1619 #define VKI_F_OK  0       /* test for existence of file */
1620 #define VKI_X_OK  0x01    /* test for execute or search permission */
1621 #define VKI_W_OK  0x02    /* test for write permission */
1622 #define VKI_R_OK  0x04    /* test for read permission */
1623
1624 #define VKI_RFSPAWN         (1U<<31U)
1625
1626 /* kcmp() options. */
1627 #define VKI_KCMP_FILE       100
1628 #define VKI_KCMP_FILEOBJ    101
1629 #define VKI_KCMP_FILES      102
1630 #define VKI_KCMP_SIGHAND    103
1631 #define VKI_KCMP_VM         104
1632
1633 #define VKI_CLOSE_RANGE_CLOEXEC     (1<<2)
1634
1635 //----------------------------------------------------------------------
1636 // From sys/msg.h
1637 //----------------------------------------------------------------------
1638
1639 #if 0 /* not in freebsd */
1640 #define VKI_MSGSND              11
1641 #define VKI_MSGRCV              12
1642 #define VKI_MSGGET              13
1643 #define VKI_MSGCTL              14
1644 #endif
1645
1646 typedef unsigned long vki_msglen_t;
1647 typedef unsigned long vki_msgqnum_t;
1648
1649 struct vki_msqid_ds_old {
1650    struct vki_ipc_perm_old msg_perm;
1651    struct vki_msg *msg_first;
1652    struct vki_msg *msg_last;
1653    vki_msglen_t msg_cbytes;
1654    vki_msgqnum_t msg_qnum;
1655    vki_msglen_t msg_qbytes;
1656    vki_pid_t   msg_lspid;
1657    vki_pid_t   msg_lrpid;
1658    vki_time_t  msg_stime;
1659    vki_uint32_t   msg_pad1;
1660    vki_time_t  msg_rtime;
1661    vki_uint32_t   msg_pad2;
1662    vki_time_t  msg_ctime;
1663    vki_uint32_t   msg_pad3;
1664    vki_uint32_t   msg_pad4[4];
1665 };
1666
1667 struct vki_msqid_ds {
1668    struct vki_ipc_perm msg_perm;
1669    struct vki_msg *msg_first;
1670    struct vki_msg *msg_last;
1671    vki_msglen_t msg_cbytes;
1672    vki_msgqnum_t msg_qnum;
1673    vki_msglen_t msg_qbytes;
1674    vki_pid_t   msg_lspid;
1675    vki_pid_t   msg_lrpid;
1676    vki_time_t  msg_stime;
1677    vki_time_t  msg_rtime;
1678    vki_time_t  msg_ctime;
1679 };
1680
1681
1682 struct vki_msgbuf {
1683    long mtype;         /* type of message */
1684    char mtext[1];      /* message text */
1685 };
1686
1687
1688 //----------------------------------------------------------------------
1689 // From sys/shm.h
1690 //----------------------------------------------------------------------
1691
1692 struct vki_shmid_ds_old {
1693    struct vki_ipc_perm_old shm_perm;   /* operation perms */
1694    int         shm_segsz;  /* size of segment (bytes) */
1695    vki_pid_t      shm_lpid;   /* pid of last operator */
1696    vki_pid_t      shm_cpid;   /* pid of creator */
1697    short       shm_nattch; /* no. of current attaches */
1698    vki_time_t     shm_atime;  /* last attach time */
1699    vki_time_t     shm_dtime;  /* last detach time */
1700    vki_time_t     shm_ctime;  /* last change time */
1701    void        *shm_internal; /* sysv stupidity */
1702 };
1703
1704
1705 struct vki_shmid_ds {
1706    struct vki_ipc_perm  shm_perm;   /* operation perms */
1707    vki_size_t     shm_segsz;  /* size of segment (bytes) */
1708    vki_pid_t      shm_lpid;   /* pid of last operator */
1709    vki_pid_t      shm_cpid;   /* pid of creator */
1710    int         shm_nattch; /* no. of current attaches */
1711    vki_time_t     shm_atime;  /* last attach time */
1712    vki_time_t     shm_dtime;  /* last detach time */
1713    vki_time_t     shm_ctime;  /* last change time */
1714 };
1715
1716 #define VKI_SHMLBA  VKI_PAGE_SIZE
1717 #define VKI_SHM_RDONLY  010000  /* read-only access */
1718 #define  VKI_SHM_ANON   (1UL)
1719
1720 #if 0 /* not in freebsd abi */
1721 #define VKI_SHMAT               21
1722 #define VKI_SHMDT               22
1723 #define VKI_SHMGET              23
1724 #define VKI_SHMCTL              24
1725 #endif
1726
1727 #if 0
1728 //----------------------------------------------------------------------
1729 // From linux-2.6.8.1/include/linux/sockios.h
1730 //----------------------------------------------------------------------
1731
1732 #define VKI_SIOCOUTQ    VKI_TIOCOUTQ
1733
1734 #define VKI_SIOCADDRT      0x890B   /* add routing table entry */
1735 #define VKI_SIOCDELRT      0x890C   /* delete routing table entry */
1736
1737 #define VKI_SIOCGIFNAME    0x8910   /* get iface name    */
1738 #define VKI_SIOCGIFCONF    0x8912   /* get iface list    */
1739 #define VKI_SIOCGIFFLAGS   0x8913   /* get flags         */
1740 #define VKI_SIOCSIFFLAGS   0x8914   /* set flags         */
1741 #define VKI_SIOCGIFADDR    0x8915   /* get PA address    */
1742 #define VKI_SIOCSIFADDR    0x8916   /* set PA address    */
1743 #define VKI_SIOCGIFDSTADDR 0x8917   /* get remote PA address   */
1744 #define VKI_SIOCSIFDSTADDR 0x8918   /* set remote PA address   */
1745 #define VKI_SIOCGIFBRDADDR 0x8919   /* get broadcast PA address   */
1746 #define VKI_SIOCSIFBRDADDR 0x891a   /* set broadcast PA address   */
1747 #define VKI_SIOCGIFNETMASK 0x891b   /* get network PA mask     */
1748 #define VKI_SIOCSIFNETMASK 0x891c   /* set network PA mask     */
1749 #define VKI_SIOCGIFMETRIC  0x891d   /* get metric        */
1750 #define VKI_SIOCSIFMETRIC  0x891e   /* set metric        */
1751 #define VKI_SIOCGIFMTU     0x8921   /* get MTU size         */
1752 #define VKI_SIOCSIFMTU     0x8922   /* set MTU size         */
1753 #define  VKI_SIOCSIFHWADDR 0x8924   /* set hardware address    */
1754 #define VKI_SIOCGIFHWADDR  0x8927   /* Get hardware address    */
1755 #define VKI_SIOCGIFINDEX   0x8933   /* name -> if_index mapping   */
1756
1757 #define VKI_SIOCGIFTXQLEN  0x8942   /* Get the tx queue length */
1758 #define VKI_SIOCSIFTXQLEN  0x8943   /* Set the tx queue length    */
1759
1760 #define VKI_SIOCGMIIPHY    0x8947   /* Get address of MII PHY in use. */
1761 #define VKI_SIOCGMIIREG    0x8948   /* Read MII PHY register.  */
1762 #define VKI_SIOCSMIIREG    0x8949   /* Write MII PHY register. */
1763
1764 #define VKI_SIOCDARP    0x8953   /* delete ARP table entry  */
1765 #define VKI_SIOCGARP    0x8954   /* get ARP table entry     */
1766 #define VKI_SIOCSARP    0x8955   /* set ARP table entry     */
1767
1768 #define VKI_SIOCDRARP      0x8960   /* delete RARP table entry */
1769 #define VKI_SIOCGRARP      0x8961   /* get RARP table entry    */
1770 #define VKI_SIOCSRARP      0x8962   /* set RARP table entry    */
1771
1772 #define VKI_SIOCGIFMAP     0x8970   /* Get device parameters   */
1773 #define VKI_SIOCSIFMAP     0x8971   /* Set device parameters   */
1774
1775 //----------------------------------------------------------------------
1776 // From linux-2.6.9/include/linux/kb.h
1777 //----------------------------------------------------------------------
1778
1779 #define VKI_GIO_FONT       0x4B60  /* gets font in expanded form */
1780 #define VKI_PIO_FONT       0x4B61  /* use font in expanded form */
1781
1782 #define VKI_GIO_FONTX      0x4B6B  /* get font using struct consolefontdesc */
1783 #define VKI_PIO_FONTX      0x4B6C  /* set font using struct consolefontdesc */
1784 struct vki_consolefontdesc {
1785    unsigned short charcount;  /* characters in font (256 or 512) */
1786    unsigned short charheight; /* scan lines per character (1-32) */
1787    char __user *chardata;     /* font data in expanded form */
1788 };
1789
1790 #define VKI_PIO_FONTRESET  0x4B6D  /* reset to default font */
1791
1792 #define VKI_GIO_CMAP       0x4B70  /* gets colour palette on VGA+ */
1793 #define VKI_PIO_CMAP       0x4B71  /* sets colour palette on VGA+ */
1794
1795 #define VKI_KIOCSOUND      0x4B2F  /* start sound generation (0 for off) */
1796 #define VKI_KDMKTONE       0x4B30  /* generate tone */
1797
1798 #define VKI_KDGETLED       0x4B31  /* return current led state */
1799 #define VKI_KDSETLED       0x4B32  /* set led state [lights, not flags] */
1800
1801 #define VKI_KDGKBTYPE      0x4B33  /* get keyboard type */
1802
1803 #define VKI_KDADDIO        0x4B34  /* add i/o port as valid */
1804 #define VKI_KDDELIO        0x4B35  /* del i/o port as valid */
1805 #define VKI_KDENABIO       0x4B36  /* enable i/o to video board */
1806 #define VKI_KDDISABIO      0x4B37  /* disable i/o to video board */
1807
1808 #define VKI_KDSETMODE      0x4B3A  /* set text/graphics mode */
1809 #define VKI_KDGETMODE      0x4B3B  /* get current mode */
1810
1811 #define VKI_KDMAPDISP      0x4B3C  /* map display into address space */
1812 #define VKI_KDUNMAPDISP    0x4B3D  /* unmap display from address space */
1813
1814 #define     VKI_E_TABSZ    256
1815 #define VKI_GIO_SCRNMAP    0x4B40  /* get screen mapping from kernel */
1816 #define VKI_PIO_SCRNMAP    0x4B41  /* put screen mapping table in kernel */
1817 #define VKI_GIO_UNISCRNMAP 0x4B69  /* get full Unicode screen mapping */
1818 #define VKI_PIO_UNISCRNMAP 0x4B6A  /* set full Unicode screen mapping */
1819
1820 #define VKI_GIO_UNIMAP     0x4B66  /* get unicode-to-font mapping from kernel */
1821 #define VKI_PIO_UNIMAP     0x4B67  /* put unicode-to-font mapping in kernel */
1822 #define VKI_PIO_UNIMAPCLR  0x4B68  /* clear table, possibly advise hash algorithm */
1823
1824 #define VKI_KDGKBMODE      0x4B44  /* gets current keyboard mode */
1825 #define VKI_KDSKBMODE      0x4B45  /* sets current keyboard mode */
1826
1827 #define VKI_KDGKBMETA      0x4B62  /* gets meta key handling mode */
1828 #define VKI_KDSKBMETA      0x4B63  /* sets meta key handling mode */
1829
1830 #define VKI_KDGKBLED       0x4B64  /* get led flags (not lights) */
1831 #define VKI_KDSKBLED       0x4B65  /* set led flags (not lights) */
1832
1833 struct vki_kbentry {
1834    unsigned char kb_table;
1835    unsigned char kb_index;
1836    unsigned short kb_value;
1837 };
1838 #define VKI_KDGKBENT       0x4B46  /* gets one entry in translation table */
1839 #define VKI_KDSKBENT       0x4B47  /* sets one entry in translation table */
1840
1841 struct vki_kbsentry {
1842    unsigned char kb_func;
1843    unsigned char kb_string[512];
1844 };
1845 #define VKI_KDGKBSENT      0x4B48  /* gets one function key string entry */
1846 #define VKI_KDSKBSENT      0x4B49  /* sets one function key string entry */
1847
1848 struct vki_kbdiacr {
1849    unsigned char diacr, base, result;
1850 };
1851 struct vki_kbdiacrs {
1852    unsigned int kb_cnt;    /* number of entries in following array */
1853    struct vki_kbdiacr kbdiacr[256];    /* MAX_DIACR from keyboard.h */
1854 };
1855 #define VKI_KDGKBDIACR     0x4B4A  /* read kernel accent table */
1856 #define VKI_KDSKBDIACR     0x4B4B  /* write kernel accent table */
1857
1858 struct vki_kbkeycode {
1859    unsigned int scancode, keycode;
1860 };
1861 #define VKI_KDGETKEYCODE   0x4B4C  /* read kernel keycode table entry */
1862 #define VKI_KDSETKEYCODE   0x4B4D  /* write kernel keycode table entry */
1863
1864 #define VKI_KDSIGACCEPT    0x4B4E  /* accept kbd generated signals */
1865
1866 struct vki_kbd_repeat {
1867    int delay;  /* in msec; <= 0: don't change */
1868    int period; /* in msec; <= 0: don't change */
1869    /* earlier this field was misnamed "rate" */
1870 };
1871 #define VKI_KDKBDREP       0x4B52  /* set keyboard delay/repeat rate;
1872                                     * actually used values are returned */
1873
1874 #define VKI_KDFONTOP       0x4B72  /* font operations */
1875
1876 //----------------------------------------------------------------------
1877 // From linux-2.6.9/include/linux/kb.h
1878 //----------------------------------------------------------------------
1879
1880 typedef __vki_kernel_uid32_t vki_qid_t; /* Type in which we store ids in memory */
1881
1882 #endif
1883
1884 //----------------------------------------------------------------------
1885 // From sys/ptrace.h
1886 //----------------------------------------------------------------------
1887
1888 #define VKI_PTRACE_TRACEME         0
1889 #define VKI_PTRACE_READ_I     1
1890 #define VKI_PTRACE_READ_D     2
1891 /* 3 - read user struct */
1892 #define VKI_PTRACE_WRITE_I    4
1893 #define VKI_PTRACE_WRITE_D    5
1894 /* 6 - write user struct */
1895 #define VKI_PTRACE_CONTINUE      7
1896 #define VKI_PTRACE_KILL       8
1897 #define VKI_PTRACE_STEP       9
1898 #define VKI_PTRACE_ATTACH     10
1899 #define VKI_PTRACE_DETACH     11
1900 #define VKI_PTRACE_IO         12
1901 #define VKI_PTRACE_LWPINFO    13
1902 #define VKI_PTRACE_GETNUMLWPS    14
1903 #define VKI_PTRACE_GETLWPLIST    15
1904 #define VKI_PTRACE_CLEARSTEP     16
1905 #define VKI_PTRACE_SETSTEP    17
1906 #define VKI_PTRACE_SUSPEND    18
1907 #define VKI_PTRACE_RESUME     19
1908 #define VKI_PTRACE_TO_SCE     20
1909 #define VKI_PTRACE_TO_SCX     21
1910 #define VKI_PTRACE_SYSCALL    22
1911 /* md */
1912 #define VKI_PTRACE_GETREGS    33
1913 #define VKI_PTRACE_SETREGS    34
1914 #define VKI_PTRACE_GETFPREGS     35
1915 #define VKI_PTRACE_SETFPREGS     36
1916 #define VKI_PTRACE_GETDBREGS     37
1917 #define VKI_PTRACE_SETDBREGS     38
1918
1919 #define  VKI_PTRACE_VM_TIMESTAMP    40
1920 #define  VKI_PTRACE_VM_ENTRY        41
1921
1922 #define VKI_PTRACE_FIRSTMACH     64
1923
1924 struct vki_ptrace_io_desc {
1925    int      piod_op;
1926    void *      piod_offs;
1927    void *      piod_addr;
1928    vki_size_t  piod_len;
1929 };
1930 #define VKI_PIOD_READ_D    1
1931 #define VKI_PIOD_WRITE_D   2
1932 #define VKI_PIOD_READ_I    3
1933 #define VKI_PIOD_WRITE_I   4
1934
1935 struct vki_ptrace_lwpinfo {
1936    vki_lwpid_t pl_lwpid;
1937    int      pl_event;
1938 #define  VKI_PL_EVENT_NONE 0
1939 #define  VKI_PL_EVENT_SIGNAL  1
1940    int      pl_flags;
1941 #define VKI_FLAG_SA     0x01
1942 #define  VKI_FLAG_BOUND    0x02
1943    vki_sigset_t pl_sigmask;
1944    vki_sigset_t pl_siglist;
1945 };
1946
1947 struct vki_ptrace_vm_entry {
1948    int      pve_entry;  /* Entry number used for iteration. */
1949    int      pve_timestamp; /* Generation number of VM map. */
1950    unsigned long  pve_start;  /* Start VA of range. */
1951    unsigned long  pve_end; /* End VA of range (incl). */
1952    unsigned long  pve_offset; /* Offset in backing object. */
1953    unsigned int   pve_prot;   /* Protection of memory range. */
1954    unsigned int   pve_pathlen;   /* Size of path. */
1955    long     pve_fileid; /* File ID. */
1956    vki_uint32_t   pve_fsid;   /* File system ID. */
1957    char     *pve_path;  /* Path name of object. */
1958 };
1959
1960 #endif // __VKI_FREEBSD_H
1961
1962 //----------------------------------------------------------------------
1963 // From x86/sysarch.h
1964 //----------------------------------------------------------------------
1965
1966 // @todo PJF missing VKI_I386_VM86 VKI_I386_SET_PKRU VKI_I386_CLEAR_PKRU VKI_AMD64_SET_PKRU VKI_AMD64_CLEAR_PKRU
1967 #define VKI_I386_GET_FSBASE     7
1968 #define VKI_I386_SET_FSBASE     8
1969 #define VKI_I386_GET_GSBASE     9
1970 #define VKI_I386_SET_GSBASE     10
1971 #define VKI_I386_GET_XFPUSTATE  11
1972
1973 #define VKI_AMD64_GET_FSBASE    128
1974 #define VKI_AMD64_SET_FSBASE    129
1975 #define VKI_AMD64_GET_GSBASE    130
1976 #define VKI_AMD64_SET_GSBASE    131
1977 #define VKI_AMD64_GET_XFPUSTATE  132
1978
1979 //----------------------------------------------------------------------
1980 // From sys/module.h
1981 //----------------------------------------------------------------------
1982
1983 #define VKI_MAXMODNAME 32
1984
1985 typedef union vki_modspecific {
1986    vki_int32_t intval;
1987    vki_uint32_t   u_intval;
1988 #if defined(VGP_x86_freebsd)
1989    vki_int32_t longval;
1990    vki_uint32_t   u_longval;
1991 #elif defined(VGP_amd64_freebsd) || defined(VGP_arm64_freebsd)
1992    vki_int64_t longval;
1993    vki_uint64_t   u_longval;
1994 #else
1995 #error Unknown platform
1996 #endif
1997 } vki_modspecific_t;
1998
1999 struct vki_module_stat {
2000    int   version;
2001    char  name[VKI_MAXMODNAME];
2002    int   refs;
2003    int   id;
2004    vki_modspecific_t data;
2005 };
2006
2007 //----------------------------------------------------------------------
2008 // From sys/rtprio.h
2009 //----------------------------------------------------------------------
2010
2011 struct vki_rtprio {
2012    vki_uint16_t   type;
2013    vki_uint16_t   prio;
2014 };
2015
2016 #define VKI_RTP_LOOKUP  0
2017 #define VKI_RTP_SET  1
2018
2019 //----------------------------------------------------------------------
2020 // From sys/umtx.h
2021 //----------------------------------------------------------------------
2022
2023 struct vki_umtx {
2024    unsigned long  u_owner;
2025 };
2026
2027 struct vki_umutex {
2028    vki_lwpid_t m_owner;
2029    vki_uint32_t   m_flags;
2030    vki_uint32_t   m_ceilings[2];
2031    vki_uint32_t   m_spare[4];
2032 };
2033
2034 struct vki_ucond {
2035    vki_uint32_t   c_has_waiters;
2036    vki_uint32_t   c_flags;
2037    vki_uint32_t   c_spare[2];
2038 };
2039
2040 struct vki_urwlock {
2041    vki_uint32_t   rw_state;
2042    vki_uint32_t   rw_flags;
2043    vki_uint32_t   rw_blocked_readers;
2044    vki_uint32_t   rw_blocked_writers;
2045    vki_uint32_t   rw_spare[4];
2046 };
2047
2048 struct vki_usem {
2049    vki_uint32_t   has_waiters;
2050    vki_uint32_t   count;
2051    vki_uint32_t   flags;
2052 };
2053
2054 struct vki_umtx_time {
2055    struct vki_timespec  timeout;
2056    vki_uint32_t      flags;
2057    vki_uint32_t      clockid;
2058 };
2059
2060 struct vki_usem2 {
2061    vki_uint32_t    count;
2062    vki_uint32_t  flags;
2063 };
2064
2065 struct vki_umtx_robust_lists_params {
2066    vki_uintptr_t robust_list_offset;
2067    vki_uintptr_t robust_priv_list_offset;
2068    vki_uintptr_t robust_inact_offset;
2069 };
2070
2071 #define VKI_UMTX_OP_LOCK     0
2072 #define VKI_UMTX_OP_UNLOCK      1
2073 #define VKI_UMTX_OP_WAIT     2
2074 #define VKI_UMTX_OP_WAKE     3
2075 #define VKI_UMTX_OP_MUTEX_TRYLOCK  4
2076 #define VKI_UMTX_OP_MUTEX_LOCK     5
2077 #define VKI_UMTX_OP_MUTEX_UNLOCK   6
2078 #define VKI_UMTX_OP_SET_CEILING    7
2079 #define VKI_UMTX_OP_CV_WAIT     8
2080 #define VKI_UMTX_OP_CV_SIGNAL      9
2081 #define VKI_UMTX_OP_CV_BROADCAST   10
2082 #define VKI_UMTX_OP_WAIT_UINT      11
2083 #define VKI_UMTX_OP_RW_RDLOCK      12
2084 #define VKI_UMTX_OP_RW_WRLOCK      13
2085 #define VKI_UMTX_OP_RW_UNLOCK      14
2086 #define VKI_UMTX_OP_WAIT_UINT_PRIVATE 15
2087 #define VKI_UMTX_OP_WAKE_PRIVATE   16
2088 #define VKI_UMTX_OP_MUTEX_WAIT     17
2089 #define VKI_UMTX_OP_MUTEX_WAKE     18 /* deprecated */
2090 #define VKI_UMTX_OP_SEM_WAIT    19
2091 #define VKI_UMTX_OP_SEM_WAKE    20
2092 #define VKI_UMTX_OP_NWAKE_PRIVATE  21
2093 #define VKI_UMTX_OP_MUTEX_WAKE2    22
2094 #define VKI_UMTX_OP_SEM2_WAIT       23
2095 #define VKI_UMTX_OP_SEM2_WAKE       24
2096 #define VKI_UMTX_OP_SHM             25
2097 #define VKI_UMTX_OP_ROBUST_LISTS    26
2098 #if (FREEBSD_VERS >= FREEBSD_13_3)
2099 #define VKI_UMTX_OP_GET_MIN_TIMEOUT 27
2100 #define VKI_UMTX_OP_SET_MIN_TIMEOUT 28
2101 #endif
2102
2103
2104 //----------------------------------------------------------------------
2105 // From sys/acl.h
2106 //----------------------------------------------------------------------
2107
2108 struct vki_acl_entry {
2109    int      ae_tag;
2110    vki_uid_t   ae_uid;
2111    vki_mode_t  ae_perm;
2112 };
2113
2114 #define VKI_ACL_MAX_ENTRIES 32
2115 struct vki_acl {
2116    int      acl_cnt;
2117    struct vki_acl_entry acl_entry[VKI_ACL_MAX_ENTRIES];
2118 };
2119
2120
2121 //----------------------------------------------------------------------
2122 // From sys/uuid.h
2123 //----------------------------------------------------------------------
2124
2125 struct vki_uuid {
2126    vki_uint32_t   time_low;
2127    vki_uint16_t   time_mid;
2128    vki_uint16_t   time_hi_and_version;
2129    vki_uint8_t clock_seq_hi_and_reserved;
2130    vki_uint8_t clock_seq_low;
2131    vki_uint8_t node[6];
2132 };
2133
2134 //----------------------------------------------------------------------
2135 // sys/_sockaddr_storage.h
2136 //----------------------------------------------------------------------
2137
2138 #define VKI__SS_MAXSIZE     128U
2139 #define VKI__SS_ALIGNSIZE   (sizeof(__int64_t))
2140 #define VKI__SS_PAD1SIZE    (VKI__SS_ALIGNSIZE - sizeof(unsigned char) - \
2141                             sizeof(vki_sa_family_t))
2142 #define VKI__SS_PAD2SIZE    (VKI__SS_MAXSIZE - sizeof(unsigned char) - \
2143                             sizeof(sa_family_t) - VKI__SS_PAD1SIZE - VKI__SS_ALIGNSIZE)
2144
2145 struct vki_sockaddr_storage {
2146         unsigned char   vki_ss_len;         /* address length */
2147         vki_sa_family_t     vki_ss_family;      /* address family */
2148         char            vki___ss_pad1[VKI__SS_PAD1SIZE];
2149         __int64_t       vki___ss_align;     /* force desired struct alignment */
2150         char            vki___ss_pad2VKI_[_SS_PAD2SIZE];
2151 };
2152
2153 //----------------------------------------------------------------------
2154 // From sys/captrights.h
2155 //----------------------------------------------------------------------
2156
2157 #define VKI_CAP_RIGHTS_VERSION_00   0
2158 #define VKI_CAP_RIGHTS_VERSION      VKI_CAP_RIGHTS_VERSION_00
2159
2160 struct vki_cap_rights {
2161         vki_uint64_t        cki_cr_rights[VKI_CAP_RIGHTS_VERSION + 2];
2162 };
2163
2164 typedef struct vki_cap_rights       vki_cap_rights_t;
2165
2166
2167 //----------------------------------------------------------------------
2168 // From sys/user.h
2169 //----------------------------------------------------------------------
2170
2171 #define VKI_KVME_TYPE_NONE          0
2172 #define VKI_KVME_TYPE_DEFAULT       1
2173 #define VKI_KVME_TYPE_VNODE         2
2174 #define VKI_KVME_TYPE_SWAP          3
2175 #define VKI_KVME_TYPE_DEVICE        4
2176 #define VKI_KVME_TYPE_PHYS          5
2177 #define VKI_KVME_TYPE_DEAD          6
2178 #define VKI_KVME_TYPE_MGTDEVICE     8
2179 #define VKI_KVME_TYPE_GUARD         9
2180 #define VKI_KVME_TYPE_UNKNOWN       255
2181
2182 #define VKI_KVME_PROT_READ          0x00000001
2183 #define VKI_KVME_PROT_WRITE         0x00000002
2184 #define VKI_KVME_PROT_EXEC          0x00000004
2185
2186 #define VKI_KVME_FLAG_COW           0x00000001
2187 #define VKI_KVME_FLAG_NEEDS_COPY    0x00000002
2188 #define VKI_KVME_FLAG_NOCOREDUMP    0x00000004
2189 #define VKI_KVME_FLAG_SUPER         0x00000008
2190 #define VKI_KVME_FLAG_GROWS_UP      0x00000010
2191 #define VKI_KVME_FLAG_GROWS_DOWN    0x00000020
2192 #define VKI_KVME_FLAG_USER_WIRED    0x00000040
2193
2194 struct vki_kinfo_vmentry {
2195    int   kve_structsize;
2196    int   kve_type;
2197    ULong kve_start;
2198    ULong kve_end;
2199    ULong   kve_offset;
2200    ULong   kve_fileid;
2201    UInt    kve_vn_fsid_freebsd11;
2202    int   kve_flags;
2203    int   kve_resident;
2204    int   kve_private_resident;
2205    int   kve_protection;
2206    int   kve_ref_count;
2207    int   kve_shadow_count;
2208    int      kve_vn_type;
2209    ULong kve_vn_size;
2210    UInt kve_vn_rdev_freebsd11;
2211    UShort kve_vn_mode;
2212    UShort kve_status;
2213    ULong kve_vn_fsid;
2214    ULong kve_vn_rdev;
2215    int      _kve_ispare[8];
2216    char  kve_path[VKI_PATH_MAX];
2217 };
2218
2219 #define VKI_KINFO_FILE_SIZE     1392
2220
2221 struct vki_kinfo_file {
2222    int          vki_kf_structsize;              /* Variable size of record. */
2223    int          vki_kf_type;            /* Descriptor type. */
2224    int          vki_kf_fd;                      /* Array index. */
2225    int          vki_kf_ref_count;               /* Reference count. */
2226    int          vki_kf_flags;           /* Flags. */
2227    int          vki_kf_pad0;            /* Round to 64 bit alignment. */
2228    Off64T   vki_kf_offset;              /* Seek location. */
2229    union {
2230       struct {
2231          /* API compatiblity with FreeBSD < 12. */
2232          int            vki_kf_vnode_type;
2233          int            vki_kf_sock_domain;
2234          int            vki_kf_sock_type;
2235          int            kf_sock_protocol;
2236          struct vki_sockaddr_storage vki_kf_sa_local;
2237          struct vki_sockaddr_storage    vki_kf_sa_peer;
2238       };
2239       union {
2240          struct {
2241             /* Sendq size */
2242             vki_uint32_t        vki_kf_sock_sendq;
2243             /* Socket domain. */
2244             int         vki_kf_sock_domain0;
2245             /* Socket type. */
2246             int         vki_kf_sock_type0;
2247             /* Socket protocol. */
2248             int         vki_kf_sock_protocol0;
2249             /* Socket address. */
2250             struct vki_sockaddr_storage vki_kf_sa_local;
2251             /* Peer address. */
2252             struct vki_sockaddr_storage vki_kf_sa_peer;
2253             /* Address of so_pcb. */
2254             vki_uint64_t        vki_kf_sock_pcb;
2255             /* Address of inp_ppcb. */
2256             vki_uint64_t        vki_kf_sock_inpcb;
2257             /* Address of unp_conn. */
2258             vki_uint64_t        vki_kf_sock_unpconn;
2259             /* Send buffer state. */
2260             vki_uint16_t        vki_kf_sock_snd_sb_state;
2261             /* Receive buffer state. */
2262             vki_uint16_t        vki_kf_sock_rcv_sb_state;
2263             /* Recvq size. */
2264             vki_uint32_t        vki_kf_sock_recvq;
2265          } vki_kf_sock;
2266          struct {
2267             /* Vnode type. */
2268             int         vki_kf_file_type;
2269             /* Space for future use */
2270             int         vki_kf_spareint[3];
2271             vki_uint64_t        vki_kf_spareint64[30];
2272             /* Vnode filesystem id. */
2273             vki_uint64_t        vki_kf_file_fsid;
2274             /* File device. */
2275             vki_uint64_t        vki_kf_file_rdev;
2276             /* Global file id. */
2277             vki_uint64_t        vki_kf_file_fileid;
2278             /* File size. */
2279             vki_uint64_t        vki_kf_file_size;
2280             /* Vnode filesystem id, FreeBSD 11 compat. */
2281             vki_uint32_t        vki_kf_file_fsid_freebsd11;
2282             /* File device, FreeBSD 11 compat. */
2283             vki_uint32_t        kf_file_rdev_freebsd11;
2284             /* File mode. */
2285             vki_uint16_t        vki_kf_file_mode;
2286             /* Round to 64 bit alignment. */
2287             vki_uint16_t        vki_kf_file_pad0;
2288             vki_uint32_t        kf_file_pad1;
2289          } kf_file;
2290          struct {
2291             vki_uint32_t        vki_kf_spareint[4];
2292             vki_uint64_t        vki_kf_spareint64[32];
2293             vki_uint32_t        vki_kf_sem_value;
2294             vki_uint16_t        vki_kf_sem_mode;
2295          } kf_sem;
2296          struct {
2297             vki_uint32_t        vki_kf_spareint[4];
2298             vki_uint64_t        vki_kf_spareint64[32];
2299             vki_uint64_t        vki_kf_pipe_addr;
2300             vki_uint64_t        vki_kf_pipe_peer;
2301             vki_uint32_t        vki_kf_pipe_buffer_cnt;
2302             /* Round to 64 bit alignment. */
2303             vki_uint32_t        vki_kf_pipe_pad0[3];
2304          } kf_pipe;
2305          struct {
2306             vki_uint32_t        vki_kf_spareint[4];
2307             vki_uint64_t        vki_kf_spareint64[32];
2308             vki_uint32_t        vki_kf_pts_dev_freebsd11;
2309             vki_uint32_t        vki_kf_pts_pad0;
2310             vki_uint64_t        vki_kf_pts_dev;
2311             /* Round to 64 bit alignment. */
2312             vki_uint32_t        vki_kf_pts_pad1[4];
2313          } kf_pts;
2314          struct {
2315             vki_uint32_t        vki_kf_spareint[4];
2316             vki_uint64_t        vki_kf_spareint64[32];
2317             vki_pid_t           vki_kf_pid;
2318          } vki_kf_proc;
2319          struct {
2320             vki_uint64_t        vki_kf_eventfd_value;
2321             vki_uint32_t        vki_kf_eventfd_flags;
2322          } vki_kf_eventfd;
2323       } vki_kf_un;
2324    };
2325    vki_uint16_t vki_kf_status;          /* Status flags. */
2326    vki_uint16_t vki_kf_pad1;            /* Round to 32 bit alignment. */
2327    int          vki__kf_ispare0;                /* Space for more stuff. */
2328    vki_cap_rights_t     vki_kf_cap_rights;              /* Capability rights. */
2329    vki_uint64_t vki__kf_cap_spare;              /* Space for future cap_rights_t. */
2330    /* Truncated before copyout in sysctl */
2331    char         vki_kf_path[VKI_PATH_MAX];      /* Path to file, if any. */
2332 };
2333
2334 //----------------------------------------------------------------------
2335 // From sys/kenv.h
2336 //----------------------------------------------------------------------
2337 #define VKI_KENV_GET    0
2338 #define VKI_KENV_SET    1
2339 #define VKI_KENV_UNSET     2
2340 #define VKI_KENV_DUMP      3
2341
2342 //----------------------------------------------------------------------
2343 // From sys/sysctl.h (and related)
2344 //----------------------------------------------------------------------
2345
2346 #include <sys/types.h>
2347 #include <sys/sysctl.h>
2348
2349 #define VKI_CTL_KERN         CTL_KERN
2350 #define VKI_CTL_HW           CTL_HW
2351 #define VKI_KERN_PROC        KERN_PROC
2352 #define VKI_KERN_PROC_VMMAP  KERN_PROC_VMMAP
2353 #define VKI_KERN_PROC_FILEDESC KERN_PROC_FILEDESC
2354 #define VKI_HW_MACHINE       HW_MACHINE
2355
2356 //----------------------------------------------------------------------
2357 // From sys/thr.h
2358 //----------------------------------------------------------------------
2359
2360 struct vki_thr_param {
2361    void  (*start_func)(void *);
2362    void  *arg;
2363    char  *stack_base;
2364    vki_size_t  stack_size;
2365    char  *tls_base;
2366    vki_size_t  tls_size;
2367    long  *child_tid;
2368    long  *parent_tid;
2369    int   flags;
2370    struct vki_rtprio *rtp;
2371    void  *spare[3];
2372 };
2373
2374 //----------------------------------------------------------------------
2375 // From sys/linker.h
2376 //----------------------------------------------------------------------
2377
2378 struct vki_kld_file_stat {
2379    int         version;        /* set to sizeof(struct kld_file_stat) */
2380    char        name[MAXPATHLEN];
2381    int         refs;
2382    int         id;
2383    vki_caddr_t     address;        /* load address */
2384    vki_size_t      size;           /* size in bytes */
2385    char        pathname[MAXPATHLEN];
2386 };
2387
2388
2389 struct vki_kld_sym_lookup {
2390    int         version;        /* set to sizeof(struct kld_sym_lookup) */
2391    char        *symname;       /* Symbol name we are looking up */
2392    unsigned long symvalue;
2393    vki_size_t  symsize;
2394 };
2395
2396 #if !defined(VKI_INIT_ARCH_ELF_STATE)
2397 /* This structure is used to preserve architecture specific data during
2398    the loading of an ELF file, throughout the checking of architecture
2399    specific ELF headers & through to the point where the ELF load is
2400    known to be proceeding. This implementation is a dummy for
2401    architectures which require no specific state. */
2402 struct vki_arch_elf_state {
2403 };
2404
2405 #  define VKI_INIT_ARCH_ELF_STATE { }
2406
2407 #endif
2408
2409 //----------------------------------------------------------------------
2410 // From ufs/ufs/quota.h
2411 //----------------------------------------------------------------------
2412
2413 #define VKI_Q_QUOTAON       0x0100
2414 #define VKI_Q_QUOTAOFF      0x0200
2415 #define VKI_Q_GETQUOTA32    0x0300
2416 #define VKI_Q_SETQUOTA32    0x0400
2417 #define VKI_Q_SETUSE32      0x0500
2418 #define VKI_Q_SYNC          0x0600
2419 #define VKI_Q_GETQUOTA      0x0700
2420 #define VKI_Q_SETQUOTA      0x0800
2421 #define VKI_Q_SETUSE        0x0900
2422 #define VKI_Q_GETQUOTASIZE  0x0A00
2423
2424 //----------------------------------------------------------------------
2425 // From sys/_bitset.h
2426 //----------------------------------------------------------------------
2427
2428 #define  VKI_BITSET_BITS      (sizeof(long) * 8)
2429
2430 #define  vki__howmany(x, y)   (((x) + ((y) - 1)) / (y))
2431
2432 #define  vki__bitset_words(_s)   (vki__howmany(_s, VKI_BITSET_BITS))
2433
2434 #define  VKI_BITSET_DEFINE(t, _s)                  \
2435 struct t {                       \
2436         long    __bits[vki__bitset_words((_s))];            \
2437 }
2438
2439 //----------------------------------------------------------------------
2440 // From sys/_domainset.h
2441 //----------------------------------------------------------------------
2442
2443 #define  VKI_DOMAINSET_MAXSIZE   256
2444
2445 #ifndef  VKI_DOMAINSET_SETSIZE
2446 #define  VKI_DOMAINSET_SETSIZE   VKI_DOMAINSET_MAXSIZE
2447 #endif
2448
2449 VKI_BITSET_DEFINE(vki_domainset, VKI_DOMAINSET_SETSIZE);
2450
2451 typedef struct vki_domainset vki_domainset_t;
2452
2453 //----------------------------------------------------------------------
2454 // From sys/procctl.h
2455 //----------------------------------------------------------------------
2456
2457 #define VKI_PROC_SPROTECT           1
2458 #define VKI_PROC_REAP_ACQUIRE       2
2459 #define VKI_PROC_REAP_RELEASE       3
2460 #define VKI_PROC_REAP_STATUS        4
2461 #define VKI_PROC_REAP_GETPIDS       5
2462 #define VKI_PROC_REAP_KILL          6
2463 #define VKI_PROC_TRACE_CTL          7
2464 #define VKI_PROC_TRACE_STATUS       8
2465 #define VKI_PROC_TRAPCAP_CTL        9
2466 #define VKI_PROC_TRAPCAP_STATUS     10
2467 #define VKI_PROC_PDEATHSIG_CTL      11
2468 #define VKI_PROC_PDEATHSIG_STATUS   12
2469 #define VKI_PROC_ASLR_CTL           13
2470 #define VKI_PROC_ASLR_STATUS        14
2471 #define VKI_PROC_STACKGAP_CTL       17
2472 #define VKI_PROC_STACKGAP_STATUS    18
2473 #define VKI_PROC_NO_NEW_PRIVS_CTL   19
2474 #define VKI_PROC_NO_NEW_PRIVS_STATUS 20
2475 #define VKI_PROC_WXMAP_CTL          21
2476 #define VKI_PROC_WXMAP_STATUS       22
2477
2478 struct vki_procctl_reaper_status {
2479    u_int   rs_flags;
2480    u_int   rs_children;
2481    u_int   rs_descendants;
2482    vki_pid_t   rs_reaper;
2483    vki_pid_t   rs_pid;
2484    u_int   rs_pad0[15];
2485 };
2486
2487 struct vki_procctl_reaper_pidinfo;
2488
2489 struct vki_procctl_reaper_pids {
2490    u_int   rp_count;
2491    u_int   rp_pad0[15];
2492    struct vki_procctl_reaper_pidinfo *rp_pids;
2493 };
2494
2495 struct vki_procctl_reaper_kill {
2496    int     rk_sig;
2497    u_int   rk_flags;
2498    vki_pid_t   rk_subtree;
2499    u_int   rk_killed;
2500    vki_pid_t   rk_fpid;
2501    u_int   rk_pad0[15];
2502 };
2503
2504 //----------------------------------------------------------------------
2505 // From sys/jail.h
2506 //----------------------------------------------------------------------
2507
2508 struct vki_jail {
2509    uint32_t        version;
2510    char            *path;
2511    char            *hostname;
2512    char            *jailname;
2513    uint32_t        ip4s;
2514    uint32_t        ip6s;
2515    struct in_addr  *ip4;
2516    struct in6_addr *ip6;
2517 };
2518
2519 //----------------------------------------------------------------------
2520 // From sys/exec.h
2521 //----------------------------------------------------------------------
2522
2523 struct vki_ps_strings {
2524    char** ps_argvstr;
2525    unsigned int ps_nargvstr;
2526
2527    char** ps_envstr;
2528    unsigned int ps_nenvstr;
2529 };
2530
2531 //----------------------------------------------------------------------
2532 // From sys/elf_common.h
2533 //----------------------------------------------------------------------
2534
2535 #define VKI_AT_NULL 0
2536 #define VKI_AT_IGNORE 1
2537 #define VKI_AT_EXECFD 2
2538 #define VKI_AT_PHDR 3
2539 #define VKI_AT_PHENT 4
2540 #define VKI_AT_PHNUM 5
2541 #define VKI_AT_PAGESZ 6
2542 #define VKI_AT_BASE 7
2543 #define VKI_AT_FLAGS 8
2544 #define VKI_AT_ENTRY 9
2545 #define VKI_AT_NOTELF 10
2546 #define VKI_AT_UID 11
2547 #define VKI_AT_EUID 12
2548 #define VKI_AT_GID 13
2549 #define VKI_AT_EGID 14
2550 #define VKI_AT_EXECPATH 15
2551 #define VKI_AT_CANARY 16
2552 #define VKI_AT_CANARYLEN 17
2553 #define VKI_AT_OSRELDATE 18
2554 #define VKI_AT_NCPUS    19
2555 #define VKI_AT_PAGESIZES 20
2556 #define VKI_AT_PAGESIZESLEN 21
2557 #define VKI_AT_TIMEKEEP 22
2558 #define VKI_AT_STACKPROT 23
2559 #define VKI_AT_EHDRFLAGS 24
2560 #define VKI_AT_HWCAP 25
2561 #define VKI_AT_HWCAP2 26
2562 /* added in FreeBSD 13 */
2563 #define VKI_AT_BSDFLAGS 27
2564 #define VKI_AT_ARGC 28
2565 #define VKI_AT_ARGV 29
2566 #define VKI_AT_ENVC 30
2567 #define VKI_AT_ENVV 31
2568 #define VKI_AT_PS_STRINGS 32
2569 /* added in FreeBSD 13.1 */
2570 #define VKI_AT_FXRNG    33
2571 #define VKI_AT_KPRELOAD 34
2572 /* added in FreeBSD 14 */
2573 #define VKI_AT_USRSTACKBASE 35
2574 #define VKI_AT_USRSTACKLIM 36
2575
2576 /* AT_COUNT depends on the FreeBSD version, not currently used */
2577
2578
2579 #define VKI_NT_FREEBSD_ABI_TAG 1
2580 #define VKI_NT_FREEBSD_FEATURE_CTL 4
2581 #define VKI_NT_FREEBSD_FCTL_STKGAP_DISABLE 0x00000004
2582 #define VKI_NT_FREEBSD_FCTL_WXNEEDED 0x00000008
2583
2584
2585 /*
2586  * PJF this is a bit messy
2587  *
2588  * mode_t is uint16_t
2589  * No problem on x86/amd64
2590  * On arm64 there are syscalls that take mode_t but that doesn't
2591  * work with memcheck validation - arm64 doesn't have any 16bit
2592  * registers.
2593  *
2594  * I can't just change mode_t to be 32bit. that will mess up
2595  * the 'stat' structures in thie file.
2596  *
2597  * Instead I'll just do what the compiler does, and promote
2598  * it to 32bits.
2599  *
2600  * In the kernel, the syscall interface just pushes all
2601  * possible syscall args onto the stack and then
2602  * memcpy's them into an array of register sized args.
2603  * There's a struct defined for each syscall's arguments
2604  * that uses padding to type pun the values back to
2605  * the type passed in from userland. The structs are
2606  * generated from the syscall table.
2607  *
2608  * vki_mode_t is only used in syswrap files so there shouldn't
2609  * be any other side effects.
2610  */
2611
2612 #if defined(VGP_arm64_freebsd)
2613 #define vki_mode_t vki_int32_t
2614 #endif
2615
2616 // See syswrap-freebsd.c PRE/POST(sys_ioctl)
2617 #if 0
2618
2619 //----------------------------------------------------------------------
2620 // From sys/pciio.h
2621 //----------------------------------------------------------------------
2622
2623 typedef unsigned long vki_u_long;
2624 typedef unsigned int vki_u_int;
2625 #define VKI_PCI_MAXNAMELEN  16
2626
2627 typedef enum {
2628    VKI_PCI_GETCONF_LAST_DEVICE,
2629    VKI_PCI_GETCONF_LIST_CHANGED,
2630    VKI_PCI_GETCONF_MORE_DEVS,
2631    VKI_PCI_GETCONF_ERROR
2632 } vki_pci_getconf_status;
2633
2634 typedef enum {
2635    VKI_PCI_GETCONF_NO_MATCH            = 0x0000,
2636    VKI_PCI_GETCONF_MATCH_DOMAIN        = 0x0001,
2637    VKI_PCI_GETCONF_MATCH_BUS           = 0x0002,
2638    VKI_PCI_GETCONF_MATCH_DEV           = 0x0004,
2639    VKI_PCI_GETCONF_MATCH_FUNC          = 0x0008,
2640    VKI_PCI_GETCONF_MATCH_NAME          = 0x0010,
2641    VKI_PCI_GETCONF_MATCH_UNIT          = 0x0020,
2642    VKI_PCI_GETCONF_MATCH_VENDOR        = 0x0040,
2643    VKI_PCI_GETCONF_MATCH_DEVICE        = 0x0080,
2644    VKI_PCI_GETCONF_MATCH_CLASS         = 0x0100
2645 } vki_pci_getconf_flags;
2646
2647 struct vki_pcisel {
2648    vki_uint32_t   pc_domain;      /* domain number */
2649    vki_uint8_t    pc_bus;         /* bus number */
2650    vki_uint8_t    pc_dev;         /* device on this bus */
2651    vki_uint8_t    pc_func;        /* function on this device */
2652 };
2653
2654 struct vki_pci_conf {
2655    struct vki_pcisel   pc_sel;         /* domain+bus+slot+function */
2656    vki_uint8_t    pc_hdr;         /* PCI header type */
2657    vki_uint16_t   pc_subvendor;   /* card vendor ID */
2658    vki_uint16_t   pc_subdevice;   /* card device ID, assigned by
2659                                            card vendor */
2660    vki_uint16_t   pc_vendor;      /* chip vendor ID */
2661    vki_uint16_t   pc_device;      /* chip device ID, assigned by
2662                                            chip vendor */
2663    vki_uint8_t    pc_class;       /* chip PCI class */
2664    vki_uint8_t    pc_subclass;    /* chip PCI subclass */
2665    vki_uint8_t    pc_progif;      /* chip PCI programming interface */
2666    vki_uint8_t    pc_revid;       /* chip revision ID */
2667    char        pd_name[VKI_PCI_MAXNAMELEN + 1];  /* device name */
2668    vki_u_long     pd_unit;        /* device unit number */
2669 };
2670
2671 struct vki_pci_match_conf {
2672    struct vki_pcisel       pc_sel;         /* domain+bus+slot+function */
2673    char                pd_name[VKI_PCI_MAXNAMELEN + 1];  /* device name */
2674    vki_u_long             pd_unit;        /* Unit number */
2675    vki_uint16_t           pc_vendor;      /* PCI Vendor ID */
2676    vki_uint16_t           pc_device;      /* PCI Device ID */
2677    vki_uint8_t            pc_class;       /* PCI class */
2678    vki_pci_getconf_flags   flags;          /* Matching expression */
2679 };
2680
2681 struct vki_pci_conf_io {
2682    vki_uint32_t           pat_buf_len;    /* pattern buffer length */
2683    vki_uint32_t           num_patterns;   /* number of patterns */
2684    struct vki_pci_match_conf   *patterns;      /* pattern buffer */
2685    vki_uint32_t           match_buf_len;  /* match buffer length */
2686    vki_uint32_t           num_matches;    /* number of matches returned */
2687    struct vki_pci_conf     *matches;       /* match buffer */
2688    vki_uint32_t           offset;         /* offset into device list */
2689    vki_uint32_t           generation;     /* device list generation */
2690    vki_pci_getconf_status  status;         /* request status */
2691 };
2692
2693 #define VKI_PCIOCGETCONF    _VKI_IOWR('p', 5, struct vki_pci_conf_io)
2694
2695 //----------------------------------------------------------------------
2696 // From cam/cam.h
2697 //----------------------------------------------------------------------
2698
2699 #define VKI_CAM_MAX_CDBLEN 16
2700
2701 typedef unsigned int vki_path_id_t;
2702 typedef unsigned int vki_target_id_t;
2703 typedef unsigned int vki_lun_id_t;
2704
2705 typedef struct {
2706    vki_uint32_t priority;
2707    vki_uint32_t generation;
2708    int       index;
2709 } vki_cam_pinfo;
2710
2711
2712 //----------------------------------------------------------------------
2713 // From sys/ata.h
2714 //----------------------------------------------------------------------
2715
2716 struct vki_ata_params {
2717    /*000*/ vki_u_int16_t   config;         /* configuration info */
2718    /*001*/ vki_u_int16_t   cylinders;              /* # of cylinders */
2719    /*002*/ vki_u_int16_t   specconf;               /* specific configuration */
2720    /*003*/ vki_u_int16_t   heads;                  /* # heads */
2721    vki_u_int16_t   obsolete4;
2722    vki_u_int16_t   obsolete5;
2723    /*006*/ vki_u_int16_t   sectors;                /* # sectors/track */
2724    /*007*/ vki_u_int16_t   vendor7[3];
2725    /*010*/ vki_u_int8_t    serial[20];             /* serial number */
2726    /*020*/ vki_u_int16_t   retired20;
2727    vki_u_int16_t   retired21;
2728    vki_u_int16_t   obsolete22;
2729    /*023*/ vki_u_int8_t    revision[8];            /* firmware revision */
2730    /*027*/ vki_u_int8_t    model[40];              /* model name */
2731    /*047*/ vki_u_int16_t   sectors_intr;           /* sectors per interrupt */
2732    /*048*/ vki_u_int16_t   usedmovsd;              /* double word read/write? */
2733    /*049*/ vki_u_int16_t   capabilities1;
2734    /*050*/ vki_u_int16_t   capabilities2;
2735    /*051*/ vki_u_int16_t   retired_piomode;        /* PIO modes 0-2 */
2736    /*052*/ vki_u_int16_t   retired_dmamode;        /* DMA modes */
2737    /*053*/ vki_u_int16_t   atavalid;               /* fields valid */
2738    /*054*/ vki_u_int16_t   current_cylinders;
2739    /*055*/ vki_u_int16_t   current_heads;
2740    /*056*/ vki_u_int16_t   current_sectors;
2741    /*057*/ vki_u_int16_t   current_size_1;
2742    /*058*/ vki_u_int16_t   current_size_2;
2743    /*059*/ vki_u_int16_t   multi;
2744    /*060*/ vki_u_int16_t   lba_size_1;
2745    vki_u_int16_t   lba_size_2;
2746    vki_u_int16_t   obsolete62;
2747    /*063*/ vki_u_int16_t   mwdmamodes;             /* multiword DMA modes */
2748    /*064*/ vki_u_int16_t   apiomodes;              /* advanced PIO modes */
2749
2750    /*065*/ vki_u_int16_t   mwdmamin;               /* min. M/W DMA time/word ns */
2751    /*066*/ vki_u_int16_t   mwdmarec;               /* rec. M/W DMA time ns */
2752    /*067*/ vki_u_int16_t   pioblind;               /* min. PIO cycle w/o flow */
2753    /*068*/ vki_u_int16_t   pioiordy;               /* min. PIO cycle IORDY flow */
2754    /*069*/ vki_u_int16_t   support3;
2755    vki_u_int16_t   reserved70;
2756    /*071*/ vki_u_int16_t   rlsovlap;               /* rel time (us) for overlap */
2757    /*072*/ vki_u_int16_t   rlsservice;             /* rel time (us) for service */
2758    vki_u_int16_t   reserved73;
2759    vki_u_int16_t   reserved74;
2760    /*075*/ vki_u_int16_t   queue;
2761    /*76*/  vki_u_int16_t   satacapabilities;
2762    /*77*/  vki_u_int16_t   satacapabilities2;
2763    /*78*/  vki_u_int16_t   satasupport;
2764    /*79*/  vki_u_int16_t   sataenabled;
2765    /*080*/ vki_u_int16_t   version_major;
2766    /*081*/ vki_u_int16_t   version_minor;
2767
2768    struct {
2769       /*082/085*/ vki_u_int16_t   command1;
2770       /*083/086*/ vki_u_int16_t   command2;
2771       /*084/087*/ vki_u_int16_t   extension;
2772    } __packed support, enabled;
2773
2774    /*088*/ vki_u_int16_t   udmamodes;              /* UltraDMA modes */
2775    /*089*/ vki_u_int16_t   erase_time;
2776    /*090*/ vki_u_int16_t   enhanced_erase_time;
2777    /*091*/ vki_u_int16_t   apm_value;
2778    /*092*/ vki_u_int16_t   master_passwd_revision;
2779    /*093*/ vki_u_int16_t   hwres;
2780    /*094*/ vki_u_int16_t   acoustic;
2781    /*095*/ vki_u_int16_t   stream_min_req_size;
2782    /*096*/ vki_u_int16_t   stream_transfer_time;
2783    /*097*/ vki_u_int16_t   stream_access_latency;
2784    /*098*/ vki_u_int32_t   stream_granularity;
2785    /*100*/ vki_u_int16_t   lba_size48_1;
2786    vki_u_int16_t   lba_size48_2;
2787    vki_u_int16_t   lba_size48_3;
2788    vki_u_int16_t   lba_size48_4;
2789    vki_u_int16_t   reserved104;
2790    /*105*/ vki_u_int16_t   max_dsm_blocks;
2791    /*106*/ vki_u_int16_t   pss;
2792    /*107*/ vki_u_int16_t   isd;
2793    /*108*/ vki_u_int16_t   wwn[4];
2794    vki_u_int16_t   reserved112[5];
2795    /*117*/ vki_u_int16_t   lss_1;
2796    /*118*/ vki_u_int16_t   lss_2;
2797    /*119*/ vki_u_int16_t   support2;
2798    /*120*/ vki_u_int16_t   enabled2;
2799    vki_u_int16_t   reserved121[6];
2800    /*127*/ vki_u_int16_t   removable_status;
2801    /*128*/ vki_u_int16_t   security_status;
2802    vki_u_int16_t   reserved129[31];
2803    /*160*/ vki_u_int16_t   cfa_powermode1;
2804    vki_u_int16_t   reserved161;
2805    /*162*/ vki_u_int16_t   cfa_kms_support;
2806    /*163*/ vki_u_int16_t   cfa_trueide_modes;
2807    /*164*/ vki_u_int16_t   cfa_memory_modes;
2808    vki_u_int16_t   reserved165[4];
2809    /*169*/ vki_u_int16_t   support_dsm;
2810    vki_u_int16_t   reserved170[6];
2811    /*176*/ vki_u_int8_t    media_serial[60];
2812    /*206*/ vki_u_int16_t   sct;
2813    vki_u_int16_t   reserved206[2];
2814    /*209*/ vki_u_int16_t   lsalign;
2815    /*210*/ vki_u_int16_t   wrv_sectors_m3_1;
2816    vki_u_int16_t   wrv_sectors_m3_2;
2817    /*212*/ vki_u_int16_t   wrv_sectors_m2_1;
2818    vki_u_int16_t   wrv_sectors_m2_2;
2819    /*214*/ vki_u_int16_t   nv_cache_caps;
2820    /*215*/ vki_u_int16_t   nv_cache_size_1;
2821    vki_u_int16_t   nv_cache_size_2;
2822    /*217*/ vki_u_int16_t   media_rotation_rate;
2823    vki_u_int16_t   reserved218;
2824    /*219*/ vki_u_int16_t   nv_cache_opt;
2825    /*220*/ vki_u_int16_t   wrv_mode;
2826    vki_u_int16_t   reserved221;
2827    /*222*/ vki_u_int16_t   transport_major;
2828    /*223*/ vki_u_int16_t   transport_minor;
2829    vki_u_int16_t   reserved224[31];
2830    /*255*/ vki_u_int16_t   integrity;
2831 } __packed;
2832
2833 //----------------------------------------------------------------------
2834 // From sys/callout.h
2835 //----------------------------------------------------------------------
2836
2837 struct vki_callout_handle {
2838    struct vki_callout *callout;
2839 };
2840
2841
2842 //----------------------------------------------------------------------
2843 // From cam/scsi/scsi_all.h
2844 //----------------------------------------------------------------------
2845
2846 struct vki_scsi_sense_data {
2847    vki_u_int8_t error_code;
2848    vki_u_int8_t segment;
2849    vki_u_int8_t flags;
2850    vki_u_int8_t info[4];
2851    vki_u_int8_t extra_len;
2852    vki_u_int8_t cmd_spec_info[4];
2853    vki_u_int8_t add_sense_code;
2854    vki_u_int8_t add_sense_code_qual;
2855    vki_u_int8_t fru;
2856    vki_u_int8_t sense_key_spec[3];
2857    vki_u_int8_t extra_bytes[14];
2858 #define VKI_SSD_FULL_SIZE sizeof(struct vki_scsi_sense_data)
2859 };
2860
2861 struct vki_scsi_inquiry_data {
2862    vki_uint8_t device;
2863    vki_uint8_t dev_qual2;
2864    vki_uint8_t version;
2865    vki_uint8_t response_format;
2866    vki_uint8_t additional_length;
2867    vki_uint8_t spc3_flags;
2868    vki_uint8_t spc2_flags;
2869    vki_uint8_t flags;
2870 #define VKI_SID_VENDOR_SIZE   8
2871    char     vendor[VKI_SID_VENDOR_SIZE];
2872 #define VKI_SID_PRODUCT_SIZE  16
2873    char     product[VKI_SID_PRODUCT_SIZE];
2874 #define VKI_SID_REVISION_SIZE 4
2875    char     revision[VKI_SID_REVISION_SIZE];
2876 #define VKI_SID_VENDOR_SPECIFIC_0_SIZE      20
2877    vki_uint8_t vendor_specific0[VKI_SID_VENDOR_SPECIFIC_0_SIZE];
2878    vki_uint8_t spi3data;
2879    vki_uint8_t reserved2;
2880    /*
2881     * Version Descriptors, stored 2 byte values.
2882     */
2883    vki_uint8_t version1[2];
2884    vki_uint8_t version2[2];
2885    vki_uint8_t version3[2];
2886    vki_uint8_t version4[2];
2887    vki_uint8_t version5[2];
2888    vki_uint8_t version6[2];
2889    vki_uint8_t version7[2];
2890    vki_uint8_t version8[2];
2891
2892    vki_uint8_t reserved3[22];
2893
2894 #define VKI_SID_VENDOR_SPECIFIC_1_SIZE      160
2895    vki_uint8_t vendor_specific1[VKI_SID_VENDOR_SPECIFIC_1_SIZE];
2896 };
2897
2898 //----------------------------------------------------------------------
2899 // From sys/queue.h
2900 //----------------------------------------------------------------------
2901
2902 #define SLIST_ENTRY(type)                                               \
2903 struct {                                                                \
2904         struct type *sle_next;  /* next element */                      \
2905 }
2906
2907 #define LIST_ENTRY(type)                                                \
2908 struct {                                                                \
2909         struct type *le_next;   /* next element */                      \
2910         struct type **le_prev;  /* address of previous next element */  \
2911 }
2912
2913 #define STAILQ_ENTRY(type)                                              \
2914 struct {                                                                \
2915         struct type *stqe_next; /* next element */                      \
2916 }
2917
2918 struct qm_trace {
2919    unsigned long    lastline;
2920    unsigned long    prevline;
2921    const char      *lastfile;
2922    const char      *prevfile;
2923 };
2924
2925 #define TRACEBUF        struct qm_trace trace;
2926
2927 #define TAILQ_ENTRY(type)                                               \
2928 struct {                                                                \
2929         struct type *tqe_next;  /* next element */                      \
2930         struct type **tqe_prev; /* address of previous next element */  \
2931         TRACEBUF                                                        \
2932 }
2933
2934
2935 //----------------------------------------------------------------------
2936 // From cam/cam_ccb.h
2937 //----------------------------------------------------------------------
2938
2939 #define VKI_CAM_VERSION       0x15    /* Hex value for current version */
2940
2941 typedef union {
2942    LIST_ENTRY(vki_ccb_hdr) le;
2943    SLIST_ENTRY(vki_ccb_hdr) sle;
2944    TAILQ_ENTRY(vki_ccb_hdr) tqe;
2945    STAILQ_ENTRY(vki_ccb_hdr) stqe;
2946 } vki_camq_entry;
2947
2948 typedef enum {
2949    /* Function code flags are bits greater than 0xff */
2950    VKI_XPT_FC_QUEUED           = 0x100,
2951    /* Non-immediate function code */
2952    VKI_XPT_FC_USER_CCB         = 0x200,
2953    VKI_XPT_FC_XPT_ONLY         = 0x400,
2954    /* Only for the transport layer device */
2955    VKI_XPT_FC_DEV_QUEUED       = 0x800 | VKI_XPT_FC_QUEUED,
2956    /* Passes through the device queues */
2957    /* Common function commands: 0x00->0x0F */
2958    VKI_XPT_NOOP                = 0x00,
2959    /* Execute Nothing */
2960    VKI_XPT_SCSI_IO             = 0x01 | VKI_XPT_FC_DEV_QUEUED,
2961    /* Execute the requested I/O operation */
2962    VKI_XPT_GDEV_TYPE           = 0x02,
2963    /* Get type information for specified device */
2964    VKI_XPT_GDEVLIST            = 0x03,
2965    /* Get a list of peripheral devices */
2966    VKI_XPT_PATH_INQ            = 0x04,
2967    /* Path routing inquiry */
2968    VKI_XPT_REL_SIMQ            = 0x05,
2969    /* Release a frozen device queue */
2970    VKI_XPT_SASYNC_CB           = 0x06,
2971    /* Set Asynchronous Callback Parameters */
2972    VKI_XPT_SDEV_TYPE           = 0x07,
2973    /* Set device type information */
2974    VKI_XPT_SCAN_BUS            = 0x08 | VKI_XPT_FC_QUEUED | VKI_XPT_FC_USER_CCB
2975                                  | VKI_XPT_FC_XPT_ONLY,
2976    /* (Re)Scan the SCSI Bus */
2977    VKI_XPT_DEV_MATCH           = 0x09 | VKI_XPT_FC_XPT_ONLY,
2978    /* Get EDT entries matching the given pattern */
2979    VKI_XPT_DEBUG               = 0x0a,
2980    /* Turn on debugging for a bus, target or lun */
2981    VKI_XPT_PATH_STATS          = 0x0b,
2982    /* Path statistics (error counts, etc.) */
2983    VKI_XPT_GDEV_STATS          = 0x0c,
2984    /* Device statistics (error counts, etc.) */
2985    VKI_XPT_FREEZE_QUEUE        = 0x0d,
2986    /* Freeze device queue */
2987    /* SCSI Control Functions: 0x10->0x1F */
2988    VKI_XPT_ABORT               = 0x10,
2989    /* Abort the specified CCB */
2990    VKI_XPT_RESET_BUS           = 0x11 | VKI_XPT_FC_XPT_ONLY,
2991    /* Reset the specified SCSI bus */
2992    VKI_XPT_RESET_DEV           = 0x12 | VKI_XPT_FC_DEV_QUEUED,
2993    /* Bus Device Reset the specified SCSI device */
2994    VKI_XPT_TERM_IO             = 0x13,
2995    /* Terminate the I/O process */
2996    VKI_XPT_SCAN_LUN            = 0x14 | VKI_XPT_FC_QUEUED | VKI_XPT_FC_USER_CCB
2997                                  | VKI_XPT_FC_XPT_ONLY,
2998    /* Scan Logical Unit */
2999    VKI_XPT_GET_TRAN_SETTINGS   = 0x15,
3000    /*
3001     * Get default/user transfer settings
3002     * for the target
3003     */
3004    VKI_XPT_SET_TRAN_SETTINGS   = 0x16,
3005    /*
3006     * Set transfer rate/width
3007     * negotiation settings
3008     */
3009    VKI_XPT_CALC_GEOMETRY       = 0x17,
3010    /*
3011     * Calculate the geometry parameters for
3012     * a device give the sector size and
3013     * volume size.
3014     */
3015    VKI_XPT_ATA_IO              = 0x18 | VKI_XPT_FC_DEV_QUEUED,
3016    /* Execute the requested ATA I/O operation */
3017    VKI_XPT_GET_SIM_KNOB        = 0x18,
3018    /*
3019     * Get SIM specific knob values.
3020     */
3021
3022    VKI_XPT_SET_SIM_KNOB        = 0x19,
3023    /*
3024     * Set SIM specific knob values.
3025     */
3026    /* HBA engine commands 0x20->0x2F */
3027    VKI_XPT_ENG_INQ             = 0x20 | VKI_XPT_FC_XPT_ONLY,
3028    /* HBA engine feature inquiry */
3029    VKI_XPT_ENG_EXEC            = 0x21 | VKI_XPT_FC_DEV_QUEUED,
3030    /* HBA execute engine request */
3031
3032    /* Target mode commands: 0x30->0x3F */
3033    VKI_XPT_EN_LUN              = 0x30,
3034    /* Enable LUN as a target */
3035    VKI_XPT_TARGET_IO           = 0x31 | VKI_XPT_FC_DEV_QUEUED,
3036    /* Execute target I/O request */
3037    VKI_XPT_ACCEPT_TARGET_IO    = 0x32 | VKI_XPT_FC_QUEUED | VKI_XPT_FC_USER_CCB,
3038    /* Accept Host Target Mode CDB */
3039    VKI_XPT_CONT_TARGET_IO      = 0x33 | VKI_XPT_FC_DEV_QUEUED,
3040    /* Continue Host Target I/O Connection */
3041    VKI_XPT_IMMED_NOTIFY        = 0x34 | VKI_XPT_FC_QUEUED | VKI_XPT_FC_USER_CCB,
3042    /* Notify Host Target driver of event (obsolete) */
3043    VKI_XPT_NOTIFY_ACK          = 0x35,
3044    /* Acknowledgement of event (obsolete) */
3045    VKI_XPT_IMMEDIATE_NOTIFY    = 0x36 | VKI_XPT_FC_QUEUED | VKI_XPT_FC_USER_CCB,
3046    /* Notify Host Target driver of event */
3047    VKI_XPT_NOTIFY_ACKNOWLEDGE  = 0x37 | VKI_XPT_FC_QUEUED | VKI_XPT_FC_USER_CCB,
3048    /* Acknowledgement of event */
3049
3050    /* Vendor Unique codes: 0x80->0x8F */
3051    VKI_XPT_VUNIQUE             = 0x80
3052 } vki_xpt_opcode;
3053
3054
3055 /* CAM CCB flags */
3056 typedef enum {
3057    VKI_CAM_CDB_POINTER         = 0x00000001,/* The CDB field is a pointer    */
3058    VKI_CAM_QUEUE_ENABLE        = 0x00000002,/* SIM queue actions are enabled */
3059    VKI_CAM_CDB_LINKED          = 0x00000004,/* CCB contains a linked CDB     */
3060    VKI_CAM_NEGOTIATE           = 0x00000008,/*
3061                                               * Perform transport negotiation
3062                                               * with this command.
3063                                               */
3064    VKI_CAM_SCATTER_VALID       = 0x00000010,/* Scatter/gather list is valid  */
3065    VKI_CAM_DIS_AUTOSENSE       = 0x00000020,/* Disable autosense feature     */
3066    VKI_CAM_DIR_RESV            = 0x00000000,/* Data direction (00:reserved)  */
3067    VKI_CAM_DIR_IN              = 0x00000040,/* Data direction (01:DATA IN)   */
3068    VKI_CAM_DIR_OUT             = 0x00000080,/* Data direction (10:DATA OUT)  */
3069    VKI_CAM_DIR_NONE            = 0x000000C0,/* Data direction (11:no data)   */
3070    VKI_CAM_DIR_MASK            = 0x000000C0,/* Data direction Mask           */
3071    VKI_CAM_SOFT_RST_OP         = 0x00000100,/* Use Soft reset alternative    */
3072    VKI_CAM_ENG_SYNC            = 0x00000200,/* Flush resid bytes on complete */
3073    VKI_CAM_DEV_QFRZDIS         = 0x00000400,/* Disable DEV Q freezing        */
3074    VKI_CAM_DEV_QFREEZE         = 0x00000800,/* Freeze DEV Q on execution     */
3075    VKI_CAM_HIGH_POWER          = 0x00001000,/* Command takes a lot of power  */
3076    VKI_CAM_SENSE_PTR           = 0x00002000,/* Sense data is a pointer       */
3077    VKI_CAM_SENSE_PHYS          = 0x00004000,/* Sense pointer is physical addr*/
3078    VKI_CAM_TAG_ACTION_VALID    = 0x00008000,/* Use the tag action in this ccb*/
3079    VKI_CAM_PASS_ERR_RECOVER    = 0x00010000,/* Pass driver does err. recovery*/
3080    VKI_CAM_DIS_DISCONNECT      = 0x00020000,/* Disable disconnect            */
3081    VKI_CAM_SG_LIST_PHYS        = 0x00040000,/* SG list has physical addrs.   */
3082    VKI_CAM_MSG_BUF_PHYS        = 0x00080000,/* Message buffer ptr is physical*/
3083    VKI_CAM_SNS_BUF_PHYS        = 0x00100000,/* Autosense data ptr is physical*/
3084    VKI_CAM_DATA_PHYS           = 0x00200000,/* SG/Buffer data ptrs are phys. */
3085    VKI_CAM_CDB_PHYS            = 0x00400000,/* CDB poiner is physical        */
3086    VKI_CAM_ENG_SGLIST          = 0x00800000,/* SG list is for the HBA engine */
3087
3088    /* Phase cognizant mode flags */
3089    VKI_CAM_DIS_AUTOSRP         = 0x01000000,/* Disable autosave/restore ptrs */
3090    VKI_CAM_DIS_AUTODISC        = 0x02000000,/* Disable auto disconnect       */
3091    VKI_CAM_TGT_CCB_AVAIL       = 0x04000000,/* Target CCB available          */
3092    VKI_CAM_TGT_PHASE_MODE      = 0x08000000,/* The SIM runs in phase mode    */
3093    VKI_CAM_MSGB_VALID          = 0x10000000,/* Message buffer valid          */
3094    VKI_CAM_STATUS_VALID        = 0x20000000,/* Status buffer valid           */
3095    VKI_CAM_DATAB_VALID         = 0x40000000,/* Data buffer valid             */
3096
3097    /* Host target Mode flags */
3098    VKI_CAM_SEND_SENSE          = 0x08000000,/* Send sense data with status   */
3099    VKI_CAM_TERM_IO             = 0x10000000,/* Terminate I/O Message sup.    */
3100    VKI_CAM_DISCONNECT          = 0x20000000,/* Disconnects are mandatory     */
3101    VKI_CAM_SEND_STATUS         = 0x40000000 /* Send status after data phase  */
3102 } vki_ccb_flags;
3103
3104 typedef union {
3105    void            *ptr;
3106    vki_u_long      field;
3107    vki_uint8_t     bytes[sizeof(vki_uintptr_t)];
3108 } vki_ccb_priv_entry;
3109
3110 #define VKI_IOCDBLEN  VKI_CAM_MAX_CDBLEN  /* Space for CDB bytes/pointer */
3111 #define VKI_CCB_PERIPH_PRIV_SIZE    2   /* size of peripheral private area */
3112 #define VKI_CCB_SIM_PRIV_SIZE       2   /* size of sim private area */
3113
3114 typedef union {
3115    vki_ccb_priv_entry entries[VKI_CCB_PERIPH_PRIV_SIZE];
3116    vki_uint8_t        bytes[VKI_CCB_PERIPH_PRIV_SIZE * sizeof(vki_ccb_priv_entry)];
3117 } vki_ccb_ppriv_area;
3118
3119 typedef union {
3120    vki_ccb_priv_entry entries[VKI_CCB_SIM_PRIV_SIZE];
3121    vki_uint8_t        bytes[VKI_CCB_SIM_PRIV_SIZE * sizeof(vki_ccb_priv_entry)];
3122 } vki_ccb_spriv_area;
3123
3124 union vki_ccb;
3125 struct vki_cam_periph;
3126
3127 struct vki_ccb_hdr {
3128    vki_cam_pinfo   pinfo;          /* Info for priority scheduling */
3129    vki_camq_entry  xpt_links;      /* For chaining in the XPT layer */
3130    vki_camq_entry  sim_links;      /* For chaining in the SIM layer */
3131    vki_camq_entry  periph_links;   /* For chaining in the type driver */
3132    vki_uint32_t    retry_count;
3133    void         (*cbfcnp)(struct vki_cam_periph *, union vki_ccb *);
3134    /* Callback on completion function */
3135    vki_xpt_opcode  func_code;      /* XPT function code */
3136    vki_uint32_t    status;         /* Status returned by CAM subsystem */
3137    struct      vki_cam_path *path; /* Compiled path for this ccb */
3138    vki_path_id_t   path_id;        /* Path ID for the request */
3139    vki_target_id_t target_id;      /* Target device ID */
3140    vki_lun_id_t    target_lun;     /* Target LUN number */
3141    vki_uint32_t    flags;          /* ccb_flags */
3142    vki_ccb_ppriv_area  periph_priv;
3143    vki_ccb_spriv_area  sim_priv;
3144    vki_uint32_t    timeout;        /* Timeout value */
3145
3146    /*
3147     * Deprecated, only for use by non-MPSAFE SIMs.  All others must
3148     * allocate and initialize their own callout storage.
3149     */
3150    struct      vki_callout_handle timeout_ch;
3151 };
3152
3153 typedef union {
3154    vki_u_int8_t  *cdb_ptr;             /* Pointer to the CDB bytes to send */
3155    /* Area for the CDB send */
3156    vki_u_int8_t  cdb_bytes[VKI_IOCDBLEN];
3157 } vki_cdb_t;
3158
3159
3160 /*
3161  * SCSI I/O Request CCB used for the XPT_SCSI_IO and XPT_CONT_TARGET_IO
3162  * function codes.
3163  */
3164 struct vki_ccb_scsiio {
3165    struct     vki_ccb_hdr ccb_h;
3166    union      vki_ccb *next_ccb;   /* Ptr for next CCB for action */
3167    vki_u_int8_t   *req_map;        /* Ptr to mapping info */
3168    vki_u_int8_t   *data_ptr;       /* Ptr to the data buf/SG list */
3169    vki_u_int32_t  dxfer_len;       /* Data transfer length */
3170    /* Autosense storage */
3171    struct     vki_scsi_sense_data sense_data;
3172    vki_u_int8_t   sense_len;       /* Number of bytes to autosense */
3173    vki_u_int8_t   cdb_len;         /* Number of bytes for the CDB */
3174    vki_u_int16_t  sglist_cnt;      /* Number of SG list entries */
3175    vki_u_int8_t   scsi_status;     /* Returned SCSI status */
3176    vki_u_int8_t   sense_resid;     /* Autosense resid length: 2's comp */
3177    vki_u_int32_t  resid;           /* Transfer residual length: 2's comp */
3178    vki_cdb_t      cdb_io;          /* Union for CDB bytes/pointer */
3179    vki_u_int8_t   *msg_ptr;        /* Pointer to the message buffer */
3180    vki_u_int16_t  msg_len;         /* Number of bytes for the Message */
3181    vki_u_int8_t   tag_action;      /* What to do for tag queueing */
3182    /*
3183     * The tag action should be either the define below (to send a
3184     * non-tagged transaction) or one of the defined scsi tag messages
3185     * from scsi_message.h.
3186     */
3187    vki_u_int      tag_id;          /* tag id from initator (target mode) */
3188    vki_u_int      init_id;         /* initiator id of who selected */
3189 };
3190
3191 typedef enum {
3192    VKI_CAM_DEV_MATCH_LAST,
3193    VKI_CAM_DEV_MATCH_MORE,
3194    VKI_CAM_DEV_MATCH_LIST_CHANGED,
3195    VKI_CAM_DEV_MATCH_SIZE_ERROR,
3196    VKI_CAM_DEV_MATCH_ERROR
3197 } vki_ccb_dev_match_status;
3198
3199
3200 struct vki_dev_match_pattern;
3201
3202 typedef enum {
3203    VKI_DEV_MATCH_PERIPH,
3204    VKI_DEV_MATCH_DEVICE,
3205    VKI_DEV_MATCH_BUS
3206 } vki_dev_match_type;
3207
3208 #define VKI_DEV_IDLEN       16          /* ASCII string len for device names */
3209
3210 struct vki_periph_match_result {
3211    char                    periph_name[VKI_DEV_IDLEN];
3212    vki_uint32_t            unit_number;
3213    vki_path_id_t           path_id;
3214    vki_target_id_t         target_id;
3215    vki_lun_id_t            target_lun;
3216 };
3217
3218 typedef enum {
3219    VKI_PROTO_UNKNOWN,
3220    VKI_PROTO_UNSPECIFIED,
3221    VKI_PROTO_SCSI,     /* Small Computer System Interface */
3222    VKI_PROTO_ATA,      /* AT Attachment */
3223    VKI_PROTO_ATAPI,    /* AT Attachment Packetized Interface */
3224    VKI_PROTO_SATAPM,   /* SATA Port Multiplier */
3225 } vki_cam_proto;
3226
3227 typedef enum {
3228    VKI_DEV_RESULT_NOFLAG               = 0x00,
3229    VKI_DEV_RESULT_UNCONFIGURED         = 0x01
3230 } vki_dev_result_flags;
3231
3232
3233 struct vki_device_match_result {
3234    vki_path_id_t                   path_id;
3235    vki_target_id_t                 target_id;
3236    vki_lun_id_t                    target_lun;
3237    vki_cam_proto                   protocol;
3238    struct vki_scsi_inquiry_data    inq_data;
3239    struct vki_ata_params           ident_data;
3240    vki_dev_result_flags            flags;
3241 };
3242
3243 struct vki_bus_match_result {
3244    vki_path_id_t   path_id;
3245    char            dev_name[VKI_DEV_IDLEN];
3246    vki_uint32_t    unit_number;
3247    vki_uint32_t    bus_id;
3248 };
3249
3250 union vki_match_result {
3251    struct vki_periph_match_result      periph_result;
3252    struct vki_device_match_result      device_result;
3253    struct vki_bus_match_result         bus_result;
3254 };
3255
3256 struct vki_dev_match_result {
3257    vki_dev_match_type          type;
3258    union vki_match_result      result;
3259 };
3260
3261 typedef enum {
3262    VKI_CAM_DEV_POS_NONE        = 0x000,
3263    VKI_CAM_DEV_POS_BUS         = 0x001,
3264    VKI_CAM_DEV_POS_TARGET      = 0x002,
3265    VKI_CAM_DEV_POS_DEVICE      = 0x004,
3266    VKI_CAM_DEV_POS_PERIPH      = 0x008,
3267    VKI_CAM_DEV_POS_PDPTR       = 0x010,
3268    VKI_CAM_DEV_POS_TYPEMASK    = 0xf00,
3269    VKI_CAM_DEV_POS_EDT         = 0x100,
3270    VKI_CAM_DEV_POS_PDRV        = 0x200
3271 } vki_dev_pos_type;
3272
3273 struct vki_ccb_dm_cookie {
3274    void    *bus;
3275    void    *target;
3276    void    *device;
3277    void    *periph;
3278    void    *pdrv;
3279 };
3280
3281 struct vki_ccb_dev_position {
3282    vki_u_int                generations[4];
3283 #define VKI_CAM_BUS_GENERATION      0x00
3284 #define VKI_CAM_TARGET_GENERATION   0x01
3285 #define VKI_CAM_DEV_GENERATION      0x02
3286 #define VKI_CAM_PERIPH_GENERATION   0x03
3287    vki_dev_pos_type        position_type;
3288    struct vki_ccb_dm_cookie cookie;
3289 };
3290
3291 struct vki_ccb_dev_match {
3292    struct vki_ccb_hdr              ccb_h;
3293    vki_ccb_dev_match_status        status;
3294    vki_uint32_t                    num_patterns;
3295    vki_uint32_t                    pattern_buf_len;
3296    struct vki_dev_match_pattern    *patterns;
3297    vki_uint32_t                    num_matches;
3298    vki_uint32_t                    match_buf_len;
3299    struct vki_dev_match_result     *matches;
3300    struct vki_ccb_dev_position     pos;
3301 };
3302
3303 /*
3304  * Union of all CCB types for kernel space allocation.  This union should
3305  * never be used for manipulating CCBs - its only use is for the allocation
3306  * and deallocation of raw CCB space and is the return type of xpt_ccb_alloc
3307  * and the argument to xpt_ccb_free.
3308  */
3309 union vki_ccb {
3310    /* Only letting out ones currently handled */
3311    struct  vki_ccb_hdr             ccb_h;  /* For convenience */
3312    struct  vki_ccb_scsiio          csio;
3313 #if 0
3314    struct  ccb_getdev              cgd;
3315    struct  ccb_getdevlist          cgdl;
3316    struct  ccb_pathinq             cpi;
3317    struct  ccb_relsim              crs;
3318    struct  ccb_setasync            csa;
3319    struct  ccb_setdev              csd;
3320    struct  ccb_pathstats           cpis;
3321    struct  ccb_getdevstats         cgds;
3322 #endif
3323    struct  vki_ccb_dev_match       cdm;
3324 #if 0
3325    struct  ccb_trans_settings      cts;
3326    struct  ccb_calc_geometry       ccg;
3327    struct  ccb_sim_knob            knob;
3328    struct  ccb_abort               cab;
3329    struct  ccb_resetbus            crb;
3330    struct  ccb_resetdev            crd;
3331    struct  ccb_termio              tio;
3332    struct  ccb_accept_tio          atio;
3333    struct  ccb_scsiio              ctio;
3334    struct  ccb_en_lun              cel;
3335    struct  ccb_immed_notify        cin;
3336    struct  ccb_notify_ack          cna;
3337    struct  ccb_immediate_notify    cin1;
3338    struct  ccb_notify_acknowledge  cna2;
3339    struct  ccb_eng_inq             cei;
3340    struct  ccb_eng_exec            cee;
3341    struct  ccb_rescan              crcn;
3342    struct  ccb_debug               cdbg;
3343    struct  ccb_ataio               ataio;
3344 #endif
3345    char make_union_right_size[0x4A8];
3346 };
3347
3348 #define VKI_CAMIOCOMMAND    _VKI_IOWR(VKI_CAM_VERSION, 2, union vki_ccb)
3349
3350 #endif
3351 /*--------------------------------------------------------------------*/
3352 /*--- end                                                          ---*/
3353 /*--------------------------------------------------------------------*/