l4/pkg/valgrind/src/valgrind-3.6.0-svn/include/vki/vki-linux.h

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Linux-specific kernel interface.                 vki-linux.h ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2000-2010 Julian Seward
  11       jseward@acm.org
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of the
  16    License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful, but
  19    WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public License
  24    along with this program; if not, write to the Free Software
  25    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  26    02111-1307, USA.
  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    Note especially that the types are not the glibc versions, many of which
  45    are different to those in here.
  46
  47    Also note that this file contains all the generic header info, ie. that
  48    from linux/include/linux/ *.h.  The arch-specific header info, eg. that
  49    from linux/include/asm-i386/ *.h, is in vki-$PLATFORM.h and
  50    vki_posixtypes-$PLATFORM.h.  (Two files are required to avoid
  51    circular dependencies between the generic VKI header and the
  52    arch-specific VKI header.  It's possible in the future, as more stuff
  53    gets pulled in, that we might have to split files up some more to avoid
  54    further circular dependencies.)
  55
  56    Finally, note that it is assumed that __KERNEL__ is set for all these
  57    definitions, which affects some of them.
  58 */
  59
  60 /* The structure is (aiui, jrs 20060504):
  61
  62      #include plat-specific posix types (vki-posixtypes-ARCH-linux.h)
  63
  64      Lots more types, structs, consts, in this file
  65
  66      #include other plat-specific stuff (vki-ARCH-linux.h)
  67
  68      Even more types, structs, consts, in this file
  69
  70    The system call numbers are dealt with by
  71    pub_{core,tool}_vkiscnums.h, not via pub_{core,tool}_vki.h, which
  72    is what this file is part of.
  73 */
  74
  75 #ifndef __VKI_LINUX_H
  76 #define __VKI_LINUX_H
  77
  78 //----------------------------------------------------------------------
  79 // Arch-specific POSIX types
  80 //----------------------------------------------------------------------
  81
  82 #if defined(VGA_x86)
  83 #  include "vki-posixtypes-x86-linux.h"
  84 #elif defined(VGA_amd64)
  85 #  include "vki-posixtypes-amd64-linux.h"
  86 #elif defined(VGA_ppc32)
  87 #  include "vki-posixtypes-ppc32-linux.h"
  88 #elif defined(VGA_ppc64)
  89 #  include "vki-posixtypes-ppc64-linux.h"
  90 #elif defined(VGA_arm)
  91 #  include "vki-posixtypes-arm-linux.h"
  92 #else
  93 #  error Unknown platform
  94 #endif
  95
  96 //----------------------------------------------------------------------
  97 // VKI_STATIC_ASSERT(). Inspired by BUILD_BUG_ON() from
  98 // linux-2.6.34/include/linux/kernel.h
  99 //----------------------------------------------------------------------
 100
 101 /*
 102  * Evaluates to zero if 'expr' is true and forces a compilation error if
 103  * 'expr' is false. Can be used in a context where no comma expressions
 104  * are allowed.
 105  */
 106 #ifdef __cplusplus
 107 template <bool b> struct vki_static_assert { int m_bitfield:(2*b-1); };
 108 #define VKI_STATIC_ASSERT(expr)                         \
 109     (sizeof(vki_static_assert<(expr)>) - sizeof(int))
 110 #else
 111 #define VKI_STATIC_ASSERT(expr) (sizeof(struct { int:-!(expr); }))
 112 #endif
 113
 114 //----------------------------------------------------------------------
 115 // Based on _IOC_TYPECHECK() from linux-2.6.34/asm-generic/ioctl.h
 116 //----------------------------------------------------------------------
 117
 118 /* provoke compile error for invalid uses of size argument */
 119 #define _VKI_IOC_TYPECHECK(t)                                           \
 120     (VKI_STATIC_ASSERT((sizeof(t) == sizeof(t[1])                       \
 121                         && sizeof(t) < (1 << _VKI_IOC_SIZEBITS)))       \
 122      + sizeof(t))
 123
 124 //----------------------------------------------------------------------
 125 // From linux-2.6.8.1/include/linux/compiler.h
 126 //----------------------------------------------------------------------
 127
 128 # define __user
 129
 130 # define __attribute_const__    /* unimplemented */
 131
 132 //----------------------------------------------------------------------
 133 // From linux-2.6.8.1/include/linux/posix_types.h
 134 //----------------------------------------------------------------------
 135
 136 #undef __VKI_NFDBITS
 137 #define __VKI_NFDBITS   (8 * sizeof(unsigned long))
 138
 139 #undef __VKI_FD_SETSIZE
 140 #define __VKI_FD_SETSIZE        1024
 141
 142 #undef __VKI_FDSET_LONGS
 143 #define __VKI_FDSET_LONGS       (__VKI_FD_SETSIZE/__VKI_NFDBITS)
 144
 145 #undef __VKI_FDELT
 146 #define __VKI_FDELT(d)  ((d) / __VKI_NFDBITS)
 147
 148 #undef __VKI_FDMASK
 149 #define __VKI_FDMASK(d) (1UL << ((d) % __VKI_NFDBITS))
 150
 151 typedef struct {
 152         unsigned long fds_bits [__VKI_FDSET_LONGS];
 153 } __vki_kernel_fd_set;
 154
 155 typedef int __vki_kernel_key_t;
 156 typedef int __vki_kernel_mqd_t;
 157
 158 //----------------------------------------------------------------------
 159 // From linux-2.6.8.1/include/linux/types.h
 160 //----------------------------------------------------------------------
 161
 162 typedef __vki_kernel_fd_set     vki_fd_set;
 163 typedef __vki_kernel_mode_t     vki_mode_t;
 164 typedef __vki_kernel_off_t      vki_off_t;
 165 typedef __vki_kernel_pid_t      vki_pid_t;
 166 typedef __vki_kernel_key_t      vki_key_t;
 167 typedef __vki_kernel_suseconds_t        vki_suseconds_t;
 168 typedef __vki_kernel_timer_t    vki_timer_t;
 169 typedef __vki_kernel_clockid_t  vki_clockid_t;
 170 typedef __vki_kernel_mqd_t      vki_mqd_t;
 171
 172 // [[Nb: it's a bit unclear due to a #ifdef, but I think this is right. --njn]]
 173 typedef __vki_kernel_uid32_t    vki_uid_t;
 174 typedef __vki_kernel_gid32_t    vki_gid_t;
 175
 176 typedef __vki_kernel_old_uid_t  vki_old_uid_t;
 177 typedef __vki_kernel_old_gid_t  vki_old_gid_t;
 178
 179 typedef __vki_kernel_loff_t     vki_loff_t;
 180
 181 typedef __vki_kernel_size_t     vki_size_t;
 182 typedef __vki_kernel_time_t     vki_time_t;
 183 typedef __vki_kernel_clock_t    vki_clock_t;
 184 typedef __vki_kernel_caddr_t    vki_caddr_t;
 185
 186 typedef unsigned long           vki_u_long;
 187
 188 typedef unsigned int            vki_uint;
 189
 190 //----------------------------------------------------------------------
 191 // Now the rest of the arch-specific stuff
 192 //----------------------------------------------------------------------
 193
 194 #if defined(VGA_x86)
 195 #  include "vki-x86-linux.h"
 196 #elif defined(VGA_amd64)
 197 #  include "vki-amd64-linux.h"
 198 #elif defined(VGA_ppc32)
 199 #  include "vki-ppc32-linux.h"
 200 #elif defined(VGA_ppc64)
 201 #  include "vki-ppc64-linux.h"
 202 #elif defined(VGA_arm)
 203 #  include "vki-arm-linux.h"
 204 #else
 205 #  error Unknown platform
 206 #endif
 207
 208 //----------------------------------------------------------------------
 209 // From linux-2.6.20.1/include/linux/types.h
 210 //----------------------------------------------------------------------
 211
 212 typedef         __vki_s32       vki_int32_t;
 213
 214 typedef         __vki_u8        vki_uint8_t;
 215 typedef         __vki_u16       vki_uint16_t;
 216 typedef         __vki_u32       vki_uint32_t;
 217
 218 //----------------------------------------------------------------------
 219 // From linux-2.6.8.1/include/linux/limits.h
 220 //----------------------------------------------------------------------
 221
 222 #define VKI_PATH_MAX       4096 /* # chars in a path name including nul */
 223
 224 //----------------------------------------------------------------------
 225 // From linux-2.6.8.1/include/linux/kernel.h
 226 //----------------------------------------------------------------------
 227
 228 struct vki_sysinfo {
 229         long uptime;                    /* Seconds since boot */
 230         unsigned long loads[3];         /* 1, 5, and 15 minute load averages */
 231         unsigned long totalram;         /* Total usable main memory size */
 232         unsigned long freeram;          /* Available memory size */
 233         unsigned long sharedram;        /* Amount of shared memory */
 234         unsigned long bufferram;        /* Memory used by buffers */
 235         unsigned long totalswap;        /* Total swap space size */
 236         unsigned long freeswap;         /* swap space still available */
 237         unsigned short procs;           /* Number of current processes */
 238         unsigned short pad;             /* explicit padding for m68k */
 239         unsigned long totalhigh;        /* Total high memory size */
 240         unsigned long freehigh;         /* Available high memory size */
 241         unsigned int mem_unit;          /* Memory unit size in bytes */
 242         char _f[20-2*sizeof(long)-sizeof(int)]; /* Padding: libc5 uses this.. */
 243 };
 244
 245 //----------------------------------------------------------------------
 246 // From linux-2.6.8.1/include/linux/time.h
 247 //----------------------------------------------------------------------
 248
 249 #define VKI_CLOCK_REALTIME            0
 250 #define VKI_CLOCK_MONOTONIC           1
 251 #define VKI_CLOCK_PROCESS_CPUTIME_ID  2
 252 #define VKI_CLOCK_THREAD_CPUTIME_ID   3
 253
 254 struct vki_timespec {
 255         vki_time_t      tv_sec;         /* seconds */
 256         long            tv_nsec;        /* nanoseconds */
 257 };
 258
 259 struct vki_timeval {
 260         vki_time_t      tv_sec;         /* seconds */
 261         vki_suseconds_t tv_usec;        /* microseconds */
 262 };
 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_itimerspec {
 270         struct  vki_timespec it_interval;    /* timer period */
 271         struct  vki_timespec it_value;       /* timer expiration */
 272 };
 273
 274 struct  vki_itimerval {
 275         struct  vki_timeval it_interval;        /* timer interval */
 276         struct  vki_timeval it_value;   /* current value */
 277 };
 278
 279 //----------------------------------------------------------------------
 280 // From linux-2.6.8.1/include/linux/timex.h
 281 //----------------------------------------------------------------------
 282
 283 struct vki_timex {
 284         unsigned int modes;     /* mode selector */
 285         long offset;            /* time offset (usec) */
 286         long freq;              /* frequency offset (scaled ppm) */
 287         long maxerror;          /* maximum error (usec) */
 288         long esterror;          /* estimated error (usec) */
 289         int status;             /* clock command/status */
 290         long constant;          /* pll time constant */
 291         long precision;         /* clock precision (usec) (read only) */
 292         long tolerance;         /* clock frequency tolerance (ppm)
 293                                  * (read only)
 294                                  */
 295         struct vki_timeval time;        /* (read only) */
 296         long tick;              /* (modified) usecs between clock ticks */
 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         int  :32; int  :32; int  :32; int  :32;
 308         int  :32; int  :32; int  :32; int  :32;
 309         int  :32; int  :32; int  :32; int  :32;
 310 };
 311
 312 #define VKI_ADJ_OFFSET                  0x0001  /* time offset */
 313 #define VKI_ADJ_FREQUENCY               0x0002  /* frequency offset */
 314 #define VKI_ADJ_MAXERROR                0x0004  /* maximum time error */
 315 #define VKI_ADJ_ESTERROR                0x0008  /* estimated time error */
 316 #define VKI_ADJ_STATUS                  0x0010  /* clock status */
 317 #define VKI_ADJ_TIMECONST               0x0020  /* pll time constant */
 318 #define VKI_ADJ_TAI                     0x0080  /* set TAI offset */
 319 #define VKI_ADJ_TICK                    0x4000  /* tick value */
 320 #define VKI_ADJ_ADJTIME                 0x8000  /* switch between adjtime/adjtimex modes */
 321 //#define VKI_ADJ_OFFSET_SINGLESHOT     0x8001  /* old-fashioned adjtime */
 322 #define VKI_ADJ_OFFSET_READONLY         0x2000  /* read-only adjtime */
 323
 324 //----------------------------------------------------------------------
 325 // From linux-2.6.8.1/include/linux/times.h
 326 //----------------------------------------------------------------------
 327
 328 struct vki_tms {
 329         vki_clock_t tms_utime;
 330         vki_clock_t tms_stime;
 331         vki_clock_t tms_cutime;
 332         vki_clock_t tms_cstime;
 333 };
 334
 335 //----------------------------------------------------------------------
 336 // From linux-2.6.8.1/include/linux/utime.h
 337 //----------------------------------------------------------------------
 338
 339 struct vki_utimbuf {
 340         vki_time_t actime;
 341         vki_time_t modtime;
 342 };
 343
 344 //----------------------------------------------------------------------
 345 // From linux-2.6.8.1/include/linux/sched.h
 346 //----------------------------------------------------------------------
 347
 348 #define VKI_CSIGNAL             0x000000ff      /* signal mask to be sent at exit */
 349 #define VKI_CLONE_VM            0x00000100      /* set if VM shared between processes */
 350 #define VKI_CLONE_FS            0x00000200      /* set if fs info shared between processes */
 351 #define VKI_CLONE_FILES         0x00000400      /* set if open files shared between processes */
 352 #define VKI_CLONE_SIGHAND       0x00000800      /* set if signal handlers and blocked signals shared */
 353 #define VKI_CLONE_VFORK         0x00004000      /* set if the parent wants the child to wake it up on mm_release */
 354 #define VKI_CLONE_PARENT        0x00008000      /* set if we want to have the same parent as the cloner */
 355 #define VKI_CLONE_THREAD        0x00010000      /* Same thread group? */
 356 #define VKI_CLONE_SYSVSEM       0x00040000      /* share system V SEM_UNDO semantics */
 357 #define VKI_CLONE_SETTLS        0x00080000      /* create a new TLS for the child */
 358 #define VKI_CLONE_PARENT_SETTID 0x00100000      /* set the TID in the parent */
 359 #define VKI_CLONE_CHILD_CLEARTID        0x00200000      /* clear the TID in the child */
 360 #define VKI_CLONE_DETACHED      0x00400000      /* Unused, ignored */
 361 #define VKI_CLONE_CHILD_SETTID  0x01000000      /* set the TID in the child */
 362
 363 struct vki_sched_param {
 364         int sched_priority;
 365 };
 366
 367 #define VKI_TASK_COMM_LEN 16
 368
 369 //----------------------------------------------------------------------
 370 // From linux-2.6.8.1/include/asm-generic/siginfo.h
 371 //----------------------------------------------------------------------
 372
 373 typedef union vki_sigval {
 374         int sival_int;
 375         void __user *sival_ptr;
 376 } vki_sigval_t;
 377
 378 #ifndef __VKI_ARCH_SI_PREAMBLE_SIZE
 379 #define __VKI_ARCH_SI_PREAMBLE_SIZE     (3 * sizeof(int))
 380 #endif
 381
 382 #define VKI_SI_MAX_SIZE 128
 383
 384 #ifndef VKI_SI_PAD_SIZE
 385 #define VKI_SI_PAD_SIZE ((VKI_SI_MAX_SIZE - __VKI_ARCH_SI_PREAMBLE_SIZE) / sizeof(int))
 386 #endif
 387
 388 #ifndef __VKI_ARCH_SI_UID_T
 389 #define __VKI_ARCH_SI_UID_T     vki_uid_t
 390 #endif
 391
 392 #ifndef __VKI_ARCH_SI_BAND_T
 393 #define __VKI_ARCH_SI_BAND_T long
 394 #endif
 395
 396 // [[Nb: this type changed between 2.4 and 2.6, but not in a way that
 397 // affects Valgrind.]]
 398 typedef struct vki_siginfo {
 399         int si_signo;
 400         int si_errno;
 401         int si_code;
 402
 403         union {
 404                 int _pad[VKI_SI_PAD_SIZE];
 405
 406                 /* kill() */
 407                 struct {
 408                         vki_pid_t _pid;         /* sender's pid */
 409                         __VKI_ARCH_SI_UID_T _uid;       /* sender's uid */
 410                 } _kill;
 411
 412                 /* POSIX.1b timers */
 413                 struct {
 414                         vki_timer_t _tid;               /* timer id */
 415                         int _overrun;           /* overrun count */
 416                         char _pad[sizeof( __VKI_ARCH_SI_UID_T) - sizeof(int)];
 417                         vki_sigval_t _sigval;   /* same as below */
 418                         int _sys_private;       /* not to be passed to user */
 419                 } _timer;
 420
 421                 /* POSIX.1b signals */
 422                 struct {
 423                         vki_pid_t _pid;         /* sender's pid */
 424                         __VKI_ARCH_SI_UID_T _uid;       /* sender's uid */
 425                         vki_sigval_t _sigval;
 426                 } _rt;
 427
 428                 /* SIGCHLD */
 429                 struct {
 430                         vki_pid_t _pid;         /* which child */
 431                         __VKI_ARCH_SI_UID_T _uid;       /* sender's uid */
 432                         int _status;            /* exit code */
 433                         vki_clock_t _utime;
 434                         vki_clock_t _stime;
 435                 } _sigchld;
 436
 437                 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
 438                 struct {
 439                         void __user *_addr; /* faulting insn/memory ref. */
 440 #ifdef __ARCH_SI_TRAPNO
 441                         int _trapno;    /* TRAP # which caused the signal */
 442 #endif
 443                 } _sigfault;
 444
 445                 /* SIGPOLL */
 446                 struct {
 447                         __VKI_ARCH_SI_BAND_T _band;     /* POLL_IN, POLL_OUT, POLL_MSG */
 448                         int _fd;
 449                 } _sigpoll;
 450         } _sifields;
 451 } vki_siginfo_t;
 452
 453 #define __VKI_SI_FAULT  0
 454
 455 /*
 456  * si_code values
 457  * Digital reserves positive values for kernel-generated signals.
 458  */
 459 #define VKI_SI_USER     0               /* sent by kill, sigsend, raise */
 460 #define VKI_SI_TKILL    -6              /* sent by tkill system call */
 461
 462 /*
 463  * SIGILL si_codes
 464  */
 465 #define VKI_ILL_ILLOPC  (__VKI_SI_FAULT|1)      /* illegal opcode */
 466 #define VKI_ILL_ILLOPN  (__VKI_SI_FAULT|2)      /* illegal operand */
 467 #define VKI_ILL_ILLADR  (__VKI_SI_FAULT|3)      /* illegal addressing mode */
 468 #define VKI_ILL_ILLTRP  (__VKI_SI_FAULT|4)      /* illegal trap */
 469 #define VKI_ILL_PRVOPC  (__VKI_SI_FAULT|5)      /* privileged opcode */
 470 #define VKI_ILL_PRVREG  (__VKI_SI_FAULT|6)      /* privileged register */
 471 #define VKI_ILL_COPROC  (__VKI_SI_FAULT|7)      /* coprocessor error */
 472 #define VKI_ILL_BADSTK  (__VKI_SI_FAULT|8)      /* internal stack error */
 473
 474 /*
 475  * SIGFPE si_codes
 476  */
 477 #define VKI_FPE_INTDIV  (__VKI_SI_FAULT|1)      /* integer divide by zero */
 478 #define VKI_FPE_INTOVF  (__VKI_SI_FAULT|2)      /* integer overflow */
 479 #define VKI_FPE_FLTDIV  (__VKI_SI_FAULT|3)      /* floating point divide by zero */
 480 #define VKI_FPE_FLTOVF  (__VKI_SI_FAULT|4)      /* floating point overflow */
 481 #define VKI_FPE_FLTUND  (__VKI_SI_FAULT|5)      /* floating point underflow */
 482 #define VKI_FPE_FLTRES  (__VKI_SI_FAULT|6)      /* floating point inexact result */
 483 #define VKI_FPE_FLTINV  (__VKI_SI_FAULT|7)      /* floating point invalid operation */
 484 #define VKI_FPE_FLTSUB  (__VKI_SI_FAULT|8)      /* subscript out of range */
 485
 486 /*
 487  * SIGSEGV si_codes
 488  */
 489 #define VKI_SEGV_MAPERR (__VKI_SI_FAULT|1)      /* address not mapped to object */
 490 #define VKI_SEGV_ACCERR (__VKI_SI_FAULT|2)      /* invalid permissions for mapped object */
 491
 492 /*
 493  * SIGBUS si_codes
 494  */
 495 #define VKI_BUS_ADRALN  (__VKI_SI_FAULT|1)      /* invalid address alignment */
 496 #define VKI_BUS_ADRERR  (__VKI_SI_FAULT|2)      /* non-existant physical address */
 497 #define VKI_BUS_OBJERR  (__VKI_SI_FAULT|3)      /* object specific hardware error */
 498
 499 /*
 500  * SIGTRAP si_codes
 501  */
 502 #define VKI_TRAP_BRKPT      (__VKI_SI_FAULT|1)  /* process breakpoint */
 503 #define VKI_TRAP_TRACE      (__VKI_SI_FAULT|2)  /* process trace trap */
 504
 505 /*
 506  * This works because the alignment is ok on all current architectures
 507  * but we leave open this being overridden in the future
 508  */
 509 #ifndef VKI___ARCH_SIGEV_PREAMBLE_SIZE
 510 #define VKI___ARCH_SIGEV_PREAMBLE_SIZE  (sizeof(int) * 2 + sizeof(vki_sigval_t))
 511 #endif
 512
 513 #define VKI_SIGEV_MAX_SIZE      64
 514 #define VKI_SIGEV_PAD_SIZE      ((VKI_SIGEV_MAX_SIZE - VKI___ARCH_SIGEV_PREAMBLE_SIZE) \
 515                 / sizeof(int))
 516
 517 typedef struct vki_sigevent {
 518         vki_sigval_t sigev_value;
 519         int sigev_signo;
 520         int sigev_notify;
 521         union {
 522                 int _pad[VKI_SIGEV_PAD_SIZE];
 523                  int _tid;
 524
 525                 struct {
 526                         void (*_function)(vki_sigval_t);
 527                         void *_attribute;       /* really pthread_attr_t */
 528                 } _sigev_thread;
 529         } _sigev_un;
 530 } vki_sigevent_t;
 531
 532 //----------------------------------------------------------------------
 533 // From elsewhere...
 534 //----------------------------------------------------------------------
 535
 536 // [[The kernel actually uses the numbers 0,1,2 directly here, believe it or
 537 // not.  So we introduce our own constants, based on the glibc ones.]]
 538 #define VKI_SEEK_SET              0
 539 #define VKI_SEEK_CUR              1
 540 #define VKI_SEEK_END              2
 541
 542 //----------------------------------------------------------------------
 543 // From linux-2.6.8.1/include/linux/net.h
 544 //----------------------------------------------------------------------
 545
 546 #define VKI_SYS_SOCKET          1       /* sys_socket(2)                */
 547 #define VKI_SYS_BIND            2       /* sys_bind(2)                  */
 548 #define VKI_SYS_CONNECT         3       /* sys_connect(2)               */
 549 #define VKI_SYS_LISTEN          4       /* sys_listen(2)                */
 550 #define VKI_SYS_ACCEPT          5       /* sys_accept(2)                */
 551 #define VKI_SYS_GETSOCKNAME     6       /* sys_getsockname(2)           */
 552 #define VKI_SYS_GETPEERNAME     7       /* sys_getpeername(2)           */
 553 #define VKI_SYS_SOCKETPAIR      8       /* sys_socketpair(2)            */
 554 #define VKI_SYS_SEND            9       /* sys_send(2)                  */
 555 #define VKI_SYS_RECV            10      /* sys_recv(2)                  */
 556 #define VKI_SYS_SENDTO          11      /* sys_sendto(2)                */
 557 #define VKI_SYS_RECVFROM        12      /* sys_recvfrom(2)              */
 558 #define VKI_SYS_SHUTDOWN        13      /* sys_shutdown(2)              */
 559 #define VKI_SYS_SETSOCKOPT      14      /* sys_setsockopt(2)            */
 560 #define VKI_SYS_GETSOCKOPT      15      /* sys_getsockopt(2)            */
 561 #define VKI_SYS_SENDMSG         16      /* sys_sendmsg(2)               */
 562 #define VKI_SYS_RECVMSG         17      /* sys_recvmsg(2)               */
 563 #define VKI_SYS_ACCEPT4         18      /* sys_accept4(2)               */
 564
 565 enum vki_sock_type {
 566         VKI_SOCK_STREAM = 1,
 567         // [[others omitted]]
 568 };
 569
 570 //----------------------------------------------------------------------
 571 // From linux-2.6.8.1/include/linux/uio.h
 572 //----------------------------------------------------------------------
 573
 574 struct vki_iovec
 575 {
 576         void __user *iov_base;  /* BSD uses caddr_t (1003.1g requires void *) */
 577         __vki_kernel_size_t iov_len; /* Must be size_t (1003.1g) */
 578 };
 579
 580 //----------------------------------------------------------------------
 581 // From linux-2.6.8.1/include/linux/socket.h
 582 //----------------------------------------------------------------------
 583
 584 // [[Resolved arbitrarily;  doesn't really matter whether it's '__inline__'
 585 //   or 'inline']]
 586 #define __KINLINE static __inline__
 587
 588 typedef unsigned short  vki_sa_family_t;
 589
 590 struct vki_sockaddr {
 591         vki_sa_family_t sa_family;      /* address family, AF_xxx       */
 592         char            sa_data[14];    /* 14 bytes of protocol address */
 593 };
 594
 595 struct vki_msghdr {
 596         void    *       msg_name;       /* Socket name                  */
 597         int             msg_namelen;    /* Length of name               */
 598         struct vki_iovec *      msg_iov;        /* Data blocks                  */
 599         __vki_kernel_size_t     msg_iovlen;     /* Number of blocks             */
 600         void    *       msg_control;    /* Per protocol magic (eg BSD file descriptor passing) */
 601         __vki_kernel_size_t     msg_controllen; /* Length of cmsg list */
 602         unsigned        msg_flags;
 603 };
 604
 605 struct vki_cmsghdr {
 606         __vki_kernel_size_t     cmsg_len;       /* data byte count, including hdr */
 607         int             cmsg_level;     /* originating protocol */
 608         int             cmsg_type;      /* protocol-specific type */
 609 };
 610
 611 #define __VKI_CMSG_NXTHDR(ctl, len, cmsg) __vki_cmsg_nxthdr((ctl),(len),(cmsg))
 612 #define VKI_CMSG_NXTHDR(mhdr, cmsg) vki_cmsg_nxthdr((mhdr), (cmsg))
 613
 614 #define VKI_CMSG_ALIGN(len) ( ((len)+sizeof(long)-1) & ~(sizeof(long)-1) )
 615
 616 #define VKI_CMSG_DATA(cmsg)     ((void *)((char *)(cmsg) + VKI_CMSG_ALIGN(sizeof(struct vki_cmsghdr))))
 617
 618 #define __VKI_CMSG_FIRSTHDR(ctl,len) ((len) >= sizeof(struct vki_cmsghdr) ? \
 619                                   (struct vki_cmsghdr *)(ctl) : \
 620                                   (struct vki_cmsghdr *)NULL)
 621 #define VKI_CMSG_FIRSTHDR(msg)  __VKI_CMSG_FIRSTHDR((msg)->msg_control, (msg)->msg_controllen)
 622
 623 // [[Urgh, this is revolting...]
 624 __KINLINE struct vki_cmsghdr * __vki_cmsg_nxthdr(void *__ctl, __vki_kernel_size_t __size,
 625                                                struct vki_cmsghdr *__cmsg)
 626 {
 627         struct vki_cmsghdr * __ptr;
 628
 629         __ptr = (struct vki_cmsghdr*)(((unsigned char *) __cmsg) +  VKI_CMSG_ALIGN(__cmsg->cmsg_len));
 630         if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
 631                 return (struct vki_cmsghdr *)0;
 632
 633         return __ptr;
 634 }
 635
 636 __KINLINE struct vki_cmsghdr * vki_cmsg_nxthdr (struct vki_msghdr *__msg, struct vki_cmsghdr *__cmsg)
 637 {
 638         return __vki_cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
 639 }
 640
 641 #define VKI_SCM_RIGHTS  0x01            /* rw: access rights (array of int) */
 642
 643 #define VKI_AF_UNIX     1       /* Unix domain sockets          */
 644 #define VKI_AF_INET     2       /* Internet IP Protocol         */
 645 #define VKI_AF_INET6    10      /* IP version 6                 */
 646
 647 #define VKI_MSG_NOSIGNAL        0x4000  /* Do not generate SIGPIPE */
 648
 649 #define VKI_SOL_SCTP    132
 650
 651 //----------------------------------------------------------------------
 652 // From linux-2.6.8.1/include/linux/in.h
 653 //----------------------------------------------------------------------
 654
 655 struct vki_in_addr {
 656         __vki_u32       s_addr;
 657 };
 658
 659 /* Structure describing an Internet (IP) socket address. */
 660 #define __VKI_SOCK_SIZE__       16      /* sizeof(struct sockaddr)      */
 661 struct vki_sockaddr_in {
 662   vki_sa_family_t       sin_family;     /* Address family               */
 663   unsigned short int    sin_port;       /* Port number                  */
 664   struct vki_in_addr    sin_addr;       /* Internet address             */
 665
 666   /* Pad to size of `struct sockaddr'. */
 667   unsigned char         __pad[__VKI_SOCK_SIZE__ - sizeof(short int) -
 668                         sizeof(unsigned short int) - sizeof(struct vki_in_addr)];
 669 };
 670
 671 //----------------------------------------------------------------------
 672 // From linux-2.6.8.1/include/linux/in6.h
 673 //----------------------------------------------------------------------
 674
 675 struct vki_in6_addr
 676 {
 677         union
 678         {
 679                 __vki_u8        u6_addr8[16];
 680                 __vki_u16       u6_addr16[8];
 681                 __vki_u32       u6_addr32[4];
 682         } vki_in6_u;
 683 #define vki_s6_addr             vki_in6_u.u6_addr8
 684 #define vki_s6_addr16           vki_in6_u.u6_addr16
 685 #define vki_s6_addr32           vki_in6_u.u6_addr32
 686 };
 687
 688 struct vki_sockaddr_in6 {
 689         unsigned short int      sin6_family;    /* AF_INET6 */
 690         __vki_u16               sin6_port;      /* Transport layer port # */
 691         __vki_u32               sin6_flowinfo;  /* IPv6 flow information */
 692         struct vki_in6_addr     sin6_addr;      /* IPv6 address */
 693         __vki_u32               sin6_scope_id;  /* scope id (new in RFC2553) */
 694 };
 695
 696 //----------------------------------------------------------------------
 697 // From linux-2.6.8.1/include/linux/un.h
 698 //----------------------------------------------------------------------
 699
 700 #define VKI_UNIX_PATH_MAX       108
 701
 702 struct vki_sockaddr_un {
 703         vki_sa_family_t sun_family;     /* AF_UNIX */
 704         char sun_path[VKI_UNIX_PATH_MAX];       /* pathname */
 705 };
 706
 707 //----------------------------------------------------------------------
 708 // From linux-2.6.8.1/include/linux/if.h
 709 //----------------------------------------------------------------------
 710
 711 #define VKI_IFNAMSIZ    16
 712
 713 struct vki_ifmap
 714 {
 715         unsigned long mem_start;
 716         unsigned long mem_end;
 717         unsigned short base_addr;
 718         unsigned char irq;
 719         unsigned char dma;
 720         unsigned char port;
 721         /* 3 bytes spare */
 722 };
 723
 724 struct vki_if_settings
 725 {
 726         unsigned int type;      /* Type of physical device or protocol */
 727         unsigned int size;      /* Size of the data allocated by the caller */
 728         union {
 729                 // [[Nb: converted these all to void* to avoid pulling in
 730                 //   unnecessary headers]]]
 731                 /* {atm/eth/dsl}_settings anyone ? */
 732                 void /*raw_hdlc_proto           */__user *raw_hdlc;
 733                 void /*cisco_proto              */__user *cisco;
 734                 void /*fr_proto                 */__user *fr;
 735                 void /*fr_proto_pvc             */__user *fr_pvc;
 736                 void /*fr_proto_pvc_info        */__user *fr_pvc_info;
 737
 738                 /* interface settings */
 739                 void /*sync_serial_settings     */__user *sync;
 740                 void /*te1_settings             */__user *te1;
 741         } ifs_ifsu;
 742 };
 743
 744 struct vki_ifreq
 745 {
 746 #define VKI_IFHWADDRLEN 6
 747         union
 748         {
 749                 char    ifrn_name[VKI_IFNAMSIZ];                /* if name, e.g. "en0" */
 750         } ifr_ifrn;
 751
 752         union {
 753                 struct  vki_sockaddr ifru_addr;
 754                 struct  vki_sockaddr ifru_dstaddr;
 755                 struct  vki_sockaddr ifru_broadaddr;
 756                 struct  vki_sockaddr ifru_netmask;
 757                 struct  vki_sockaddr ifru_hwaddr;
 758                 short   ifru_flags;
 759                 int     ifru_ivalue;
 760                 int     ifru_mtu;
 761                 struct  vki_ifmap ifru_map;
 762                 char    ifru_slave[VKI_IFNAMSIZ];       /* Just fits the size */
 763                 char    ifru_newname[VKI_IFNAMSIZ];
 764                 void __user *   ifru_data;
 765                 struct  vki_if_settings ifru_settings;
 766         } ifr_ifru;
 767 };
 768
 769 #define vki_ifr_name    ifr_ifrn.ifrn_name      /* interface name       */
 770 #define ifr_hwaddr      ifr_ifru.ifru_hwaddr    /* MAC address          */
 771 #define ifr_addr        ifr_ifru.ifru_addr      /* address              */
 772 #define ifr_dstaddr     ifr_ifru.ifru_dstaddr   /* other end of p-p lnk */
 773 #define ifr_broadaddr   ifr_ifru.ifru_broadaddr /* broadcast address    */
 774 #define ifr_netmask     ifr_ifru.ifru_netmask   /* interface net mask   */
 775 #define vki_ifr_flags   ifr_ifru.ifru_flags     /* flags                */
 776 #define vki_ifr_metric  ifr_ifru.ifru_ivalue    /* metric               */
 777 #define vki_ifr_mtu             ifr_ifru.ifru_mtu       /* mtu                  */
 778 #define ifr_map         ifr_ifru.ifru_map       /* device map           */
 779 #define ifr_slave       ifr_ifru.ifru_slave     /* slave device         */
 780 #define vki_ifr_data    ifr_ifru.ifru_data      /* for use by interface */
 781 #define vki_ifr_ifindex ifr_ifru.ifru_ivalue    /* interface index      */
 782 #define ifr_bandwidth   ifr_ifru.ifru_ivalue    /* link bandwidth       */
 783 #define ifr_qlen        ifr_ifru.ifru_ivalue    /* Queue length         */
 784 #define ifr_newname     ifr_ifru.ifru_newname   /* New name             */
 785 #define ifr_settings    ifr_ifru.ifru_settings  /* Device/proto settings*/
 786
 787 struct vki_ifconf
 788 {
 789         int     ifc_len;                        /* size of buffer       */
 790         union
 791         {
 792                 char __user *ifcu_buf;
 793                 struct vki_ifreq __user *ifcu_req;
 794         } ifc_ifcu;
 795 };
 796 #define vki_ifc_buf     ifc_ifcu.ifcu_buf       /* buffer address       */
 797
 798 //----------------------------------------------------------------------
 799 // From linux-2.6.8.1/include/linux/if_arp.h
 800 //----------------------------------------------------------------------
 801
 802 struct vki_arpreq {
 803   struct vki_sockaddr   arp_pa;         /* protocol address             */
 804   struct vki_sockaddr   arp_ha;         /* hardware address             */
 805   int                   arp_flags;      /* flags                        */
 806   struct vki_sockaddr   arp_netmask;    /* netmask (only for proxy arps) */
 807   char                  arp_dev[16];
 808 };
 809
 810 //----------------------------------------------------------------------
 811 // From linux-2.6.8.1/include/linux/route.h
 812 //----------------------------------------------------------------------
 813
 814 struct vki_rtentry
 815 {
 816         unsigned long   rt_pad1;
 817         struct vki_sockaddr     rt_dst;         /* target address               */
 818         struct vki_sockaddr     rt_gateway;     /* gateway addr (RTF_GATEWAY)   */
 819         struct vki_sockaddr     rt_genmask;     /* target network mask (IP)     */
 820         unsigned short  rt_flags;
 821         short           rt_pad2;
 822         unsigned long   rt_pad3;
 823         void            *rt_pad4;
 824         short           rt_metric;      /* +1 for binary compatibility! */
 825         char __user     *rt_dev;        /* forcing the device at add    */
 826         unsigned long   rt_mtu;         /* per route MTU/Window         */
 827 // [[Not important for Valgrind]]
 828 //#ifndef __KERNEL__
 829 //#define rt_mss        rt_mtu          /* Compatibility :-(            */
 830 //#endif
 831         unsigned long   rt_window;      /* Window clamping              */
 832         unsigned short  rt_irtt;        /* Initial RTT                  */
 833 };
 834
 835 //----------------------------------------------------------------------
 836 // From linux-2.6.13-rc5/include/net/sctp/user.h
 837 //----------------------------------------------------------------------
 838
 839 typedef __vki_s32 vki_sctp_assoc_t;
 840
 841 enum vki_sctp_optname {
 842         VKI_SCTP_RTOINFO,
 843 #define VKI_SCTP_RTOINFO VKI_SCTP_RTOINFO
 844         VKI_SCTP_ASSOCINFO,
 845 #define VKI_SCTP_ASSOCINFO VKI_SCTP_ASSOCINFO
 846         VKI_SCTP_INITMSG,
 847 #define VKI_SCTP_INITMSG VKI_SCTP_INITMSG
 848         VKI_SCTP_NODELAY,       /* Get/set nodelay option. */
 849 #define VKI_SCTP_NODELAY        VKI_SCTP_NODELAY
 850         VKI_SCTP_AUTOCLOSE,
 851 #define VKI_SCTP_AUTOCLOSE VKI_SCTP_AUTOCLOSE
 852         VKI_SCTP_SET_PEER_PRIMARY_ADDR,
 853 #define VKI_SCTP_SET_PEER_PRIMARY_ADDR VKI_SCTP_SET_PEER_PRIMARY_ADDR
 854         VKI_SCTP_PRIMARY_ADDR,
 855 #define VKI_SCTP_PRIMARY_ADDR VKI_SCTP_PRIMARY_ADDR
 856         VKI_SCTP_ADAPTION_LAYER,
 857 #define VKI_SCTP_ADAPTION_LAYER VKI_SCTP_ADAPTION_LAYER
 858         VKI_SCTP_DISABLE_FRAGMENTS,
 859 #define VKI_SCTP_DISABLE_FRAGMENTS VKI_SCTP_DISABLE_FRAGMENTS
 860         VKI_SCTP_PEER_ADDR_PARAMS,
 861 #define VKI_SCTP_PEER_ADDR_PARAMS VKI_SCTP_PEER_ADDR_PARAMS
 862         VKI_SCTP_DEFAULT_SEND_PARAM,
 863 #define VKI_SCTP_DEFAULT_SEND_PARAM VKI_SCTP_DEFAULT_SEND_PARAM
 864         VKI_SCTP_EVENTS,
 865 #define VKI_SCTP_EVENTS VKI_SCTP_EVENTS
 866         VKI_SCTP_I_WANT_MAPPED_V4_ADDR,  /* Turn on/off mapped v4 addresses  */
 867 #define VKI_SCTP_I_WANT_MAPPED_V4_ADDR VKI_SCTP_I_WANT_MAPPED_V4_ADDR
 868         VKI_SCTP_MAXSEG,        /* Get/set maximum fragment. */
 869 #define VKI_SCTP_MAXSEG         VKI_SCTP_MAXSEG
 870         VKI_SCTP_STATUS,
 871 #define VKI_SCTP_STATUS VKI_SCTP_STATUS
 872         VKI_SCTP_GET_PEER_ADDR_INFO,
 873 #define VKI_SCTP_GET_PEER_ADDR_INFO VKI_SCTP_GET_PEER_ADDR_INFO
 874
 875         /* Internal Socket Options. Some of the sctp library functions are
 876          * implemented using these socket options.
 877          */
 878         VKI_SCTP_SOCKOPT_BINDX_ADD = 100,/* BINDX requests for adding addresses. */
 879 #define VKI_SCTP_SOCKOPT_BINDX_ADD      VKI_SCTP_SOCKOPT_BINDX_ADD
 880         VKI_SCTP_SOCKOPT_BINDX_REM, /* BINDX requests for removing addresses. */
 881 #define VKI_SCTP_SOCKOPT_BINDX_REM      VKI_SCTP_SOCKOPT_BINDX_REM
 882         VKI_SCTP_SOCKOPT_PEELOFF,       /* peel off association. */
 883 #define VKI_SCTP_SOCKOPT_PEELOFF        VKI_SCTP_SOCKOPT_PEELOFF
 884         VKI_SCTP_GET_PEER_ADDRS_NUM,    /* Get number of peer addresss. */
 885 #define VKI_SCTP_GET_PEER_ADDRS_NUM     VKI_SCTP_GET_PEER_ADDRS_NUM
 886         VKI_SCTP_GET_PEER_ADDRS,        /* Get all peer addresss. */
 887 #define VKI_SCTP_GET_PEER_ADDRS VKI_SCTP_GET_PEER_ADDRS
 888         VKI_SCTP_GET_LOCAL_ADDRS_NUM,   /* Get number of local addresss. */
 889 #define VKI_SCTP_GET_LOCAL_ADDRS_NUM    VKI_SCTP_GET_LOCAL_ADDRS_NUM
 890         VKI_SCTP_GET_LOCAL_ADDRS,       /* Get all local addresss. */
 891 #define VKI_SCTP_GET_LOCAL_ADDRS        VKI_SCTP_GET_LOCAL_ADDRS
 892         VKI_SCTP_SOCKOPT_CONNECTX, /* CONNECTX requests. */
 893 #define VKI_SCTP_SOCKOPT_CONNECTX       VKI_SCTP_SOCKOPT_CONNECTX
 894 };
 895
 896 struct vki_sctp_getaddrs {
 897         vki_sctp_assoc_t        assoc_id;
 898         int                     addr_num;
 899         struct vki_sockaddr     *addrs;
 900 };
 901
 902 //----------------------------------------------------------------------
 903 // From linux-2.6.8.1/include/linux/resource.h
 904 //----------------------------------------------------------------------
 905
 906 struct  vki_rusage {
 907         struct vki_timeval ru_utime;    /* user time used */
 908         struct vki_timeval ru_stime;    /* system time used */
 909         long    ru_maxrss;              /* maximum resident set size */
 910         long    ru_ixrss;               /* integral shared memory size */
 911         long    ru_idrss;               /* integral unshared data size */
 912         long    ru_isrss;               /* integral unshared stack size */
 913         long    ru_minflt;              /* page reclaims */
 914         long    ru_majflt;              /* page faults */
 915         long    ru_nswap;               /* swaps */
 916         long    ru_inblock;             /* block input operations */
 917         long    ru_oublock;             /* block output operations */
 918         long    ru_msgsnd;              /* messages sent */
 919         long    ru_msgrcv;              /* messages received */
 920         long    ru_nsignals;            /* signals received */
 921         long    ru_nvcsw;               /* voluntary context switches */
 922         long    ru_nivcsw;              /* involuntary " */
 923 };
 924
 925 struct vki_rlimit {
 926         unsigned long   rlim_cur;
 927         unsigned long   rlim_max;
 928 };
 929
 930 //----------------------------------------------------------------------
 931 // From linux-2.6.8.1/include/linux/elfcore.h
 932 //----------------------------------------------------------------------
 933
 934 struct vki_elf_siginfo
 935 {
 936         int     si_signo;                       /* signal number */
 937         int     si_code;                        /* extra code */
 938         int     si_errno;                       /* errno */
 939 };
 940
 941 // [[Removed some commented out lines here]]
 942 struct vki_elf_prstatus
 943 {
 944         struct vki_elf_siginfo pr_info; /* Info associated with signal */
 945         short   pr_cursig;              /* Current signal */
 946         unsigned long pr_sigpend;       /* Set of pending signals */
 947         unsigned long pr_sighold;       /* Set of held signals */
 948         vki_pid_t       pr_pid;
 949         vki_pid_t       pr_ppid;
 950         vki_pid_t       pr_pgrp;
 951         vki_pid_t       pr_sid;
 952         struct vki_timeval pr_utime;    /* User time */
 953         struct vki_timeval pr_stime;    /* System time */
 954         struct vki_timeval pr_cutime;   /* Cumulative user time */
 955         struct vki_timeval pr_cstime;   /* Cumulative system time */
 956         vki_elf_gregset_t pr_reg;       /* GP registers */
 957         int pr_fpvalid;         /* True if math co-processor being used.  */
 958 };
 959
 960 #define VKI_ELF_PRARGSZ (80)    /* Number of chars for args */
 961
 962 struct vki_elf_prpsinfo
 963 {
 964         char    pr_state;       /* numeric process state */
 965         char    pr_sname;       /* char for pr_state */
 966         char    pr_zomb;        /* zombie */
 967         char    pr_nice;        /* nice val */
 968         unsigned long pr_flag;  /* flags */
 969         __vki_kernel_uid_t      pr_uid;
 970         __vki_kernel_gid_t      pr_gid;
 971         vki_pid_t       pr_pid, pr_ppid, pr_pgrp, pr_sid;
 972         /* Lots missing */
 973         char    pr_fname[16];   /* filename of executable */
 974         char    pr_psargs[VKI_ELF_PRARGSZ];     /* initial part of arg list */
 975 };
 976
 977 //----------------------------------------------------------------------
 978 // From linux-2.6.12.1/include/linux/eventpoll.h
 979 //----------------------------------------------------------------------
 980
 981 /* Valid opcodes to issue to sys_epoll_ctl() */
 982 #define VKI_EPOLL_CTL_ADD 1
 983 #define VKI_EPOLL_CTL_DEL 2
 984 #define VKI_EPOLL_CTL_MOD 3
 985
 986 #ifdef __x86_64__
 987 #define VKI_EPOLL_PACKED __attribute__((packed))
 988 #else
 989 #define VKI_EPOLL_PACKED
 990 #endif
 991
 992 struct vki_epoll_event {
 993         __vki_u32 events;
 994         __vki_u64 data;
 995 } VKI_EPOLL_PACKED;
 996
 997
 998 //----------------------------------------------------------------------
 999 // From linux-2.6.8.1/include/linux/mqueue.h
1000 //----------------------------------------------------------------------
1001
1002 struct vki_mq_attr {
1003         long    mq_flags;       /* message queue flags                  */
1004         long    mq_maxmsg;      /* maximum number of messages           */
1005         long    mq_msgsize;     /* maximum message size                 */
1006         long    mq_curmsgs;     /* number of messages currently queued  */
1007         long    __reserved[4];  /* ignored for input, zeroed for output */
1008 };
1009
1010 //----------------------------------------------------------------------
1011 // From linux-2.6.8.1/include/linux/utsname.h
1012 //----------------------------------------------------------------------
1013
1014 struct vki_new_utsname {
1015         char sysname[65];
1016         char nodename[65];
1017         char release[65];
1018         char version[65];
1019         char machine[65];
1020         char domainname[65];
1021 };
1022
1023 //----------------------------------------------------------------------
1024 // From linux-2.6.8.1/include/linux/mii.h
1025 //----------------------------------------------------------------------
1026
1027 /* This structure is used in all SIOCxMIIxxx ioctl calls */
1028 struct vki_mii_ioctl_data {
1029         vki_u16         phy_id;
1030         vki_u16         reg_num;
1031         vki_u16         val_in;
1032         vki_u16         val_out;
1033 };
1034
1035 //----------------------------------------------------------------------
1036 // From linux-2.6.8.1/include/linux/capability.h
1037 //----------------------------------------------------------------------
1038
1039 // [[capget()/capset() man page says this, ominously:
1040 //
1041 //   The kernel API is likely to change and use of these functions  (in
1042 //   particular the format of the cap_user_*_t types) is subject to
1043 //   change with each kernel revision.
1044 //
1045 // However, the format hasn't changed since at least Linux 2.4.6.]]
1046
1047 typedef struct __vki_user_cap_header_struct {
1048         __vki_u32 version;
1049         int pid;
1050 } __user *vki_cap_user_header_t;
1051
1052 typedef struct __vki_user_cap_data_struct {
1053         __vki_u32 effective;
1054         __vki_u32 permitted;
1055         __vki_u32 inheritable;
1056 } __user *vki_cap_user_data_t;
1057
1058
1059 //----------------------------------------------------------------------
1060 // From linux-2.6.8.1/include/linux/module.h
1061 //----------------------------------------------------------------------
1062
1063 // [[We do a VKI_SIZEOF_* here because this type is so big, and its size
1064 //   depends on the word size, so see vki_arch.h]]
1065
1066 //----------------------------------------------------------------------
1067 // From linux-2.6.8.1/include/linux/ipc.h
1068 //----------------------------------------------------------------------
1069
1070 /* Obsolete, used only for backwards compatibility and libc5 compiles */
1071 struct vki_ipc_perm
1072 {
1073         __vki_kernel_key_t      key;
1074         __vki_kernel_uid_t      uid;
1075         __vki_kernel_gid_t      gid;
1076         __vki_kernel_uid_t      cuid;
1077         __vki_kernel_gid_t      cgid;
1078         __vki_kernel_mode_t     mode;
1079         unsigned short  seq;
1080 };
1081
1082 #define VKI_IPC_CREAT  00001000   /* create if key is nonexistent */
1083 #define VKI_IPC_EXCL   00002000   /* fail if key exists */
1084 #define VKI_IPC_NOWAIT 00004000   /* return error on wait */
1085
1086 //#define VKI_IPC_RMID 0     /* remove resource */
1087 #define VKI_IPC_SET  1     /* set ipc_perm options */
1088 #define VKI_IPC_STAT 2     /* get ipc_perm options */
1089 #define VKI_IPC_INFO 3     /* see ipcs */
1090
1091 #define VKI_IPC_64  0x0100  /* New version (support 32-bit UIDs, bigger
1092                                message sizes, etc. */
1093
1094 //----------------------------------------------------------------------
1095 // From linux-2.6.8.1/include/linux/sem.h
1096 //----------------------------------------------------------------------
1097
1098 #define VKI_GETALL  13       /* get all semval's */
1099 #define VKI_SETVAL  16       /* set semval */
1100 #define VKI_SETALL  17       /* set all semval's */
1101
1102 #define VKI_SEM_STAT 18
1103 #define VKI_SEM_INFO 19
1104
1105 /* Obsolete, used only for backwards compatibility and libc5 compiles */
1106 struct vki_semid_ds {
1107         struct vki_ipc_perm     sem_perm;               /* permissions .. see ipc.h */
1108         __vki_kernel_time_t     sem_otime;              /* last semop time */
1109         __vki_kernel_time_t     sem_ctime;              /* last change time */
1110         // [[Use void* to avoid excess header copying]]
1111         void/*struct sem        */*sem_base;            /* ptr to first semaphore in array */
1112         void/*struct sem_queue */*sem_pending;          /* pending operations to be processed */
1113         void/*struct sem_queue */**sem_pending_last;    /* last pending operation */
1114         void/*struct sem_undo   */*undo;                        /* undo requests on this array */
1115         unsigned short  sem_nsems;              /* no. of semaphores in array */
1116 };
1117
1118 struct vki_sembuf {
1119         unsigned short  sem_num;        /* semaphore index in array */
1120         short           sem_op;         /* semaphore operation */
1121         short           sem_flg;        /* operation flags */
1122 };
1123
1124 union vki_semun {
1125         int val;                        /* value for SETVAL */
1126         struct vki_semid_ds __user *buf;        /* buffer for IPC_STAT & IPC_SET */
1127         unsigned short __user *array;   /* array for GETALL & SETALL */
1128         struct vki_seminfo __user *__buf;       /* buffer for IPC_INFO */
1129         void __user *__pad;
1130 };
1131
1132 struct  vki_seminfo {
1133         int semmap;
1134         int semmni;
1135         int semmns;
1136         int semmnu;
1137         int semmsl;
1138         int semopm;
1139         int semume;
1140         int semusz;
1141         int semvmx;
1142         int semaem;
1143 };
1144
1145 //----------------------------------------------------------------------
1146 // From linux-2.6.8.1/include/asm-generic/errno-base.h
1147 //----------------------------------------------------------------------
1148
1149 #define VKI_EPERM                1      /* Operation not permitted */
1150 #define VKI_ENOENT               2      /* No such file or directory */
1151 #define VKI_ESRCH                3      /* No such process */
1152 #define VKI_EINTR                4      /* Interrupted system call */
1153 #define VKI_ENOEXEC              8      /* Exec format error */
1154 #define VKI_EBADF                9      /* Bad file number */
1155 #define VKI_ECHILD              10      /* No child processes */
1156 #define VKI_EAGAIN              11      /* Try again */
1157 #define VKI_EWOULDBLOCK         VKI_EAGAIN
1158 #define VKI_ENOMEM              12      /* Out of memory */
1159 #define VKI_EACCES              13      /* Permission denied */
1160 #define VKI_EFAULT              14      /* Bad address */
1161 #define VKI_EEXIST              17      /* File exists */
1162 #define VKI_EINVAL              22      /* Invalid argument */
1163 #define VKI_EMFILE              24      /* Too many open files */
1164
1165 //----------------------------------------------------------------------
1166 // From linux-2.6.8.1/include/asm-generic/errno.h
1167 //----------------------------------------------------------------------
1168
1169 #define VKI_ENOSYS              38      /* Function not implemented */
1170 #define VKI_EOVERFLOW           75      /* Value too large for defined data type */
1171
1172 //----------------------------------------------------------------------
1173 // From linux-2.6.8.1/include/linux/wait.h
1174 //----------------------------------------------------------------------
1175
1176 #define VKI_WNOHANG     0x00000001
1177
1178 #define __VKI_WALL      0x40000000      /* Wait on all children, regardless of type */
1179 #define __VKI_WCLONE    0x80000000      /* Wait only on non-SIGCHLD children */
1180
1181 //----------------------------------------------------------------------
1182 // From linux-2.6.8.1/include/linux/mman.h
1183 //----------------------------------------------------------------------
1184
1185 #define VKI_MREMAP_MAYMOVE      1
1186 #define VKI_MREMAP_FIXED        2
1187
1188 //----------------------------------------------------------------------
1189 // From linux-2.6.31-rc4/include/linux/futex.h
1190 //----------------------------------------------------------------------
1191
1192 #define VKI_FUTEX_WAIT (0)
1193 #define VKI_FUTEX_WAKE (1)
1194 #define VKI_FUTEX_FD (2)
1195 #define VKI_FUTEX_REQUEUE (3)
1196 #define VKI_FUTEX_CMP_REQUEUE (4)
1197 #define VKI_FUTEX_WAKE_OP (5)
1198 #define VKI_FUTEX_LOCK_PI (6)
1199 #define VKI_FUTEX_UNLOCK_PI (7)
1200 #define VKI_FUTEX_TRYLOCK_PI (8)
1201 #define VKI_FUTEX_WAIT_BITSET (9)
1202 #define VKI_FUTEX_WAKE_BITSET (10)
1203 #define VKI_FUTEX_WAIT_REQUEUE_PI (11)
1204 #define VKI_FUTEX_CMP_REQUEUE_PI (12)
1205 #define VKI_FUTEX_PRIVATE_FLAG (128)
1206 #define VKI_FUTEX_CLOCK_REALTIME (256)
1207
1208 struct vki_robust_list {
1209         struct vki_robust_list __user *next;
1210 };
1211
1212 struct vki_robust_list_head {
1213         /*
1214          * The head of the list. Points back to itself if empty:
1215          */
1216         struct vki_robust_list list;
1217
1218         /*
1219          * This relative offset is set by user-space, it gives the kernel
1220          * the relative position of the futex field to examine. This way
1221          * we keep userspace flexible, to freely shape its data-structure,
1222          * without hardcoding any particular offset into the kernel:
1223          */
1224         long futex_offset;
1225
1226         /*
1227          * The death of the thread may race with userspace setting
1228          * up a lock's links. So to handle this race, userspace first
1229          * sets this field to the address of the to-be-taken lock,
1230          * then does the lock acquire, and then adds itself to the
1231          * list, and then clears this field. Hence the kernel will
1232          * always have full knowledge of all locks that the thread
1233          * _might_ have taken. We check the owner TID in any case,
1234          * so only truly owned locks will be handled.
1235          */
1236         struct vki_robust_list __user *list_op_pending;
1237 };
1238
1239 //----------------------------------------------------------------------
1240 // From linux-2.6.8.1/include/linux/errno.h
1241 //----------------------------------------------------------------------
1242
1243 #define VKI_ERESTARTSYS 512
1244
1245 //----------------------------------------------------------------------
1246 // From linux-2.6.8.1/include/linux/stat.h
1247 //----------------------------------------------------------------------
1248
1249 #define VKI_S_IFMT  00170000
1250 #define VKI_S_IFSOCK 0140000
1251 #define VKI_S_IFLNK  0120000
1252 #define VKI_S_IFREG  0100000
1253 #define VKI_S_IFBLK  0060000
1254 #define VKI_S_IFDIR  0040000
1255 #define VKI_S_IFCHR  0020000
1256 #define VKI_S_IFIFO  0010000
1257 #define VKI_S_ISUID  0004000
1258 #define VKI_S_ISGID  0002000
1259 #define VKI_S_ISVTX  0001000
1260
1261 #define VKI_S_ISLNK(m)  (((m) & VKI_S_IFMT) == VKI_S_IFLNK)
1262 #define VKI_S_ISREG(m)  (((m) & VKI_S_IFMT) == VKI_S_IFREG)
1263 #define VKI_S_ISDIR(m)  (((m) & VKI_S_IFMT) == VKI_S_IFDIR)
1264 #define VKI_S_ISCHR(m)  (((m) & VKI_S_IFMT) == VKI_S_IFCHR)
1265 #define VKI_S_ISBLK(m)  (((m) & VKI_S_IFMT) == VKI_S_IFBLK)
1266 #define VKI_S_ISFIFO(m) (((m) & VKI_S_IFMT) == VKI_S_IFIFO)
1267 #define VKI_S_ISSOCK(m) (((m) & VKI_S_IFMT) == VKI_S_IFSOCK)
1268
1269 #define VKI_S_IRWXU 00700
1270 #define VKI_S_IRUSR 00400
1271 #define VKI_S_IWUSR 00200
1272 #define VKI_S_IXUSR 00100
1273
1274 #define VKI_S_IRWXG 00070
1275 #define VKI_S_IRGRP 00040
1276 #define VKI_S_IWGRP 00020
1277 #define VKI_S_IXGRP 00010
1278
1279 #define VKI_S_IRWXO 00007
1280 #define VKI_S_IROTH 00004
1281 #define VKI_S_IWOTH 00002
1282 #define VKI_S_IXOTH 00001
1283
1284 //----------------------------------------------------------------------
1285 // From linux-2.6.8.1/include/linux/dirent.h
1286 //----------------------------------------------------------------------
1287
1288 struct vki_dirent {
1289         long            d_ino;
1290         __vki_kernel_off_t      d_off;
1291         unsigned short  d_reclen;
1292         char            d_name[256]; /* We must not include limits.h! */
1293 };
1294
1295 //----------------------------------------------------------------------
1296 // From linux-2.6.8.1/include/linux/fcntl.h
1297 //----------------------------------------------------------------------
1298
1299 #define VKI_F_SETLEASE  (VKI_F_LINUX_SPECIFIC_BASE+0)
1300 #define VKI_F_GETLEASE  (VKI_F_LINUX_SPECIFIC_BASE+1)
1301
1302 #define VKI_F_NOTIFY    (VKI_F_LINUX_SPECIFIC_BASE+2)
1303
1304 //----------------------------------------------------------------------
1305 // From linux-2.6.8.1/include/linux/sysctl.h
1306 //----------------------------------------------------------------------
1307
1308 struct __vki_sysctl_args {
1309         int __user *name;
1310         int nlen;
1311         void __user *oldval;
1312         vki_size_t __user *oldlenp;
1313         void __user *newval;
1314         vki_size_t newlen;
1315         unsigned long __unused[4];
1316 };
1317
1318 //----------------------------------------------------------------------
1319 // From linux-2.6.8.1/include/linux/aio_abi.h
1320 //----------------------------------------------------------------------
1321
1322 typedef unsigned long   vki_aio_context_t;
1323
1324 enum {
1325         VKI_IOCB_CMD_PREAD = 0,
1326         VKI_IOCB_CMD_PWRITE = 1,
1327         VKI_IOCB_CMD_FSYNC = 2,
1328         VKI_IOCB_CMD_FDSYNC = 3,
1329         VKI_IOCB_CMD_PREADV = 7,
1330         VKI_IOCB_CMD_PWRITEV = 8,
1331 };
1332
1333 /* read() from /dev/aio returns these structures. */
1334 struct vki_io_event {
1335         __vki_u64       data;           /* the data field from the iocb */
1336         __vki_u64       obj;            /* what iocb this event came from */
1337         // [[Nb: These fields renamed from 'res' and 'res2' because 'res' is
1338         //   a macro in vg_syscalls.c!]]
1339         __vki_s64       result;         /* result code for this event */
1340         __vki_s64       result2;        /* secondary result */
1341 };
1342
1343 #if defined(VKI_LITTLE_ENDIAN)
1344 #  define VKI_PADDED(x,y)       x, y
1345 #elif defined(VKI_BIG_ENDIAN)
1346 #  define VKI_PADDED(x,y)       y, x
1347 #else
1348 #error edit for your odd byteorder.
1349 #endif
1350
1351 struct vki_iocb {
1352         /* these are internal to the kernel/libc. */
1353         __vki_u64       aio_data;       /* data to be returned in event's data */
1354         __vki_u32       VKI_PADDED(aio_key, aio_reserved1);
1355                                 /* the kernel sets aio_key to the req # */
1356
1357         /* common fields */
1358         __vki_u16       aio_lio_opcode; /* see IOCB_CMD_ above */
1359         __vki_s16       aio_reqprio;
1360         __vki_u32       aio_fildes;
1361
1362         __vki_u64       aio_buf;
1363         __vki_u64       aio_nbytes;
1364         __vki_s64       aio_offset;
1365
1366         /* extra parameters */
1367         __vki_u64       aio_reserved2;  /* TODO: use this for a (struct sigevent *) */
1368         __vki_u64       aio_reserved3;
1369 }; /* 64 bytes */
1370
1371 //----------------------------------------------------------------------
1372 // From linux-2.6.8.1/include/linux/aio.h
1373 //----------------------------------------------------------------------
1374
1375 struct vki_aio_ring {
1376         unsigned        id;     /* kernel internal index number */
1377         unsigned        nr;     /* number of io_events */
1378         unsigned        head;
1379         unsigned        tail;
1380
1381         unsigned        magic;
1382         unsigned        compat_features;
1383         unsigned        incompat_features;
1384         unsigned        header_length;  /* size of aio_ring */
1385
1386         struct vki_io_event             io_events[0];
1387 }; /* 128 bytes + ring size */
1388
1389 //----------------------------------------------------------------------
1390 // From linux-2.6.8.1/include/linux/msg.h
1391 //----------------------------------------------------------------------
1392
1393 #define VKI_MSG_STAT 11
1394 #define VKI_MSG_INFO 12
1395
1396 struct vki_msqid_ds {
1397         struct vki_ipc_perm msg_perm;
1398         struct vki_msg *msg_first;              /* first message on queue,unused  */
1399         struct vki_msg *msg_last;               /* last message in queue,unused */
1400         __vki_kernel_time_t msg_stime;  /* last msgsnd time */
1401         __vki_kernel_time_t msg_rtime;  /* last msgrcv time */
1402         __vki_kernel_time_t msg_ctime;  /* last change time */
1403         unsigned long  msg_lcbytes;     /* Reuse junk fields for 32 bit */
1404         unsigned long  msg_lqbytes;     /* ditto */
1405         unsigned short msg_cbytes;      /* current number of bytes on queue */
1406         unsigned short msg_qnum;        /* number of messages in queue */
1407         unsigned short msg_qbytes;      /* max number of bytes on queue */
1408         __vki_kernel_ipc_pid_t msg_lspid;       /* pid of last msgsnd */
1409         __vki_kernel_ipc_pid_t msg_lrpid;       /* last receive pid */
1410 };
1411
1412 struct vki_msgbuf {
1413         long mtype;         /* type of message */
1414         char mtext[1];      /* message text */
1415 };
1416
1417 struct vki_msginfo {
1418         int msgpool;
1419         int msgmap;
1420         int msgmax;
1421         int msgmnb;
1422         int msgmni;
1423         int msgssz;
1424         int msgtql;
1425         unsigned short  msgseg;
1426 };
1427
1428 //----------------------------------------------------------------------
1429 // From linux-2.6.8.1/include/linux/shm.h
1430 //----------------------------------------------------------------------
1431
1432 struct vki_shmid_ds {
1433         struct vki_ipc_perm             shm_perm;       /* operation perms */
1434         int                     shm_segsz;      /* size of segment (bytes) */
1435         __vki_kernel_time_t             shm_atime;      /* last attach time */
1436         __vki_kernel_time_t             shm_dtime;      /* last detach time */
1437         __vki_kernel_time_t             shm_ctime;      /* last change time */
1438         __vki_kernel_ipc_pid_t  shm_cpid;       /* pid of creator */
1439         __vki_kernel_ipc_pid_t  shm_lpid;       /* pid of last operator */
1440         unsigned short          shm_nattch;     /* no. of current attaches */
1441         unsigned short          shm_unused;     /* compatibility */
1442         void                    *shm_unused2;   /* ditto - used by DIPC */
1443         void                    *shm_unused3;   /* unused */
1444 };
1445
1446 #define VKI_SHM_RDONLY  010000  /* read-only access */
1447
1448 #define VKI_SHM_STAT    13
1449 #define VKI_SHM_INFO    14
1450
1451 /* Obsolete, used only for backwards compatibility */
1452 struct  vki_shminfo {
1453         int shmmax;
1454         int shmmin;
1455         int shmmni;
1456         int shmseg;
1457         int shmall;
1458 };
1459
1460 struct vki_shm_info {
1461         int used_ids;
1462         unsigned long shm_tot;  /* total allocated shm */
1463         unsigned long shm_rss;  /* total resident shm */
1464         unsigned long shm_swp;  /* total swapped shm */
1465         unsigned long swap_attempts;
1466         unsigned long swap_successes;
1467 };
1468
1469 //----------------------------------------------------------------------
1470 // From linux-2.6.8.1/include/linux/rtc.h
1471 //----------------------------------------------------------------------
1472
1473 struct vki_rtc_time {
1474         int tm_sec;
1475         int tm_min;
1476         int tm_hour;
1477         int tm_mday;
1478         int tm_mon;
1479         int tm_year;
1480         int tm_wday;
1481         int tm_yday;
1482         int tm_isdst;
1483 };
1484
1485 #define VKI_RTC_AIE_ON  _VKI_IO('p', 0x01)      /* Alarm int. enable on */
1486 #define VKI_RTC_AIE_OFF _VKI_IO('p', 0x02)      /* ... off              */
1487 #define VKI_RTC_UIE_ON  _VKI_IO('p', 0x03)      /* Update int. enable on*/
1488 #define VKI_RTC_UIE_OFF _VKI_IO('p', 0x04)      /* ... off              */
1489 #define VKI_RTC_PIE_ON  _VKI_IO('p', 0x05)      /* Periodic int. enable on*/
1490 #define VKI_RTC_PIE_OFF _VKI_IO('p', 0x06)      /* ... off              */
1491
1492 #define VKI_RTC_ALM_SET         _VKI_IOW('p', 0x07, struct vki_rtc_time) /* Set alarm time  */
1493 #define VKI_RTC_ALM_READ        _VKI_IOR('p', 0x08, struct vki_rtc_time) /* Read alarm time */
1494 #define VKI_RTC_RD_TIME         _VKI_IOR('p', 0x09, struct vki_rtc_time) /* Read RTC time   */
1495 //#define RTC_SET_TIME  _IOW('p', 0x0a, struct rtc_time) /* Set RTC time    */
1496 #define VKI_RTC_IRQP_READ       _VKI_IOR('p', 0x0b, unsigned long)       /* Read IRQ rate   */
1497 #define VKI_RTC_IRQP_SET        _VKI_IOW('p', 0x0c, unsigned long)       /* Set IRQ rate    */
1498
1499 //----------------------------------------------------------------------
1500 // From linux-2.6.8.1/include/linux/isdn.h
1501 //----------------------------------------------------------------------
1502
1503 // [[Nb: Resolved this for the common case where CONFIG_COBALT_MICRO_SERVER
1504 //   is not defined]]
1505 #define VKI_ISDN_MAX_CHANNELS   64
1506
1507 #define VKI_IIOCGETCPS  _VKI_IO('I',21)
1508
1509 #define VKI_IIOCNETGPN  _VKI_IO('I',34)
1510
1511 #define VKI_ISDN_MSNLEN          32
1512
1513 typedef struct {
1514   char name[10];
1515   char phone[VKI_ISDN_MSNLEN];
1516   int  outgoing;
1517 } vki_isdn_net_ioctl_phone;
1518
1519 //----------------------------------------------------------------------
1520 // From linux-2.6.8.1/include/linux/sockios.h
1521 //----------------------------------------------------------------------
1522
1523 #define VKI_SIOCOUTQ            VKI_TIOCOUTQ
1524
1525 #define VKI_SIOCADDRT           0x890B  /* add routing table entry      */
1526 #define VKI_SIOCDELRT           0x890C  /* delete routing table entry   */
1527
1528 #define VKI_SIOCGIFNAME         0x8910  /* get iface name               */
1529 #define VKI_SIOCGIFCONF         0x8912  /* get iface list               */
1530 #define VKI_SIOCGIFFLAGS        0x8913  /* get flags                    */
1531 #define VKI_SIOCSIFFLAGS        0x8914  /* set flags                    */
1532 #define VKI_SIOCGIFADDR         0x8915  /* get PA address               */
1533 #define VKI_SIOCSIFADDR         0x8916  /* set PA address               */
1534 #define VKI_SIOCGIFDSTADDR      0x8917  /* get remote PA address        */
1535 #define VKI_SIOCSIFDSTADDR      0x8918  /* set remote PA address        */
1536 #define VKI_SIOCGIFBRDADDR      0x8919  /* get broadcast PA address     */
1537 #define VKI_SIOCSIFBRDADDR      0x891a  /* set broadcast PA address     */
1538 #define VKI_SIOCGIFNETMASK      0x891b  /* get network PA mask          */
1539 #define VKI_SIOCSIFNETMASK      0x891c  /* set network PA mask          */
1540 #define VKI_SIOCGIFMETRIC       0x891d  /* get metric                   */
1541 #define VKI_SIOCSIFMETRIC       0x891e  /* set metric                   */
1542 #define VKI_SIOCGIFMTU          0x8921  /* get MTU size                 */
1543 #define VKI_SIOCSIFMTU          0x8922  /* set MTU size                 */
1544 #define VKI_SIOCSIFHWADDR       0x8924  /* set hardware address         */
1545 #define VKI_SIOCGIFHWADDR       0x8927  /* Get hardware address         */
1546 #define VKI_SIOCGIFINDEX        0x8933  /* name -> if_index mapping     */
1547
1548 #define VKI_SIOCGIFTXQLEN       0x8942  /* Get the tx queue length      */
1549 #define VKI_SIOCSIFTXQLEN       0x8943  /* Set the tx queue length      */
1550
1551 #define VKI_SIOCGMIIPHY         0x8947  /* Get address of MII PHY in use. */
1552 #define VKI_SIOCGMIIREG         0x8948  /* Read MII PHY register.       */
1553 #define VKI_SIOCSMIIREG         0x8949  /* Write MII PHY register.      */
1554
1555 #define VKI_SIOCDARP            0x8953  /* delete ARP table entry       */
1556 #define VKI_SIOCGARP            0x8954  /* get ARP table entry          */
1557 #define VKI_SIOCSARP            0x8955  /* set ARP table entry          */
1558
1559 #define VKI_SIOCDRARP           0x8960  /* delete RARP table entry      */
1560 #define VKI_SIOCGRARP           0x8961  /* get RARP table entry         */
1561 #define VKI_SIOCSRARP           0x8962  /* set RARP table entry         */
1562
1563 #define VKI_SIOCGIFMAP          0x8970  /* Get device parameters        */
1564 #define VKI_SIOCSIFMAP          0x8971  /* Set device parameters        */
1565
1566 //----------------------------------------------------------------------
1567 // From linux-2.6.8.1/include/linux/ppdev.h
1568 //----------------------------------------------------------------------
1569
1570 #define VKI_PP_MAJOR    99
1571
1572 #define VKI_PP_IOCTL    'p'
1573
1574 /* Set mode for read/write (e.g. IEEE1284_MODE_EPP) */
1575 #define VKI_PPSETMODE   _VKI_IOW(VKI_PP_IOCTL, 0x80, int)
1576
1577 /* Read status */
1578 #define VKI_PPRSTATUS   _VKI_IOR(VKI_PP_IOCTL, 0x81, unsigned char)
1579 //#define PPWSTATUS     OBSOLETE__IOW(PP_IOCTL, 0x82, unsigned char)
1580
1581 /* Read/write control */
1582 #define VKI_PPRCONTROL  _VKI_IOR(VKI_PP_IOCTL, 0x83, unsigned char)
1583 #define VKI_PPWCONTROL  _VKI_IOW(VKI_PP_IOCTL, 0x84, unsigned char)
1584
1585 struct vki_ppdev_frob_struct {
1586         unsigned char mask;
1587         unsigned char val;
1588 };
1589 #define VKI_PPFCONTROL      _VKI_IOW(VKI_PP_IOCTL, 0x8e, struct vki_ppdev_frob_struct)
1590
1591 /* Read/write data */
1592 #define VKI_PPRDATA             _VKI_IOR(VKI_PP_IOCTL, 0x85, unsigned char)
1593 #define VKI_PPWDATA             _VKI_IOW(VKI_PP_IOCTL, 0x86, unsigned char)
1594
1595 /* Claim the port to start using it */
1596 #define VKI_PPCLAIM             _VKI_IO(VKI_PP_IOCTL, 0x8b)
1597
1598 /* Release the port when you aren't using it */
1599 #define VKI_PPRELEASE   _VKI_IO(VKI_PP_IOCTL, 0x8c)
1600
1601 /* Yield the port (release it if another driver is waiting,
1602  * then reclaim) */
1603 #define VKI_PPYIELD             _VKI_IO(VKI_PP_IOCTL, 0x8d)
1604
1605 /* Register device exclusively (must be before PPCLAIM). */
1606 #define VKI_PPEXCL              _VKI_IO(VKI_PP_IOCTL, 0x8f)
1607
1608 /* Data line direction: non-zero for input mode. */
1609 #define VKI_PPDATADIR   _VKI_IOW(VKI_PP_IOCTL, 0x90, int)
1610
1611 /* Negotiate a particular IEEE 1284 mode. */
1612 #define VKI_PPNEGOT     _VKI_IOW(VKI_PP_IOCTL, 0x91, int)
1613
1614 /* Set control lines when an interrupt occurs. */
1615 #define VKI_PPWCTLONIRQ _VKI_IOW(VKI_PP_IOCTL, 0x92, unsigned char)
1616
1617 /* Clear (and return) interrupt count. */
1618 #define VKI_PPCLRIRQ    _VKI_IOR(VKI_PP_IOCTL, 0x93, int)
1619
1620 /* Set the IEEE 1284 phase that we're in (e.g. IEEE1284_PH_FWD_IDLE) */
1621 #define VKI_PPSETPHASE  _VKI_IOW(VKI_PP_IOCTL, 0x94, int)
1622
1623 /* Set and get port timeout (struct timeval's) */
1624 #define VKI_PPGETTIME   _VKI_IOR(VKI_PP_IOCTL, 0x95, struct vki_timeval)
1625 #define VKI_PPSETTIME   _VKI_IOW(VKI_PP_IOCTL, 0x96, struct vki_timeval)
1626
1627 #define VKI_PPGETMODES  _VKI_IOR(VKI_PP_IOCTL, 0x97, unsigned int)
1628
1629 #define VKI_PPGETMODE   _VKI_IOR(VKI_PP_IOCTL, 0x98, int)
1630 #define VKI_PPGETPHASE  _VKI_IOR(VKI_PP_IOCTL, 0x99, int)
1631
1632 #define VKI_PPGETFLAGS  _VKI_IOR(VKI_PP_IOCTL, 0x9a, int)
1633 #define VKI_PPSETFLAGS  _VKI_IOW(VKI_PP_IOCTL, 0x9b, int)
1634
1635 //----------------------------------------------------------------------
1636 // From linux-2.6.8.1/include/linux/fs.h
1637 //----------------------------------------------------------------------
1638
1639 #define VKI_BLKROSET   _VKI_IO(0x12,93) /* set device read-only (0 = read-write) */
1640 #define VKI_BLKROGET   _VKI_IO(0x12,94) /* get read-only status (0 = read_write) */
1641 #define VKI_BLKGETSIZE _VKI_IO(0x12,96) /* return device size /512 (long *arg) */
1642 #define VKI_BLKRASET   _VKI_IO(0x12,98) /* set read ahead for block device */
1643 #define VKI_BLKRAGET   _VKI_IO(0x12,99) /* get current read ahead setting */
1644 #define VKI_BLKFRASET  _VKI_IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
1645 #define VKI_BLKFRAGET  _VKI_IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
1646 #define VKI_BLKSECTGET _VKI_IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
1647 #define VKI_BLKSSZGET  _VKI_IO(0x12,104)/* get block device sector size */
1648 #define VKI_BLKBSZGET  _VKI_IOR(0x12,112,vki_size_t)
1649 #define VKI_BLKBSZSET  _VKI_IOW(0x12,113,vki_size_t)
1650 #define VKI_BLKGETSIZE64 _VKI_IOR(0x12,114,vki_size_t) /* return device size in bytes (u64 *arg) */
1651
1652 #define VKI_FIBMAP      _VKI_IO(0x00,1) /* bmap access */
1653 #define VKI_FIGETBSZ    _VKI_IO(0x00,2) /* get the block size used for bmap */
1654
1655 //----------------------------------------------------------------------
1656 // From linux-2.6.8.1/include/scsi/sg.h
1657 //----------------------------------------------------------------------
1658
1659 typedef struct vki_sg_io_hdr
1660 {
1661     int interface_id;           /* [i] 'S' for SCSI generic (required) */
1662     int dxfer_direction;        /* [i] data transfer direction  */
1663     unsigned char cmd_len;      /* [i] SCSI command length ( <= 16 bytes) */
1664     unsigned char mx_sb_len;    /* [i] max length to write to sbp */
1665     unsigned short iovec_count; /* [i] 0 implies no scatter gather */
1666     unsigned int dxfer_len;     /* [i] byte count of data transfer */
1667     void __user *dxferp;        /* [i], [*io] points to data transfer memory
1668                                               or scatter gather list */
1669     unsigned char __user *cmdp; /* [i], [*i] points to command to perform */
1670     void __user *sbp;           /* [i], [*o] points to sense_buffer memory */
1671     unsigned int timeout;       /* [i] MAX_UINT->no timeout (unit: millisec) */
1672     unsigned int flags;         /* [i] 0 -> default, see SG_FLAG... */
1673     int pack_id;                /* [i->o] unused internally (normally) */
1674     void __user * usr_ptr;      /* [i->o] unused internally */
1675     unsigned char status;       /* [o] scsi status */
1676     unsigned char masked_status;/* [o] shifted, masked scsi status */
1677     unsigned char msg_status;   /* [o] messaging level data (optional) */
1678     unsigned char sb_len_wr;    /* [o] byte count actually written to sbp */
1679     unsigned short host_status; /* [o] errors from host adapter */
1680     unsigned short driver_status;/* [o] errors from software driver */
1681     int resid;                  /* [o] dxfer_len - actual_transferred */
1682     unsigned int duration;      /* [o] time taken by cmd (unit: millisec) */
1683     unsigned int info;          /* [o] auxiliary information */
1684 } vki_sg_io_hdr_t;  /* 64 bytes long (on i386) */
1685
1686 typedef struct vki_sg_scsi_id { /* used by SG_GET_SCSI_ID ioctl() */
1687     int host_no;        /* as in "scsi<n>" where 'n' is one of 0, 1, 2 etc */
1688     int channel;
1689     int scsi_id;        /* scsi id of target device */
1690     int lun;
1691     int scsi_type;      /* TYPE_... defined in scsi/scsi.h */
1692     short h_cmd_per_lun;/* host (adapter) maximum commands per lun */
1693     short d_queue_depth;/* device (or adapter) maximum queue length */
1694     int unused[2];      /* probably find a good use, set 0 for now */
1695 } vki_sg_scsi_id_t; /* 32 bytes long on i386 */
1696
1697 #define VKI_SG_EMULATED_HOST 0x2203 /* true for emulated host adapter (ATAPI) */
1698
1699 #define VKI_SG_SET_RESERVED_SIZE 0x2275  /* request a new reserved buffer size */
1700 #define VKI_SG_GET_RESERVED_SIZE 0x2272  /* actual size of reserved buffer */
1701
1702 #define VKI_SG_GET_SCSI_ID 0x2276   /* Yields fd's bus, chan, dev, lun + type */
1703
1704 #define VKI_SG_GET_SG_TABLESIZE 0x227F  /* 0 implies can't do scatter gather */
1705
1706 #define VKI_SG_GET_VERSION_NUM 0x2282 /* Example: version 2.1.34 yields 20134 */
1707
1708 #define VKI_SG_IO 0x2285   /* similar effect as write() followed by read() */
1709
1710 #define VKI_SG_SET_TIMEOUT 0x2201  /* unit: jiffies (10ms on i386) */
1711 #define VKI_SG_GET_TIMEOUT 0x2202  /* yield timeout as _return_ value */
1712
1713 //#define SG_GET_COMMAND_Q 0x2270   /* Yields 0 (queuing off) or 1 (on) */
1714 #define VKI_SG_SET_COMMAND_Q 0x2271   /* Change queuing state with 0 or 1 */
1715
1716 //----------------------------------------------------------------------
1717 // From linux-2.6.8.1/include/linux/cdrom.h
1718 //----------------------------------------------------------------------
1719
1720 #define VKI_CDROMPLAYMSF        0x5303 /* Play Audio MSF (struct cdrom_msf) */
1721 #define VKI_CDROMREADTOCHDR     0x5305 /* Read TOC header
1722                                            (struct cdrom_tochdr) */
1723 #define VKI_CDROMREADTOCENTRY   0x5306 /* Read TOC entry
1724                                            (struct cdrom_tocentry) */
1725 #define VKI_CDROMSUBCHNL        0x530b /* Read subchannel data
1726                                            (struct cdrom_subchnl) */
1727 #define VKI_CDROMREADMODE2      0x530c /* Read CDROM mode 2 data (2336 Bytes)
1728                                            (struct cdrom_read) */
1729 #define VKI_CDROMREADAUDIO      0x530e /* (struct cdrom_read_audio) */
1730 #define VKI_CDROMMULTISESSION   0x5310 /* Obtain the start-of-last-session
1731                                            address of multi session disks
1732                                            (struct cdrom_multisession) */
1733 #define VKI_CDROM_GET_MCN       0x5311 /* Obtain the "Universal Product Code"
1734                                            if available (struct cdrom_mcn) */
1735 #define VKI_CDROMVOLREAD        0x5313 /* Get the drive's volume setting
1736                                           (struct cdrom_volctrl) */
1737 #define VKI_CDROMREADRAW        0x5314  /* read data in raw mode (2352 Bytes)
1738                                            (struct cdrom_read) */
1739 #define VKI_CDROM_CLEAR_OPTIONS 0x5321  /* Clear behavior options */
1740 #define VKI_CDROM_DRIVE_STATUS  0x5326  /* Get tray position, etc. */
1741
1742 #define VKI_CDROM_SEND_PACKET   0x5393  /* send a packet to the drive */
1743
1744 struct vki_cdrom_msf0
1745 {
1746         __vki_u8        minute;
1747         __vki_u8        second;
1748         __vki_u8        frame;
1749 };
1750
1751 union vki_cdrom_addr
1752 {
1753         struct vki_cdrom_msf0   msf;
1754         int                     lba;
1755 };
1756
1757 struct vki_cdrom_msf
1758 {
1759         __vki_u8        cdmsf_min0;     /* start minute */
1760         __vki_u8        cdmsf_sec0;     /* start second */
1761         __vki_u8        cdmsf_frame0;   /* start frame */
1762         __vki_u8        cdmsf_min1;     /* end minute */
1763         __vki_u8        cdmsf_sec1;     /* end second */
1764         __vki_u8        cdmsf_frame1;   /* end frame */
1765 };
1766
1767 struct vki_cdrom_tochdr
1768 {
1769         __vki_u8        cdth_trk0;      /* start track */
1770         __vki_u8        cdth_trk1;      /* end track */
1771 };
1772
1773 struct vki_cdrom_volctrl
1774 {
1775         __vki_u8        channel0;
1776         __vki_u8        channel1;
1777         __vki_u8        channel2;
1778         __vki_u8        channel3;
1779 };
1780
1781 struct vki_cdrom_subchnl
1782 {
1783         __vki_u8        cdsc_format;
1784         __vki_u8        cdsc_audiostatus;
1785         __vki_u8        cdsc_adr:       4;
1786         __vki_u8        cdsc_ctrl:      4;
1787         __vki_u8        cdsc_trk;
1788         __vki_u8        cdsc_ind;
1789         union vki_cdrom_addr cdsc_absaddr;
1790         union vki_cdrom_addr cdsc_reladdr;
1791 };
1792
1793 struct vki_cdrom_tocentry
1794 {
1795         __vki_u8        cdte_track;
1796         __vki_u8        cdte_adr        :4;
1797         __vki_u8        cdte_ctrl       :4;
1798         __vki_u8        cdte_format;
1799         union vki_cdrom_addr cdte_addr;
1800         __vki_u8        cdte_datamode;
1801 };
1802
1803 struct vki_cdrom_read
1804 {
1805         int     cdread_lba;
1806         char    *cdread_bufaddr;
1807         int     cdread_buflen;
1808 };
1809
1810 struct vki_cdrom_read_audio
1811 {
1812         union vki_cdrom_addr addr; /* frame address */
1813         __vki_u8 addr_format;      /* CDROM_LBA or CDROM_MSF */
1814         int nframes;           /* number of 2352-byte-frames to read at once */
1815         __vki_u8 __user *buf;      /* frame buffer (size: nframes*2352 bytes) */
1816 };
1817
1818 struct vki_cdrom_multisession
1819 {
1820         union vki_cdrom_addr addr; /* frame address: start-of-last-session
1821                                    (not the new "frame 16"!).  Only valid
1822                                    if the "xa_flag" is true. */
1823         __vki_u8 xa_flag;        /* 1: "is XA disk" */
1824         __vki_u8 addr_format;    /* CDROM_LBA or CDROM_MSF */
1825 };
1826
1827 struct vki_cdrom_mcn
1828 {
1829   __vki_u8 medium_catalog_number[14]; /* 13 ASCII digits, null-terminated */
1830 };
1831
1832 #define VKI_CDROM_PACKET_SIZE   12
1833
1834 struct vki_cdrom_generic_command
1835 {
1836         unsigned char           cmd[VKI_CDROM_PACKET_SIZE];
1837         unsigned char           __user *buffer;
1838         unsigned int            buflen;
1839         int                     stat;
1840         // [[replace with void* to reduce inclusion amounts]]
1841         void/*struct vki_request_sense  */__user *sense;
1842         unsigned char           data_direction;
1843         int                     quiet;
1844         int                     timeout;
1845         void                    __user *reserved[1];    /* unused, actually */
1846 };
1847
1848 #define VKI_CD_SYNC_SIZE         12 /* 12 sync bytes per raw data frame */
1849 #define VKI_CD_HEAD_SIZE          4 /* header (address) bytes per raw data frame */
1850 #define VKI_CD_FRAMESIZE_RAW   2352 /* bytes per frame, "raw" mode */
1851 #define VKI_CD_FRAMESIZE_RAW0 (VKI_CD_FRAMESIZE_RAW-VKI_CD_SYNC_SIZE-VKI_CD_HEAD_SIZE) /*2336*/
1852
1853 //----------------------------------------------------------------------
1854 // From linux-2.6.8.1/include/linux/soundcard.h
1855 //----------------------------------------------------------------------
1856
1857 #ifndef _VKI_SIOWR
1858 #if defined(_VKI_IOWR) && (defined(_AIX) || (!defined(sun) && !defined(sparc) && !defined(__sparc__) && !defined(__INCioctlh) && !defined(__Lynx__)))
1859 /* Use already defined ioctl defines if they exist (except with Sun or Sparc) */
1860 #define _VKI_SIO                _VKI_IO
1861 #define _VKI_SIOR               _VKI_IOR
1862 #define _VKI_SIOW               _VKI_IOW
1863 #define _VKI_SIOWR              _VKI_IOWR
1864 #else
1865 // [[Valgrind: Install this case if/when necessary]
1866 #error Valgrind: Cannot handle sparc/sun case yet...
1867 #  endif /* _IOWR */
1868 #endif  /* !_VKI_SIOWR */
1869
1870 #define VKI_SNDCTL_SEQ_CTRLRATE         _VKI_SIOWR('Q', 3, int) /* Set/get timer resolution (HZ) */
1871 #define VKI_SNDCTL_SEQ_GETOUTCOUNT      _VKI_SIOR ('Q', 4, int)
1872 #define VKI_SNDCTL_SEQ_GETINCOUNT       _VKI_SIOR ('Q', 5, int)
1873 #define VKI_SNDCTL_SEQ_PERCMODE         _VKI_SIOW ('Q', 6, int)
1874 #define VKI_SNDCTL_SEQ_TESTMIDI         _VKI_SIOW ('Q', 8, int)
1875 #define VKI_SNDCTL_SEQ_RESETSAMPLES     _VKI_SIOW ('Q', 9, int)
1876 #define VKI_SNDCTL_SEQ_NRSYNTHS         _VKI_SIOR ('Q',10, int)
1877 #define VKI_SNDCTL_SEQ_NRMIDIS          _VKI_SIOR ('Q',11, int)
1878 #define VKI_SNDCTL_SEQ_GETTIME          _VKI_SIOR ('Q',19, int)
1879
1880 #define VKI_SNDCTL_TMR_TIMEBASE         _VKI_SIOWR('T', 1, int)
1881 #define VKI_SNDCTL_TMR_TEMPO            _VKI_SIOWR('T', 5, int)
1882 #define VKI_SNDCTL_TMR_SOURCE           _VKI_SIOWR('T', 6, int)
1883
1884 #define VKI_SNDCTL_MIDI_PRETIME         _VKI_SIOWR('m', 0, int)
1885 #define VKI_SNDCTL_MIDI_MPUMODE         _VKI_SIOWR('m', 1, int)
1886
1887 #define VKI_SNDCTL_DSP_RESET            _VKI_SIO  ('P', 0)
1888 #define VKI_SNDCTL_DSP_SYNC             _VKI_SIO  ('P', 1)
1889 #define VKI_SNDCTL_DSP_SPEED            _VKI_SIOWR('P', 2, int)
1890 #define VKI_SNDCTL_DSP_STEREO           _VKI_SIOWR('P', 3, int)
1891 #define VKI_SNDCTL_DSP_GETBLKSIZE       _VKI_SIOWR('P', 4, int)
1892 #define VKI_SNDCTL_DSP_CHANNELS         _VKI_SIOWR('P', 6, int)
1893 #define VKI_SOUND_PCM_WRITE_FILTER      _VKI_SIOWR('P', 7, int)
1894 #define VKI_SNDCTL_DSP_POST             _VKI_SIO  ('P', 8)
1895 #define VKI_SNDCTL_DSP_SUBDIVIDE        _VKI_SIOWR('P', 9, int)
1896 #define VKI_SNDCTL_DSP_SETFRAGMENT      _VKI_SIOWR('P',10, int)
1897
1898 #define VKI_SNDCTL_DSP_GETFMTS          _VKI_SIOR ('P',11, int) /* Returns a mask */
1899 #define VKI_SNDCTL_DSP_SETFMT           _VKI_SIOWR('P', 5, int) /* Selects ONE fmt */
1900
1901 typedef struct vki_audio_buf_info {
1902                         int fragments;  /* # of available fragments (partially usend ones not counted) */
1903                         int fragstotal; /* Total # of fragments allocated */
1904                         int fragsize;   /* Size of a fragment in bytes */
1905
1906                         int bytes;      /* Available space in bytes (includes partially used fragments) */
1907                         /* Note! 'bytes' could be more than fragments*fragsize */
1908                 } vki_audio_buf_info;
1909
1910 #define VKI_SNDCTL_DSP_GETOSPACE        _VKI_SIOR ('P',12, vki_audio_buf_info)
1911 #define VKI_SNDCTL_DSP_GETISPACE        _VKI_SIOR ('P',13, vki_audio_buf_info)
1912 #define VKI_SNDCTL_DSP_NONBLOCK         _VKI_SIO  ('P',14)
1913 #define VKI_SNDCTL_DSP_GETCAPS          _VKI_SIOR ('P',15, int)
1914
1915 #define VKI_SNDCTL_DSP_GETTRIGGER       _VKI_SIOR ('P',16, int)
1916 #define VKI_SNDCTL_DSP_SETTRIGGER       _VKI_SIOW ('P',16, int)
1917
1918 #define VKI_SNDCTL_DSP_SETSYNCRO        _VKI_SIO  ('P', 21)
1919 #define VKI_SNDCTL_DSP_SETDUPLEX        _VKI_SIO  ('P', 22)
1920 #define VKI_SNDCTL_DSP_GETODELAY        _VKI_SIOR ('P', 23, int)
1921
1922 #define VKI_SNDCTL_DSP_GETCHANNELMASK   _VKI_SIOWR('P', 64, int)
1923 #define VKI_SNDCTL_DSP_BIND_CHANNEL     _VKI_SIOWR('P', 65, int)
1924
1925 #define VKI_SNDCTL_DSP_SETSPDIF         _VKI_SIOW ('P', 66, int)
1926 #define VKI_SNDCTL_DSP_GETSPDIF         _VKI_SIOR ('P', 67, int)
1927
1928 #define VKI_SOUND_PCM_READ_RATE         _VKI_SIOR ('P', 2, int)
1929 #define VKI_SOUND_PCM_READ_CHANNELS     _VKI_SIOR ('P', 6, int)
1930 #define VKI_SOUND_PCM_READ_BITS         _VKI_SIOR ('P', 5, int)
1931 #define VKI_SOUND_PCM_READ_FILTER       _VKI_SIOR ('P', 7, int)
1932
1933
1934 //----------------------------------------------------------------------
1935 // From linux-2.6.8.1/include/linux/hdreg.h
1936 //----------------------------------------------------------------------
1937
1938 struct vki_hd_geometry {
1939       unsigned char heads;
1940       unsigned char sectors;
1941       unsigned short cylinders;
1942       unsigned long start;
1943 };
1944
1945 #define VKI_HDIO_GETGEO         0x0301  /* get device geometry */
1946 #define VKI_HDIO_GET_DMA        0x030b  /* get use-dma flag */
1947 #define VKI_HDIO_GET_IDENTITY   0x030d  /* get IDE identification info */
1948
1949 // [[Nb: done like this because the original type is a huge struct that will
1950 //   always be the same size.]]
1951 #define VKI_SIZEOF_STRUCT_HD_DRIVEID   512
1952
1953 //----------------------------------------------------------------------
1954 // From linux-2.6.8.1/include/linux/fb.h
1955 //----------------------------------------------------------------------
1956
1957 #define VKI_FBIOGET_VSCREENINFO 0x4600
1958 #define VKI_FBIOGET_FSCREENINFO 0x4602
1959
1960 struct vki_fb_fix_screeninfo {
1961         char id[16];                    /* identification string eg "TT Builtin" */
1962         unsigned long smem_start;       /* Start of frame buffer mem */
1963                                         /* (physical address) */
1964         __vki_u32 smem_len;                     /* Length of frame buffer mem */
1965         __vki_u32 type;                 /* see FB_TYPE_*                */
1966         __vki_u32 type_aux;             /* Interleave for interleaved Planes */
1967         __vki_u32 visual;               /* see FB_VISUAL_*              */
1968         __vki_u16 xpanstep;             /* zero if no hardware panning  */
1969         __vki_u16 ypanstep;             /* zero if no hardware panning  */
1970         __vki_u16 ywrapstep;            /* zero if no hardware ywrap    */
1971         __vki_u32 line_length;          /* length of a line in bytes    */
1972         unsigned long mmio_start;       /* Start of Memory Mapped I/O   */
1973                                         /* (physical address) */
1974         __vki_u32 mmio_len;             /* Length of Memory Mapped I/O  */
1975         __vki_u32 accel;                /* Indicate to driver which     */
1976                                         /*  specific chip/card we have  */
1977         __vki_u16 reserved[3];          /* Reserved for future compatibility */
1978 };
1979
1980 struct vki_fb_bitfield {
1981         __vki_u32 offset;               /* beginning of bitfield        */
1982         __vki_u32 length;               /* length of bitfield           */
1983         __vki_u32 msb_right;            /* != 0 : Most significant bit is */
1984                                         /* right */
1985 };
1986
1987 struct vki_fb_var_screeninfo {
1988         __vki_u32 xres;                 /* visible resolution           */
1989         __vki_u32 yres;
1990         __vki_u32 xres_virtual;         /* virtual resolution           */
1991         __vki_u32 yres_virtual;
1992         __vki_u32 xoffset;              /* offset from virtual to visible */
1993         __vki_u32 yoffset;              /* resolution                   */
1994
1995         __vki_u32 bits_per_pixel;       /* guess what                   */
1996         __vki_u32 grayscale;            /* != 0 Graylevels instead of colors */
1997
1998         struct vki_fb_bitfield red;     /* bitfield in fb mem if true color, */
1999         struct vki_fb_bitfield green;   /* else only length is significant */
2000         struct vki_fb_bitfield blue;
2001         struct vki_fb_bitfield transp;  /* transparency                 */
2002
2003         __vki_u32 nonstd;               /* != 0 Non standard pixel format */
2004
2005         __vki_u32 activate;             /* see FB_ACTIVATE_*            */
2006
2007         __vki_u32 height;               /* height of picture in mm    */
2008         __vki_u32 width;                /* width of picture in mm     */
2009
2010         __vki_u32 accel_flags;          /* (OBSOLETE) see fb_info.flags */
2011
2012         /* Timing: All values in pixclocks, except pixclock (of course) */
2013         __vki_u32 pixclock;             /* pixel clock in ps (pico seconds) */
2014         __vki_u32 left_margin;          /* time from sync to picture    */
2015         __vki_u32 right_margin;         /* time from picture to sync    */
2016         __vki_u32 upper_margin;         /* time from sync to picture    */
2017         __vki_u32 lower_margin;
2018         __vki_u32 hsync_len;            /* length of horizontal sync    */
2019         __vki_u32 vsync_len;            /* length of vertical sync      */
2020         __vki_u32 sync;                 /* see FB_SYNC_*                */
2021         __vki_u32 vmode;                /* see FB_VMODE_*               */
2022         __vki_u32 rotate;               /* angle we rotate counter clockwise */
2023         __vki_u32 reserved[5];          /* Reserved for future compatibility */
2024 };
2025
2026 //----------------------------------------------------------------------
2027 // From linux-2.6.9/include/linux/kd.h
2028 //----------------------------------------------------------------------
2029
2030 #define VKI_GIO_FONT       0x4B60  /* gets font in expanded form */
2031 #define VKI_PIO_FONT       0x4B61  /* use font in expanded form */
2032
2033 #define VKI_GIO_FONTX      0x4B6B  /* get font using struct consolefontdesc */
2034 #define VKI_PIO_FONTX      0x4B6C  /* set font using struct consolefontdesc */
2035 struct vki_consolefontdesc {
2036         unsigned short charcount;       /* characters in font (256 or 512) */
2037         unsigned short charheight;      /* scan lines per character (1-32) */
2038         char __user *chardata;          /* font data in expanded form */
2039 };
2040
2041 #define VKI_PIO_FONTRESET  0x4B6D  /* reset to default font */
2042
2043 #define VKI_GIO_CMAP       0x4B70  /* gets colour palette on VGA+ */
2044 #define VKI_PIO_CMAP       0x4B71  /* sets colour palette on VGA+ */
2045
2046 #define VKI_KIOCSOUND      0x4B2F  /* start sound generation (0 for off) */
2047 #define VKI_KDMKTONE       0x4B30  /* generate tone */
2048
2049 #define VKI_KDGETLED       0x4B31  /* return current led state */
2050 #define VKI_KDSETLED       0x4B32  /* set led state [lights, not flags] */
2051
2052 #define VKI_KDGKBTYPE      0x4B33  /* get keyboard type */
2053
2054 #define VKI_KDADDIO        0x4B34  /* add i/o port as valid */
2055 #define VKI_KDDELIO        0x4B35  /* del i/o port as valid */
2056 #define VKI_KDENABIO       0x4B36  /* enable i/o to video board */
2057 #define VKI_KDDISABIO      0x4B37  /* disable i/o to video board */
2058
2059 #define VKI_KDSETMODE      0x4B3A  /* set text/graphics mode */
2060 #define VKI_KDGETMODE      0x4B3B  /* get current mode */
2061
2062 #define VKI_KDMAPDISP      0x4B3C  /* map display into address space */
2063 #define VKI_KDUNMAPDISP    0x4B3D  /* unmap display from address space */
2064
2065 #define         VKI_E_TABSZ             256
2066 #define VKI_GIO_SCRNMAP    0x4B40  /* get screen mapping from kernel */
2067 #define VKI_PIO_SCRNMAP    0x4B41  /* put screen mapping table in kernel */
2068 #define VKI_GIO_UNISCRNMAP 0x4B69  /* get full Unicode screen mapping */
2069 #define VKI_PIO_UNISCRNMAP 0x4B6A  /* set full Unicode screen mapping */
2070
2071 #define VKI_GIO_UNIMAP     0x4B66  /* get unicode-to-font mapping from kernel */
2072 struct vki_unipair {
2073         unsigned short unicode;
2074         unsigned short fontpos;
2075 };
2076 struct vki_unimapdesc {
2077         unsigned short entry_ct;
2078         struct vki_unipair __user *entries;
2079 };
2080 #define VKI_PIO_UNIMAP     0x4B67  /* put unicode-to-font mapping in kernel */
2081 #define VKI_PIO_UNIMAPCLR  0x4B68  /* clear table, possibly advise hash algorithm */
2082 struct vki_unimapinit {
2083         unsigned short advised_hashsize;  /* 0 if no opinion */
2084         unsigned short advised_hashstep;  /* 0 if no opinion */
2085         unsigned short advised_hashlevel; /* 0 if no opinion */
2086 };
2087
2088 #define VKI_KDGKBMODE      0x4B44  /* gets current keyboard mode */
2089 #define VKI_KDSKBMODE      0x4B45  /* sets current keyboard mode */
2090
2091 #define VKI_KDGKBMETA      0x4B62  /* gets meta key handling mode */
2092 #define VKI_KDSKBMETA      0x4B63  /* sets meta key handling mode */
2093
2094 #define VKI_KDGKBLED       0x4B64  /* get led flags (not lights) */
2095 #define VKI_KDSKBLED       0x4B65  /* set led flags (not lights) */
2096
2097 struct vki_kbentry {
2098         unsigned char kb_table;
2099         unsigned char kb_index;
2100         unsigned short kb_value;
2101 };
2102 #define VKI_KDGKBENT       0x4B46  /* gets one entry in translation table */
2103 #define VKI_KDSKBENT       0x4B47  /* sets one entry in translation table */
2104
2105 struct vki_kbsentry {
2106         unsigned char kb_func;
2107         unsigned char kb_string[512];
2108 };
2109 #define VKI_KDGKBSENT      0x4B48  /* gets one function key string entry */
2110 #define VKI_KDSKBSENT      0x4B49  /* sets one function key string entry */
2111
2112 struct vki_kbdiacr {
2113         unsigned char diacr, base, result;
2114 };
2115 struct vki_kbdiacrs {
2116         unsigned int kb_cnt;    /* number of entries in following array */
2117         struct vki_kbdiacr kbdiacr[256];    /* MAX_DIACR from keyboard.h */
2118 };
2119 #define VKI_KDGKBDIACR     0x4B4A  /* read kernel accent table */
2120 #define VKI_KDSKBDIACR     0x4B4B  /* write kernel accent table */
2121
2122 struct vki_kbkeycode {
2123         unsigned int scancode, keycode;
2124 };
2125 #define VKI_KDGETKEYCODE   0x4B4C  /* read kernel keycode table entry */
2126 #define VKI_KDSETKEYCODE   0x4B4D  /* write kernel keycode table entry */
2127
2128 #define VKI_KDSIGACCEPT    0x4B4E  /* accept kbd generated signals */
2129
2130 struct vki_kbd_repeat {
2131         int delay;      /* in msec; <= 0: don't change */
2132         int period;     /* in msec; <= 0: don't change */
2133                         /* earlier this field was misnamed "rate" */
2134 };
2135 #define VKI_KDKBDREP       0x4B52  /* set keyboard delay/repeat rate;
2136                                     * actually used values are returned */
2137
2138 #define VKI_KDFONTOP       0x4B72  /* font operations */
2139
2140 struct vki_console_font_op {
2141         unsigned int op;        /* operation code KD_FONT_OP_* */
2142         unsigned int flags;     /* KD_FONT_FLAG_* */
2143         unsigned int width, height;     /* font size */
2144         unsigned int charcount;
2145         unsigned char __user *data;     /* font data with height fixed to 32 */
2146 };
2147
2148 #define VKI_KD_FONT_OP_SET              0       /* Set font */
2149 #define VKI_KD_FONT_OP_GET              1       /* Get font */
2150 #define VKI_KD_FONT_OP_SET_DEFAULT      2       /* Set font to default, data points to name / NULL */
2151 #define VKI_KD_FONT_OP_COPY             3       /* Copy from another console */
2152
2153 //----------------------------------------------------------------------
2154 // From linux-2.6.9/include/linux/kb.h
2155 //----------------------------------------------------------------------
2156
2157 typedef __vki_kernel_uid32_t vki_qid_t; /* Type in which we store ids in memory */
2158
2159 //----------------------------------------------------------------------
2160 // From linux-2.6.20.1/include/linux/ptrace.h
2161 //----------------------------------------------------------------------
2162
2163 #define VKI_PTRACE_TRACEME         0
2164 #define VKI_PTRACE_PEEKTEXT        1
2165 #define VKI_PTRACE_PEEKDATA        2
2166 #define VKI_PTRACE_PEEKUSR         3
2167 #define VKI_PTRACE_POKEUSR         6
2168
2169 #define VKI_PTRACE_DETACH         17
2170
2171 #define VKI_PTRACE_GETEVENTMSG  0x4201
2172 #define VKI_PTRACE_GETSIGINFO   0x4202
2173 #define VKI_PTRACE_SETSIGINFO   0x4203
2174
2175 //----------------------------------------------------------------------
2176 // From linux-2.6.14/include/sound/asound.h
2177 //----------------------------------------------------------------------
2178
2179 enum {
2180         VKI_SNDRV_PCM_IOCTL_HW_FREE = _VKI_IO('A', 0x12),
2181         VKI_SNDRV_PCM_IOCTL_HWSYNC = _VKI_IO('A', 0x22),
2182         VKI_SNDRV_PCM_IOCTL_PREPARE = _VKI_IO('A', 0x40),
2183         VKI_SNDRV_PCM_IOCTL_RESET = _VKI_IO('A', 0x41),
2184         VKI_SNDRV_PCM_IOCTL_START = _VKI_IO('A', 0x42),
2185         VKI_SNDRV_PCM_IOCTL_DROP = _VKI_IO('A', 0x43),
2186         VKI_SNDRV_PCM_IOCTL_DRAIN = _VKI_IO('A', 0x44),
2187         VKI_SNDRV_PCM_IOCTL_PAUSE = _VKI_IOW('A', 0x45, int),
2188         VKI_SNDRV_PCM_IOCTL_RESUME = _VKI_IO('A', 0x47),
2189         VKI_SNDRV_PCM_IOCTL_XRUN = _VKI_IO('A', 0x48),
2190         VKI_SNDRV_PCM_IOCTL_LINK = _VKI_IOW('A', 0x60, int),
2191         VKI_SNDRV_PCM_IOCTL_UNLINK = _VKI_IO('A', 0x61),
2192 };
2193
2194 enum {
2195         VKI_SNDRV_TIMER_IOCTL_START = _VKI_IO('T', 0xa0),
2196         VKI_SNDRV_TIMER_IOCTL_STOP = _VKI_IO('T', 0xa1),
2197         VKI_SNDRV_TIMER_IOCTL_CONTINUE = _VKI_IO('T', 0xa2),
2198         VKI_SNDRV_TIMER_IOCTL_PAUSE = _VKI_IO('T', 0xa3),
2199 };
2200
2201 //----------------------------------------------------------------------
2202 // From linux-2.6.15.4/include/linux/serial.h
2203 //----------------------------------------------------------------------
2204
2205 struct vki_serial_icounter_struct {
2206         int cts, dsr, rng, dcd;
2207         int rx, tx;
2208         int frame, overrun, parity, brk;
2209         int buf_overrun;
2210         int reserved[9];
2211 };
2212
2213 //----------------------------------------------------------------------
2214 // From linux-2.6.16/include/linux/vt.h
2215 //----------------------------------------------------------------------
2216
2217 #define VKI_VT_OPENQRY  0x5600  /* find available vt */
2218
2219 struct vki_vt_mode {
2220         char mode;              /* vt mode */
2221         char waitv;             /* if set, hang on writes if not active */
2222         short relsig;           /* signal to raise on release req */
2223         short acqsig;           /* signal to raise on acquisition */
2224         short frsig;            /* unused (set to 0) */
2225 };
2226 #define VKI_VT_GETMODE  0x5601  /* get mode of active vt */
2227 #define VKI_VT_SETMODE  0x5602  /* set mode of active vt */
2228
2229 struct vki_vt_stat {
2230         unsigned short v_active;        /* active vt */
2231         unsigned short v_signal;        /* signal to send */
2232         unsigned short v_state;         /* vt bitmask */
2233 };
2234 #define VKI_VT_GETSTATE 0x5603  /* get global vt state info */
2235 #define VKI_VT_SENDSIG  0x5604  /* signal to send to bitmask of vts */
2236
2237 #define VKI_VT_RELDISP  0x5605  /* release display */
2238
2239 #define VKI_VT_ACTIVATE 0x5606  /* make vt active */
2240 #define VKI_VT_WAITACTIVE       0x5607  /* wait for vt active */
2241 #define VKI_VT_DISALLOCATE      0x5608  /* free memory associated to vt */
2242
2243 struct vki_vt_sizes {
2244         unsigned short v_rows;          /* number of rows */
2245         unsigned short v_cols;          /* number of columns */
2246         unsigned short v_scrollsize;    /* number of lines of scrollback */
2247 };
2248 #define VKI_VT_RESIZE   0x5609  /* set kernel's idea of screensize */
2249
2250 struct vki_vt_consize {
2251         unsigned short v_rows;  /* number of rows */
2252         unsigned short v_cols;  /* number of columns */
2253         unsigned short v_vlin;  /* number of pixel rows on screen */
2254         unsigned short v_clin;  /* number of pixel rows per character */
2255         unsigned short v_vcol;  /* number of pixel columns on screen */
2256         unsigned short v_ccol;  /* number of pixel columns per character */
2257 };
2258 #define VKI_VT_RESIZEX      0x560A  /* set kernel's idea of screensize + more */
2259 #define VKI_VT_LOCKSWITCH   0x560B  /* disallow vt switching */
2260 #define VKI_VT_UNLOCKSWITCH 0x560C  /* allow vt switching */
2261
2262 //----------------------------------------------------------------------
2263 // From linux-2.6.19/include/linux/prctl.h
2264 //----------------------------------------------------------------------
2265
2266 #define VKI_PR_SET_PDEATHSIG  1  /* Second arg is a signal */
2267 #define VKI_PR_GET_PDEATHSIG  2  /* Second arg is a ptr to return the signal */
2268
2269 #define VKI_PR_GET_DUMPABLE   3
2270 #define VKI_PR_SET_DUMPABLE   4
2271
2272 #define VKI_PR_GET_UNALIGN        5
2273 #define VKI_PR_SET_UNALIGN        6
2274 # define VKI_PR_UNALIGN_NOPRINT 1       /* silently fix up unaligned user accesses */
2275 # define VKI_PR_UNALIGN_SIGBUS  2       /* generate SIGBUS on unaligned user access */
2276
2277 #define VKI_PR_GET_KEEPCAPS   7
2278 #define VKI_PR_SET_KEEPCAPS   8
2279
2280 #define VKI_PR_GET_FPEMU  9
2281 #define VKI_PR_SET_FPEMU 10
2282 # define VKI_PR_FPEMU_NOPRINT   1       /* silently emulate fp operations accesses */
2283 # define VKI_PR_FPEMU_SIGFPE    2       /* don't emulate fp operations, send SIGFPE instead */
2284
2285 #define VKI_PR_GET_FPEXC        11
2286 #define VKI_PR_SET_FPEXC        12
2287 # define VKI_PR_FP_EXC_SW_ENABLE        0x80    /* Use FPEXC for FP exception enables */
2288 # define VKI_PR_FP_EXC_DIV              0x010000        /* floating point divide by zero */
2289 # define VKI_PR_FP_EXC_OVF              0x020000        /* floating point overflow */
2290 # define VKI_PR_FP_EXC_UND              0x040000        /* floating point underflow */
2291 # define VKI_PR_FP_EXC_RES              0x080000        /* floating point inexact result */
2292 # define VKI_PR_FP_EXC_INV              0x100000        /* floating point invalid operation */
2293 # define VKI_PR_FP_EXC_DISABLED 0       /* FP exceptions disabled */
2294 # define VKI_PR_FP_EXC_NONRECOV 1       /* async non-recoverable exc. mode */
2295 # define VKI_PR_FP_EXC_ASYNC    2       /* async recoverable exception mode */
2296 # define VKI_PR_FP_EXC_PRECISE  3       /* precise exception mode */
2297
2298 #define VKI_PR_GET_TIMING   13
2299 #define VKI_PR_SET_TIMING   14
2300 # define VKI_PR_TIMING_STATISTICAL  0       /* Normal, traditional,
2301                                                    statistical process timing */
2302 # define VKI_PR_TIMING_TIMESTAMP    1       /* Accurate timestamp based
2303                                                    process timing */
2304
2305 #define VKI_PR_SET_NAME    15           /* Set process name */
2306 #define VKI_PR_GET_NAME    16           /* Get process name */
2307
2308 #define VKI_PR_GET_ENDIAN       19
2309 #define VKI_PR_SET_ENDIAN       20
2310 # define VKI_PR_ENDIAN_BIG              0
2311 # define VKI_PR_ENDIAN_LITTLE   1       /* True little endian mode */
2312 # define VKI_PR_ENDIAN_PPC_LITTLE       2       /* "PowerPC" pseudo little endian */
2313
2314 //----------------------------------------------------------------------
2315 // From linux-2.6.19/include/linux/usbdevice_fs.h
2316 //----------------------------------------------------------------------
2317
2318 struct vki_usbdevfs_ctrltransfer {
2319         __vki_u8 bRequestType;
2320         __vki_u8 bRequest;
2321         __vki_u16 wValue;
2322         __vki_u16 wIndex;
2323         __vki_u16 wLength;
2324         __vki_u32 timeout;  /* in milliseconds */
2325         void __user *data;
2326 };
2327
2328 struct vki_usbdevfs_bulktransfer {
2329         unsigned int ep;
2330         unsigned int len;
2331         unsigned int timeout; /* in milliseconds */
2332         void __user *data;
2333 };
2334
2335 #define VKI_USBDEVFS_MAXDRIVERNAME 255
2336
2337 struct vki_usbdevfs_getdriver {
2338         unsigned int interface;
2339         char driver[VKI_USBDEVFS_MAXDRIVERNAME + 1];
2340 };
2341
2342 struct vki_usbdevfs_connectinfo {
2343         unsigned int devnum;
2344         unsigned char slow;
2345 };
2346
2347 struct vki_usbdevfs_iso_packet_desc {
2348         unsigned int length;
2349         unsigned int actual_length;
2350         unsigned int status;
2351 };
2352
2353 struct vki_usbdevfs_urb {
2354         unsigned char type;
2355         unsigned char endpoint;
2356         int status;
2357         unsigned int flags;
2358         void __user *buffer;
2359         int buffer_length;
2360         int actual_length;
2361         int start_frame;
2362         int number_of_packets;
2363         int error_count;
2364         unsigned int signr;  /* signal to be sent on error, -1 if none should be sent */
2365         void *usercontext;
2366         struct vki_usbdevfs_iso_packet_desc iso_frame_desc[0];
2367 };
2368
2369 struct vki_usbdevfs_ioctl {
2370         int     ifno;           /* interface 0..N ; negative numbers reserved */
2371         int     ioctl_code;     /* MUST encode size + direction of data so the
2372                                  * macros in <asm/ioctl.h> give correct values */
2373         void __user *data;      /* param buffer (in, or out) */
2374 };
2375
2376 #define VKI_USBDEVFS_CONTROL           _VKI_IOWR('U', 0, struct vki_usbdevfs_ctrltransfer)
2377 #define VKI_USBDEVFS_BULK              _VKI_IOWR('U', 2, struct vki_usbdevfs_bulktransfer)
2378 #define VKI_USBDEVFS_GETDRIVER         _VKI_IOW('U', 8, struct vki_usbdevfs_getdriver)
2379 #define VKI_USBDEVFS_SUBMITURB         _VKI_IOR('U', 10, struct vki_usbdevfs_urb)
2380 #define VKI_USBDEVFS_DISCARDURB        _VKI_IO('U', 11)
2381 #define VKI_USBDEVFS_REAPURB           _VKI_IOW('U', 12, void *)
2382 #define VKI_USBDEVFS_REAPURBNDELAY     _VKI_IOW('U', 13, void *)
2383 #define VKI_USBDEVFS_CONNECTINFO       _VKI_IOW('U', 17, struct vki_usbdevfs_connectinfo)
2384 #define VKI_USBDEVFS_IOCTL             _VKI_IOWR('U', 18, struct vki_usbdevfs_ioctl)
2385
2386 #define VKI_USBDEVFS_URB_TYPE_ISO              0
2387 #define VKI_USBDEVFS_URB_TYPE_INTERRUPT        1
2388 #define VKI_USBDEVFS_URB_TYPE_CONTROL          2
2389 #define VKI_USBDEVFS_URB_TYPE_BULK             3
2390
2391 // [[this is missing in usbdevice_fs.h]]
2392 struct vki_usbdevfs_setuppacket {
2393        __vki_u8 bRequestType;
2394        __vki_u8 bRequest;
2395        __vki_u16 wValue;
2396        __vki_u16 wIndex;
2397        __vki_u16 wLength;
2398 };
2399
2400 //----------------------------------------------------------------------
2401 // From linux-2.6.20.1/include/linux/i2c.h
2402 //----------------------------------------------------------------------
2403
2404 #define VKI_I2C_SLAVE           0x0703  /* Change slave address                 */
2405                                         /* Attn.: Slave address is 7 or 10 bits */
2406 #define VKI_I2C_SLAVE_FORCE     0x0706  /* Change slave address                 */
2407                                         /* Attn.: Slave address is 7 or 10 bits */
2408                                         /* This changes the address, even if it */
2409                                         /* is already taken!                    */
2410 #define VKI_I2C_TENBIT          0x0704  /* 0 for 7 bit addrs, != 0 for 10 bit   */
2411 #define VKI_I2C_FUNCS           0x0705  /* Get the adapter functionality */
2412 #define VKI_I2C_PEC             0x0708  /* != 0 for SMBus PEC                   */
2413
2414 //----------------------------------------------------------------------
2415 // From linux-2.6.20.1/include/linux/keyctl.h
2416 //----------------------------------------------------------------------
2417
2418 /* keyctl commands */
2419 #define VKI_KEYCTL_GET_KEYRING_ID       0       /* ask for a keyring's ID */
2420 #define VKI_KEYCTL_JOIN_SESSION_KEYRING 1       /* join or start named session keyring */
2421 #define VKI_KEYCTL_UPDATE               2       /* update a key */
2422 #define VKI_KEYCTL_REVOKE               3       /* revoke a key */
2423 #define VKI_KEYCTL_CHOWN                4       /* set ownership of a key */
2424 #define VKI_KEYCTL_SETPERM              5       /* set perms on a key */
2425 #define VKI_KEYCTL_DESCRIBE             6       /* describe a key */
2426 #define VKI_KEYCTL_CLEAR                7       /* clear contents of a keyring */
2427 #define VKI_KEYCTL_LINK                 8       /* link a key into a keyring */
2428 #define VKI_KEYCTL_UNLINK               9       /* unlink a key from a keyring */
2429 #define VKI_KEYCTL_SEARCH               10      /* search for a key in a keyring */
2430 #define VKI_KEYCTL_READ                 11      /* read a key or keyring's contents */
2431 #define VKI_KEYCTL_INSTANTIATE          12      /* instantiate a partially constructed key */
2432 #define VKI_KEYCTL_NEGATE               13      /* negate a partially constructed key */
2433 #define VKI_KEYCTL_SET_REQKEY_KEYRING   14      /* set default request-key keyring */
2434 #define VKI_KEYCTL_SET_TIMEOUT          15      /* set key timeout */
2435 #define VKI_KEYCTL_ASSUME_AUTHORITY     16      /* assume request_key() authorisation */
2436
2437 /*--------------------------------------------------------------------*/
2438 // From linux-2.6.20.1/include/linux/key.h
2439 /*--------------------------------------------------------------------*/
2440
2441 /* key handle serial number */
2442 typedef vki_int32_t vki_key_serial_t;
2443
2444 /* key handle permissions mask */
2445 typedef vki_uint32_t vki_key_perm_t;
2446
2447 //----------------------------------------------------------------------
2448 // From linux-2.6.24.7/include/linux/wireless.h
2449 // (wireless extensions version 22, 2007-03-16)
2450 //----------------------------------------------------------------------
2451
2452 /*
2453  * [[Wireless extensions ioctls.]]
2454  */
2455
2456 /* Wireless Identification */
2457 #define VKI_SIOCSIWCOMMIT       0x8B00  /* Commit pending changes to driver */
2458 #define VKI_SIOCGIWNAME         0x8B01  /* get name == wireless protocol */
2459
2460 /* Basic operations */
2461 #define VKI_SIOCSIWNWID         0x8B02  /* set network id (pre-802.11) */
2462 #define VKI_SIOCGIWNWID         0x8B03  /* get network id (the cell) */
2463 #define VKI_SIOCSIWFREQ         0x8B04  /* set channel/frequency (Hz) */
2464 #define VKI_SIOCGIWFREQ         0x8B05  /* get channel/frequency (Hz) */
2465 #define VKI_SIOCSIWMODE         0x8B06  /* set operation mode */
2466 #define VKI_SIOCGIWMODE         0x8B07  /* get operation mode */
2467 #define VKI_SIOCSIWSENS         0x8B08  /* set sensitivity (dBm) */
2468 #define VKI_SIOCGIWSENS         0x8B09  /* get sensitivity (dBm) */
2469
2470 /* Informative stuff */
2471 #define VKI_SIOCSIWRANGE        0x8B0A  /* Unused */
2472 #define VKI_SIOCGIWRANGE        0x8B0B  /* Get range of parameters */
2473 #define VKI_SIOCSIWPRIV         0x8B0C  /* Unused */
2474 #define VKI_SIOCGIWPRIV         0x8B0D  /* get private ioctl interface info */
2475 #define VKI_SIOCSIWSTATS        0x8B0E  /* Unused */
2476 #define VKI_SIOCGIWSTATS        0x8B0F  /* Get /proc/net/wireless stats */
2477
2478 /* Spy support (statistics per MAC address - used for Mobile IP support) */
2479 #define VKI_SIOCSIWSPY          0x8B10  /* set spy addresses */
2480 #define VKI_SIOCGIWSPY          0x8B11  /* get spy info (quality of link) */
2481 #define VKI_SIOCSIWTHRSPY       0x8B12  /* set spy threshold (spy event) */
2482 #define VKI_SIOCGIWTHRSPY       0x8B13  /* get spy threshold */
2483
2484 /* Access Point manipulation */
2485 #define VKI_SIOCSIWAP           0x8B14  /* set access point MAC addresses */
2486 #define VKI_SIOCGIWAP           0x8B15  /* get access point MAC addresses */
2487 #define VKI_SIOCGIWAPLIST       0x8B17  /* Deprecated in favor of scanning */
2488 #define VKI_SIOCSIWSCAN         0x8B18  /* trigger scanning (list cells) */
2489 #define VKI_SIOCGIWSCAN         0x8B19  /* get scanning results */
2490
2491 /* 802.11 specific support */
2492 #define VKI_SIOCSIWESSID        0x8B1A  /* set ESSID (network name) */
2493 #define VKI_SIOCGIWESSID        0x8B1B  /* get ESSID */
2494 #define VKI_SIOCSIWNICKN        0x8B1C  /* set node name/nickname */
2495 #define VKI_SIOCGIWNICKN        0x8B1D  /* get node name/nickname */
2496
2497 /* Other parameters useful in 802.11 and some other devices */
2498 #define VKI_SIOCSIWRATE         0x8B20  /* set default bit rate (bps) */
2499 #define VKI_SIOCGIWRATE         0x8B21  /* get default bit rate (bps) */
2500 #define VKI_SIOCSIWRTS          0x8B22  /* set RTS/CTS threshold (bytes) */
2501 #define VKI_SIOCGIWRTS          0x8B23  /* get RTS/CTS threshold (bytes) */
2502 #define VKI_SIOCSIWFRAG         0x8B24  /* set fragmentation thr (bytes) */
2503 #define VKI_SIOCGIWFRAG         0x8B25  /* get fragmentation thr (bytes) */
2504 #define VKI_SIOCSIWTXPOW        0x8B26  /* set transmit power (dBm) */
2505 #define VKI_SIOCGIWTXPOW        0x8B27  /* get transmit power (dBm) */
2506 #define VKI_SIOCSIWRETRY        0x8B28  /* set retry limits and lifetime */
2507 #define VKI_SIOCGIWRETRY        0x8B29  /* get retry limits and lifetime */
2508
2509 /* Encoding stuff (scrambling, hardware security, WEP...) */
2510 #define VKI_SIOCSIWENCODE       0x8B2A  /* set encoding token & mode */
2511 #define VKI_SIOCGIWENCODE       0x8B2B  /* get encoding token & mode */
2512
2513 /* Power saving stuff (power management, unicast and multicast) */
2514 #define VKI_SIOCSIWPOWER        0x8B2C  /* set Power Management settings */
2515 #define VKI_SIOCGIWPOWER        0x8B2D  /* get Power Management settings */
2516
2517 /* WPA : Generic IEEE 802.11 informatiom element (e.g., for WPA/RSN/WMM). */
2518 #define VKI_SIOCSIWGENIE        0x8B30          /* set generic IE */
2519 #define VKI_SIOCGIWGENIE        0x8B31          /* get generic IE */
2520
2521 /* WPA : IEEE 802.11 MLME requests */
2522 #define VKI_SIOCSIWMLME         0x8B16  /* request MLME operation; uses
2523                                          * struct iw_mlme */
2524 /* WPA : Authentication mode parameters */
2525 #define VKI_SIOCSIWAUTH         0x8B32  /* set authentication mode params */
2526 #define VKI_SIOCGIWAUTH         0x8B33  /* get authentication mode params */
2527
2528 /* WPA : Extended version of encoding configuration */
2529 #define VKI_SIOCSIWENCODEEXT    0x8B34  /* set encoding token & mode */
2530 #define VKI_SIOCGIWENCODEEXT    0x8B35  /* get encoding token & mode */
2531
2532 /* WPA2 : PMKSA cache management */
2533 #define VKI_SIOCSIWPMKSA        0x8B36  /* PMKSA cache operation */
2534
2535 /*
2536  * [[Payload for the wireless extensions ioctls.]]
2537  */
2538
2539 struct  vki_iw_param
2540 {
2541   __vki_s32     value;          /* The value of the parameter itself */
2542   __vki_u8      fixed;          /* Hardware should not use auto select */
2543   __vki_u8      disabled;       /* Disable the feature */
2544   __vki_u16     flags;          /* Various specifc flags (if any) */
2545 };
2546
2547 struct  vki_iw_point
2548 {
2549   void __user   *pointer;       /* Pointer to the data  (in user space) */
2550   __vki_u16     length;         /* number of fields or size in bytes */
2551   __vki_u16     flags;          /* Optional params */
2552 };
2553
2554 struct  vki_iw_freq
2555 {
2556         __vki_s32       m;              /* Mantissa */
2557         __vki_s16       e;              /* Exponent */
2558         __vki_u8        i;              /* List index (when in range struct) */
2559         __vki_u8        flags;          /* Flags (fixed/auto) */
2560 };
2561
2562 struct  vki_iw_quality
2563 {
2564         __vki_u8        qual;           /* link quality (%retries, SNR,
2565                                            %missed beacons or better...) */
2566         __vki_u8        level;          /* signal level (dBm) */
2567         __vki_u8        noise;          /* noise level (dBm) */
2568         __vki_u8        updated;        /* Flags to know if updated */
2569 };
2570
2571 union   vki_iwreq_data
2572 {
2573         /* Config - generic */
2574         char            name[VKI_IFNAMSIZ];
2575         /* Name : used to verify the presence of  wireless extensions.
2576          * Name of the protocol/provider... */
2577
2578         struct vki_iw_point     essid;  /* Extended network name */
2579         struct vki_iw_param     nwid;   /* network id (or domain - the cell) */
2580         struct vki_iw_freq      freq;   /* frequency or channel :
2581                                          * 0-1000 = channel
2582                                          * > 1000 = frequency in Hz */
2583
2584         struct vki_iw_param     sens;   /* signal level threshold */
2585         struct vki_iw_param     bitrate;/* default bit rate */
2586         struct vki_iw_param     txpower;/* default transmit power */
2587         struct vki_iw_param     rts;    /* RTS threshold threshold */
2588         struct vki_iw_param     frag;   /* Fragmentation threshold */
2589         __vki_u32               mode;   /* Operation mode */
2590         struct vki_iw_param     retry;  /* Retry limits & lifetime */
2591
2592         struct vki_iw_point     encoding; /* Encoding stuff : tokens */
2593         struct vki_iw_param     power;  /* PM duration/timeout */
2594         struct vki_iw_quality   qual;   /* Quality part of statistics */
2595
2596         struct vki_sockaddr ap_addr;    /* Access point address */
2597         struct vki_sockaddr addr;       /* Destination address (hw/mac) */
2598
2599         struct vki_iw_param     param;  /* Other small parameters */
2600         struct vki_iw_point     data;   /* Other large parameters */
2601 };
2602
2603 struct  vki_iwreq
2604 {
2605         union
2606         {
2607                 char ifrn_name[VKI_IFNAMSIZ];   /* if name, e.g. "eth0" */
2608         } ifr_ifrn;
2609
2610         /* Data part (defined just above) */
2611         union   vki_iwreq_data  u;
2612 };
2613
2614 /*--------------------------------------------------------------------*/
2615 // From linux-2.6.31.5/include/linux/perf_counter.h
2616 /*--------------------------------------------------------------------*/
2617
2618 struct vki_perf_counter_attr {
2619
2620         /*
2621          * Major type: hardware/software/tracepoint/etc.
2622          */
2623         __vki_u32                       type;
2624
2625         /*
2626          * Size of the attr structure, for fwd/bwd compat.
2627          */
2628         __vki_u32                       size;
2629
2630         /*
2631          * Type specific configuration information.
2632          */
2633         __vki_u64                       config;
2634
2635         union {
2636                 __vki_u64               sample_period;
2637                 __vki_u64               sample_freq;
2638         };
2639
2640         __vki_u64                       sample_type;
2641         __vki_u64                       read_format;
2642
2643         __vki_u64                       disabled       :  1, /* off by default        */
2644                                         inherit        :  1, /* children inherit it   */
2645                                         pinned         :  1, /* must always be on PMU */
2646                                         exclusive      :  1, /* only group on PMU     */
2647                                         exclude_user   :  1, /* don't count user      */
2648                                         exclude_kernel :  1, /* ditto kernel          */
2649                                         exclude_hv     :  1, /* ditto hypervisor      */
2650                                         exclude_idle   :  1, /* don't count when idle */
2651                                         mmap           :  1, /* include mmap data     */
2652                                         comm           :  1, /* include comm data     */
2653                                         freq           :  1, /* use freq, not period  */
2654                                         inherit_stat   :  1, /* per task counts       */
2655                                         enable_on_exec :  1, /* next exec enables     */
2656                                         task           :  1, /* trace fork/exit       */
2657
2658                                         __reserved_1   : 50;
2659
2660         __vki_u32                       wakeup_events;  /* wakeup every n events */
2661         __vki_u32                       __reserved_2;
2662
2663         __vki_u64                       __reserved_3;
2664 };
2665
2666 /*--------------------------------------------------------------------*/
2667 // From linux-2.6.32.4/include/linux/getcpu.h
2668 /*--------------------------------------------------------------------*/
2669
2670 struct vki_getcpu_cache {
2671         unsigned long blob[128 / sizeof(long)];
2672 };
2673
2674 //----------------------------------------------------------------------
2675 // From linux-2.6.33.3/include/linux/input.h
2676 //----------------------------------------------------------------------
2677
2678 /*
2679  * IOCTLs (0x00 - 0x7f)
2680  */
2681
2682 #define VKI_EVIOCGNAME(len)     _VKI_IOC(_VKI_IOC_READ, 'E', 0x06, len)         /* get device name */
2683 #define VKI_EVIOCGPHYS(len)     _VKI_IOC(_VKI_IOC_READ, 'E', 0x07, len)         /* get physical location */
2684 #define VKI_EVIOCGUNIQ(len)     _VKI_IOC(_VKI_IOC_READ, 'E', 0x08, len)         /* get unique identifier */
2685
2686 #define VKI_EVIOCGKEY(len)      _VKI_IOC(_VKI_IOC_READ, 'E', 0x18, len)         /* get global keystate */
2687 #define VKI_EVIOCGLED(len)      _VKI_IOC(_VKI_IOC_READ, 'E', 0x19, len)         /* get all LEDs */
2688 #define VKI_EVIOCGSND(len)      _VKI_IOC(_VKI_IOC_READ, 'E', 0x1a, len)         /* get all sounds status */
2689 #define VKI_EVIOCGSW(len)       _VKI_IOC(_VKI_IOC_READ, 'E', 0x1b, len)         /* get all switch states */
2690
2691 #define VKI_EVIOCGBIT(ev,len)   _VKI_IOC(_VKI_IOC_READ, 'E', 0x20 + ev, len)    /* get event bits */
2692
2693 /*
2694  * Event types
2695  */
2696
2697 #define VKI_EV_SYN              0x00
2698 #define VKI_EV_KEY              0x01
2699 #define VKI_EV_REL              0x02
2700 #define VKI_EV_ABS              0x03
2701 #define VKI_EV_MSC              0x04
2702 #define VKI_EV_SW               0x05
2703 #define VKI_EV_LED              0x11
2704 #define VKI_EV_SND              0x12
2705 #define VKI_EV_REP              0x14
2706 #define VKI_EV_FF               0x15
2707 #define VKI_EV_PWR              0x16
2708 #define VKI_EV_FF_STATUS        0x17
2709 #define VKI_EV_MAX              0x1f
2710 #define VKI_EV_CNT              (VKI_EV_MAX+1)
2711
2712 #endif // __VKI_LINUX_H
2713
2714 /*--------------------------------------------------------------------*/
2715 /*--- end                                                          ---*/
2716 /*--------------------------------------------------------------------*/