• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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-2015 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_ppc64be) || defined(VGA_ppc64le)
89  #  include "vki-posixtypes-ppc64-linux.h"
90  #elif defined(VGA_arm)
91  #  include "vki-posixtypes-arm-linux.h"
92  #elif defined(VGA_arm64)
93  #  include "vki-posixtypes-arm64-linux.h"
94  #elif defined(VGA_s390x)
95  #  include "vki-posixtypes-s390x-linux.h"
96  #elif defined(VGA_mips32)
97  #  include "vki-posixtypes-mips32-linux.h"
98  #elif defined(VGA_mips64)
99  #  include "vki-posixtypes-mips64-linux.h"
100  #elif defined(VGA_tilegx)
101  #  include "vki-posixtypes-tilegx-linux.h"
102  #else
103  #  error Unknown platform
104  #endif
105  
106  //----------------------------------------------------------------------
107  // VKI_STATIC_ASSERT(). Inspired by BUILD_BUG_ON() from
108  // linux-2.6.34/include/linux/kernel.h
109  //----------------------------------------------------------------------
110  
111  /*
112   * Evaluates to zero if 'expr' is true and forces a compilation error if
113   * 'expr' is false. Can be used in a context where no comma expressions
114   * are allowed.
115   */
116  #ifdef __cplusplus
117  template <bool b> struct vki_static_assert { int m_bitfield:(2*b-1); };
118  #define VKI_STATIC_ASSERT(expr)                         \
119      (sizeof(vki_static_assert<(expr)>) - sizeof(int))
120  #else
121  #define VKI_STATIC_ASSERT(expr) (sizeof(struct { int:-!(expr); }))
122  #endif
123  
124  //----------------------------------------------------------------------
125  // Based on _IOC_TYPECHECK() from linux-2.6.34/asm-generic/ioctl.h
126  //----------------------------------------------------------------------
127  
128  /* provoke compile error for invalid uses of size argument */
129  #define _VKI_IOC_TYPECHECK(t)                                           \
130      (VKI_STATIC_ASSERT((sizeof(t) == sizeof(t[1])                       \
131                          && sizeof(t) < (1 << _VKI_IOC_SIZEBITS)))       \
132       + sizeof(t))
133  
134  //----------------------------------------------------------------------
135  // From linux-2.6.8.1/include/linux/compiler.h
136  //----------------------------------------------------------------------
137  
138  # define __user
139  
140  //----------------------------------------------------------------------
141  // From linux/include/linux/compiler-gcc.h
142  //----------------------------------------------------------------------
143  
144  #ifdef __GNUC__
145  #define __vki_packed			__attribute__((packed))
146  #endif
147  
148  //----------------------------------------------------------------------
149  // From linux-2.6.8.1/include/linux/posix_types.h
150  //----------------------------------------------------------------------
151  
152  #undef __VKI_NFDBITS
153  #define __VKI_NFDBITS	(8 * sizeof(unsigned long))
154  
155  #undef __VKI_FD_SETSIZE
156  #define __VKI_FD_SETSIZE	1024
157  
158  #undef __VKI_FDSET_LONGS
159  #define __VKI_FDSET_LONGS	(__VKI_FD_SETSIZE/__VKI_NFDBITS)
160  
161  #undef __VKI_FDELT
162  #define	__VKI_FDELT(d)	((d) / __VKI_NFDBITS)
163  
164  #undef __VKI_FDMASK
165  #define	__VKI_FDMASK(d)	(1UL << ((d) % __VKI_NFDBITS))
166  
167  typedef struct {
168  	unsigned long fds_bits [__VKI_FDSET_LONGS];
169  } __vki_kernel_fd_set;
170  
171  typedef int __vki_kernel_key_t;
172  typedef int __vki_kernel_mqd_t;
173  
174  //----------------------------------------------------------------------
175  // From linux-2.6.8.1/include/linux/types.h
176  //----------------------------------------------------------------------
177  
178  typedef __vki_kernel_fd_set	vki_fd_set;
179  typedef __vki_kernel_mode_t	vki_mode_t;
180  typedef __vki_kernel_off_t	vki_off_t;
181  typedef __vki_kernel_pid_t	vki_pid_t;
182  typedef __vki_kernel_key_t	vki_key_t;
183  typedef __vki_kernel_suseconds_t	vki_suseconds_t;
184  typedef __vki_kernel_timer_t	vki_timer_t;
185  typedef __vki_kernel_clockid_t	vki_clockid_t;
186  typedef __vki_kernel_mqd_t	vki_mqd_t;
187  
188  // [[Nb: it's a bit unclear due to a #ifdef, but I think this is right. --njn]]
189  typedef __vki_kernel_uid32_t	vki_uid_t;
190  typedef __vki_kernel_gid32_t	vki_gid_t;
191  
192  typedef __vki_kernel_old_uid_t	vki_old_uid_t;
193  typedef __vki_kernel_old_gid_t	vki_old_gid_t;
194  
195  typedef __vki_kernel_loff_t	vki_loff_t;
196  
197  typedef __vki_kernel_size_t	vki_size_t;
198  typedef __vki_kernel_time_t	vki_time_t;
199  typedef __vki_kernel_clock_t	vki_clock_t;
200  typedef __vki_kernel_caddr_t	vki_caddr_t;
201  
202  typedef unsigned long           vki_u_long;
203  
204  typedef unsigned int	        vki_uint;
205  
206  //----------------------------------------------------------------------
207  // Now the rest of the arch-specific stuff
208  //----------------------------------------------------------------------
209  
210  #if defined(VGA_x86)
211  #  include "vki-x86-linux.h"
212  #elif defined(VGA_amd64)
213  #  include "vki-amd64-linux.h"
214  #elif defined(VGA_ppc32)
215  #  include "vki-ppc32-linux.h"
216  #elif defined(VGA_ppc64be) || defined(VGA_ppc64le)
217  #  include "vki-ppc64-linux.h"
218  #elif defined(VGA_arm)
219  #  include "vki-arm-linux.h"
220  #elif defined(VGA_arm64)
221  #  include "vki-arm64-linux.h"
222  #elif defined(VGA_s390x)
223  #  include "vki-s390x-linux.h"
224  #elif defined(VGA_mips32)
225  #  include "vki-mips32-linux.h"
226  #elif defined(VGA_mips64)
227  #  include "vki-mips64-linux.h"
228  #elif defined(VGA_tilegx)
229  #  include "vki-tilegx-linux.h"
230  #else
231  #  error Unknown platform
232  #endif
233  
234  //----------------------------------------------------------------------
235  // From linux-2.6.20.1/include/linux/types.h
236  //----------------------------------------------------------------------
237  
238  typedef		__vki_s32	vki_int32_t;
239  typedef		__vki_s16	vki_int16_t;
240  typedef		__vki_s64	vki_int64_t;
241  
242  typedef		__vki_u8	vki_uint8_t;
243  typedef		__vki_u16	vki_uint16_t;
244  typedef		__vki_u32	vki_uint32_t;
245  typedef		__vki_u64	vki_uint64_t;
246  
247  typedef		__vki_u16	__vki_le16;
248  
249  //----------------------------------------------------------------------
250  // From linux-2.6.8.1/include/linux/limits.h
251  //----------------------------------------------------------------------
252  
253  #define VKI_PATH_MAX       4096	/* # chars in a path name including nul */
254  
255  //----------------------------------------------------------------------
256  // From linux-2.6.8.1/include/linux/kernel.h
257  //----------------------------------------------------------------------
258  
259  struct vki_sysinfo {
260  	long uptime;			/* Seconds since boot */
261  	unsigned long loads[3];		/* 1, 5, and 15 minute load averages */
262  	unsigned long totalram;		/* Total usable main memory size */
263  	unsigned long freeram;		/* Available memory size */
264  	unsigned long sharedram;	/* Amount of shared memory */
265  	unsigned long bufferram;	/* Memory used by buffers */
266  	unsigned long totalswap;	/* Total swap space size */
267  	unsigned long freeswap;		/* swap space still available */
268  	unsigned short procs;		/* Number of current processes */
269  	unsigned short pad;		/* explicit padding for m68k */
270  	unsigned long totalhigh;	/* Total high memory size */
271  	unsigned long freehigh;		/* Available high memory size */
272  	unsigned int mem_unit;		/* Memory unit size in bytes */
273  	char _f[20-2*sizeof(long)-sizeof(int)];	/* Padding: libc5 uses this.. */
274  };
275  
276  //----------------------------------------------------------------------
277  // From linux-2.6.8.1/include/linux/time.h
278  //----------------------------------------------------------------------
279  
280  #define VKI_CLOCK_REALTIME            0
281  #define VKI_CLOCK_MONOTONIC           1
282  #define VKI_CLOCK_PROCESS_CPUTIME_ID  2
283  #define VKI_CLOCK_THREAD_CPUTIME_ID   3
284  
285  struct vki_timespec {
286  	vki_time_t	tv_sec;		/* seconds */
287  	long		tv_nsec;	/* nanoseconds */
288  };
289  
290  struct vki_timeval {
291  	vki_time_t	tv_sec;		/* seconds */
292  	vki_suseconds_t	tv_usec;	/* microseconds */
293  };
294  
295  struct vki_timezone {
296  	int	tz_minuteswest;	/* minutes west of Greenwich */
297  	int	tz_dsttime;	/* type of dst correction */
298  };
299  
300  struct  vki_itimerspec {
301          struct  vki_timespec it_interval;    /* timer period */
302          struct  vki_timespec it_value;       /* timer expiration */
303  };
304  
305  struct	vki_itimerval {
306  	struct	vki_timeval it_interval;	/* timer interval */
307  	struct	vki_timeval it_value;	/* current value */
308  };
309  
310  //----------------------------------------------------------------------
311  // From linux-2.6.8.1/include/linux/timex.h
312  //----------------------------------------------------------------------
313  
314  struct vki_timex {
315  	unsigned int modes;	/* mode selector */
316  	long offset;		/* time offset (usec) */
317  	long freq;		/* frequency offset (scaled ppm) */
318  	long maxerror;		/* maximum error (usec) */
319  	long esterror;		/* estimated error (usec) */
320  	int status;		/* clock command/status */
321  	long constant;		/* pll time constant */
322  	long precision;		/* clock precision (usec) (read only) */
323  	long tolerance;		/* clock frequency tolerance (ppm)
324  				 * (read only)
325  				 */
326  	struct vki_timeval time;	/* (read only) */
327  	long tick;		/* (modified) usecs between clock ticks */
328  
329  	long ppsfreq;           /* pps frequency (scaled ppm) (ro) */
330  	long jitter;            /* pps jitter (us) (ro) */
331  	int shift;              /* interval duration (s) (shift) (ro) */
332  	long stabil;            /* pps stability (scaled ppm) (ro) */
333  	long jitcnt;            /* jitter limit exceeded (ro) */
334  	long calcnt;            /* calibration intervals (ro) */
335  	long errcnt;            /* calibration errors (ro) */
336  	long stbcnt;            /* stability limit exceeded (ro) */
337  
338  	int  :32; int  :32; int  :32; int  :32;
339  	int  :32; int  :32; int  :32; int  :32;
340  	int  :32; int  :32; int  :32; int  :32;
341  };
342  
343  #define VKI_ADJ_OFFSET			0x0001	/* time offset */
344  #define VKI_ADJ_FREQUENCY		0x0002	/* frequency offset */
345  #define VKI_ADJ_MAXERROR		0x0004	/* maximum time error */
346  #define VKI_ADJ_ESTERROR		0x0008	/* estimated time error */
347  #define VKI_ADJ_STATUS			0x0010	/* clock status */
348  #define VKI_ADJ_TIMECONST		0x0020	/* pll time constant */
349  #define VKI_ADJ_TAI			0x0080	/* set TAI offset */
350  #define VKI_ADJ_TICK			0x4000	/* tick value */
351  #define VKI_ADJ_ADJTIME			0x8000	/* switch between adjtime/adjtimex modes */
352  //#define VKI_ADJ_OFFSET_SINGLESHOT	0x8001	/* old-fashioned adjtime */
353  #define VKI_ADJ_OFFSET_READONLY		0x2000	/* read-only adjtime */
354  
355  //----------------------------------------------------------------------
356  // From linux-2.6.8.1/include/linux/times.h
357  //----------------------------------------------------------------------
358  
359  struct vki_tms {
360  	vki_clock_t tms_utime;
361  	vki_clock_t tms_stime;
362  	vki_clock_t tms_cutime;
363  	vki_clock_t tms_cstime;
364  };
365  
366  //----------------------------------------------------------------------
367  // From linux-2.6.8.1/include/linux/utime.h
368  //----------------------------------------------------------------------
369  
370  struct vki_utimbuf {
371  	vki_time_t actime;
372  	vki_time_t modtime;
373  };
374  
375  //----------------------------------------------------------------------
376  // From linux-2.6.8.1/include/linux/sched.h
377  //----------------------------------------------------------------------
378  
379  #define VKI_CSIGNAL		0x000000ff	/* signal mask to be sent at exit */
380  #define VKI_CLONE_VM		0x00000100	/* set if VM shared between processes */
381  #define VKI_CLONE_FS		0x00000200	/* set if fs info shared between processes */
382  #define VKI_CLONE_FILES		0x00000400	/* set if open files shared between processes */
383  #define VKI_CLONE_SIGHAND	0x00000800	/* set if signal handlers and blocked signals shared */
384  #define VKI_CLONE_VFORK		0x00004000	/* set if the parent wants the child to wake it up on mm_release */
385  #define VKI_CLONE_PARENT	0x00008000	/* set if we want to have the same parent as the cloner */
386  #define VKI_CLONE_THREAD	0x00010000	/* Same thread group? */
387  #define VKI_CLONE_SYSVSEM	0x00040000	/* share system V SEM_UNDO semantics */
388  #define VKI_CLONE_SETTLS	0x00080000	/* create a new TLS for the child */
389  #define VKI_CLONE_PARENT_SETTID	0x00100000	/* set the TID in the parent */
390  #define VKI_CLONE_CHILD_CLEARTID	0x00200000	/* clear the TID in the child */
391  #define VKI_CLONE_DETACHED	0x00400000	/* Unused, ignored */
392  #define VKI_CLONE_CHILD_SETTID	0x01000000	/* set the TID in the child */
393  
394  struct vki_sched_param {
395  	int sched_priority;
396  };
397  
398  #define VKI_TASK_COMM_LEN 16
399  
400  //----------------------------------------------------------------------
401  // From linux-2.6.8.1/include/asm-generic/siginfo.h
402  //----------------------------------------------------------------------
403  
404  // Some archs, such as MIPS, have non-standard vki_siginfo.
405  #ifndef HAVE_ARCH_SIGINFO_T
406  typedef union vki_sigval {
407  	int sival_int;
408  	void __user *sival_ptr;
409  } vki_sigval_t;
410  
411  #ifndef __VKI_ARCH_SI_PREAMBLE_SIZE
412  #define __VKI_ARCH_SI_PREAMBLE_SIZE	(3 * sizeof(int))
413  #endif
414  
415  #define VKI_SI_MAX_SIZE	128
416  
417  #ifndef VKI_SI_PAD_SIZE
418  #define VKI_SI_PAD_SIZE	((VKI_SI_MAX_SIZE - __VKI_ARCH_SI_PREAMBLE_SIZE) / sizeof(int))
419  #endif
420  
421  #ifndef __VKI_ARCH_SI_UID_T
422  #define __VKI_ARCH_SI_UID_T	vki_uid_t
423  #endif
424  
425  #ifndef __VKI_ARCH_SI_BAND_T
426  #define __VKI_ARCH_SI_BAND_T long
427  #endif
428  
429  // [[Nb: this type changed between 2.4 and 2.6, but not in a way that
430  // affects Valgrind.]]
431  typedef struct vki_siginfo {
432  	int si_signo;
433  	int si_errno;
434  	int si_code;
435  
436  	union {
437  		int _pad[VKI_SI_PAD_SIZE];
438  
439  		/* kill() */
440  		struct {
441  			vki_pid_t _pid;		/* sender's pid */
442  			__VKI_ARCH_SI_UID_T _uid;	/* sender's uid */
443  		} _kill;
444  
445  		/* POSIX.1b timers */
446  		struct {
447  			vki_timer_t _tid;		/* timer id */
448  			int _overrun;		/* overrun count */
449  			char _pad[sizeof( __VKI_ARCH_SI_UID_T) - sizeof(int)];
450  			vki_sigval_t _sigval;	/* same as below */
451  			int _sys_private;       /* not to be passed to user */
452  		} _timer;
453  
454  		/* POSIX.1b signals */
455  		struct {
456  			vki_pid_t _pid;		/* sender's pid */
457  			__VKI_ARCH_SI_UID_T _uid;	/* sender's uid */
458  			vki_sigval_t _sigval;
459  		} _rt;
460  
461  		/* SIGCHLD */
462  		struct {
463  			vki_pid_t _pid;		/* which child */
464  			__VKI_ARCH_SI_UID_T _uid;	/* sender's uid */
465  			int _status;		/* exit code */
466  			vki_clock_t _utime;
467  			vki_clock_t _stime;
468  		} _sigchld;
469  
470  		/* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
471  		struct {
472  			void __user *_addr; /* faulting insn/memory ref. */
473  #ifdef __ARCH_SI_TRAPNO
474  			int _trapno;	/* TRAP # which caused the signal */
475  #endif
476  		} _sigfault;
477  
478  		/* SIGPOLL */
479  		struct {
480  			__VKI_ARCH_SI_BAND_T _band;	/* POLL_IN, POLL_OUT, POLL_MSG */
481  			int _fd;
482  		} _sigpoll;
483  	} _sifields;
484  } vki_siginfo_t;
485  #endif
486  
487  #define __VKI_SI_FAULT	0
488  
489  /*
490   * si_code values
491   * Digital reserves positive values for kernel-generated signals.
492   */
493  #define VKI_SI_USER	0		/* sent by kill, sigsend, raise */
494  #define VKI_SI_TKILL	-6		/* sent by tkill system call */
495  
496  /*
497   * SIGILL si_codes
498   */
499  #define VKI_ILL_ILLOPC	(__VKI_SI_FAULT|1)	/* illegal opcode */
500  #define VKI_ILL_ILLOPN	(__VKI_SI_FAULT|2)	/* illegal operand */
501  #define VKI_ILL_ILLADR	(__VKI_SI_FAULT|3)	/* illegal addressing mode */
502  #define VKI_ILL_ILLTRP	(__VKI_SI_FAULT|4)	/* illegal trap */
503  #define VKI_ILL_PRVOPC	(__VKI_SI_FAULT|5)	/* privileged opcode */
504  #define VKI_ILL_PRVREG	(__VKI_SI_FAULT|6)	/* privileged register */
505  #define VKI_ILL_COPROC	(__VKI_SI_FAULT|7)	/* coprocessor error */
506  #define VKI_ILL_BADSTK	(__VKI_SI_FAULT|8)	/* internal stack error */
507  
508  /*
509   * SIGFPE si_codes
510   */
511  #define VKI_FPE_INTDIV	(__VKI_SI_FAULT|1)	/* integer divide by zero */
512  #define VKI_FPE_INTOVF	(__VKI_SI_FAULT|2)	/* integer overflow */
513  #define VKI_FPE_FLTDIV	(__VKI_SI_FAULT|3)	/* floating point divide by zero */
514  #define VKI_FPE_FLTOVF	(__VKI_SI_FAULT|4)	/* floating point overflow */
515  #define VKI_FPE_FLTUND	(__VKI_SI_FAULT|5)	/* floating point underflow */
516  #define VKI_FPE_FLTRES	(__VKI_SI_FAULT|6)	/* floating point inexact result */
517  #define VKI_FPE_FLTINV	(__VKI_SI_FAULT|7)	/* floating point invalid operation */
518  #define VKI_FPE_FLTSUB	(__VKI_SI_FAULT|8)	/* subscript out of range */
519  
520  /*
521   * SIGSEGV si_codes
522   */
523  #define VKI_SEGV_MAPERR	(__VKI_SI_FAULT|1)	/* address not mapped to object */
524  #define VKI_SEGV_ACCERR	(__VKI_SI_FAULT|2)	/* invalid permissions for mapped object */
525  
526  /*
527   * SIGBUS si_codes
528   */
529  #define VKI_BUS_ADRALN	(__VKI_SI_FAULT|1)	/* invalid address alignment */
530  #define VKI_BUS_ADRERR	(__VKI_SI_FAULT|2)	/* non-existant physical address */
531  #define VKI_BUS_OBJERR	(__VKI_SI_FAULT|3)	/* object specific hardware error */
532  
533  /*
534   * SIGTRAP si_codes
535   */
536  #define VKI_TRAP_BRKPT      (__VKI_SI_FAULT|1)  /* process breakpoint */
537  #define VKI_TRAP_TRACE      (__VKI_SI_FAULT|2)  /* process trace trap */
538  
539  /*
540   * This works because the alignment is ok on all current architectures
541   * but we leave open this being overridden in the future
542   */
543  #ifndef VKI___ARCH_SIGEV_PREAMBLE_SIZE
544  #define VKI___ARCH_SIGEV_PREAMBLE_SIZE	(sizeof(int) * 2 + sizeof(vki_sigval_t))
545  #endif
546  
547  #define VKI_SIGEV_MAX_SIZE	64
548  #define VKI_SIGEV_PAD_SIZE	((VKI_SIGEV_MAX_SIZE - VKI___ARCH_SIGEV_PREAMBLE_SIZE) \
549  		/ sizeof(int))
550  
551  /* This is the flag the kernel handles, userspace/glibc handles SEGEV_THEAD. */
552  #define VKI_SIGEV_THREAD_ID	4
553  
554  typedef struct vki_sigevent {
555  	vki_sigval_t sigev_value;
556  	int sigev_signo;
557  	int sigev_notify;
558  	union {
559  		int _pad[VKI_SIGEV_PAD_SIZE];
560  		 int _tid;
561  
562  		struct {
563  			void (*_function)(vki_sigval_t);
564  			void *_attribute;	/* really pthread_attr_t */
565  		} _sigev_thread;
566  	} _sigev_un;
567  } vki_sigevent_t;
568  
569  #define vki_sigev_notify_thread_id	_sigev_un._tid
570  
571  //----------------------------------------------------------------------
572  // From elsewhere...
573  //----------------------------------------------------------------------
574  
575  // [[The kernel actually uses the numbers 0,1,2 directly here, believe it or
576  // not.  So we introduce our own constants, based on the glibc ones.]]
577  #define VKI_SEEK_SET              0
578  #define VKI_SEEK_CUR              1
579  #define VKI_SEEK_END              2
580  
581  //----------------------------------------------------------------------
582  // From linux-2.6.8.1/include/linux/net.h
583  //----------------------------------------------------------------------
584  
585  #define VKI_SYS_SOCKET		1	/* sys_socket(2)		*/
586  #define VKI_SYS_BIND		2	/* sys_bind(2)			*/
587  #define VKI_SYS_CONNECT		3	/* sys_connect(2)		*/
588  #define VKI_SYS_LISTEN		4	/* sys_listen(2)		*/
589  #define VKI_SYS_ACCEPT		5	/* sys_accept(2)		*/
590  #define VKI_SYS_GETSOCKNAME	6	/* sys_getsockname(2)		*/
591  #define VKI_SYS_GETPEERNAME	7	/* sys_getpeername(2)		*/
592  #define VKI_SYS_SOCKETPAIR	8	/* sys_socketpair(2)		*/
593  #define VKI_SYS_SEND		9	/* sys_send(2)			*/
594  #define VKI_SYS_RECV		10	/* sys_recv(2)			*/
595  #define VKI_SYS_SENDTO		11	/* sys_sendto(2)		*/
596  #define VKI_SYS_RECVFROM	12	/* sys_recvfrom(2)		*/
597  #define VKI_SYS_SHUTDOWN	13	/* sys_shutdown(2)		*/
598  #define VKI_SYS_SETSOCKOPT	14	/* sys_setsockopt(2)		*/
599  #define VKI_SYS_GETSOCKOPT	15	/* sys_getsockopt(2)		*/
600  #define VKI_SYS_SENDMSG		16	/* sys_sendmsg(2)		*/
601  #define VKI_SYS_RECVMSG		17	/* sys_recvmsg(2)		*/
602  #define VKI_SYS_ACCEPT4		18	/* sys_accept4(2)		*/
603  #define VKI_SYS_RECVMMSG	19	/* sys_recvmmsg(2)              */
604  #define VKI_SYS_SENDMMSG	20	/* sys_sendmmsg(2)              */
605  
606  #ifndef ARCH_HAS_SOCKET_TYPES
607  enum vki_sock_type {
608  	VKI_SOCK_STREAM	= 1,
609  	// [[others omitted]]
610  };
611  #endif /* ARCH_HAS_SOCKET_TYPES */
612  
613  //----------------------------------------------------------------------
614  // From linux-2.6.8.1/include/linux/uio.h
615  //----------------------------------------------------------------------
616  
617  struct vki_iovec
618  {
619  	void __user *iov_base;	/* BSD uses caddr_t (1003.1g requires void *) */
620  	__vki_kernel_size_t iov_len; /* Must be size_t (1003.1g) */
621  };
622  
623  //----------------------------------------------------------------------
624  // From linux-2.6.8.1/include/linux/socket.h
625  //----------------------------------------------------------------------
626  
627  // [[Resolved arbitrarily;  doesn't really matter whether it's '__inline__'
628  //   or 'inline']]
629  #define __KINLINE static __inline__
630  
631  typedef unsigned short	vki_sa_family_t;
632  
633  struct vki_sockaddr {
634  	vki_sa_family_t	sa_family;	/* address family, AF_xxx	*/
635  	char		sa_data[14];	/* 14 bytes of protocol address	*/
636  };
637  
638  struct vki_msghdr {
639  	void	*	msg_name;	/* Socket name			*/
640  	int		msg_namelen;	/* Length of name		*/
641  	struct vki_iovec *	msg_iov;	/* Data blocks			*/
642  	__vki_kernel_size_t	msg_iovlen;	/* Number of blocks		*/
643  	void 	*	msg_control;	/* Per protocol magic (eg BSD file descriptor passing) */
644  	__vki_kernel_size_t	msg_controllen;	/* Length of cmsg list */
645  	unsigned	msg_flags;
646  };
647  
648  struct vki_mmsghdr {
649  	struct vki_msghdr   msg_hdr;
650  	unsigned        msg_len;
651  };
652  
653  struct vki_cmsghdr {
654  	__vki_kernel_size_t	cmsg_len;	/* data byte count, including hdr */
655          int		cmsg_level;	/* originating protocol */
656          int		cmsg_type;	/* protocol-specific type */
657  };
658  
659  #define __VKI_CMSG_NXTHDR(ctl, len, cmsg) __vki_cmsg_nxthdr((ctl),(len),(cmsg))
660  #define VKI_CMSG_NXTHDR(mhdr, cmsg) vki_cmsg_nxthdr((mhdr), (cmsg))
661  
662  #define VKI_CMSG_ALIGN(len) ( ((len)+sizeof(long)-1) & ~(sizeof(long)-1) )
663  
664  #define VKI_CMSG_DATA(cmsg)	((void *)((char *)(cmsg) + VKI_CMSG_ALIGN(sizeof(struct vki_cmsghdr))))
665  
666  #define __VKI_CMSG_FIRSTHDR(ctl,len) ((len) >= sizeof(struct vki_cmsghdr) ? \
667  				  (struct vki_cmsghdr *)(ctl) : \
668  				  (struct vki_cmsghdr *)NULL)
669  #define VKI_CMSG_FIRSTHDR(msg)	__VKI_CMSG_FIRSTHDR((msg)->msg_control, (msg)->msg_controllen)
670  
671  // [[Urgh, this is revolting...]
__vki_cmsg_nxthdr(void * __ctl,__vki_kernel_size_t __size,struct vki_cmsghdr * __cmsg)672  __KINLINE struct vki_cmsghdr * __vki_cmsg_nxthdr(void *__ctl, __vki_kernel_size_t __size,
673  					       struct vki_cmsghdr *__cmsg)
674  {
675  	struct vki_cmsghdr * __ptr;
676  
677  	__ptr = (struct vki_cmsghdr*)(((unsigned char *) __cmsg) +  VKI_CMSG_ALIGN(__cmsg->cmsg_len));
678  	if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
679  		return (struct vki_cmsghdr *)0;
680  
681  	return __ptr;
682  }
683  
vki_cmsg_nxthdr(struct vki_msghdr * __msg,struct vki_cmsghdr * __cmsg)684  __KINLINE struct vki_cmsghdr * vki_cmsg_nxthdr (struct vki_msghdr *__msg, struct vki_cmsghdr *__cmsg)
685  {
686  	return __vki_cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
687  }
688  
689  #define	VKI_SCM_RIGHTS	0x01		/* rw: access rights (array of int) */
690  
691  #define VKI_AF_UNSPEC   0
692  #define VKI_AF_UNIX	1	/* Unix domain sockets 		*/
693  #define VKI_AF_INET	2	/* Internet IP Protocol		*/
694  #define VKI_AF_INET6	10	/* IP version 6			*/
695  #define VKI_AF_NETLINK  16
696  #define VKI_AF_BLUETOOTH 31	/* Bluetooth sockets		*/
697  
698  #define VKI_MSG_NOSIGNAL	0x4000	/* Do not generate SIGPIPE */
699  
700  #define VKI_SOL_SCTP	132
701  
702  //----------------------------------------------------------------------
703  // From linux-2.6.8.1/include/linux/in.h
704  //----------------------------------------------------------------------
705  
706  struct vki_in_addr {
707  	__vki_u32	s_addr;
708  };
709  
710  /* Structure describing an Internet (IP) socket address. */
711  #define __VKI_SOCK_SIZE__	16	/* sizeof(struct sockaddr)	*/
712  struct vki_sockaddr_in {
713    vki_sa_family_t	sin_family;	/* Address family		*/
714    unsigned short int	sin_port;	/* Port number			*/
715    struct vki_in_addr	sin_addr;	/* Internet address		*/
716  
717    /* Pad to size of `struct sockaddr'. */
718    unsigned char		__pad[__VKI_SOCK_SIZE__ - sizeof(short int) -
719  			sizeof(unsigned short int) - sizeof(struct vki_in_addr)];
720  };
721  
722  #define VKI_IPPROTO_TCP 6       /* Transmission Control Protocol        */
723  
724  //----------------------------------------------------------------------
725  // From linux-2.6.8.1/include/linux/in6.h
726  //----------------------------------------------------------------------
727  
728  struct vki_in6_addr
729  {
730  	union
731  	{
732  		__vki_u8	u6_addr8[16];
733  		__vki_u16	u6_addr16[8];
734  		__vki_u32	u6_addr32[4];
735  	} vki_in6_u;
736  #define vki_s6_addr		vki_in6_u.u6_addr8
737  #define vki_s6_addr16		vki_in6_u.u6_addr16
738  #define vki_s6_addr32		vki_in6_u.u6_addr32
739  };
740  
741  struct vki_sockaddr_in6 {
742  	unsigned short int	sin6_family;    /* AF_INET6 */
743  	__vki_u16		sin6_port;      /* Transport layer port # */
744  	__vki_u32		sin6_flowinfo;  /* IPv6 flow information */
745  	struct vki_in6_addr	sin6_addr;      /* IPv6 address */
746  	__vki_u32		sin6_scope_id;  /* scope id (new in RFC2553) */
747  };
748  
749  //----------------------------------------------------------------------
750  // From linux-2.6.8.1/include/linux/tcp.h
751  //----------------------------------------------------------------------
752  
753  #define VKI_TCP_NODELAY    1       /* Turn off Nagle's algorithm. */
754  
755  
756  //----------------------------------------------------------------------
757  // From linux-2.6.8.1/include/linux/un.h
758  //----------------------------------------------------------------------
759  
760  #define VKI_UNIX_PATH_MAX	108
761  
762  struct vki_sockaddr_un {
763  	vki_sa_family_t sun_family;	/* AF_UNIX */
764  	char sun_path[VKI_UNIX_PATH_MAX];	/* pathname */
765  };
766  
767  //----------------------------------------------------------------------
768  // From linux-3.15.8/include/uapi/linux/netlink.h
769  //----------------------------------------------------------------------
770  
771  struct vki_sockaddr_nl {
772          vki_sa_family_t    nl_family;      /* AF_NETLINK   */
773          unsigned short     nl_pad;         /* zero         */
774          __vki_u32          nl_pid;         /* port ID      */
775          __vki_u32          nl_groups;      /* multicast groups mask */
776  };
777  
778  //----------------------------------------------------------------------
779  // From linux-2.6.8.1/include/linux/if.h
780  //----------------------------------------------------------------------
781  
782  #define	VKI_IFNAMSIZ	16
783  
784  struct vki_ifmap
785  {
786  	unsigned long mem_start;
787  	unsigned long mem_end;
788  	unsigned short base_addr;
789  	unsigned char irq;
790  	unsigned char dma;
791  	unsigned char port;
792  	/* 3 bytes spare */
793  };
794  
795  struct vki_if_settings
796  {
797  	unsigned int type;	/* Type of physical device or protocol */
798  	unsigned int size;	/* Size of the data allocated by the caller */
799  	union {
800                  // [[Nb: converted these all to void* to avoid pulling in
801                  //   unnecessary headers]]]
802  		/* {atm/eth/dsl}_settings anyone ? */
803  		void /*raw_hdlc_proto		*/__user *raw_hdlc;
804  		void /*cisco_proto		*/__user *cisco;
805  		void /*fr_proto			*/__user *fr;
806  		void /*fr_proto_pvc		*/__user *fr_pvc;
807  		void /*fr_proto_pvc_info	*/__user *fr_pvc_info;
808  
809  		/* interface settings */
810  		void /*sync_serial_settings	*/__user *sync;
811  		void /*te1_settings		*/__user *te1;
812  	} ifs_ifsu;
813  };
814  
815  struct vki_ifreq
816  {
817  #define VKI_IFHWADDRLEN	6
818  	union
819  	{
820  		char	ifrn_name[VKI_IFNAMSIZ];		/* if name, e.g. "en0" */
821  	} ifr_ifrn;
822  
823  	union {
824  		struct	vki_sockaddr ifru_addr;
825  		struct	vki_sockaddr ifru_dstaddr;
826  		struct	vki_sockaddr ifru_broadaddr;
827  		struct	vki_sockaddr ifru_netmask;
828  		struct  vki_sockaddr ifru_hwaddr;
829  		short	ifru_flags;
830  		int	ifru_ivalue;
831  		int	ifru_mtu;
832  		struct  vki_ifmap ifru_map;
833  		char	ifru_slave[VKI_IFNAMSIZ];	/* Just fits the size */
834  		char	ifru_newname[VKI_IFNAMSIZ];
835  		void __user *	ifru_data;
836  		struct	vki_if_settings ifru_settings;
837  	} ifr_ifru;
838  };
839  
840  #define vki_ifr_name	ifr_ifrn.ifrn_name	/* interface name 	*/
841  #define vki_ifr_hwaddr	ifr_ifru.ifru_hwaddr	/* MAC address 		*/
842  #define	vki_ifr_addr	ifr_ifru.ifru_addr	/* address		*/
843  #define	vki_ifr_dstaddr	ifr_ifru.ifru_dstaddr	/* other end of p-p lnk	*/
844  #define	vki_ifr_broadaddr ifr_ifru.ifru_broadaddr /* broadcast address	*/
845  #define	vki_ifr_netmask	ifr_ifru.ifru_netmask	/* interface net mask	*/
846  #define	vki_ifr_flags	ifr_ifru.ifru_flags	/* flags		*/
847  #define	vki_ifr_metric	ifr_ifru.ifru_ivalue	/* metric		*/
848  #define	vki_ifr_mtu	ifr_ifru.ifru_mtu	/* mtu			*/
849  #define vki_ifr_map	ifr_ifru.ifru_map	/* device map		*/
850  #define vki_ifr_slave	ifr_ifru.ifru_slave	/* slave device		*/
851  #define	vki_ifr_data	ifr_ifru.ifru_data	/* for use by interface	*/
852  #define vki_ifr_ifindex	ifr_ifru.ifru_ivalue	/* interface index	*/
853  #define vki_ifr_bandwidth ifr_ifru.ifru_ivalue  /* link bandwidth	*/
854  #define vki_ifr_qlen	ifr_ifru.ifru_ivalue	/* Queue length 	*/
855  #define vki_ifr_newname	ifr_ifru.ifru_newname	/* New name		*/
856  #define vki_ifr_settings ifr_ifru.ifru_settings	/* Device/proto settings*/
857  
858  struct vki_ifconf
859  {
860  	int	ifc_len;			/* size of buffer	*/
861  	union
862  	{
863  		char __user *ifcu_buf;
864  		struct vki_ifreq __user *ifcu_req;
865  	} ifc_ifcu;
866  };
867  #define	vki_ifc_buf	ifc_ifcu.ifcu_buf	/* buffer address	*/
868  
869  //----------------------------------------------------------------------
870  // From linux-2.6.8.1/include/linux/if_arp.h
871  //----------------------------------------------------------------------
872  
873  struct vki_arpreq {
874    struct vki_sockaddr	arp_pa;		/* protocol address		*/
875    struct vki_sockaddr	arp_ha;		/* hardware address		*/
876    int			arp_flags;	/* flags			*/
877    struct vki_sockaddr   arp_netmask;    /* netmask (only for proxy arps) */
878    char			arp_dev[16];
879  };
880  
881  //----------------------------------------------------------------------
882  // From linux-2.6.8.1/include/linux/route.h
883  //----------------------------------------------------------------------
884  
885  struct vki_rtentry
886  {
887  	unsigned long	rt_pad1;
888  	struct vki_sockaddr	rt_dst;		/* target address		*/
889  	struct vki_sockaddr	rt_gateway;	/* gateway addr (RTF_GATEWAY)	*/
890  	struct vki_sockaddr	rt_genmask;	/* target network mask (IP)	*/
891  	unsigned short	rt_flags;
892  	short		rt_pad2;
893  	unsigned long	rt_pad3;
894  	void		*rt_pad4;
895  	short		rt_metric;	/* +1 for binary compatibility!	*/
896  	char __user	*rt_dev;	/* forcing the device at add	*/
897  	unsigned long	rt_mtu;		/* per route MTU/Window 	*/
898  // [[Not important for Valgrind]]
899  //#ifndef __KERNEL__
900  //#define rt_mss	rt_mtu		/* Compatibility :-(            */
901  //#endif
902  	unsigned long	rt_window;	/* Window clamping 		*/
903  	unsigned short	rt_irtt;	/* Initial RTT			*/
904  };
905  
906  //----------------------------------------------------------------------
907  // From linux-2.6.13-rc5/include/net/sctp/user.h
908  //----------------------------------------------------------------------
909  
910  typedef __vki_s32 vki_sctp_assoc_t;
911  
912  enum vki_sctp_optname {
913  	VKI_SCTP_RTOINFO,
914  #define VKI_SCTP_RTOINFO VKI_SCTP_RTOINFO
915  	VKI_SCTP_ASSOCINFO,
916  #define VKI_SCTP_ASSOCINFO VKI_SCTP_ASSOCINFO
917  	VKI_SCTP_INITMSG,
918  #define VKI_SCTP_INITMSG VKI_SCTP_INITMSG
919  	VKI_SCTP_NODELAY, 	/* Get/set nodelay option. */
920  #define VKI_SCTP_NODELAY	VKI_SCTP_NODELAY
921  	VKI_SCTP_AUTOCLOSE,
922  #define VKI_SCTP_AUTOCLOSE VKI_SCTP_AUTOCLOSE
923  	VKI_SCTP_SET_PEER_PRIMARY_ADDR,
924  #define VKI_SCTP_SET_PEER_PRIMARY_ADDR VKI_SCTP_SET_PEER_PRIMARY_ADDR
925  	VKI_SCTP_PRIMARY_ADDR,
926  #define VKI_SCTP_PRIMARY_ADDR VKI_SCTP_PRIMARY_ADDR
927  	VKI_SCTP_ADAPTION_LAYER,
928  #define VKI_SCTP_ADAPTION_LAYER VKI_SCTP_ADAPTION_LAYER
929  	VKI_SCTP_DISABLE_FRAGMENTS,
930  #define VKI_SCTP_DISABLE_FRAGMENTS VKI_SCTP_DISABLE_FRAGMENTS
931  	VKI_SCTP_PEER_ADDR_PARAMS,
932  #define VKI_SCTP_PEER_ADDR_PARAMS VKI_SCTP_PEER_ADDR_PARAMS
933  	VKI_SCTP_DEFAULT_SEND_PARAM,
934  #define VKI_SCTP_DEFAULT_SEND_PARAM VKI_SCTP_DEFAULT_SEND_PARAM
935  	VKI_SCTP_EVENTS,
936  #define VKI_SCTP_EVENTS VKI_SCTP_EVENTS
937  	VKI_SCTP_I_WANT_MAPPED_V4_ADDR,  /* Turn on/off mapped v4 addresses  */
938  #define VKI_SCTP_I_WANT_MAPPED_V4_ADDR VKI_SCTP_I_WANT_MAPPED_V4_ADDR
939  	VKI_SCTP_MAXSEG, 	/* Get/set maximum fragment. */
940  #define VKI_SCTP_MAXSEG 	VKI_SCTP_MAXSEG
941  	VKI_SCTP_STATUS,
942  #define VKI_SCTP_STATUS VKI_SCTP_STATUS
943  	VKI_SCTP_GET_PEER_ADDR_INFO,
944  #define VKI_SCTP_GET_PEER_ADDR_INFO VKI_SCTP_GET_PEER_ADDR_INFO
945  
946  	/* Internal Socket Options. Some of the sctp library functions are
947  	 * implemented using these socket options.
948  	 */
949  	VKI_SCTP_SOCKOPT_BINDX_ADD = 100,/* BINDX requests for adding addresses. */
950  #define VKI_SCTP_SOCKOPT_BINDX_ADD	VKI_SCTP_SOCKOPT_BINDX_ADD
951  	VKI_SCTP_SOCKOPT_BINDX_REM, /* BINDX requests for removing addresses. */
952  #define VKI_SCTP_SOCKOPT_BINDX_REM	VKI_SCTP_SOCKOPT_BINDX_REM
953  	VKI_SCTP_SOCKOPT_PEELOFF, 	/* peel off association. */
954  #define VKI_SCTP_SOCKOPT_PEELOFF	VKI_SCTP_SOCKOPT_PEELOFF
955  	VKI_SCTP_GET_PEER_ADDRS_NUM, 	/* Get number of peer addresss. */
956  #define VKI_SCTP_GET_PEER_ADDRS_NUM	VKI_SCTP_GET_PEER_ADDRS_NUM
957  	VKI_SCTP_GET_PEER_ADDRS, 	/* Get all peer addresss. */
958  #define VKI_SCTP_GET_PEER_ADDRS	VKI_SCTP_GET_PEER_ADDRS
959  	VKI_SCTP_GET_LOCAL_ADDRS_NUM, 	/* Get number of local addresss. */
960  #define VKI_SCTP_GET_LOCAL_ADDRS_NUM	VKI_SCTP_GET_LOCAL_ADDRS_NUM
961  	VKI_SCTP_GET_LOCAL_ADDRS, 	/* Get all local addresss. */
962  #define VKI_SCTP_GET_LOCAL_ADDRS	VKI_SCTP_GET_LOCAL_ADDRS
963  	VKI_SCTP_SOCKOPT_CONNECTX, /* CONNECTX requests. */
964  #define VKI_SCTP_SOCKOPT_CONNECTX	VKI_SCTP_SOCKOPT_CONNECTX
965  };
966  
967  struct vki_sctp_getaddrs {
968  	vki_sctp_assoc_t        assoc_id;
969  	int			addr_num;
970  	struct vki_sockaddr	*addrs;
971  };
972  
973  //----------------------------------------------------------------------
974  // From linux-2.6.8.1/include/linux/resource.h
975  //----------------------------------------------------------------------
976  
977  struct	vki_rusage {
978  	struct vki_timeval ru_utime;	/* user time used */
979  	struct vki_timeval ru_stime;	/* system time used */
980  	long	ru_maxrss;		/* maximum resident set size */
981  	long	ru_ixrss;		/* integral shared memory size */
982  	long	ru_idrss;		/* integral unshared data size */
983  	long	ru_isrss;		/* integral unshared stack size */
984  	long	ru_minflt;		/* page reclaims */
985  	long	ru_majflt;		/* page faults */
986  	long	ru_nswap;		/* swaps */
987  	long	ru_inblock;		/* block input operations */
988  	long	ru_oublock;		/* block output operations */
989  	long	ru_msgsnd;		/* messages sent */
990  	long	ru_msgrcv;		/* messages received */
991  	long	ru_nsignals;		/* signals received */
992  	long	ru_nvcsw;		/* voluntary context switches */
993  	long	ru_nivcsw;		/* involuntary " */
994  };
995  
996  struct vki_rlimit {
997  	unsigned long	rlim_cur;
998  	unsigned long	rlim_max;
999  };
1000  
1001  struct vki_rlimit64 {
1002  	__vki_u64 rlim_cur;
1003  	__vki_u64 rlim_max;
1004  };
1005  
1006  //----------------------------------------------------------------------
1007  // From linux-2.6.8.1/include/linux/elfcore.h
1008  //----------------------------------------------------------------------
1009  
1010  struct vki_elf_siginfo
1011  {
1012  	int	si_signo;			/* signal number */
1013  	int	si_code;			/* extra code */
1014  	int	si_errno;			/* errno */
1015  };
1016  
1017  // [[Removed some commented out lines here]]
1018  struct vki_elf_prstatus
1019  {
1020  	struct vki_elf_siginfo pr_info;	/* Info associated with signal */
1021  	short	pr_cursig;		/* Current signal */
1022  	unsigned long pr_sigpend;	/* Set of pending signals */
1023  	unsigned long pr_sighold;	/* Set of held signals */
1024  	vki_pid_t	pr_pid;
1025  	vki_pid_t	pr_ppid;
1026  	vki_pid_t	pr_pgrp;
1027  	vki_pid_t	pr_sid;
1028  	struct vki_timeval pr_utime;	/* User time */
1029  	struct vki_timeval pr_stime;	/* System time */
1030  	struct vki_timeval pr_cutime;	/* Cumulative user time */
1031  	struct vki_timeval pr_cstime;	/* Cumulative system time */
1032  	vki_elf_gregset_t pr_reg;	/* GP registers */
1033  	int pr_fpvalid;		/* True if math co-processor being used.  */
1034  };
1035  
1036  #define VKI_ELF_PRARGSZ	(80)	/* Number of chars for args */
1037  
1038  struct vki_elf_prpsinfo
1039  {
1040  	char	pr_state;	/* numeric process state */
1041  	char	pr_sname;	/* char for pr_state */
1042  	char	pr_zomb;	/* zombie */
1043  	char	pr_nice;	/* nice val */
1044  	unsigned long pr_flag;	/* flags */
1045  	__vki_kernel_uid_t	pr_uid;
1046  	__vki_kernel_gid_t	pr_gid;
1047  	vki_pid_t	pr_pid, pr_ppid, pr_pgrp, pr_sid;
1048  	/* Lots missing */
1049  	char	pr_fname[16];	/* filename of executable */
1050  	char	pr_psargs[VKI_ELF_PRARGSZ];	/* initial part of arg list */
1051  };
1052  
1053  //----------------------------------------------------------------------
1054  // From linux-2.6.12.1/include/linux/eventpoll.h
1055  //----------------------------------------------------------------------
1056  
1057  /* Valid opcodes to issue to sys_epoll_ctl() */
1058  #define VKI_EPOLL_CTL_ADD 1
1059  #define VKI_EPOLL_CTL_DEL 2
1060  #define VKI_EPOLL_CTL_MOD 3
1061  
1062  #ifdef __x86_64__
1063  #define VKI_EPOLL_PACKED __attribute__((packed))
1064  #else
1065  #define VKI_EPOLL_PACKED
1066  #endif
1067  
1068  struct vki_epoll_event {
1069  	__vki_u32 events;
1070  	__vki_u64 data;
1071  } VKI_EPOLL_PACKED;
1072  
1073  
1074  //----------------------------------------------------------------------
1075  // From linux-2.6.8.1/include/linux/mqueue.h
1076  //----------------------------------------------------------------------
1077  
1078  struct vki_mq_attr {
1079  	long	mq_flags;	/* message queue flags			*/
1080  	long	mq_maxmsg;	/* maximum number of messages		*/
1081  	long	mq_msgsize;	/* maximum message size			*/
1082  	long	mq_curmsgs;	/* number of messages currently queued	*/
1083  	long	__reserved[4];	/* ignored for input, zeroed for output */
1084  };
1085  
1086  //----------------------------------------------------------------------
1087  // From linux-2.6.8.1/include/linux/utsname.h
1088  //----------------------------------------------------------------------
1089  
1090  struct vki_new_utsname {
1091  	char sysname[65];
1092  	char nodename[65];
1093  	char release[65];
1094  	char version[65];
1095  	char machine[65];
1096  	char domainname[65];
1097  };
1098  
1099  //----------------------------------------------------------------------
1100  // From linux-2.6.8.1/include/linux/mii.h
1101  //----------------------------------------------------------------------
1102  
1103  /* This structure is used in all SIOCxMIIxxx ioctl calls */
1104  struct vki_mii_ioctl_data {
1105  	vki_u16		phy_id;
1106  	vki_u16		reg_num;
1107  	vki_u16		val_in;
1108  	vki_u16		val_out;
1109  };
1110  
1111  //----------------------------------------------------------------------
1112  // From linux-2.6.8.1/include/linux/capability.h
1113  //----------------------------------------------------------------------
1114  
1115  // [[capget()/capset() man page says this, ominously:
1116  //
1117  //   The kernel API is likely to change and use of these functions  (in
1118  //   particular the format of the cap_user_*_t types) is subject to
1119  //   change with each kernel revision.
1120  //
1121  // However, the format hasn't changed since at least Linux 2.4.6.]]
1122  
1123  typedef struct __vki_user_cap_header_struct {
1124  	__vki_u32 version;
1125  	int pid;
1126  } __user *vki_cap_user_header_t;
1127  
1128  typedef struct __vki_user_cap_data_struct {
1129          __vki_u32 effective;
1130          __vki_u32 permitted;
1131          __vki_u32 inheritable;
1132  } __user *vki_cap_user_data_t;
1133  
1134  
1135  //----------------------------------------------------------------------
1136  // From linux-2.6.8.1/include/linux/module.h
1137  //----------------------------------------------------------------------
1138  
1139  // [[We do a VKI_SIZEOF_* here because this type is so big, and its size
1140  //   depends on the word size, so see vki_arch.h]]
1141  
1142  //----------------------------------------------------------------------
1143  // From linux-2.6.8.1/include/linux/ipc.h
1144  //----------------------------------------------------------------------
1145  
1146  /* Obsolete, used only for backwards compatibility and libc5 compiles */
1147  struct vki_ipc_perm
1148  {
1149  	__vki_kernel_key_t	key;
1150  	__vki_kernel_uid_t	uid;
1151  	__vki_kernel_gid_t	gid;
1152  	__vki_kernel_uid_t	cuid;
1153  	__vki_kernel_gid_t	cgid;
1154  	__vki_kernel_mode_t	mode;
1155  	unsigned short	seq;
1156  };
1157  
1158  #define VKI_IPC_CREAT  00001000   /* create if key is nonexistent */
1159  #define VKI_IPC_EXCL   00002000   /* fail if key exists */
1160  #define VKI_IPC_NOWAIT 00004000   /* return error on wait */
1161  
1162  //#define VKI_IPC_RMID 0     /* remove resource */
1163  #define VKI_IPC_SET  1     /* set ipc_perm options */
1164  #define VKI_IPC_STAT 2     /* get ipc_perm options */
1165  #define VKI_IPC_INFO 3     /* see ipcs */
1166  
1167  #define VKI_IPC_64  0x0100  /* New version (support 32-bit UIDs, bigger
1168  			       message sizes, etc. */
1169  // From /usr/include/bits/shm.h
1170  # define VKI_SHM_HUGETLB   04000
1171  
1172  
1173  //----------------------------------------------------------------------
1174  // From linux-2.6.8.1/include/linux/sem.h
1175  //----------------------------------------------------------------------
1176  
1177  #define VKI_GETALL  13       /* get all semval's */
1178  #define VKI_SETVAL  16       /* set semval */
1179  #define VKI_SETALL  17       /* set all semval's */
1180  
1181  #define VKI_SEM_STAT 18
1182  #define VKI_SEM_INFO 19
1183  
1184  /* Obsolete, used only for backwards compatibility and libc5 compiles */
1185  struct vki_semid_ds {
1186  	struct vki_ipc_perm	sem_perm;		/* permissions .. see ipc.h */
1187  	__vki_kernel_time_t	sem_otime;		/* last semop time */
1188  	__vki_kernel_time_t	sem_ctime;		/* last change time */
1189          // [[Use void* to avoid excess header copying]]
1190  	void/*struct sem	*/*sem_base;		/* ptr to first semaphore in array */
1191  	void/*struct sem_queue */*sem_pending;		/* pending operations to be processed */
1192  	void/*struct sem_queue */**sem_pending_last;	/* last pending operation */
1193  	void/*struct sem_undo	*/*undo;			/* undo requests on this array */
1194  	unsigned short	sem_nsems;		/* no. of semaphores in array */
1195  };
1196  
1197  struct vki_sembuf {
1198  	unsigned short  sem_num;	/* semaphore index in array */
1199  	short		sem_op;		/* semaphore operation */
1200  	short		sem_flg;	/* operation flags */
1201  };
1202  
1203  union vki_semun {
1204  	int val;			/* value for SETVAL */
1205  	struct vki_semid_ds __user *buf;	/* buffer for IPC_STAT & IPC_SET */
1206  	unsigned short __user *array;	/* array for GETALL & SETALL */
1207  	struct vki_seminfo __user *__buf;	/* buffer for IPC_INFO */
1208  	void __user *__pad;
1209  };
1210  
1211  struct  vki_seminfo {
1212  	int semmap;
1213  	int semmni;
1214  	int semmns;
1215  	int semmnu;
1216  	int semmsl;
1217  	int semopm;
1218  	int semume;
1219  	int semusz;
1220  	int semvmx;
1221  	int semaem;
1222  };
1223  
1224  //----------------------------------------------------------------------
1225  // From linux-2.6.8.1/include/asm-generic/errno-base.h
1226  //----------------------------------------------------------------------
1227  
1228  #define	VKI_EPERM		 1	/* Operation not permitted */
1229  #define	VKI_ENOENT		 2	/* No such file or directory */
1230  #define	VKI_ESRCH		 3	/* No such process */
1231  #define	VKI_EINTR		 4	/* Interrupted system call */
1232  #define	VKI_EIO			 5	/* I/O error */
1233  #define	VKI_ENXIO		 6	/* No such device or address */
1234  #define	VKI_E2BIG		 7	/* Argument list too long */
1235  #define	VKI_ENOEXEC		 8	/* Exec format error */
1236  #define	VKI_EBADF		 9	/* Bad file number */
1237  #define	VKI_ECHILD		10	/* No child processes */
1238  #define	VKI_EAGAIN		11	/* Try again */
1239  #define	VKI_ENOMEM		12	/* Out of memory */
1240  #define	VKI_EACCES		13	/* Permission denied */
1241  #define	VKI_EFAULT		14	/* Bad address */
1242  #define	VKI_ENOTBLK		15	/* Block device required */
1243  #define	VKI_EBUSY		16	/* Device or resource busy */
1244  #define	VKI_EEXIST		17	/* File exists */
1245  #define	VKI_EXDEV		18	/* Cross-device link */
1246  #define	VKI_ENODEV		19	/* No such device */
1247  #define	VKI_ENOTDIR		20	/* Not a directory */
1248  #define	VKI_EISDIR		21	/* Is a directory */
1249  #define	VKI_EINVAL		22	/* Invalid argument */
1250  #define	VKI_ENFILE		23	/* File table overflow */
1251  #define	VKI_EMFILE		24	/* Too many open files */
1252  #define	VKI_ENOTTY		25	/* Not a typewriter */
1253  #define	VKI_ETXTBSY		26	/* Text file busy */
1254  #define	VKI_EFBIG		27	/* File too large */
1255  #define	VKI_ENOSPC		28	/* No space left on device */
1256  #define	VKI_ESPIPE		29	/* Illegal seek */
1257  #define	VKI_EROFS		30	/* Read-only file system */
1258  #define	VKI_EMLINK		31	/* Too many links */
1259  #define	VKI_EPIPE		32	/* Broken pipe */
1260  #define	VKI_EDOM		33	/* Math argument out of domain of func */
1261  #define	VKI_ERANGE		34	/* Math result not representable */
1262  
1263  //----------------------------------------------------------------------
1264  // From linux-2.6.8.1/include/asm-generic/errno.h
1265  //----------------------------------------------------------------------
1266  
1267  #define VKI_EWOULDBLOCK		VKI_EAGAIN
1268  
1269  //----------------------------------------------------------------------
1270  // From linux-2.6.8.1/include/linux/wait.h
1271  //----------------------------------------------------------------------
1272  
1273  #define VKI_WNOHANG	0x00000001
1274  
1275  #define __VKI_WALL	0x40000000	/* Wait on all children, regardless of type */
1276  #define __VKI_WCLONE	0x80000000	/* Wait only on non-SIGCHLD children */
1277  
1278  //----------------------------------------------------------------------
1279  // From linux-2.6.8.1/include/linux/mman.h
1280  //----------------------------------------------------------------------
1281  
1282  #define VKI_MREMAP_MAYMOVE	1
1283  #define VKI_MREMAP_FIXED	2
1284  
1285  //----------------------------------------------------------------------
1286  // From linux-2.6.31-rc4/include/linux/futex.h
1287  //----------------------------------------------------------------------
1288  
1289  #define VKI_FUTEX_WAIT (0)
1290  #define VKI_FUTEX_WAKE (1)
1291  #define VKI_FUTEX_FD (2)
1292  #define VKI_FUTEX_REQUEUE (3)
1293  #define VKI_FUTEX_CMP_REQUEUE (4)
1294  #define VKI_FUTEX_WAKE_OP (5)
1295  #define VKI_FUTEX_LOCK_PI (6)
1296  #define VKI_FUTEX_UNLOCK_PI (7)
1297  #define VKI_FUTEX_TRYLOCK_PI (8)
1298  #define VKI_FUTEX_WAIT_BITSET (9)
1299  #define VKI_FUTEX_WAKE_BITSET (10)
1300  #define VKI_FUTEX_WAIT_REQUEUE_PI (11)
1301  #define VKI_FUTEX_CMP_REQUEUE_PI (12)
1302  #define VKI_FUTEX_PRIVATE_FLAG (128)
1303  #define VKI_FUTEX_CLOCK_REALTIME (256)
1304  
1305  struct vki_robust_list {
1306  	struct vki_robust_list __user *next;
1307  };
1308  
1309  struct vki_robust_list_head {
1310  	/*
1311  	 * The head of the list. Points back to itself if empty:
1312  	 */
1313  	struct vki_robust_list list;
1314  
1315  	/*
1316  	 * This relative offset is set by user-space, it gives the kernel
1317  	 * the relative position of the futex field to examine. This way
1318  	 * we keep userspace flexible, to freely shape its data-structure,
1319  	 * without hardcoding any particular offset into the kernel:
1320  	 */
1321  	long futex_offset;
1322  
1323  	/*
1324  	 * The death of the thread may race with userspace setting
1325  	 * up a lock's links. So to handle this race, userspace first
1326  	 * sets this field to the address of the to-be-taken lock,
1327  	 * then does the lock acquire, and then adds itself to the
1328  	 * list, and then clears this field. Hence the kernel will
1329  	 * always have full knowledge of all locks that the thread
1330  	 * _might_ have taken. We check the owner TID in any case,
1331  	 * so only truly owned locks will be handled.
1332  	 */
1333  	struct vki_robust_list __user *list_op_pending;
1334  };
1335  
1336  //----------------------------------------------------------------------
1337  // From linux-2.6.8.1/include/linux/errno.h
1338  //----------------------------------------------------------------------
1339  
1340  #define VKI_ERESTARTSYS	512
1341  
1342  //----------------------------------------------------------------------
1343  // From linux-2.6.8.1/include/linux/stat.h
1344  //----------------------------------------------------------------------
1345  
1346  #define VKI_S_IFMT  00170000
1347  #define VKI_S_IFSOCK 0140000
1348  #define VKI_S_IFLNK  0120000
1349  #define VKI_S_IFREG  0100000
1350  #define VKI_S_IFBLK  0060000
1351  #define VKI_S_IFDIR  0040000
1352  #define VKI_S_IFCHR  0020000
1353  #define VKI_S_IFIFO  0010000
1354  #define VKI_S_ISUID  0004000
1355  #define VKI_S_ISGID  0002000
1356  #define VKI_S_ISVTX  0001000
1357  
1358  #define VKI_S_ISLNK(m)	(((m) & VKI_S_IFMT) == VKI_S_IFLNK)
1359  #define VKI_S_ISREG(m)	(((m) & VKI_S_IFMT) == VKI_S_IFREG)
1360  #define VKI_S_ISDIR(m)	(((m) & VKI_S_IFMT) == VKI_S_IFDIR)
1361  #define VKI_S_ISCHR(m)	(((m) & VKI_S_IFMT) == VKI_S_IFCHR)
1362  #define VKI_S_ISBLK(m)	(((m) & VKI_S_IFMT) == VKI_S_IFBLK)
1363  #define VKI_S_ISFIFO(m)	(((m) & VKI_S_IFMT) == VKI_S_IFIFO)
1364  #define VKI_S_ISSOCK(m)	(((m) & VKI_S_IFMT) == VKI_S_IFSOCK)
1365  
1366  #define VKI_S_IRWXU 00700
1367  #define VKI_S_IRUSR 00400
1368  #define VKI_S_IWUSR 00200
1369  #define VKI_S_IXUSR 00100
1370  
1371  #define VKI_S_IRWXG 00070
1372  #define VKI_S_IRGRP 00040
1373  #define VKI_S_IWGRP 00020
1374  #define VKI_S_IXGRP 00010
1375  
1376  #define VKI_S_IRWXO 00007
1377  #define VKI_S_IROTH 00004
1378  #define VKI_S_IWOTH 00002
1379  #define VKI_S_IXOTH 00001
1380  
1381  //----------------------------------------------------------------------
1382  // From linux-2.6.8.1/include/linux/dirent.h
1383  //----------------------------------------------------------------------
1384  
1385  /* This is the old compat structure to use with the old dirent syscall. */
1386  struct vki_dirent {
1387  	long		d_ino;
1388  	__vki_kernel_off_t	d_off;
1389  	unsigned short	d_reclen;
1390  	char		d_name[256]; /* We must not include limits.h! */
1391  };
1392  
1393  /* This is the new structure to use with the dirent64 syscall. */
1394  struct vki_dirent64 {
1395  	__vki_u64 d_ino;
1396  	__vki_s64 d_off;
1397  	unsigned short d_reclen;
1398  	unsigned char d_type;
1399  	char d_name[256]; /* Note we hard code a max file length here. */
1400  };
1401  
1402  //----------------------------------------------------------------------
1403  // From linux-2.6.8.1/include/linux/fcntl.h
1404  //----------------------------------------------------------------------
1405  
1406  #define VKI_F_SETLEASE      (VKI_F_LINUX_SPECIFIC_BASE + 0)
1407  #define VKI_F_GETLEASE      (VKI_F_LINUX_SPECIFIC_BASE + 1)
1408  
1409  #define VKI_F_CANCELLK      (VKI_F_LINUX_SPECIFIC_BASE + 5)
1410  
1411  #define VKI_F_DUPFD_CLOEXEC (VKI_F_LINUX_SPECIFIC_BASE + 6)
1412  
1413  #define VKI_F_NOTIFY        (VKI_F_LINUX_SPECIFIC_BASE + 2)
1414  
1415  #define VKI_F_SETPIPE_SZ    (VKI_F_LINUX_SPECIFIC_BASE + 7)
1416  #define VKI_F_GETPIPE_SZ    (VKI_F_LINUX_SPECIFIC_BASE + 8)
1417  
1418  //----------------------------------------------------------------------
1419  // From linux-2.6.8.1/include/linux/sysctl.h
1420  //----------------------------------------------------------------------
1421  
1422  struct __vki_sysctl_args {
1423  	int __user *name;
1424  	int nlen;
1425  	void __user *oldval;
1426  	vki_size_t __user *oldlenp;
1427  	void __user *newval;
1428  	vki_size_t newlen;
1429  	unsigned long __unused0[4];
1430  };
1431  
1432  //----------------------------------------------------------------------
1433  // From linux-2.6.8.1/include/linux/aio_abi.h
1434  //----------------------------------------------------------------------
1435  
1436  typedef unsigned long	vki_aio_context_t;
1437  
1438  enum {
1439  	VKI_IOCB_CMD_PREAD = 0,
1440  	VKI_IOCB_CMD_PWRITE = 1,
1441  	VKI_IOCB_CMD_FSYNC = 2,
1442  	VKI_IOCB_CMD_FDSYNC = 3,
1443  	VKI_IOCB_CMD_PREADV = 7,
1444  	VKI_IOCB_CMD_PWRITEV = 8,
1445  };
1446  
1447  /* read() from /dev/aio returns these structures. */
1448  struct vki_io_event {
1449  	__vki_u64	data;		/* the data field from the iocb */
1450  	__vki_u64	obj;		/* what iocb this event came from */
1451          // [[Nb: These fields renamed from 'res' and 'res2' because 'res' is
1452          //   a macro in vg_syscalls.c!]]
1453  	__vki_s64	result;		/* result code for this event */
1454  	__vki_s64	result2;	/* secondary result */
1455  };
1456  
1457  #if defined(VKI_LITTLE_ENDIAN)
1458  #  define VKI_PADDED(x,y)	x, y
1459  #elif defined(VKI_BIG_ENDIAN)
1460  #  define VKI_PADDED(x,y)	y, x
1461  #else
1462  #error edit for your odd byteorder.
1463  #endif
1464  
1465  struct vki_iocb {
1466  	/* these are internal to the kernel/libc. */
1467  	__vki_u64	aio_data;	/* data to be returned in event's data */
1468  	__vki_u32	VKI_PADDED(aio_key, aio_reserved1);
1469  				/* the kernel sets aio_key to the req # */
1470  
1471  	/* common fields */
1472  	__vki_u16	aio_lio_opcode;	/* see IOCB_CMD_ above */
1473  	__vki_s16	aio_reqprio;
1474  	__vki_u32	aio_fildes;
1475  
1476  	__vki_u64	aio_buf;
1477  	__vki_u64	aio_nbytes;
1478  	__vki_s64	aio_offset;
1479  
1480  	/* extra parameters */
1481  	__vki_u64	aio_reserved2;	/* TODO: use this for a (struct sigevent *) */
1482  	__vki_u64	aio_reserved3;
1483  }; /* 64 bytes */
1484  
1485  //----------------------------------------------------------------------
1486  // From linux-2.6.8.1/include/linux/aio.h
1487  //----------------------------------------------------------------------
1488  
1489  struct vki_aio_ring {
1490  	unsigned	id;	/* kernel internal index number */
1491  	unsigned	nr;	/* number of io_events */
1492  	unsigned	head;
1493  	unsigned	tail;
1494  
1495  	unsigned	magic;
1496  	unsigned	compat_features;
1497  	unsigned	incompat_features;
1498  	unsigned	header_length;	/* size of aio_ring */
1499  
1500  	struct vki_io_event		io_events[0];
1501  }; /* 128 bytes + ring size */
1502  
1503  //----------------------------------------------------------------------
1504  // From linux-2.6.8.1/include/linux/msg.h
1505  //----------------------------------------------------------------------
1506  
1507  #define VKI_MSG_STAT 11
1508  #define VKI_MSG_INFO 12
1509  
1510  struct vki_msqid_ds {
1511  	struct vki_ipc_perm msg_perm;
1512  	struct vki_msg *msg_first;		/* first message on queue,unused  */
1513  	struct vki_msg *msg_last;		/* last message in queue,unused */
1514  	__vki_kernel_time_t msg_stime;	/* last msgsnd time */
1515  	__vki_kernel_time_t msg_rtime;	/* last msgrcv time */
1516  	__vki_kernel_time_t msg_ctime;	/* last change time */
1517  	unsigned long  msg_lcbytes;	/* Reuse junk fields for 32 bit */
1518  	unsigned long  msg_lqbytes;	/* ditto */
1519  	unsigned short msg_cbytes;	/* current number of bytes on queue */
1520  	unsigned short msg_qnum;	/* number of messages in queue */
1521  	unsigned short msg_qbytes;	/* max number of bytes on queue */
1522  	__vki_kernel_ipc_pid_t msg_lspid;	/* pid of last msgsnd */
1523  	__vki_kernel_ipc_pid_t msg_lrpid;	/* last receive pid */
1524  };
1525  
1526  struct vki_msgbuf {
1527  	long mtype;         /* type of message */
1528  	char mtext[1];      /* message text */
1529  };
1530  
1531  struct vki_msginfo {
1532  	int msgpool;
1533  	int msgmap;
1534  	int msgmax;
1535  	int msgmnb;
1536  	int msgmni;
1537  	int msgssz;
1538  	int msgtql;
1539  	unsigned short  msgseg;
1540  };
1541  
1542  //----------------------------------------------------------------------
1543  // From linux-2.6.8.1/include/linux/shm.h
1544  //----------------------------------------------------------------------
1545  
1546  struct vki_shmid_ds {
1547  	struct vki_ipc_perm		shm_perm;	/* operation perms */
1548  	int			shm_segsz;	/* size of segment (bytes) */
1549  	__vki_kernel_time_t		shm_atime;	/* last attach time */
1550  	__vki_kernel_time_t		shm_dtime;	/* last detach time */
1551  	__vki_kernel_time_t		shm_ctime;	/* last change time */
1552  	__vki_kernel_ipc_pid_t	shm_cpid;	/* pid of creator */
1553  	__vki_kernel_ipc_pid_t	shm_lpid;	/* pid of last operator */
1554  	unsigned short		shm_nattch;	/* no. of current attaches */
1555  	unsigned short 		shm_unused;	/* compatibility */
1556  	void 			*shm_unused2;	/* ditto - used by DIPC */
1557  	void			*shm_unused3;	/* unused */
1558  };
1559  
1560  #define VKI_SHM_RDONLY  010000  /* read-only access */
1561  #define VKI_SHM_RND     020000  /* round attach address to SHMLBA boundary */
1562  
1563  #define VKI_SHM_STAT 	13
1564  #define VKI_SHM_INFO 	14
1565  
1566  /* Obsolete, used only for backwards compatibility */
1567  struct	vki_shminfo {
1568  	int shmmax;
1569  	int shmmin;
1570  	int shmmni;
1571  	int shmseg;
1572  	int shmall;
1573  };
1574  
1575  struct vki_shm_info {
1576  	int used_ids;
1577  	unsigned long shm_tot;	/* total allocated shm */
1578  	unsigned long shm_rss;	/* total resident shm */
1579  	unsigned long shm_swp;	/* total swapped shm */
1580  	unsigned long swap_attempts;
1581  	unsigned long swap_successes;
1582  };
1583  
1584  //----------------------------------------------------------------------
1585  // From linux-2.6.8.1/include/linux/rtc.h
1586  //----------------------------------------------------------------------
1587  
1588  struct vki_rtc_time {
1589  	int tm_sec;
1590  	int tm_min;
1591  	int tm_hour;
1592  	int tm_mday;
1593  	int tm_mon;
1594  	int tm_year;
1595  	int tm_wday;
1596  	int tm_yday;
1597  	int tm_isdst;
1598  };
1599  
1600  #define VKI_RTC_AIE_ON	_VKI_IO('p', 0x01)	/* Alarm int. enable on	*/
1601  #define VKI_RTC_AIE_OFF	_VKI_IO('p', 0x02)	/* ... off		*/
1602  #define VKI_RTC_UIE_ON	_VKI_IO('p', 0x03)	/* Update int. enable on*/
1603  #define VKI_RTC_UIE_OFF	_VKI_IO('p', 0x04)	/* ... off		*/
1604  #define VKI_RTC_PIE_ON	_VKI_IO('p', 0x05)	/* Periodic int. enable on*/
1605  #define VKI_RTC_PIE_OFF	_VKI_IO('p', 0x06)	/* ... off		*/
1606  
1607  #define VKI_RTC_ALM_SET		_VKI_IOW('p', 0x07, struct vki_rtc_time) /* Set alarm time  */
1608  #define VKI_RTC_ALM_READ	_VKI_IOR('p', 0x08, struct vki_rtc_time) /* Read alarm time */
1609  #define VKI_RTC_RD_TIME		_VKI_IOR('p', 0x09, struct vki_rtc_time) /* Read RTC time   */
1610  //#define RTC_SET_TIME	_IOW('p', 0x0a, struct rtc_time) /* Set RTC time    */
1611  #define VKI_RTC_IRQP_READ	_VKI_IOR('p', 0x0b, unsigned long)	 /* Read IRQ rate   */
1612  #define VKI_RTC_IRQP_SET	_VKI_IOW('p', 0x0c, unsigned long)	 /* Set IRQ rate    */
1613  
1614  //----------------------------------------------------------------------
1615  // From linux-2.6.8.1/include/linux/isdn.h
1616  //----------------------------------------------------------------------
1617  
1618  // [[Nb: Resolved this for the common case where CONFIG_COBALT_MICRO_SERVER
1619  //   is not defined]]
1620  #define VKI_ISDN_MAX_CHANNELS   64
1621  
1622  #define VKI_IIOCGETCPS  _VKI_IO('I',21)
1623  
1624  #define VKI_IIOCNETGPN  _VKI_IO('I',34)
1625  
1626  #define VKI_ISDN_MSNLEN          32
1627  
1628  typedef struct {
1629    char name[10];
1630    char phone[VKI_ISDN_MSNLEN];
1631    int  outgoing;
1632  } vki_isdn_net_ioctl_phone;
1633  
1634  //----------------------------------------------------------------------
1635  // From linux-2.6.8.1/include/linux/sockios.h
1636  //----------------------------------------------------------------------
1637  
1638  #define VKI_SIOCOUTQ		VKI_TIOCOUTQ
1639  
1640  #define VKI_SIOCADDRT		0x890B	/* add routing table entry	*/
1641  #define VKI_SIOCDELRT		0x890C	/* delete routing table entry	*/
1642  
1643  #define VKI_SIOCGIFNAME		0x8910	/* get iface name		*/
1644  #define VKI_SIOCGIFCONF		0x8912	/* get iface list		*/
1645  #define VKI_SIOCGIFFLAGS	0x8913	/* get flags			*/
1646  #define VKI_SIOCSIFFLAGS	0x8914	/* set flags			*/
1647  #define VKI_SIOCGIFADDR		0x8915	/* get PA address		*/
1648  #define VKI_SIOCSIFADDR		0x8916	/* set PA address		*/
1649  #define VKI_SIOCGIFDSTADDR	0x8917	/* get remote PA address	*/
1650  #define VKI_SIOCSIFDSTADDR	0x8918	/* set remote PA address	*/
1651  #define VKI_SIOCGIFBRDADDR	0x8919	/* get broadcast PA address	*/
1652  #define VKI_SIOCSIFBRDADDR	0x891a	/* set broadcast PA address	*/
1653  #define VKI_SIOCGIFNETMASK	0x891b	/* get network PA mask		*/
1654  #define VKI_SIOCSIFNETMASK	0x891c	/* set network PA mask		*/
1655  #define VKI_SIOCGIFMETRIC	0x891d	/* get metric			*/
1656  #define VKI_SIOCSIFMETRIC	0x891e	/* set metric			*/
1657  #define VKI_SIOCGIFMTU		0x8921	/* get MTU size			*/
1658  #define VKI_SIOCSIFMTU		0x8922	/* set MTU size			*/
1659  #define	VKI_SIOCSIFHWADDR	0x8924	/* set hardware address 	*/
1660  #define VKI_SIOCGIFHWADDR	0x8927	/* Get hardware address		*/
1661  #define VKI_SIOCGIFINDEX	0x8933	/* name -> if_index mapping	*/
1662  
1663  #define VKI_SIOCGIFTXQLEN	0x8942	/* Get the tx queue length	*/
1664  #define VKI_SIOCSIFTXQLEN	0x8943	/* Set the tx queue length 	*/
1665  
1666  #define VKI_SIOCETHTOOL		0x8946	/* Ethtool interface		*/
1667  
1668  #define VKI_SIOCGMIIPHY		0x8947	/* Get address of MII PHY in use. */
1669  #define VKI_SIOCGMIIREG		0x8948	/* Read MII PHY register.	*/
1670  #define VKI_SIOCSMIIREG		0x8949	/* Write MII PHY register.	*/
1671  
1672  #define VKI_SIOCDARP		0x8953	/* delete ARP table entry	*/
1673  #define VKI_SIOCGARP		0x8954	/* get ARP table entry		*/
1674  #define VKI_SIOCSARP		0x8955	/* set ARP table entry		*/
1675  
1676  #define VKI_SIOCDRARP		0x8960	/* delete RARP table entry	*/
1677  #define VKI_SIOCGRARP		0x8961	/* get RARP table entry		*/
1678  #define VKI_SIOCSRARP		0x8962	/* set RARP table entry		*/
1679  
1680  #define VKI_SIOCGIFMAP		0x8970	/* Get device parameters	*/
1681  #define VKI_SIOCSIFMAP		0x8971	/* Set device parameters	*/
1682  
1683  #define VKI_SIOCSHWTSTAMP	0x89B0	/* Set hardware time stamping */
1684  
1685  //----------------------------------------------------------------------
1686  // From linux-2.6.8.1/include/linux/ppdev.h
1687  //----------------------------------------------------------------------
1688  
1689  #define VKI_PP_MAJOR	99
1690  
1691  #define VKI_PP_IOCTL	'p'
1692  
1693  /* Set mode for read/write (e.g. IEEE1284_MODE_EPP) */
1694  #define VKI_PPSETMODE	_VKI_IOW(VKI_PP_IOCTL, 0x80, int)
1695  
1696  /* Read status */
1697  #define VKI_PPRSTATUS	_VKI_IOR(VKI_PP_IOCTL, 0x81, unsigned char)
1698  //#define PPWSTATUS	OBSOLETE__IOW(PP_IOCTL, 0x82, unsigned char)
1699  
1700  /* Read/write control */
1701  #define VKI_PPRCONTROL	_VKI_IOR(VKI_PP_IOCTL, 0x83, unsigned char)
1702  #define VKI_PPWCONTROL	_VKI_IOW(VKI_PP_IOCTL, 0x84, unsigned char)
1703  
1704  struct vki_ppdev_frob_struct {
1705  	unsigned char mask;
1706  	unsigned char val;
1707  };
1708  #define VKI_PPFCONTROL      _VKI_IOW(VKI_PP_IOCTL, 0x8e, struct vki_ppdev_frob_struct)
1709  
1710  /* Read/write data */
1711  #define VKI_PPRDATA		_VKI_IOR(VKI_PP_IOCTL, 0x85, unsigned char)
1712  #define VKI_PPWDATA		_VKI_IOW(VKI_PP_IOCTL, 0x86, unsigned char)
1713  
1714  /* Claim the port to start using it */
1715  #define VKI_PPCLAIM		_VKI_IO(VKI_PP_IOCTL, 0x8b)
1716  
1717  /* Release the port when you aren't using it */
1718  #define VKI_PPRELEASE	_VKI_IO(VKI_PP_IOCTL, 0x8c)
1719  
1720  /* Yield the port (release it if another driver is waiting,
1721   * then reclaim) */
1722  #define VKI_PPYIELD		_VKI_IO(VKI_PP_IOCTL, 0x8d)
1723  
1724  /* Register device exclusively (must be before PPCLAIM). */
1725  #define VKI_PPEXCL		_VKI_IO(VKI_PP_IOCTL, 0x8f)
1726  
1727  /* Data line direction: non-zero for input mode. */
1728  #define VKI_PPDATADIR	_VKI_IOW(VKI_PP_IOCTL, 0x90, int)
1729  
1730  /* Negotiate a particular IEEE 1284 mode. */
1731  #define VKI_PPNEGOT	_VKI_IOW(VKI_PP_IOCTL, 0x91, int)
1732  
1733  /* Set control lines when an interrupt occurs. */
1734  #define VKI_PPWCTLONIRQ	_VKI_IOW(VKI_PP_IOCTL, 0x92, unsigned char)
1735  
1736  /* Clear (and return) interrupt count. */
1737  #define VKI_PPCLRIRQ	_VKI_IOR(VKI_PP_IOCTL, 0x93, int)
1738  
1739  /* Set the IEEE 1284 phase that we're in (e.g. IEEE1284_PH_FWD_IDLE) */
1740  #define VKI_PPSETPHASE	_VKI_IOW(VKI_PP_IOCTL, 0x94, int)
1741  
1742  /* Set and get port timeout (struct timeval's) */
1743  #define VKI_PPGETTIME	_VKI_IOR(VKI_PP_IOCTL, 0x95, struct vki_timeval)
1744  #define VKI_PPSETTIME	_VKI_IOW(VKI_PP_IOCTL, 0x96, struct vki_timeval)
1745  
1746  #define VKI_PPGETMODES	_VKI_IOR(VKI_PP_IOCTL, 0x97, unsigned int)
1747  
1748  #define VKI_PPGETMODE	_VKI_IOR(VKI_PP_IOCTL, 0x98, int)
1749  #define VKI_PPGETPHASE	_VKI_IOR(VKI_PP_IOCTL, 0x99, int)
1750  
1751  #define VKI_PPGETFLAGS	_VKI_IOR(VKI_PP_IOCTL, 0x9a, int)
1752  #define VKI_PPSETFLAGS	_VKI_IOW(VKI_PP_IOCTL, 0x9b, int)
1753  
1754  //----------------------------------------------------------------------
1755  // From linux-3.16/include/uapi/linux/fs.h
1756  //----------------------------------------------------------------------
1757  
1758  #define VKI_BLKROSET   _VKI_IO(0x12,93)	/* set device read-only (0 = read-write) */
1759  #define VKI_BLKROGET   _VKI_IO(0x12,94)	/* get read-only status (0 = read_write) */
1760  #define VKI_BLKGETSIZE _VKI_IO(0x12,96) /* return device size /512 (long *arg) */
1761  #define VKI_BLKRASET   _VKI_IO(0x12,98)	/* set read ahead for block device */
1762  #define VKI_BLKRAGET   _VKI_IO(0x12,99)	/* get current read ahead setting */
1763  #define VKI_BLKFRASET  _VKI_IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
1764  #define VKI_BLKFRAGET  _VKI_IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
1765  #define VKI_BLKSECTGET _VKI_IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
1766  #define VKI_BLKSSZGET  _VKI_IO(0x12,104)/* get block device sector size */
1767  #define VKI_BLKBSZGET  _VKI_IOR(0x12,112,vki_size_t)
1768  #define VKI_BLKBSZSET  _VKI_IOW(0x12,113,vki_size_t)
1769  #define VKI_BLKGETSIZE64 _VKI_IOR(0x12,114,vki_size_t) /* return device size in bytes (u64 *arg) */
1770  #define VKI_BLKPBSZGET _VKI_IO(0x12,123)
1771  #define VKI_BLKDISCARDZEROES _VKI_IO(0x12,124)
1772  
1773  #define VKI_FIBMAP	_VKI_IO(0x00,1)	/* bmap access */
1774  #define VKI_FIGETBSZ    _VKI_IO(0x00,2)	/* get the block size used for bmap */
1775  
1776  //----------------------------------------------------------------------
1777  // From linux-2.6.8.1/include/scsi/sg.h
1778  //----------------------------------------------------------------------
1779  
1780  typedef struct vki_sg_io_hdr
1781  {
1782      int interface_id;           /* [i] 'S' for SCSI generic (required) */
1783      int dxfer_direction;        /* [i] data transfer direction  */
1784      unsigned char cmd_len;      /* [i] SCSI command length ( <= 16 bytes) */
1785      unsigned char mx_sb_len;    /* [i] max length to write to sbp */
1786      unsigned short iovec_count; /* [i] 0 implies no scatter gather */
1787      unsigned int dxfer_len;     /* [i] byte count of data transfer */
1788      void __user *dxferp;	/* [i], [*io] points to data transfer memory
1789  					      or scatter gather list */
1790      unsigned char __user *cmdp; /* [i], [*i] points to command to perform */
1791      void __user *sbp;		/* [i], [*o] points to sense_buffer memory */
1792      unsigned int timeout;       /* [i] MAX_UINT->no timeout (unit: millisec) */
1793      unsigned int flags;         /* [i] 0 -> default, see SG_FLAG... */
1794      int pack_id;                /* [i->o] unused internally (normally) */
1795      void __user * usr_ptr;      /* [i->o] unused internally */
1796      unsigned char status;       /* [o] scsi status */
1797      unsigned char masked_status;/* [o] shifted, masked scsi status */
1798      unsigned char msg_status;   /* [o] messaging level data (optional) */
1799      unsigned char sb_len_wr;    /* [o] byte count actually written to sbp */
1800      unsigned short host_status; /* [o] errors from host adapter */
1801      unsigned short driver_status;/* [o] errors from software driver */
1802      int resid;                  /* [o] dxfer_len - actual_transferred */
1803      unsigned int duration;      /* [o] time taken by cmd (unit: millisec) */
1804      unsigned int info;          /* [o] auxiliary information */
1805  } vki_sg_io_hdr_t;  /* 64 bytes long (on i386) */
1806  
1807  #define VKI_SG_DXFER_NONE -1        /* e.g. a SCSI Test Unit Ready command */
1808  #define VKI_SG_DXFER_TO_DEV -2      /* e.g. a SCSI WRITE command */
1809  #define VKI_SG_DXFER_FROM_DEV -3    /* e.g. a SCSI READ command */
1810  #define VKI_SG_DXFER_TO_FROM_DEV -4 /* treated like SG_DXFER_FROM_DEV with the
1811  				   additional property than during indirect
1812  				   IO the user buffer is copied into the
1813  				   kernel buffers before the transfer */
1814  
1815  typedef struct vki_sg_scsi_id { /* used by SG_GET_SCSI_ID ioctl() */
1816      int host_no;        /* as in "scsi<n>" where 'n' is one of 0, 1, 2 etc */
1817      int channel;
1818      int scsi_id;        /* scsi id of target device */
1819      int lun;
1820      int scsi_type;      /* TYPE_... defined in scsi/scsi.h */
1821      short h_cmd_per_lun;/* host (adapter) maximum commands per lun */
1822      short d_queue_depth;/* device (or adapter) maximum queue length */
1823      int unused[2];      /* probably find a good use, set 0 for now */
1824  } vki_sg_scsi_id_t; /* 32 bytes long on i386 */
1825  
1826  #define VKI_SG_EMULATED_HOST 0x2203 /* true for emulated host adapter (ATAPI) */
1827  
1828  #define VKI_SG_SET_RESERVED_SIZE 0x2275  /* request a new reserved buffer size */
1829  #define VKI_SG_GET_RESERVED_SIZE 0x2272  /* actual size of reserved buffer */
1830  
1831  #define VKI_SG_GET_SCSI_ID 0x2276   /* Yields fd's bus, chan, dev, lun + type */
1832  
1833  #define VKI_SG_GET_SG_TABLESIZE 0x227F  /* 0 implies can't do scatter gather */
1834  
1835  #define VKI_SG_GET_VERSION_NUM 0x2282 /* Example: version 2.1.34 yields 20134 */
1836  
1837  #define VKI_SG_IO 0x2285   /* similar effect as write() followed by read() */
1838  
1839  #define VKI_SG_SET_TIMEOUT 0x2201  /* unit: jiffies (10ms on i386) */
1840  #define VKI_SG_GET_TIMEOUT 0x2202  /* yield timeout as _return_ value */
1841  
1842  //#define SG_GET_COMMAND_Q 0x2270   /* Yields 0 (queuing off) or 1 (on) */
1843  #define VKI_SG_SET_COMMAND_Q 0x2271   /* Change queuing state with 0 or 1 */
1844  
1845  //----------------------------------------------------------------------
1846  // From linux-2.6.34/include/scsi/scsi.h and scsi/scsi_ioctl.h
1847  //----------------------------------------------------------------------
1848  
1849  #define VKI_SCSI_IOCTL_DOORLOCK		0x5380 /* Lock the eject mechanism.  */
1850  #define VKI_SCSI_IOCTL_DOORUNLOCK	0x5381 /* Unlock the mechanism.  */
1851  #define VKI_SCSI_IOCTL_GET_IDLUN	0x5382
1852  #define VKI_SCSI_IOCTL_GET_BUS_NUMBER	0x5386
1853  
1854  struct vki_scsi_idlun {
1855  	__vki_u32 dev_id;
1856  	__vki_u32 host_unique_id;
1857  };
1858  
1859  //----------------------------------------------------------------------
1860  // From linux-2.6.8.1/include/linux/cdrom.h
1861  //----------------------------------------------------------------------
1862  
1863  #define VKI_CDROMPLAYMSF		0x5303 /* Play Audio MSF (struct cdrom_msf) */
1864  #define VKI_CDROMREADTOCHDR		0x5305 /* Read TOC header
1865                                  	           (struct cdrom_tochdr) */
1866  #define VKI_CDROMREADTOCENTRY		0x5306 /* Read TOC entry
1867                                  	           (struct cdrom_tocentry) */
1868  #define VKI_CDROMSUBCHNL		0x530b /* Read subchannel data
1869                                  	           (struct cdrom_subchnl) */
1870  #define VKI_CDROMREADMODE2		0x530c /* Read CDROM mode 2 data (2336 Bytes)
1871                                  	           (struct cdrom_read) */
1872  #define VKI_CDROMREADAUDIO		0x530e /* (struct cdrom_read_audio) */
1873  #define VKI_CDROMMULTISESSION		0x5310 /* Obtain the start-of-last-session
1874                                  	           address of multi session disks
1875                                  	           (struct cdrom_multisession) */
1876  #define VKI_CDROM_GET_MCN		0x5311 /* Obtain the "Universal Product Code"
1877                                  	           if available (struct cdrom_mcn) */
1878  #define VKI_CDROMVOLREAD		0x5313 /* Get the drive's volume setting
1879                                  	          (struct cdrom_volctrl) */
1880  #define VKI_CDROMREADRAW		0x5314	/* read data in raw mode (2352 Bytes)
1881                                  	           (struct cdrom_read) */
1882  #define VKI_CDROM_CLEAR_OPTIONS		0x5321  /* Clear behavior options */
1883  #define VKI_CDROM_DRIVE_STATUS		0x5326  /* Get tray position, etc. */
1884  #define VKI_CDROM_DISC_STATUS		0x5327	/* get CD type information */
1885  #define VKI_CDROM_GET_CAPABILITY	0x5331	/* get capabilities */
1886  
1887  #define VKI_CDROM_SEND_PACKET		0x5393	/* send a packet to the drive */
1888  
1889  struct vki_cdrom_msf0
1890  {
1891  	__vki_u8	minute;
1892  	__vki_u8	second;
1893  	__vki_u8	frame;
1894  };
1895  
1896  union vki_cdrom_addr
1897  {
1898  	struct vki_cdrom_msf0	msf;
1899  	int			lba;
1900  };
1901  
1902  struct vki_cdrom_msf
1903  {
1904  	__vki_u8	cdmsf_min0;	/* start minute */
1905  	__vki_u8	cdmsf_sec0;	/* start second */
1906  	__vki_u8	cdmsf_frame0;	/* start frame */
1907  	__vki_u8	cdmsf_min1;	/* end minute */
1908  	__vki_u8	cdmsf_sec1;	/* end second */
1909  	__vki_u8	cdmsf_frame1;	/* end frame */
1910  };
1911  
1912  struct vki_cdrom_tochdr
1913  {
1914  	__vki_u8	cdth_trk0;	/* start track */
1915  	__vki_u8	cdth_trk1;	/* end track */
1916  };
1917  
1918  struct vki_cdrom_volctrl
1919  {
1920  	__vki_u8	channel0;
1921  	__vki_u8	channel1;
1922  	__vki_u8	channel2;
1923  	__vki_u8	channel3;
1924  };
1925  
1926  struct vki_cdrom_subchnl
1927  {
1928  	__vki_u8	cdsc_format;
1929  	__vki_u8	cdsc_audiostatus;
1930  	__vki_u8	cdsc_adr:	4;
1931  	__vki_u8	cdsc_ctrl:	4;
1932  	__vki_u8	cdsc_trk;
1933  	__vki_u8	cdsc_ind;
1934  	union vki_cdrom_addr cdsc_absaddr;
1935  	union vki_cdrom_addr cdsc_reladdr;
1936  };
1937  
1938  struct vki_cdrom_tocentry
1939  {
1940  	__vki_u8	cdte_track;
1941  	__vki_u8	cdte_adr	:4;
1942  	__vki_u8	cdte_ctrl	:4;
1943  	__vki_u8	cdte_format;
1944  	union vki_cdrom_addr cdte_addr;
1945  	__vki_u8	cdte_datamode;
1946  };
1947  
1948  struct vki_cdrom_read
1949  {
1950  	int	cdread_lba;
1951  	char 	*cdread_bufaddr;
1952  	int	cdread_buflen;
1953  };
1954  
1955  struct vki_cdrom_read_audio
1956  {
1957  	union vki_cdrom_addr addr; /* frame address */
1958  	__vki_u8 addr_format;      /* CDROM_LBA or CDROM_MSF */
1959  	int nframes;           /* number of 2352-byte-frames to read at once */
1960  	__vki_u8 __user *buf;      /* frame buffer (size: nframes*2352 bytes) */
1961  };
1962  
1963  struct vki_cdrom_multisession
1964  {
1965  	union vki_cdrom_addr addr; /* frame address: start-of-last-session
1966  	                           (not the new "frame 16"!).  Only valid
1967  	                           if the "xa_flag" is true. */
1968  	__vki_u8 xa_flag;        /* 1: "is XA disk" */
1969  	__vki_u8 addr_format;    /* CDROM_LBA or CDROM_MSF */
1970  };
1971  
1972  struct vki_cdrom_mcn
1973  {
1974    __vki_u8 medium_catalog_number[14]; /* 13 ASCII digits, null-terminated */
1975  };
1976  
1977  #define VKI_CDROM_PACKET_SIZE	12
1978  
1979  struct vki_cdrom_generic_command
1980  {
1981  	unsigned char 		cmd[VKI_CDROM_PACKET_SIZE];
1982  	unsigned char		__user *buffer;
1983  	unsigned int 		buflen;
1984  	int			stat;
1985          // [[replace with void* to reduce inclusion amounts]]
1986  	void/*struct vki_request_sense	*/__user *sense;
1987  	unsigned char		data_direction;
1988  	int			quiet;
1989  	int			timeout;
1990  	void			__user *reserved[1];	/* unused, actually */
1991  };
1992  
1993  #define VKI_CD_SYNC_SIZE         12 /* 12 sync bytes per raw data frame */
1994  #define VKI_CD_HEAD_SIZE          4 /* header (address) bytes per raw data frame */
1995  #define VKI_CD_FRAMESIZE_RAW   2352 /* bytes per frame, "raw" mode */
1996  #define VKI_CD_FRAMESIZE_RAW0 (VKI_CD_FRAMESIZE_RAW-VKI_CD_SYNC_SIZE-VKI_CD_HEAD_SIZE) /*2336*/
1997  
1998  //----------------------------------------------------------------------
1999  // From linux-2.6.8.1/include/linux/soundcard.h
2000  //----------------------------------------------------------------------
2001  
2002  #ifndef _VKI_SIOWR
2003  #if defined(_VKI_IOWR) && (defined(_AIX) || (!defined(sun) && !defined(sparc) && !defined(__sparc__) && !defined(__INCioctlh) && !defined(__Lynx__)))
2004  /* Use already defined ioctl defines if they exist (except with Sun or Sparc) */
2005  #define	_VKI_SIO		_VKI_IO
2006  #define	_VKI_SIOR		_VKI_IOR
2007  #define	_VKI_SIOW		_VKI_IOW
2008  #define	_VKI_SIOWR		_VKI_IOWR
2009  #else
2010  // [[Valgrind: Install this case if/when necessary]
2011  #error Valgrind: Cannot handle sparc/sun case yet...
2012  #  endif /* _IOWR */
2013  #endif  /* !_VKI_SIOWR */
2014  
2015  #define VKI_SNDCTL_SEQ_CTRLRATE		_VKI_SIOWR('Q', 3, int)	/* Set/get timer resolution (HZ) */
2016  #define VKI_SNDCTL_SEQ_GETOUTCOUNT	_VKI_SIOR ('Q', 4, int)
2017  #define VKI_SNDCTL_SEQ_GETINCOUNT	_VKI_SIOR ('Q', 5, int)
2018  #define VKI_SNDCTL_SEQ_PERCMODE		_VKI_SIOW ('Q', 6, int)
2019  #define VKI_SNDCTL_SEQ_TESTMIDI		_VKI_SIOW ('Q', 8, int)
2020  #define VKI_SNDCTL_SEQ_RESETSAMPLES	_VKI_SIOW ('Q', 9, int)
2021  #define VKI_SNDCTL_SEQ_NRSYNTHS		_VKI_SIOR ('Q',10, int)
2022  #define VKI_SNDCTL_SEQ_NRMIDIS		_VKI_SIOR ('Q',11, int)
2023  #define VKI_SNDCTL_SEQ_GETTIME		_VKI_SIOR ('Q',19, int)
2024  
2025  #define VKI_SNDCTL_TMR_TIMEBASE		_VKI_SIOWR('T', 1, int)
2026  #define VKI_SNDCTL_TMR_TEMPO		_VKI_SIOWR('T', 5, int)
2027  #define VKI_SNDCTL_TMR_SOURCE		_VKI_SIOWR('T', 6, int)
2028  
2029  #define VKI_SNDCTL_MIDI_PRETIME		_VKI_SIOWR('m', 0, int)
2030  #define VKI_SNDCTL_MIDI_MPUMODE		_VKI_SIOWR('m', 1, int)
2031  
2032  #define VKI_SNDCTL_DSP_RESET		_VKI_SIO  ('P', 0)
2033  #define VKI_SNDCTL_DSP_SYNC		_VKI_SIO  ('P', 1)
2034  #define VKI_SNDCTL_DSP_SPEED		_VKI_SIOWR('P', 2, int)
2035  #define VKI_SNDCTL_DSP_STEREO		_VKI_SIOWR('P', 3, int)
2036  #define VKI_SNDCTL_DSP_GETBLKSIZE	_VKI_SIOWR('P', 4, int)
2037  #define VKI_SNDCTL_DSP_CHANNELS		_VKI_SIOWR('P', 6, int)
2038  #define VKI_SOUND_PCM_WRITE_FILTER	_VKI_SIOWR('P', 7, int)
2039  #define VKI_SNDCTL_DSP_POST		_VKI_SIO  ('P', 8)
2040  #define VKI_SNDCTL_DSP_SUBDIVIDE	_VKI_SIOWR('P', 9, int)
2041  #define VKI_SNDCTL_DSP_SETFRAGMENT	_VKI_SIOWR('P',10, int)
2042  
2043  #define VKI_SNDCTL_DSP_GETFMTS		_VKI_SIOR ('P',11, int) /* Returns a mask */
2044  #define VKI_SNDCTL_DSP_SETFMT		_VKI_SIOWR('P', 5, int) /* Selects ONE fmt */
2045  
2046  typedef struct vki_audio_buf_info {
2047  			int fragments;	/* # of available fragments (partially usend ones not counted) */
2048  			int fragstotal;	/* Total # of fragments allocated */
2049  			int fragsize;	/* Size of a fragment in bytes */
2050  
2051  			int bytes;	/* Available space in bytes (includes partially used fragments) */
2052  			/* Note! 'bytes' could be more than fragments*fragsize */
2053  		} vki_audio_buf_info;
2054  
2055  #define VKI_SNDCTL_DSP_GETOSPACE	_VKI_SIOR ('P',12, vki_audio_buf_info)
2056  #define VKI_SNDCTL_DSP_GETISPACE	_VKI_SIOR ('P',13, vki_audio_buf_info)
2057  #define VKI_SNDCTL_DSP_NONBLOCK		_VKI_SIO  ('P',14)
2058  #define VKI_SNDCTL_DSP_GETCAPS		_VKI_SIOR ('P',15, int)
2059  
2060  #define VKI_SNDCTL_DSP_GETTRIGGER	_VKI_SIOR ('P',16, int)
2061  #define VKI_SNDCTL_DSP_SETTRIGGER	_VKI_SIOW ('P',16, int)
2062  
2063  #define VKI_SNDCTL_DSP_SETSYNCRO	_VKI_SIO  ('P', 21)
2064  #define VKI_SNDCTL_DSP_SETDUPLEX	_VKI_SIO  ('P', 22)
2065  #define VKI_SNDCTL_DSP_GETODELAY	_VKI_SIOR ('P', 23, int)
2066  
2067  #define VKI_SNDCTL_DSP_GETCHANNELMASK	_VKI_SIOWR('P', 64, int)
2068  #define VKI_SNDCTL_DSP_BIND_CHANNEL	_VKI_SIOWR('P', 65, int)
2069  
2070  #define VKI_SNDCTL_DSP_SETSPDIF		_VKI_SIOW ('P', 66, int)
2071  #define VKI_SNDCTL_DSP_GETSPDIF		_VKI_SIOR ('P', 67, int)
2072  
2073  #define VKI_SOUND_PCM_READ_RATE		_VKI_SIOR ('P', 2, int)
2074  #define VKI_SOUND_PCM_READ_CHANNELS	_VKI_SIOR ('P', 6, int)
2075  #define VKI_SOUND_PCM_READ_BITS		_VKI_SIOR ('P', 5, int)
2076  #define VKI_SOUND_PCM_READ_FILTER	_VKI_SIOR ('P', 7, int)
2077  
2078  
2079  //----------------------------------------------------------------------
2080  // From linux-2.6.8.1/include/linux/hdreg.h
2081  //----------------------------------------------------------------------
2082  
2083  struct vki_hd_geometry {
2084        unsigned char heads;
2085        unsigned char sectors;
2086        unsigned short cylinders;
2087        unsigned long start;
2088  };
2089  
2090  #define VKI_HDIO_GETGEO		0x0301	/* get device geometry */
2091  #define VKI_HDIO_GET_DMA	0x030b	/* get use-dma flag */
2092  #define VKI_HDIO_GET_IDENTITY	0x030d	/* get IDE identification info */
2093  
2094  // [[Nb: done like this because the original type is a huge struct that will
2095  //   always be the same size.]]
2096  #define VKI_SIZEOF_STRUCT_HD_DRIVEID   512
2097  
2098  //----------------------------------------------------------------------
2099  // From linux-2.6.8.1/include/linux/fb.h
2100  //----------------------------------------------------------------------
2101  
2102  #define VKI_FBIOGET_VSCREENINFO	0x4600
2103  #define VKI_FBIOPUT_VSCREENINFO	0x4601
2104  #define VKI_FBIOGET_FSCREENINFO	0x4602
2105  #define VKI_FBIOPAN_DISPLAY	0x4606
2106  
2107  struct vki_fb_fix_screeninfo {
2108  	char id[16];			/* identification string eg "TT Builtin" */
2109  	unsigned long smem_start;	/* Start of frame buffer mem */
2110  					/* (physical address) */
2111  	__vki_u32 smem_len;			/* Length of frame buffer mem */
2112  	__vki_u32 type;			/* see FB_TYPE_*		*/
2113  	__vki_u32 type_aux;		/* Interleave for interleaved Planes */
2114  	__vki_u32 visual;		/* see FB_VISUAL_*		*/
2115  	__vki_u16 xpanstep;		/* zero if no hardware panning  */
2116  	__vki_u16 ypanstep;		/* zero if no hardware panning  */
2117  	__vki_u16 ywrapstep;		/* zero if no hardware ywrap    */
2118  	__vki_u32 line_length;		/* length of a line in bytes    */
2119  	unsigned long mmio_start;	/* Start of Memory Mapped I/O   */
2120  					/* (physical address) */
2121  	__vki_u32 mmio_len;		/* Length of Memory Mapped I/O  */
2122  	__vki_u32 accel;		/* Indicate to driver which	*/
2123  					/*  specific chip/card we have	*/
2124  	__vki_u16 reserved[3];		/* Reserved for future compatibility */
2125  };
2126  
2127  struct vki_fb_bitfield {
2128  	__vki_u32 offset;		/* beginning of bitfield	*/
2129  	__vki_u32 length;		/* length of bitfield		*/
2130  	__vki_u32 msb_right;		/* != 0 : Most significant bit is */
2131  					/* right */
2132  };
2133  
2134  struct vki_fb_var_screeninfo {
2135  	__vki_u32 xres;			/* visible resolution		*/
2136  	__vki_u32 yres;
2137  	__vki_u32 xres_virtual;		/* virtual resolution		*/
2138  	__vki_u32 yres_virtual;
2139  	__vki_u32 xoffset;		/* offset from virtual to visible */
2140  	__vki_u32 yoffset;		/* resolution			*/
2141  
2142  	__vki_u32 bits_per_pixel;	/* guess what			*/
2143  	__vki_u32 grayscale;		/* != 0 Graylevels instead of colors */
2144  
2145  	struct vki_fb_bitfield red;	/* bitfield in fb mem if true color, */
2146  	struct vki_fb_bitfield green;	/* else only length is significant */
2147  	struct vki_fb_bitfield blue;
2148  	struct vki_fb_bitfield transp;	/* transparency			*/
2149  
2150  	__vki_u32 nonstd;		/* != 0 Non standard pixel format */
2151  
2152  	__vki_u32 activate;		/* see FB_ACTIVATE_*		*/
2153  
2154  	__vki_u32 height;		/* height of picture in mm    */
2155  	__vki_u32 width;		/* width of picture in mm     */
2156  
2157  	__vki_u32 accel_flags;		/* (OBSOLETE) see fb_info.flags */
2158  
2159  	/* Timing: All values in pixclocks, except pixclock (of course) */
2160  	__vki_u32 pixclock;		/* pixel clock in ps (pico seconds) */
2161  	__vki_u32 left_margin;		/* time from sync to picture	*/
2162  	__vki_u32 right_margin;		/* time from picture to sync	*/
2163  	__vki_u32 upper_margin;		/* time from sync to picture	*/
2164  	__vki_u32 lower_margin;
2165  	__vki_u32 hsync_len;		/* length of horizontal sync	*/
2166  	__vki_u32 vsync_len;		/* length of vertical sync	*/
2167  	__vki_u32 sync;			/* see FB_SYNC_*		*/
2168  	__vki_u32 vmode;		/* see FB_VMODE_*		*/
2169  	__vki_u32 rotate;		/* angle we rotate counter clockwise */
2170  	__vki_u32 reserved[5];		/* Reserved for future compatibility */
2171  };
2172  
2173  //----------------------------------------------------------------------
2174  // From linux-2.6.9/include/linux/kd.h
2175  //----------------------------------------------------------------------
2176  
2177  #define VKI_GIO_FONT       0x4B60  /* gets font in expanded form */
2178  #define VKI_PIO_FONT       0x4B61  /* use font in expanded form */
2179  
2180  #define VKI_GIO_FONTX      0x4B6B  /* get font using struct consolefontdesc */
2181  #define VKI_PIO_FONTX      0x4B6C  /* set font using struct consolefontdesc */
2182  struct vki_consolefontdesc {
2183  	unsigned short charcount;	/* characters in font (256 or 512) */
2184  	unsigned short charheight;	/* scan lines per character (1-32) */
2185  	char __user *chardata;		/* font data in expanded form */
2186  };
2187  
2188  #define VKI_PIO_FONTRESET  0x4B6D  /* reset to default font */
2189  
2190  #define VKI_GIO_CMAP       0x4B70  /* gets colour palette on VGA+ */
2191  #define VKI_PIO_CMAP       0x4B71  /* sets colour palette on VGA+ */
2192  
2193  #define VKI_KIOCSOUND      0x4B2F  /* start sound generation (0 for off) */
2194  #define VKI_KDMKTONE       0x4B30  /* generate tone */
2195  
2196  #define VKI_KDGETLED       0x4B31  /* return current led state */
2197  #define VKI_KDSETLED       0x4B32  /* set led state [lights, not flags] */
2198  
2199  #define VKI_KDGKBTYPE      0x4B33  /* get keyboard type */
2200  
2201  #define VKI_KDADDIO        0x4B34  /* add i/o port as valid */
2202  #define VKI_KDDELIO        0x4B35  /* del i/o port as valid */
2203  #define VKI_KDENABIO       0x4B36  /* enable i/o to video board */
2204  #define VKI_KDDISABIO      0x4B37  /* disable i/o to video board */
2205  
2206  #define VKI_KDSETMODE      0x4B3A  /* set text/graphics mode */
2207  #define VKI_KDGETMODE      0x4B3B  /* get current mode */
2208  
2209  #define VKI_KDMAPDISP      0x4B3C  /* map display into address space */
2210  #define VKI_KDUNMAPDISP    0x4B3D  /* unmap display from address space */
2211  
2212  #define		VKI_E_TABSZ		256
2213  #define VKI_GIO_SCRNMAP    0x4B40  /* get screen mapping from kernel */
2214  #define VKI_PIO_SCRNMAP	   0x4B41  /* put screen mapping table in kernel */
2215  #define VKI_GIO_UNISCRNMAP 0x4B69  /* get full Unicode screen mapping */
2216  #define VKI_PIO_UNISCRNMAP 0x4B6A  /* set full Unicode screen mapping */
2217  
2218  #define VKI_GIO_UNIMAP     0x4B66  /* get unicode-to-font mapping from kernel */
2219  struct vki_unipair {
2220  	unsigned short unicode;
2221  	unsigned short fontpos;
2222  };
2223  struct vki_unimapdesc {
2224  	unsigned short entry_ct;
2225  	struct vki_unipair __user *entries;
2226  };
2227  #define VKI_PIO_UNIMAP     0x4B67  /* put unicode-to-font mapping in kernel */
2228  #define VKI_PIO_UNIMAPCLR  0x4B68  /* clear table, possibly advise hash algorithm */
2229  struct vki_unimapinit {
2230  	unsigned short advised_hashsize;  /* 0 if no opinion */
2231  	unsigned short advised_hashstep;  /* 0 if no opinion */
2232  	unsigned short advised_hashlevel; /* 0 if no opinion */
2233  };
2234  
2235  #define VKI_KDGKBMODE      0x4B44  /* gets current keyboard mode */
2236  #define VKI_KDSKBMODE      0x4B45  /* sets current keyboard mode */
2237  
2238  #define VKI_KDGKBMETA      0x4B62  /* gets meta key handling mode */
2239  #define VKI_KDSKBMETA      0x4B63  /* sets meta key handling mode */
2240  
2241  #define VKI_KDGKBLED       0x4B64  /* get led flags (not lights) */
2242  #define VKI_KDSKBLED       0x4B65  /* set led flags (not lights) */
2243  
2244  struct vki_kbentry {
2245  	unsigned char kb_table;
2246  	unsigned char kb_index;
2247  	unsigned short kb_value;
2248  };
2249  #define VKI_KDGKBENT       0x4B46  /* gets one entry in translation table */
2250  #define VKI_KDSKBENT       0x4B47  /* sets one entry in translation table */
2251  
2252  struct vki_kbsentry {
2253  	unsigned char kb_func;
2254  	unsigned char kb_string[512];
2255  };
2256  #define VKI_KDGKBSENT      0x4B48  /* gets one function key string entry */
2257  #define VKI_KDSKBSENT      0x4B49  /* sets one function key string entry */
2258  
2259  struct vki_kbdiacr {
2260          unsigned char diacr, base, result;
2261  };
2262  struct vki_kbdiacrs {
2263          unsigned int kb_cnt;    /* number of entries in following array */
2264  	struct vki_kbdiacr kbdiacr[256];    /* MAX_DIACR from keyboard.h */
2265  };
2266  #define VKI_KDGKBDIACR     0x4B4A  /* read kernel accent table */
2267  #define VKI_KDSKBDIACR     0x4B4B  /* write kernel accent table */
2268  
2269  struct vki_kbkeycode {
2270  	unsigned int scancode, keycode;
2271  };
2272  #define VKI_KDGETKEYCODE   0x4B4C  /* read kernel keycode table entry */
2273  #define VKI_KDSETKEYCODE   0x4B4D  /* write kernel keycode table entry */
2274  
2275  #define VKI_KDSIGACCEPT    0x4B4E  /* accept kbd generated signals */
2276  
2277  struct vki_kbd_repeat {
2278  	int delay;	/* in msec; <= 0: don't change */
2279  	int period;	/* in msec; <= 0: don't change */
2280  			/* earlier this field was misnamed "rate" */
2281  };
2282  #define VKI_KDKBDREP       0x4B52  /* set keyboard delay/repeat rate;
2283                                      * actually used values are returned */
2284  
2285  #define VKI_KDFONTOP       0x4B72  /* font operations */
2286  
2287  struct vki_console_font_op {
2288  	unsigned int op;	/* operation code KD_FONT_OP_* */
2289  	unsigned int flags;	/* KD_FONT_FLAG_* */
2290  	unsigned int width, height;	/* font size */
2291  	unsigned int charcount;
2292  	unsigned char __user *data;	/* font data with height fixed to 32 */
2293  };
2294  
2295  #define VKI_KD_FONT_OP_SET		0	/* Set font */
2296  #define VKI_KD_FONT_OP_GET		1	/* Get font */
2297  #define VKI_KD_FONT_OP_SET_DEFAULT	2	/* Set font to default, data points to name / NULL */
2298  #define VKI_KD_FONT_OP_COPY		3	/* Copy from another console */
2299  
2300  //----------------------------------------------------------------------
2301  // From linux-2.6.9/include/linux/kb.h
2302  //----------------------------------------------------------------------
2303  
2304  typedef __vki_kernel_uid32_t vki_qid_t; /* Type in which we store ids in memory */
2305  
2306  //----------------------------------------------------------------------
2307  // From linux-2.6.20.1/include/linux/ptrace.h
2308  //----------------------------------------------------------------------
2309  
2310  #define VKI_PTRACE_TRACEME         0
2311  #define VKI_PTRACE_PEEKTEXT	   1
2312  #define VKI_PTRACE_PEEKDATA	   2
2313  #define VKI_PTRACE_PEEKUSR	   3
2314  #define VKI_PTRACE_POKEUSR	   6
2315  
2316  #define VKI_PTRACE_DETACH         17
2317  
2318  #define VKI_PTRACE_GETEVENTMSG	0x4201
2319  #define VKI_PTRACE_GETSIGINFO	0x4202
2320  #define VKI_PTRACE_SETSIGINFO	0x4203
2321  #define VKI_PTRACE_GETREGSET	0x4204
2322  #define VKI_PTRACE_SETREGSET	0x4205
2323  
2324  //----------------------------------------------------------------------
2325  // From linux-2.6.14/include/sound/asound.h
2326  //----------------------------------------------------------------------
2327  
2328  enum {
2329  	VKI_SNDRV_PCM_IOCTL_HW_FREE = _VKI_IO('A', 0x12),
2330  	VKI_SNDRV_PCM_IOCTL_HWSYNC = _VKI_IO('A', 0x22),
2331  	VKI_SNDRV_PCM_IOCTL_PREPARE = _VKI_IO('A', 0x40),
2332  	VKI_SNDRV_PCM_IOCTL_RESET = _VKI_IO('A', 0x41),
2333  	VKI_SNDRV_PCM_IOCTL_START = _VKI_IO('A', 0x42),
2334  	VKI_SNDRV_PCM_IOCTL_DROP = _VKI_IO('A', 0x43),
2335  	VKI_SNDRV_PCM_IOCTL_DRAIN = _VKI_IO('A', 0x44),
2336  	VKI_SNDRV_PCM_IOCTL_PAUSE = _VKI_IOW('A', 0x45, int),
2337  	VKI_SNDRV_PCM_IOCTL_RESUME = _VKI_IO('A', 0x47),
2338  	VKI_SNDRV_PCM_IOCTL_XRUN = _VKI_IO('A', 0x48),
2339  	VKI_SNDRV_PCM_IOCTL_LINK = _VKI_IOW('A', 0x60, int),
2340  	VKI_SNDRV_PCM_IOCTL_UNLINK = _VKI_IO('A', 0x61),
2341  };
2342  
2343  enum {
2344  	VKI_SNDRV_TIMER_IOCTL_START = _VKI_IO('T', 0xa0),
2345  	VKI_SNDRV_TIMER_IOCTL_STOP = _VKI_IO('T', 0xa1),
2346  	VKI_SNDRV_TIMER_IOCTL_CONTINUE = _VKI_IO('T', 0xa2),
2347  	VKI_SNDRV_TIMER_IOCTL_PAUSE = _VKI_IO('T', 0xa3),
2348  };
2349  
2350  struct vki_snd_ctl_card_info {
2351  	int card;			/* card number */
2352  	int pad;			/* reserved for future (was type) */
2353  	unsigned char id[16];		/* ID of card (user selectable) */
2354  	unsigned char driver[16];	/* Driver name */
2355  	unsigned char name[32];		/* Short name of soundcard */
2356  	unsigned char longname[80];	/* name + info text about soundcard */
2357  	unsigned char reserved_[16];	/* reserved for future (was ID of mixer) */
2358  	unsigned char mixername[80];	/* visual mixer identification */
2359  	unsigned char components[128];	/* card components / fine identification, delimited with one space (AC97 etc..) */
2360  };
2361  
2362  typedef int vki_snd_ctl_elem_iface_t;
2363  #define	VKI_SNDRV_CTL_ELEM_IFACE_CARD		((vki_snd_ctl_elem_iface_t) 0) /* global control */
2364  #define	VKI_SNDRV_CTL_ELEM_IFACE_HWDEP		((vki_snd_ctl_elem_iface_t) 1) /* hardware dependent device */
2365  #define	VKI_SNDRV_CTL_ELEM_IFACE_MIXER		((vki_snd_ctl_elem_iface_t) 2) /* virtual mixer device */
2366  #define	VKI_SNDRV_CTL_ELEM_IFACE_PCM		((vki_snd_ctl_elem_iface_t) 3) /* PCM device */
2367  #define	VKI_SNDRV_CTL_ELEM_IFACE_RAWMIDI	((vki_snd_ctl_elem_iface_t) 4) /* RawMidi device */
2368  #define	VKI_SNDRV_CTL_ELEM_IFACE_TIMER		((vki_snd_ctl_elem_iface_t) 5) /* timer device */
2369  #define	VKI_SNDRV_CTL_ELEM_IFACE_SEQUENCER	((vki_snd_ctl_elem_iface_t) 6) /* sequencer client */
2370  #define	VKI_SNDRV_CTL_ELEM_IFACE_LAST		VKI_SNDRV_CTL_ELEM_IFACE_SEQUENCER
2371  
2372  struct vki_snd_ctl_elem_id {
2373  	unsigned int numid;		/* numeric identifier, zero = invalid */
2374  	vki_snd_ctl_elem_iface_t iface;	/* interface identifier */
2375  	unsigned int device;		/* device/client number */
2376  	unsigned int subdevice;		/* subdevice (substream) number */
2377  	unsigned char name[44];		/* ASCII name of item */
2378  	unsigned int index;		/* index of item */
2379  };
2380  
2381  struct vki_snd_ctl_elem_list {
2382  	unsigned int offset;		/* W: first element ID to get */
2383  	unsigned int space;		/* W: count of element IDs to get */
2384  	unsigned int used;		/* R: count of element IDs set */
2385  	unsigned int count;		/* R: count of all elements */
2386  	struct vki_snd_ctl_elem_id __user *pids; /* R: IDs */
2387  	unsigned char reserved[50];
2388  };
2389  
2390  struct vki_snd_ctl_tlv {
2391      unsigned int numid;	/* control element numeric identification */
2392      unsigned int length;	/* in bytes aligned to 4 */
2393      unsigned int tlv[0];	/* first TLV */
2394  };
2395  
2396  #define VKI_SNDRV_CTL_IOCTL_PVERSION	_VKI_IOR('U', 0x00, int)
2397  #define VKI_SNDRV_CTL_IOCTL_CARD_INFO	_VKI_IOR('U', 0x01, struct vki_snd_ctl_card_info)
2398  #define VKI_SNDRV_CTL_IOCTL_ELEM_LIST	_VKI_IOWR('U', 0x10, struct vki_snd_ctl_elem_list)
2399  #define VKI_SNDRV_CTL_IOCTL_TLV_READ	_VKI_IOWR('U', 0x1a, struct vki_snd_ctl_tlv)
2400  #define VKI_SNDRV_CTL_IOCTL_TLV_WRITE	_VKI_IOWR('U', 0x1b, struct vki_snd_ctl_tlv)
2401  #define VKI_SNDRV_CTL_IOCTL_TLV_COMMAND	_VKI_IOWR('U', 0x1c, struct vki_snd_ctl_tlv)
2402  
2403  //----------------------------------------------------------------------
2404  // From linux-2.6.15.4/include/linux/serial.h
2405  //----------------------------------------------------------------------
2406  
2407  struct vki_serial_icounter_struct {
2408  	int cts, dsr, rng, dcd;
2409  	int rx, tx;
2410  	int frame, overrun, parity, brk;
2411  	int buf_overrun;
2412  	int reserved[9];
2413  };
2414  
2415  //----------------------------------------------------------------------
2416  // From linux-2.6.16/include/linux/vt.h
2417  //----------------------------------------------------------------------
2418  
2419  #define VKI_VT_OPENQRY	0x5600	/* find available vt */
2420  
2421  struct vki_vt_mode {
2422  	char mode;		/* vt mode */
2423  	char waitv;		/* if set, hang on writes if not active */
2424  	short relsig;		/* signal to raise on release req */
2425  	short acqsig;		/* signal to raise on acquisition */
2426  	short frsig;		/* unused (set to 0) */
2427  };
2428  #define VKI_VT_GETMODE	0x5601	/* get mode of active vt */
2429  #define VKI_VT_SETMODE	0x5602	/* set mode of active vt */
2430  
2431  struct vki_vt_stat {
2432  	unsigned short v_active;	/* active vt */
2433  	unsigned short v_signal;	/* signal to send */
2434  	unsigned short v_state;		/* vt bitmask */
2435  };
2436  #define VKI_VT_GETSTATE	0x5603	/* get global vt state info */
2437  #define VKI_VT_SENDSIG	0x5604	/* signal to send to bitmask of vts */
2438  
2439  #define VKI_VT_RELDISP	0x5605	/* release display */
2440  
2441  #define VKI_VT_ACTIVATE	0x5606	/* make vt active */
2442  #define VKI_VT_WAITACTIVE	0x5607	/* wait for vt active */
2443  #define VKI_VT_DISALLOCATE	0x5608  /* free memory associated to vt */
2444  
2445  struct vki_vt_sizes {
2446  	unsigned short v_rows;		/* number of rows */
2447  	unsigned short v_cols;		/* number of columns */
2448  	unsigned short v_scrollsize;	/* number of lines of scrollback */
2449  };
2450  #define VKI_VT_RESIZE	0x5609	/* set kernel's idea of screensize */
2451  
2452  struct vki_vt_consize {
2453  	unsigned short v_rows;	/* number of rows */
2454  	unsigned short v_cols;	/* number of columns */
2455  	unsigned short v_vlin;	/* number of pixel rows on screen */
2456  	unsigned short v_clin;	/* number of pixel rows per character */
2457  	unsigned short v_vcol;	/* number of pixel columns on screen */
2458  	unsigned short v_ccol;	/* number of pixel columns per character */
2459  };
2460  #define VKI_VT_RESIZEX      0x560A  /* set kernel's idea of screensize + more */
2461  #define VKI_VT_LOCKSWITCH   0x560B  /* disallow vt switching */
2462  #define VKI_VT_UNLOCKSWITCH 0x560C  /* allow vt switching */
2463  
2464  //----------------------------------------------------------------------
2465  // From linux-2.6.19/include/linux/prctl.h
2466  //----------------------------------------------------------------------
2467  
2468  #define VKI_PR_SET_PDEATHSIG  1  /* Second arg is a signal */
2469  #define VKI_PR_GET_PDEATHSIG  2  /* Second arg is a ptr to return the signal */
2470  
2471  #define VKI_PR_GET_DUMPABLE   3
2472  #define VKI_PR_SET_DUMPABLE   4
2473  
2474  #define VKI_PR_GET_UNALIGN	  5
2475  #define VKI_PR_SET_UNALIGN	  6
2476  # define VKI_PR_UNALIGN_NOPRINT	1	/* silently fix up unaligned user accesses */
2477  # define VKI_PR_UNALIGN_SIGBUS	2	/* generate SIGBUS on unaligned user access */
2478  
2479  #define VKI_PR_GET_KEEPCAPS   7
2480  #define VKI_PR_SET_KEEPCAPS   8
2481  
2482  #define VKI_PR_GET_FPEMU  9
2483  #define VKI_PR_SET_FPEMU 10
2484  # define VKI_PR_FPEMU_NOPRINT	1	/* silently emulate fp operations accesses */
2485  # define VKI_PR_FPEMU_SIGFPE	2	/* don't emulate fp operations, send SIGFPE instead */
2486  
2487  #define VKI_PR_GET_FPEXC	11
2488  #define VKI_PR_SET_FPEXC	12
2489  # define VKI_PR_FP_EXC_SW_ENABLE	0x80	/* Use FPEXC for FP exception enables */
2490  # define VKI_PR_FP_EXC_DIV		0x010000	/* floating point divide by zero */
2491  # define VKI_PR_FP_EXC_OVF		0x020000	/* floating point overflow */
2492  # define VKI_PR_FP_EXC_UND		0x040000	/* floating point underflow */
2493  # define VKI_PR_FP_EXC_RES		0x080000	/* floating point inexact result */
2494  # define VKI_PR_FP_EXC_INV		0x100000	/* floating point invalid operation */
2495  # define VKI_PR_FP_EXC_DISABLED	0	/* FP exceptions disabled */
2496  # define VKI_PR_FP_EXC_NONRECOV	1	/* async non-recoverable exc. mode */
2497  # define VKI_PR_FP_EXC_ASYNC	2	/* async recoverable exception mode */
2498  # define VKI_PR_FP_EXC_PRECISE	3	/* precise exception mode */
2499  
2500  #define VKI_PR_GET_TIMING   13
2501  #define VKI_PR_SET_TIMING   14
2502  # define VKI_PR_TIMING_STATISTICAL  0       /* Normal, traditional,
2503                                                     statistical process timing */
2504  # define VKI_PR_TIMING_TIMESTAMP    1       /* Accurate timestamp based
2505                                                     process timing */
2506  
2507  #define VKI_PR_SET_NAME    15		/* Set process name */
2508  #define VKI_PR_GET_NAME    16		/* Get process name */
2509  
2510  #define VKI_PR_GET_ENDIAN	19
2511  #define VKI_PR_SET_ENDIAN	20
2512  # define VKI_PR_ENDIAN_BIG		0
2513  # define VKI_PR_ENDIAN_LITTLE	1	/* True little endian mode */
2514  # define VKI_PR_ENDIAN_PPC_LITTLE	2	/* "PowerPC" pseudo little endian */
2515  
2516  #define VKI_PR_SET_SECCOMP 22
2517  
2518  #define VKI_PR_SET_PTRACER 0x59616d61
2519  
2520  //----------------------------------------------------------------------
2521  // From linux-2.6.19/include/linux/usbdevice_fs.h
2522  //----------------------------------------------------------------------
2523  
2524  struct vki_usbdevfs_ctrltransfer {
2525  	__vki_u8 bRequestType;
2526  	__vki_u8 bRequest;
2527  	__vki_u16 wValue;
2528  	__vki_u16 wIndex;
2529  	__vki_u16 wLength;
2530  	__vki_u32 timeout;  /* in milliseconds */
2531   	void __user *data;
2532  };
2533  
2534  struct vki_usbdevfs_bulktransfer {
2535  	unsigned int ep;
2536  	unsigned int len;
2537  	unsigned int timeout; /* in milliseconds */
2538  	void __user *data;
2539  };
2540  
2541  #define VKI_USBDEVFS_MAXDRIVERNAME 255
2542  
2543  struct vki_usbdevfs_getdriver {
2544  	unsigned int interface;
2545  	char driver[VKI_USBDEVFS_MAXDRIVERNAME + 1];
2546  };
2547  
2548  struct vki_usbdevfs_connectinfo {
2549  	unsigned int devnum;
2550  	unsigned char slow;
2551  };
2552  
2553  struct vki_usbdevfs_iso_packet_desc {
2554  	unsigned int length;
2555  	unsigned int actual_length;
2556  	unsigned int status;
2557  };
2558  
2559  struct vki_usbdevfs_urb {
2560  	unsigned char type;
2561  	unsigned char endpoint;
2562  	int status;
2563  	unsigned int flags;
2564  	void __user *buffer;
2565  	int buffer_length;
2566  	int actual_length;
2567  	int start_frame;
2568  	int number_of_packets;
2569  	int error_count;
2570  	unsigned int signr;  /* signal to be sent on error, -1 if none should be sent */
2571  	void *usercontext;
2572  	struct vki_usbdevfs_iso_packet_desc iso_frame_desc[0];
2573  };
2574  
2575  struct vki_usbdevfs_ioctl {
2576  	int	ifno;		/* interface 0..N ; negative numbers reserved */
2577  	int	ioctl_code;	/* MUST encode size + direction of data so the
2578  				 * macros in <asm/ioctl.h> give correct values */
2579  	void __user *data;	/* param buffer (in, or out) */
2580  };
2581  
2582  #define VKI_USBDEVFS_CONTROL           _VKI_IOWR('U', 0, struct vki_usbdevfs_ctrltransfer)
2583  #define VKI_USBDEVFS_BULK              _VKI_IOWR('U', 2, struct vki_usbdevfs_bulktransfer)
2584  #define VKI_USBDEVFS_GETDRIVER         _VKI_IOW('U', 8, struct vki_usbdevfs_getdriver)
2585  #define VKI_USBDEVFS_SUBMITURB         _VKI_IOR('U', 10, struct vki_usbdevfs_urb)
2586  #define VKI_USBDEVFS_DISCARDURB        _VKI_IO('U', 11)
2587  #define VKI_USBDEVFS_REAPURB           _VKI_IOW('U', 12, void *)
2588  #define VKI_USBDEVFS_REAPURBNDELAY     _VKI_IOW('U', 13, void *)
2589  #define VKI_USBDEVFS_CONNECTINFO       _VKI_IOW('U', 17, struct vki_usbdevfs_connectinfo)
2590  #define VKI_USBDEVFS_IOCTL             _VKI_IOWR('U', 18, struct vki_usbdevfs_ioctl)
2591  #define VKI_USBDEVFS_RESET             _VKI_IO('U', 20)
2592  
2593  #define VKI_USBDEVFS_URB_TYPE_ISO              0
2594  #define VKI_USBDEVFS_URB_TYPE_INTERRUPT        1
2595  #define VKI_USBDEVFS_URB_TYPE_CONTROL          2
2596  #define VKI_USBDEVFS_URB_TYPE_BULK             3
2597  
2598  // [[this is missing in usbdevice_fs.h]]
2599  struct vki_usbdevfs_setuppacket {
2600         __vki_u8 bRequestType;
2601         __vki_u8 bRequest;
2602         __vki_u16 wValue;
2603         __vki_u16 wIndex;
2604         __vki_u16 wLength;
2605  };
2606  
2607  //----------------------------------------------------------------------
2608  // From linux-2.6.20.1/include/linux/i2c.h
2609  //----------------------------------------------------------------------
2610  
2611  #define VKI_I2C_SMBUS_QUICK             0
2612  #define VKI_I2C_SMBUS_BYTE              1
2613  #define VKI_I2C_SMBUS_BYTE_DATA         2
2614  #define VKI_I2C_SMBUS_WORD_DATA         3
2615  #define VKI_I2C_SMBUS_PROC_CALL         4
2616  #define VKI_I2C_SMBUS_BLOCK_DATA        5
2617  #define VKI_I2C_SMBUS_I2C_BLOCK_BROKEN  6
2618  #define VKI_I2C_SMBUS_BLOCK_PROC_CALL   7           /* SMBus 2.0 */
2619  #define VKI_I2C_SMBUS_I2C_BLOCK_DATA    8
2620  
2621  /* smbus_access read or write markers */
2622  #define VKI_I2C_SMBUS_READ  1
2623  #define VKI_I2C_SMBUS_WRITE 0
2624  
2625  #define VKI_I2C_SLAVE        0x0703  /* Change slave address                 */
2626                                       /* Attn.: Slave address is 7 or 10 bits */
2627  #define VKI_I2C_SLAVE_FORCE  0x0706  /* Change slave address                 */
2628                                       /* Attn.: Slave address is 7 or 10 bits */
2629                                       /* This changes the address, even if it */
2630                                       /* is already taken!                    */
2631  #define VKI_I2C_TENBIT       0x0704  /* 0 for 7 bit addrs, != 0 for 10 bit   */
2632  #define VKI_I2C_FUNCS        0x0705  /* Get the adapter functionality */
2633  #define VKI_I2C_RDWR         0x0707  /* Combined R/W transfer (one STOP only) */
2634  #define VKI_I2C_PEC          0x0708  /* != 0 for SMBus PEC                   */
2635  #define VKI_I2C_SMBUS        0x0720  /* SMBus transfer */
2636  
2637  #define VKI_I2C_SMBUS_BLOCK_MAX  32  /* As specified in SMBus standard */
2638  union vki_i2c_smbus_data {
2639          __vki_u8 byte;
2640          __vki_u16 word;
2641          __vki_u8 block[VKI_I2C_SMBUS_BLOCK_MAX + 2];
2642                   /* block[0] is used for length */
2643                   /* and one more for PEC */
2644  };
2645  
2646  /* This is the structure as used in the I2C_SMBUS ioctl call */
2647  struct vki_i2c_smbus_ioctl_data {
2648          __vki_u8 read_write;
2649          __vki_u8 command;
2650          __vki_u32 size;
2651          union vki_i2c_smbus_data __user *data;
2652  };
2653  
2654  struct vki_i2c_msg {
2655  	__vki_u16 addr;		/* slave address			*/
2656  	__vki_u16 flags;
2657  #define VKI_I2C_M_TEN		0x0010	/* this is a ten bit chip address */
2658  #define VKI_I2C_M_RD		0x0001	/* read data, from slave to master */
2659  #define VKI_I2C_M_NOSTART	0x4000	/* if I2C_FUNC_PROTOCOL_MANGLING */
2660  #define VKI_I2C_M_REV_DIR_ADDR	0x2000	/* if I2C_FUNC_PROTOCOL_MANGLING */
2661  #define VKI_I2C_M_IGNORE_NAK	0x1000	/* if I2C_FUNC_PROTOCOL_MANGLING */
2662  #define VKI_I2C_M_NO_RD_ACK	0x0800	/* if I2C_FUNC_PROTOCOL_MANGLING */
2663  #define VKI_I2C_M_RECV_LEN	0x0400	/* length will be first received byte */
2664  	__vki_u16 len;		/* msg length				*/
2665  	__vki_u8 *buf;		/* pointer to msg data			*/
2666  };
2667  
2668  struct vki_i2c_rdwr_ioctl_data {
2669  	struct vki_i2c_msg *msgs;	/* pointers to i2c_msgs */
2670  	__vki_u32 nmsgs;		/* number of i2c_msgs */
2671  };
2672  
2673  //----------------------------------------------------------------------
2674  // From linux-2.6.20.1/include/linux/keyctl.h
2675  //----------------------------------------------------------------------
2676  
2677  /* keyctl commands */
2678  #define VKI_KEYCTL_GET_KEYRING_ID	0	/* ask for a keyring's ID */
2679  #define VKI_KEYCTL_JOIN_SESSION_KEYRING	1	/* join or start named session keyring */
2680  #define VKI_KEYCTL_UPDATE		2	/* update a key */
2681  #define VKI_KEYCTL_REVOKE		3	/* revoke a key */
2682  #define VKI_KEYCTL_CHOWN		4	/* set ownership of a key */
2683  #define VKI_KEYCTL_SETPERM		5	/* set perms on a key */
2684  #define VKI_KEYCTL_DESCRIBE		6	/* describe a key */
2685  #define VKI_KEYCTL_CLEAR		7	/* clear contents of a keyring */
2686  #define VKI_KEYCTL_LINK			8	/* link a key into a keyring */
2687  #define VKI_KEYCTL_UNLINK		9	/* unlink a key from a keyring */
2688  #define VKI_KEYCTL_SEARCH		10	/* search for a key in a keyring */
2689  #define VKI_KEYCTL_READ			11	/* read a key or keyring's contents */
2690  #define VKI_KEYCTL_INSTANTIATE		12	/* instantiate a partially constructed key */
2691  #define VKI_KEYCTL_NEGATE		13	/* negate a partially constructed key */
2692  #define VKI_KEYCTL_SET_REQKEY_KEYRING	14	/* set default request-key keyring */
2693  #define VKI_KEYCTL_SET_TIMEOUT		15	/* set key timeout */
2694  #define VKI_KEYCTL_ASSUME_AUTHORITY	16	/* assume request_key() authorisation */
2695  
2696  /*--------------------------------------------------------------------*/
2697  // From linux-2.6.20.1/include/linux/key.h
2698  /*--------------------------------------------------------------------*/
2699  
2700  /* key handle serial number */
2701  typedef vki_int32_t vki_key_serial_t;
2702  
2703  /* key handle permissions mask */
2704  typedef vki_uint32_t vki_key_perm_t;
2705  
2706  //----------------------------------------------------------------------
2707  // From linux-2.6.24.7/include/linux/wireless.h
2708  // (wireless extensions version 22, 2007-03-16)
2709  //----------------------------------------------------------------------
2710  
2711  /*
2712   * [[Wireless extensions ioctls.]]
2713   */
2714  
2715  /* Wireless Identification */
2716  #define VKI_SIOCSIWCOMMIT	0x8B00	/* Commit pending changes to driver */
2717  #define VKI_SIOCGIWNAME		0x8B01	/* get name == wireless protocol */
2718  
2719  /* Basic operations */
2720  #define VKI_SIOCSIWNWID		0x8B02	/* set network id (pre-802.11) */
2721  #define VKI_SIOCGIWNWID		0x8B03	/* get network id (the cell) */
2722  #define VKI_SIOCSIWFREQ		0x8B04	/* set channel/frequency (Hz) */
2723  #define VKI_SIOCGIWFREQ		0x8B05	/* get channel/frequency (Hz) */
2724  #define VKI_SIOCSIWMODE		0x8B06	/* set operation mode */
2725  #define VKI_SIOCGIWMODE		0x8B07	/* get operation mode */
2726  #define VKI_SIOCSIWSENS		0x8B08	/* set sensitivity (dBm) */
2727  #define VKI_SIOCGIWSENS		0x8B09	/* get sensitivity (dBm) */
2728  
2729  /* Informative stuff */
2730  #define VKI_SIOCSIWRANGE	0x8B0A	/* Unused */
2731  #define VKI_SIOCGIWRANGE	0x8B0B	/* Get range of parameters */
2732  #define VKI_SIOCSIWPRIV		0x8B0C	/* Unused */
2733  #define VKI_SIOCGIWPRIV		0x8B0D	/* get private ioctl interface info */
2734  #define VKI_SIOCSIWSTATS	0x8B0E	/* Unused */
2735  #define VKI_SIOCGIWSTATS	0x8B0F	/* Get /proc/net/wireless stats */
2736  
2737  /* Spy support (statistics per MAC address - used for Mobile IP support) */
2738  #define VKI_SIOCSIWSPY		0x8B10	/* set spy addresses */
2739  #define VKI_SIOCGIWSPY		0x8B11	/* get spy info (quality of link) */
2740  #define VKI_SIOCSIWTHRSPY	0x8B12	/* set spy threshold (spy event) */
2741  #define VKI_SIOCGIWTHRSPY	0x8B13	/* get spy threshold */
2742  
2743  /* Access Point manipulation */
2744  #define VKI_SIOCSIWAP		0x8B14	/* set access point MAC addresses */
2745  #define VKI_SIOCGIWAP		0x8B15	/* get access point MAC addresses */
2746  #define VKI_SIOCGIWAPLIST	0x8B17	/* Deprecated in favor of scanning */
2747  #define VKI_SIOCSIWSCAN         0x8B18	/* trigger scanning (list cells) */
2748  #define VKI_SIOCGIWSCAN         0x8B19	/* get scanning results */
2749  
2750  /* 802.11 specific support */
2751  #define VKI_SIOCSIWESSID	0x8B1A	/* set ESSID (network name) */
2752  #define VKI_SIOCGIWESSID	0x8B1B	/* get ESSID */
2753  #define VKI_SIOCSIWNICKN	0x8B1C	/* set node name/nickname */
2754  #define VKI_SIOCGIWNICKN	0x8B1D	/* get node name/nickname */
2755  
2756  /* Other parameters useful in 802.11 and some other devices */
2757  #define VKI_SIOCSIWRATE		0x8B20	/* set default bit rate (bps) */
2758  #define VKI_SIOCGIWRATE		0x8B21	/* get default bit rate (bps) */
2759  #define VKI_SIOCSIWRTS		0x8B22	/* set RTS/CTS threshold (bytes) */
2760  #define VKI_SIOCGIWRTS		0x8B23	/* get RTS/CTS threshold (bytes) */
2761  #define VKI_SIOCSIWFRAG		0x8B24	/* set fragmentation thr (bytes) */
2762  #define VKI_SIOCGIWFRAG		0x8B25	/* get fragmentation thr (bytes) */
2763  #define VKI_SIOCSIWTXPOW	0x8B26	/* set transmit power (dBm) */
2764  #define VKI_SIOCGIWTXPOW	0x8B27	/* get transmit power (dBm) */
2765  #define VKI_SIOCSIWRETRY	0x8B28	/* set retry limits and lifetime */
2766  #define VKI_SIOCGIWRETRY	0x8B29	/* get retry limits and lifetime */
2767  
2768  /* Encoding stuff (scrambling, hardware security, WEP...) */
2769  #define VKI_SIOCSIWENCODE	0x8B2A	/* set encoding token & mode */
2770  #define VKI_SIOCGIWENCODE	0x8B2B	/* get encoding token & mode */
2771  
2772  /* Power saving stuff (power management, unicast and multicast) */
2773  #define VKI_SIOCSIWPOWER	0x8B2C	/* set Power Management settings */
2774  #define VKI_SIOCGIWPOWER	0x8B2D	/* get Power Management settings */
2775  
2776  /* WPA : Generic IEEE 802.11 informatiom element (e.g., for WPA/RSN/WMM). */
2777  #define VKI_SIOCSIWGENIE	0x8B30		/* set generic IE */
2778  #define VKI_SIOCGIWGENIE	0x8B31		/* get generic IE */
2779  
2780  /* WPA : IEEE 802.11 MLME requests */
2781  #define VKI_SIOCSIWMLME		0x8B16	/* request MLME operation; uses
2782  					 * struct iw_mlme */
2783  /* WPA : Authentication mode parameters */
2784  #define VKI_SIOCSIWAUTH		0x8B32	/* set authentication mode params */
2785  #define VKI_SIOCGIWAUTH		0x8B33	/* get authentication mode params */
2786  
2787  /* WPA : Extended version of encoding configuration */
2788  #define VKI_SIOCSIWENCODEEXT	0x8B34	/* set encoding token & mode */
2789  #define VKI_SIOCGIWENCODEEXT	0x8B35	/* get encoding token & mode */
2790  
2791  /* WPA2 : PMKSA cache management */
2792  #define VKI_SIOCSIWPMKSA	0x8B36	/* PMKSA cache operation */
2793  
2794  /*
2795   * [[Payload for the wireless extensions ioctls.]]
2796   */
2797  
2798  struct	vki_iw_param
2799  {
2800    __vki_s32	value;		/* The value of the parameter itself */
2801    __vki_u8	fixed;		/* Hardware should not use auto select */
2802    __vki_u8	disabled;	/* Disable the feature */
2803    __vki_u16	flags;		/* Various specifc flags (if any) */
2804  };
2805  
2806  struct	vki_iw_point
2807  {
2808    void __user	*pointer;	/* Pointer to the data  (in user space) */
2809    __vki_u16	length;		/* number of fields or size in bytes */
2810    __vki_u16	flags;		/* Optional params */
2811  };
2812  
2813  struct	vki_iw_freq
2814  {
2815  	__vki_s32	m;		/* Mantissa */
2816  	__vki_s16	e;		/* Exponent */
2817  	__vki_u8	i;		/* List index (when in range struct) */
2818  	__vki_u8	flags;		/* Flags (fixed/auto) */
2819  };
2820  
2821  struct	vki_iw_quality
2822  {
2823  	__vki_u8	qual;		/* link quality (%retries, SNR,
2824  					   %missed beacons or better...) */
2825  	__vki_u8	level;		/* signal level (dBm) */
2826  	__vki_u8	noise;		/* noise level (dBm) */
2827  	__vki_u8	updated;	/* Flags to know if updated */
2828  };
2829  
2830  union	vki_iwreq_data
2831  {
2832  	/* Config - generic */
2833  	char		name[VKI_IFNAMSIZ];
2834  	/* Name : used to verify the presence of  wireless extensions.
2835  	 * Name of the protocol/provider... */
2836  
2837  	struct vki_iw_point	essid;	/* Extended network name */
2838  	struct vki_iw_param	nwid;	/* network id (or domain - the cell) */
2839  	struct vki_iw_freq	freq;	/* frequency or channel :
2840  					 * 0-1000 = channel
2841  					 * > 1000 = frequency in Hz */
2842  
2843  	struct vki_iw_param	sens;	/* signal level threshold */
2844  	struct vki_iw_param	bitrate;/* default bit rate */
2845  	struct vki_iw_param	txpower;/* default transmit power */
2846  	struct vki_iw_param	rts;	/* RTS threshold threshold */
2847  	struct vki_iw_param	frag;	/* Fragmentation threshold */
2848  	__vki_u32		mode;	/* Operation mode */
2849  	struct vki_iw_param	retry;	/* Retry limits & lifetime */
2850  
2851  	struct vki_iw_point	encoding; /* Encoding stuff : tokens */
2852  	struct vki_iw_param	power;	/* PM duration/timeout */
2853  	struct vki_iw_quality	qual;	/* Quality part of statistics */
2854  
2855  	struct vki_sockaddr ap_addr;	/* Access point address */
2856  	struct vki_sockaddr addr;	/* Destination address (hw/mac) */
2857  
2858  	struct vki_iw_param	param;	/* Other small parameters */
2859  	struct vki_iw_point	data;	/* Other large parameters */
2860  };
2861  
2862  struct	vki_iwreq
2863  {
2864  	union
2865  	{
2866  		char ifrn_name[VKI_IFNAMSIZ];	/* if name, e.g. "eth0" */
2867  	} ifr_ifrn;
2868  
2869  	/* Data part (defined just above) */
2870  	union	vki_iwreq_data	u;
2871  };
2872  
2873  /*--------------------------------------------------------------------*/
2874  // From linux-2.6.31.5/include/linux/perf_event.h
2875  /*--------------------------------------------------------------------*/
2876  
2877  struct vki_perf_event_attr {
2878  
2879  	/*
2880  	 * Major type: hardware/software/tracepoint/etc.
2881  	 */
2882  	__vki_u32			type;
2883  
2884  	/*
2885  	 * Size of the attr structure, for fwd/bwd compat.
2886  	 */
2887  	__vki_u32			size;
2888  
2889  	/*
2890  	 * Type specific configuration information.
2891  	 */
2892  	__vki_u64			config;
2893  
2894  	union {
2895  		__vki_u64		sample_period;
2896  		__vki_u64		sample_freq;
2897  	};
2898  
2899  	__vki_u64			sample_type;
2900  	__vki_u64			read_format;
2901  
2902  	__vki_u64			disabled       :  1, /* off by default        */
2903  					inherit	       :  1, /* children inherit it   */
2904  					pinned	       :  1, /* must always be on PMU */
2905  					exclusive      :  1, /* only group on PMU     */
2906  					exclude_user   :  1, /* don't count user      */
2907  					exclude_kernel :  1, /* ditto kernel          */
2908  					exclude_hv     :  1, /* ditto hypervisor      */
2909  					exclude_idle   :  1, /* don't count when idle */
2910  					mmap           :  1, /* include mmap data     */
2911  					comm	       :  1, /* include comm data     */
2912  					freq           :  1, /* use freq, not period  */
2913  					inherit_stat   :  1, /* per task counts       */
2914  					enable_on_exec :  1, /* next exec enables     */
2915  					task           :  1, /* trace fork/exit       */
2916  					watermark      :  1, /* wakeup_watermark      */
2917  					/*
2918  					 * precise_ip:
2919  					 *
2920  					 *  0 - SAMPLE_IP can have arbitrary skid
2921  					 *  1 - SAMPLE_IP must have constant skid
2922  					 *  2 - SAMPLE_IP requested to have 0 skid
2923  					 *  3 - SAMPLE_IP must have 0 skid
2924  					 *
2925  					 *  See also PERF_RECORD_MISC_EXACT_IP
2926  					 */
2927  					precise_ip     :  2, /* skid constraint       */
2928  					mmap_data      :  1, /* non-exec mmap data    */
2929  					sample_id_all  :  1, /* sample_type all events */
2930  
2931  					__reserved_1   : 45;
2932  
2933  	union {
2934  		__vki_u32		wakeup_events;	  /* wakeup every n events */
2935  		__vki_u32		wakeup_watermark; /* bytes before wakeup   */
2936  	};
2937  
2938  	__vki_u32			bp_type;
2939  	union {
2940  		__vki_u64		bp_addr;
2941  		__vki_u64		config1; /* extension of config */
2942  	};
2943  	union {
2944  		__vki_u64		bp_len;
2945  		__vki_u64		config2; /* extension of config1 */
2946  	};
2947  };
2948  
2949  /*--------------------------------------------------------------------*/
2950  // From linux-2.6.32.4/include/linux/getcpu.h
2951  /*--------------------------------------------------------------------*/
2952  
2953  struct vki_getcpu_cache {
2954  	unsigned long blob[128 / sizeof(long)];
2955  };
2956  
2957  //----------------------------------------------------------------------
2958  // From linux-2.6.33.3/include/linux/input.h
2959  //----------------------------------------------------------------------
2960  
2961  /*
2962   * IOCTLs (0x00 - 0x7f)
2963   */
2964  
2965  #define VKI_EVIOCGNAME(len)	_VKI_IOC(_VKI_IOC_READ, 'E', 0x06, len)		/* get device name */
2966  #define VKI_EVIOCGPHYS(len)	_VKI_IOC(_VKI_IOC_READ, 'E', 0x07, len)		/* get physical location */
2967  #define VKI_EVIOCGUNIQ(len)	_VKI_IOC(_VKI_IOC_READ, 'E', 0x08, len)		/* get unique identifier */
2968  
2969  #define VKI_EVIOCGKEY(len)	_VKI_IOC(_VKI_IOC_READ, 'E', 0x18, len)		/* get global keystate */
2970  #define VKI_EVIOCGLED(len)	_VKI_IOC(_VKI_IOC_READ, 'E', 0x19, len)		/* get all LEDs */
2971  #define VKI_EVIOCGSND(len)	_VKI_IOC(_VKI_IOC_READ, 'E', 0x1a, len)		/* get all sounds status */
2972  #define VKI_EVIOCGSW(len)	_VKI_IOC(_VKI_IOC_READ, 'E', 0x1b, len)		/* get all switch states */
2973  
2974  #define VKI_EVIOCGBIT(ev,len)	_VKI_IOC(_VKI_IOC_READ, 'E', 0x20 + ev, len)	/* get event bits */
2975  
2976  /*
2977   * Event types
2978   */
2979  
2980  #define VKI_EV_SYN		0x00
2981  #define VKI_EV_KEY		0x01
2982  #define VKI_EV_REL		0x02
2983  #define VKI_EV_ABS		0x03
2984  #define VKI_EV_MSC		0x04
2985  #define VKI_EV_SW		0x05
2986  #define VKI_EV_LED		0x11
2987  #define VKI_EV_SND		0x12
2988  #define VKI_EV_REP		0x14
2989  #define VKI_EV_FF		0x15
2990  #define VKI_EV_PWR		0x16
2991  #define VKI_EV_FF_STATUS	0x17
2992  #define VKI_EV_MAX		0x1f
2993  #define VKI_EV_CNT		(VKI_EV_MAX+1)
2994  
2995  //----------------------------------------------------------------------
2996  // From linux-2.6.39-rc2/include/asm_generic/ioctls.h
2997  //----------------------------------------------------------------------
2998  
2999  #ifndef VKI_FIOQSIZE
3000  #define VKI_FIOQSIZE 0x5460     /* Value differs on some platforms */
3001  #endif
3002  
3003  #ifndef VKI_TIOCSIG
3004  #define VKI_TIOCSIG _VKI_IOW('T', 0x36, int) /* Value differs on some platforms */
3005  #endif
3006  
3007  //----------------------------------------------------------------------
3008  // From kernel/common/include/linux/ashmem.h
3009  //----------------------------------------------------------------------
3010  
3011  #if defined(VGPV_arm_linux_android) || defined(VGPV_x86_linux_android) \
3012      || defined(VGPV_mips32_linux_android)
3013  
3014  #define VKI_ASHMEM_NAME_LEN 256
3015  
3016  #define VKI_ASHMEM_NAME_DEF "dev/ashmem"
3017  
3018  #define VKI_ASHMEM_NOT_PURGED 0
3019  #define VKI_ASHMEM_WAS_PURGED 1
3020  
3021  #define VKI_ASHMEM_IS_UNPINNED 0
3022  #define VKI_ASHMEM_IS_PINNED 1
3023  
3024  struct vki_ashmem_pin {
3025     vki_uint32_t offset;
3026     vki_uint32_t len;
3027  };
3028  
3029  #define __VKI_ASHMEMIOC 0x77
3030  
3031  #define VKI_ASHMEM_SET_NAME _VKI_IOW(__VKI_ASHMEMIOC, 1, char[VKI_ASHMEM_NAME_LEN])
3032  #define VKI_ASHMEM_GET_NAME _VKI_IOR(__VKI_ASHMEMIOC, 2, char[VKI_ASHMEM_NAME_LEN])
3033  #define VKI_ASHMEM_SET_SIZE _VKI_IOW(__VKI_ASHMEMIOC, 3, vki_size_t)
3034  #define VKI_ASHMEM_GET_SIZE _VKI_IO(__VKI_ASHMEMIOC, 4)
3035  #define VKI_ASHMEM_SET_PROT_MASK _VKI_IOW(__VKI_ASHMEMIOC, 5, unsigned long)
3036  #define VKI_ASHMEM_GET_PROT_MASK _VKI_IO(__VKI_ASHMEMIOC, 6)
3037  #define VKI_ASHMEM_PIN _VKI_IOW(__VKI_ASHMEMIOC, 7, struct vki_ashmem_pin)
3038  #define VKI_ASHMEM_UNPIN _VKI_IOW(__VKI_ASHMEMIOC, 8, struct vki_ashmem_pin)
3039  #define VKI_ASHMEM_GET_PIN_STATUS _VKI_IO(__VKI_ASHMEMIOC, 9)
3040  #define VKI_ASHMEM_PURGE_ALL_CACHES _VKI_IO(__VKI_ASHMEMIOC, 10)
3041  
3042  //----------------------------------------------------------------------
3043  // From kernel/common/include/linux/binder.h
3044  //----------------------------------------------------------------------
3045  
3046  struct vki_binder_write_read {
3047   signed long write_size;
3048   signed long write_consumed;
3049   unsigned long write_buffer;
3050   signed long read_size;
3051   signed long read_consumed;
3052   unsigned long read_buffer;
3053  };
3054  
3055  struct vki_binder_version {
3056   signed long protocol_version;
3057  };
3058  
3059  #define VKI_BINDER_WRITE_READ _VKI_IOWR('b', 1, struct vki_binder_write_read)
3060  #define VKI_BINDER_SET_IDLE_TIMEOUT _VKI_IOW('b', 3, vki_int64_t)
3061  #define VKI_BINDER_SET_MAX_THREADS _VKI_IOW('b', 5, vki_size_t)
3062  #define VKI_BINDER_SET_IDLE_PRIORITY _VKI_IOW('b', 6, int)
3063  #define VKI_BINDER_SET_CONTEXT_MGR _VKI_IOW('b', 7, int)
3064  #define VKI_BINDER_THREAD_EXIT _VKI_IOW('b', 8, int)
3065  #define VKI_BINDER_VERSION _VKI_IOWR('b', 9, struct vki_binder_version)
3066  
3067  #endif /* defined(VGPV_*_linux_android) */
3068  
3069  //----------------------------------------------------------------------
3070  // From linux-3.0.4/include/net/bluetooth/bluetooth.h
3071  //----------------------------------------------------------------------
3072  
3073  typedef struct {
3074     __vki_u8 b[6];
3075  } __vki_packed vki_bdaddr_t;
3076  
3077  //----------------------------------------------------------------------
3078  // From linux-3.0.4/include/net/bluetooth/hci.h
3079  //----------------------------------------------------------------------
3080  
3081  #define VKI_HCIDEVUP        _VKI_IOW('H', 201, int)
3082  #define VKI_HCIDEVDOWN      _VKI_IOW('H', 202, int)
3083  #define VKI_HCIDEVRESET     _VKI_IOW('H', 203, int)
3084  #define VKI_HCIDEVRESTAT    _VKI_IOW('H', 204, int)
3085  
3086  #define VKI_HCIGETDEVLIST   _VKI_IOR('H', 210, int)
3087  
3088  struct vki_hci_dev_req {
3089  	__vki_u16  dev_id;
3090  	__vki_u32  dev_opt;
3091  };
3092  
3093  struct vki_hci_dev_list_req {
3094  	__vki_u16  dev_num;
3095  	struct vki_hci_dev_req dev_req[0];	/* hci_dev_req structures */
3096  };
3097  
3098  #define VKI_HCIGETDEVINFO   _VKI_IOR('H', 211, int)
3099  #define VKI_HCIGETCONNLIST  _VKI_IOR('H', 212, int)
3100  #define VKI_HCIGETCONNINFO  _VKI_IOR('H', 213, int)
3101  #define VKI_HCIGETAUTHINFO  _VKI_IOR('H', 215, int)
3102  
3103  #define VKI_HCISETRAW       _VKI_IOW('H', 220, int)
3104  #define VKI_HCISETSCAN      _VKI_IOW('H', 221, int)
3105  #define VKI_HCISETAUTH      _VKI_IOW('H', 222, int)
3106  #define VKI_HCISETENCRYPT   _VKI_IOW('H', 223, int)
3107  #define VKI_HCISETPTYPE     _VKI_IOW('H', 224, int)
3108  #define VKI_HCISETLINKPOL   _VKI_IOW('H', 225, int)
3109  #define VKI_HCISETLINKMODE  _VKI_IOW('H', 226, int)
3110  #define VKI_HCISETACLMTU    _VKI_IOW('H', 227, int)
3111  #define VKI_HCISETSCOMTU    _VKI_IOW('H', 228, int)
3112  
3113  #define VKI_HCIBLOCKADDR    _VKI_IOW('H', 230, int)
3114  #define VKI_HCIUNBLOCKADDR  _VKI_IOW('H', 231, int)
3115  
3116  #define VKI_HCIINQUIRY      _VKI_IOR('H', 240, int)
3117  
3118  struct vki_inquiry_info {
3119     vki_bdaddr_t bdaddr;
3120     __vki_u8     pscan_rep_mode;
3121     __vki_u8     pscan_period_mode;
3122     __vki_u8     pscan_mode;
3123     __vki_u8     dev_class[3];
3124     __vki_le16   clock_offset;
3125  } __vki_packed;
3126  
3127  struct vki_hci_inquiry_req {
3128     __vki_u16 dev_id;
3129     __vki_u16 flags;
3130     __vki_u8  lap[3];
3131     __vki_u8  length;
3132     __vki_u8  num_rsp;
3133  };
3134  
3135  //----------------------------------------------------------------------
3136  // From linux-3.9.2/include/net/bluetooth/rfcomm.h
3137  //----------------------------------------------------------------------
3138  
3139  struct vki_sockaddr_rc {
3140          vki_sa_family_t     rc_family;
3141          vki_bdaddr_t        rc_bdaddr;
3142          __vki_u8            rc_channel;
3143  };
3144  
3145  //----------------------------------------------------------------------
3146  // From linux-3.4/include/linux/kvm.h
3147  //----------------------------------------------------------------------
3148  #define KVMIO 0xAE
3149  
3150  #define VKI_KVM_GET_API_VERSION       _VKI_IO(KVMIO,   0x00)
3151  #define VKI_KVM_CREATE_VM             _VKI_IO(KVMIO,   0x01) /* returns a VM fd */
3152  #define VKI_KVM_CHECK_EXTENSION       _VKI_IO(KVMIO,   0x03)
3153  #define VKI_KVM_GET_VCPU_MMAP_SIZE    _VKI_IO(KVMIO,   0x04) /* in bytes */
3154  #define VKI_KVM_S390_ENABLE_SIE       _VKI_IO(KVMIO,   0x06)
3155  #define VKI_KVM_CREATE_VCPU           _VKI_IO(KVMIO,   0x41)
3156  #define VKI_KVM_SET_NR_MMU_PAGES      _VKI_IO(KVMIO,   0x44)
3157  #define VKI_KVM_GET_NR_MMU_PAGES      _VKI_IO(KVMIO,   0x45)
3158  #define VKI_KVM_SET_TSS_ADDR          _VKI_IO(KVMIO,   0x47)
3159  #define VKI_KVM_CREATE_IRQCHIP        _VKI_IO(KVMIO,   0x60)
3160  #define VKI_KVM_CREATE_PIT            _VKI_IO(KVMIO,   0x64)
3161  #define VKI_KVM_REINJECT_CONTROL      _VKI_IO(KVMIO,   0x71)
3162  #define VKI_KVM_SET_BOOT_CPU_ID       _VKI_IO(KVMIO,   0x78)
3163  #define VKI_KVM_SET_TSC_KHZ           _VKI_IO(KVMIO,  0xa2)
3164  #define VKI_KVM_GET_TSC_KHZ           _VKI_IO(KVMIO,  0xa3)
3165  #define VKI_KVM_RUN                   _VKI_IO(KVMIO,   0x80)
3166  #define VKI_KVM_S390_INITIAL_RESET    _VKI_IO(KVMIO,   0x97)
3167  #define VKI_KVM_NMI                   _VKI_IO(KVMIO,   0x9a)
3168  #define VKI_KVM_KVMCLOCK_CTRL         _VKI_IO(KVMIO,   0xad)
3169  
3170  struct vki_kvm_s390_mem_op {
3171          /* in */
3172          __vki_u64 gaddr;            /* the guest address */
3173          __vki_u64 flags;            /* flags */
3174          __vki_u32 size;             /* amount of bytes */
3175          __vki_u32 op;               /* type of operation */
3176          __vki_u64 buf;              /* buffer in userspace */
3177          __vki_u8 ar;                /* the access register number */
3178          __vki_u8 reserved[31];      /* should be set to 0 */
3179  };
3180  
3181  #define VKI_KVM_S390_MEMOP_LOGICAL_READ		0
3182  #define VKI_KVM_S390_MEMOP_LOGICAL_WRITE	1
3183  #define VKI_KVM_S390_MEMOP_F_CHECK_ONLY		(1ULL << 0)
3184  #define VKI_KVM_S390_MEMOP_F_INJECT_EXCEPTION	(1ULL << 1)
3185  
3186  #define VKI_KVM_S390_MEM_OP           _VKI_IOW(KVMIO,  0xb1, struct vki_kvm_s390_mem_op)
3187  
3188  //----------------------------------------------------------------------
3189  // From linux-2.6/include/linux/net_stamp.h
3190  //----------------------------------------------------------------------
3191  
3192  struct vki_hwtstamp_config {
3193  	int flags;
3194  	int tx_type;
3195  	int rx_filter;
3196  };
3197  
3198  //----------------------------------------------------------------------
3199  // From linux-2.6.12-rc2/include/linux/uinput.h
3200  //----------------------------------------------------------------------
3201  
3202  #define VKI_UINPUT_IOCTL_BASE       'U'
3203  #define VKI_UI_DEV_CREATE		_VKI_IO(VKI_UINPUT_IOCTL_BASE, 1)
3204  #define VKI_UI_DEV_DESTROY		_VKI_IO(VKI_UINPUT_IOCTL_BASE, 2)
3205  
3206  #define VKI_UI_SET_EVBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 100, int)
3207  #define VKI_UI_SET_KEYBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 101, int)
3208  #define VKI_UI_SET_RELBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 102, int)
3209  #define VKI_UI_SET_ABSBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 103, int)
3210  #define VKI_UI_SET_MSCBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 104, int)
3211  #define VKI_UI_SET_LEDBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 105, int)
3212  #define VKI_UI_SET_SNDBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 106, int)
3213  #define VKI_UI_SET_FFBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 107, int)
3214  #define VKI_UI_SET_SWBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 109, int)
3215  #define VKI_UI_SET_PROPBIT		_VKI_IOW(VKI_UINPUT_IOCTL_BASE, 110, int)
3216  
3217  //----------------------------------------------------------------------
3218  // From linux-2.6/include/uapi/rdma/ib_user_mad.h
3219  //----------------------------------------------------------------------
3220  
3221  #define VKI_IB_IOCTL_MAGIC          0x1b
3222  
3223  #define VKI_IB_USER_MAD_REGISTER_AGENT    _VKI_IOWR(VKI_IB_IOCTL_MAGIC, 1, \
3224                                                struct ib_user_mad_reg_req)
3225  
3226  #define VKI_IB_USER_MAD_UNREGISTER_AGENT  _VKI_IOW(VKI_IB_IOCTL_MAGIC, 2, __u32)
3227  
3228  #define VKI_IB_USER_MAD_ENABLE_PKEY       _VKI_IO(VKI_IB_IOCTL_MAGIC, 3)
3229  
3230  //----------------------------------------------------------------------
3231  // From linux-3.8/include/uapi/linux/if_tun.h
3232  //----------------------------------------------------------------------
3233  
3234  #define VKI_TUNSETNOCSUM  _VKI_IOW('T', 200, int)
3235  #define VKI_TUNSETDEBUG   _VKI_IOW('T', 201, int)
3236  #define VKI_TUNSETIFF     _VKI_IOW('T', 202, int)
3237  #define VKI_TUNSETPERSIST _VKI_IOW('T', 203, int)
3238  #define VKI_TUNSETOWNER   _VKI_IOW('T', 204, int)
3239  #define VKI_TUNSETLINK    _VKI_IOW('T', 205, int)
3240  #define VKI_TUNSETGROUP   _VKI_IOW('T', 206, int)
3241  #define VKI_TUNGETFEATURES _VKI_IOR('T', 207, unsigned int)
3242  #define VKI_TUNSETOFFLOAD  _VKI_IOW('T', 208, unsigned int)
3243  #define VKI_TUNSETTXFILTER _VKI_IOW('T', 209, unsigned int)
3244  #define VKI_TUNGETIFF      _VKI_IOR('T', 210, unsigned int)
3245  #define VKI_TUNGETSNDBUF   _VKI_IOR('T', 211, int)
3246  #define VKI_TUNSETSNDBUF   _VKI_IOW('T', 212, int)
3247  //#define VKI_TUNATTACHFILTER _VKI_IOW('T', 213, struct sock_fprog)
3248  //#define VKI_TUNDETACHFILTER _VKI_IOW('T', 214, struct sock_fprog)
3249  #define VKI_TUNGETVNETHDRSZ _VKI_IOR('T', 215, int)
3250  #define VKI_TUNSETVNETHDRSZ _VKI_IOW('T', 216, int)
3251  #define VKI_TUNSETQUEUE  _VKI_IOW('T', 217, int)
3252  #define VKI_TUNSETIFINDEX	_VKI_IOW('T', 218, unsigned int)
3253  //#define VKI_TUNGETFILTER _VKI_IOR('T', 219, struct sock_fprog)
3254  
3255  //----------------------------------------------------------------------
3256  // From linux-3.8/include/uapi/linux/vhost.h
3257  //----------------------------------------------------------------------
3258  
3259  #define VKI_VHOST_VIRTIO 0xAF
3260  #define VKI_VHOST_SET_OWNER _VKI_IO(VKI_VHOST_VIRTIO, 0x01)
3261  #define VKI_VHOST_RESET_OWNER _VKI_IO(VKI_VHOST_VIRTIO, 0x02)
3262  
3263  //----------------------------------------------------------------------
3264  // Xen privcmd IOCTL
3265  //----------------------------------------------------------------------
3266  
3267  typedef unsigned long __vki_xen_pfn_t;
3268  
3269  struct vki_xen_privcmd_hypercall {
3270         __vki_u64 op;
3271         __vki_u64 arg[5];
3272  };
3273  
3274  struct vki_xen_privcmd_mmap_entry {
3275          __vki_u64 va;
3276          __vki_u64 mfn;
3277          __vki_u64 npages;
3278  };
3279  
3280  struct vki_xen_privcmd_mmap {
3281          int num;
3282          __vki_u16 dom; /* target domain */
3283          struct vki_xen_privcmd_mmap_entry *entry;
3284  };
3285  
3286  struct vki_xen_privcmd_mmapbatch {
3287          int num;     /* number of pages to populate */
3288          __vki_u16 dom; /* target domain */
3289          __vki_u64 addr;  /* virtual address */
3290          __vki_xen_pfn_t *arr; /* array of mfns - top nibble set on err */
3291  };
3292  
3293  struct vki_xen_privcmd_mmapbatch_v2 {
3294          unsigned int num; /* number of pages to populate */
3295          __vki_u16 dom;      /* target domain */
3296          __vki_u64 addr;       /* virtual address */
3297          const __vki_xen_pfn_t *arr; /* array of mfns */
3298          int __user *err;  /* array of error codes */
3299  };
3300  
3301  #define VKI_XEN_IOCTL_PRIVCMD_HYPERCALL    _VKI_IOC(_VKI_IOC_NONE, 'P', 0, sizeof(struct vki_xen_privcmd_hypercall))
3302  #define VKI_XEN_IOCTL_PRIVCMD_MMAP         _VKI_IOC(_VKI_IOC_NONE, 'P', 2, sizeof(struct vki_xen_privcmd_mmap))
3303  
3304  #define VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH    _VKI_IOC(_VKI_IOC_NONE, 'P', 3, sizeof(struct vki_xen_privcmd_mmapbatch))
3305  #define VKI_XEN_IOCTL_PRIVCMD_MMAPBATCH_V2 _VKI_IOC(_VKI_IOC_NONE, 'P', 4, sizeof(struct vki_xen_privcmd_mmapbatch_v2))
3306  
3307  //----------------------------------------------------------------------
3308  // Xen evtchn IOCTL
3309  //----------------------------------------------------------------------
3310  
3311  #define VKI_XEN_IOCTL_EVTCHN_BIND_VIRQ				\
3312  	_VKI_IOC(_VKI_IOC_NONE, 'E', 0, sizeof(struct vki_xen_ioctl_evtchn_bind_virq))
3313  struct vki_xen_ioctl_evtchn_bind_virq {
3314  	vki_uint32_t virq;
3315  };
3316  
3317  #define VKI_XEN_IOCTL_EVTCHN_BIND_INTERDOMAIN			\
3318  	_VKI_IOC(_VKI_IOC_NONE, 'E', 1, sizeof(struct vki_xen_ioctl_evtchn_bind_interdomain))
3319  struct vki_xen_ioctl_evtchn_bind_interdomain {
3320  	vki_uint32_t remote_domain;
3321  	vki_uint32_t remote_port;
3322  };
3323  
3324  #define VKI_XEN_IOCTL_EVTCHN_BIND_UNBOUND_PORT			\
3325  	_VKI_IOC(_VKI_IOC_NONE, 'E', 2, sizeof(struct vki_xen_ioctl_evtchn_bind_unbound_port))
3326  struct vki_xen_ioctl_evtchn_bind_unbound_port {
3327  	vki_uint32_t remote_domain;
3328  };
3329  
3330  #define VKI_XEN_IOCTL_EVTCHN_UNBIND				\
3331  	_VKI_IOC(_VKI_IOC_NONE, 'E', 3, sizeof(struct vki_xen_ioctl_evtchn_unbind))
3332  struct vki_xen_ioctl_evtchn_unbind {
3333  	vki_uint32_t port;
3334  };
3335  
3336  #define VKI_XEN_IOCTL_EVTCHN_NOTIFY				\
3337  	_VKI_IOC(_VKI_IOC_NONE, 'E', 4, sizeof(struct vki_xen_ioctl_evtchn_notify))
3338  struct vki_xen_ioctl_evtchn_notify {
3339  	vki_uint32_t port;
3340  };
3341  
3342  #define VKI_XEN_IOCTL_EVTCHN_RESET				\
3343  	_VKI_IOC(_VKI_IOC_NONE, 'E', 5, 0)
3344  
3345  
3346  //----------------------------------------------------------------------
3347  // From linux-3.4.0/include/linux/fs.h
3348  //----------------------------------------------------------------------
3349  
3350  struct vki_file_handle {
3351     __vki_u32 handle_bytes;
3352     int handle_type;
3353     /* file identifier */
3354     unsigned char f_handle[0];
3355  };
3356  
3357  //----------------------------------------------------------------------
3358  // From linux-3.2.0/include/linux/filter.h
3359  //----------------------------------------------------------------------
3360  
3361  struct vki_sock_filter {
3362  	__vki_u16 code; /* Actual filter code */
3363  	__vki_u8 jt;    /* Jump true */
3364  	__vki_u8 jf;    /* Jump false */
3365  	__vki_u32 k;    /* Generic multiuse field */
3366  };
3367  
3368  struct vki_sock_fprog {
3369  	__vki_u16 len;  /* actually unsigned short */
3370  	struct vki_sock_filter *filter;
3371  };
3372  
3373  //----------------------------------------------------------------------
3374  // From linux/include/uapi/linux/ethtool.h
3375  //----------------------------------------------------------------------
3376  
3377  struct vki_ethtool_cmd {
3378  	__vki_u32	cmd;
3379  	__vki_u32	supported;
3380  	__vki_u32	advertising;
3381  	__vki_u16	speed;
3382  	__vki_u8	duplex;
3383  	__vki_u8	port;
3384  	__vki_u8	phy_address;
3385  	__vki_u8	transceiver;
3386  	__vki_u8	autoneg;
3387  	__vki_u8	mdio_support;
3388  	__vki_u32	maxtxpkt;
3389  	__vki_u32	maxrxpkt;
3390  	__vki_u16	speed_hi;
3391  	__vki_u8	eth_tp_mdix;
3392  	__vki_u8	eth_tp_mdix_ctrl;
3393  	__vki_u32	lp_advertising;
3394  	__vki_u32	reserved[2];
3395  };
3396  
3397  #define VKI_ETHTOOL_FWVERS_LEN	32
3398  #define VKI_ETHTOOL_BUSINFO_LEN	32
3399  
3400  struct vki_ethtool_drvinfo {
3401  	__vki_u32	cmd;
3402  	char	driver[32];
3403  	char	version[32];
3404  	char	fw_version[VKI_ETHTOOL_FWVERS_LEN];
3405  	char	bus_info[VKI_ETHTOOL_BUSINFO_LEN];
3406  	char	reserved1[32];
3407  	char	reserved2[12];
3408  	__vki_u32	n_priv_flags;
3409  	__vki_u32	n_stats;
3410  	__vki_u32	testinfo_len;
3411  	__vki_u32	eedump_len;
3412  	__vki_u32	regdump_len;
3413  };
3414  
3415  #define VKI_SOPASS_MAX	6
3416  
3417  struct vki_ethtool_wolinfo {
3418  	__vki_u32	cmd;
3419  	__vki_u32	supported;
3420  	__vki_u32	wolopts;
3421  	__vki_u8	sopass[VKI_SOPASS_MAX];
3422  };
3423  
3424  struct vki_ethtool_value {
3425  	__vki_u32	cmd;
3426  	__vki_u32	data;
3427  };
3428  
3429  struct vki_ethtool_regs {
3430  	__vki_u32	cmd;
3431  	__vki_u32	version;
3432  	__vki_u32	len;
3433  	__vki_u8	data[0];
3434  };
3435  
3436  struct vki_ethtool_ringparam {
3437  	__vki_u32	cmd;
3438  	__vki_u32	rx_max_pending;
3439  	__vki_u32	rx_mini_max_pending;
3440  	__vki_u32	rx_jumbo_max_pending;
3441  	__vki_u32	tx_max_pending;
3442  	__vki_u32	rx_pending;
3443  	__vki_u32	rx_mini_pending;
3444  	__vki_u32	rx_jumbo_pending;
3445  	__vki_u32	tx_pending;
3446  };
3447  
3448  struct vki_ethtool_channels {
3449  	__vki_u32	cmd;
3450  	__vki_u32	max_rx;
3451  	__vki_u32	max_tx;
3452  	__vki_u32	max_other;
3453  	__vki_u32	max_combined;
3454  	__vki_u32	rx_count;
3455  	__vki_u32	tx_count;
3456  	__vki_u32	other_count;
3457  	__vki_u32	combined_count;
3458  };
3459  
3460  struct vki_ethtool_sset_info {
3461  	__vki_u32	cmd;
3462  	__vki_u32	reserved;
3463  	__vki_u64	sset_mask;
3464  	__vki_u32	data[0];
3465  };
3466  
3467  struct vki_ethtool_test {
3468  	__vki_u32	cmd;
3469  	__vki_u32	flags;
3470  	__vki_u32	reserved;
3471  	__vki_u32	len;
3472  	__vki_u64	data[0];
3473  };
3474  
3475  struct vki_ethtool_perm_addr {
3476  	__vki_u32	cmd;
3477  	__vki_u32	size;
3478  	__vki_u8	data[0];
3479  };
3480  
3481  struct vki_ethtool_get_features_block {
3482  	__vki_u32	available;
3483  	__vki_u32	requested;
3484  	__vki_u32	active;
3485  	__vki_u32	never_changed;
3486  };
3487  
3488  struct vki_ethtool_gfeatures {
3489  	__vki_u32	cmd;
3490  	__vki_u32	size;
3491  	struct vki_ethtool_get_features_block features[0];
3492  };
3493  
3494  struct vki_ethtool_set_features_block {
3495  	__vki_u32	valid;
3496  	__vki_u32	requested;
3497  };
3498  
3499  struct vki_ethtool_sfeatures {
3500  	__vki_u32	cmd;
3501  	__vki_u32	size;
3502  	struct vki_ethtool_set_features_block features[0];
3503  };
3504  
3505  struct vki_ethtool_ts_info {
3506  	__vki_u32	cmd;
3507  	__vki_u32	so_timestamping;
3508  	__vki_s32	phc_index;
3509  	__vki_u32	tx_types;
3510  	__vki_u32	tx_reserved[3];
3511  	__vki_u32	rx_filters;
3512  	__vki_u32	rx_reserved[3];
3513  };
3514  
3515  #define VKI_ETHTOOL_GSET	0x00000001 /* Get settings. */
3516  #define VKI_ETHTOOL_SSET	0x00000002 /* Set settings. */
3517  #define VKI_ETHTOOL_GDRVINFO	0x00000003 /* Get driver info. */
3518  #define VKI_ETHTOOL_GREGS	0x00000004 /* Get NIC registers. */
3519  #define VKI_ETHTOOL_GWOL	0x00000005 /* Get wake-on-lan options. */
3520  #define VKI_ETHTOOL_SWOL	0x00000006 /* Set wake-on-lan options. */
3521  #define VKI_ETHTOOL_GMSGLVL	0x00000007 /* Get driver message level */
3522  #define VKI_ETHTOOL_SMSGLVL	0x00000008 /* Set driver msg level. */
3523  #define VKI_ETHTOOL_NWAY_RST	0x00000009 /* Restart autonegotiation. */
3524  #define VKI_ETHTOOL_GLINK	0x0000000a
3525  #define VKI_ETHTOOL_GRINGPARAM	0x00000010 /* Get ring parameters */
3526  #define VKI_ETHTOOL_SRINGPARAM	0x00000011 /* Set ring parameters. */
3527  #define VKI_ETHTOOL_GRXCSUM	0x00000014 /* Get RX hw csum enable (ethtool_value) */
3528  #define VKI_ETHTOOL_SRXCSUM	0x00000015 /* Set RX hw csum enable (ethtool_value) */
3529  #define VKI_ETHTOOL_GTXCSUM	0x00000016 /* Get TX hw csum enable (ethtool_value) */
3530  #define VKI_ETHTOOL_STXCSUM	0x00000017 /* Set TX hw csum enable (ethtool_value) */
3531  #define VKI_ETHTOOL_GSG		0x00000018 /* Get scatter-gather enable
3532  					    * (ethtool_value) */
3533  #define VKI_ETHTOOL_SSG		0x00000019 /* Set scatter-gather enable
3534  					    * (ethtool_value). */
3535  #define VKI_ETHTOOL_TEST	0x0000001a /* execute NIC self-test. */
3536  #define VKI_ETHTOOL_PHYS_ID	0x0000001c /* identify the NIC */
3537  #define VKI_ETHTOOL_GTSO	0x0000001e /* Get TSO enable (ethtool_value) */
3538  #define VKI_ETHTOOL_STSO	0x0000001f /* Set TSO enable (ethtool_value) */
3539  #define VKI_ETHTOOL_GPERMADDR	0x00000020 /* Get permanent hardware address */
3540  #define VKI_ETHTOOL_GUFO	0x00000021 /* Get UFO enable (ethtool_value) */
3541  #define VKI_ETHTOOL_SUFO	0x00000022 /* Set UFO enable (ethtool_value) */
3542  #define VKI_ETHTOOL_GGSO	0x00000023 /* Get GSO enable (ethtool_value) */
3543  #define VKI_ETHTOOL_SGSO	0x00000024 /* Set GSO enable (ethtool_value) */
3544  #define VKI_ETHTOOL_GFLAGS	0x00000025 /* Get flags bitmap(ethtool_value) */
3545  #define VKI_ETHTOOL_SFLAGS	0x00000026 /* Set flags bitmap(ethtool_value) */
3546  #define VKI_ETHTOOL_GGRO	0x0000002b /* Get GRO enable (ethtool_value) */
3547  #define VKI_ETHTOOL_SGRO	0x0000002c /* Set GRO enable (ethtool_value) */
3548  #define VKI_ETHTOOL_RESET	0x00000034 /* Reset hardware */
3549  #define VKI_ETHTOOL_GSSET_INFO	0x00000037 /* Get string set info */
3550  #define VKI_ETHTOOL_GFEATURES	0x0000003a /* Get device offload settings */
3551  #define VKI_ETHTOOL_SFEATURES	0x0000003b /* Change device offload settings */
3552  #define VKI_ETHTOOL_GCHANNELS	0x0000003c /* Get no of channels */
3553  #define VKI_ETHTOOL_SCHANNELS	0x0000003d /* Set no of channels */
3554  #define VKI_ETHTOOL_GET_TS_INFO	0x00000041 /* Get time stamping and PHC info */
3555  
3556  //----------------------------------------------------------------------
3557  // From linux-3.15.8/drivers/staging/android/uapi/ion.h
3558  //----------------------------------------------------------------------
3559  
3560  typedef int vki_ion_user_handle_t;
3561  
3562  struct vki_ion_allocation_data {
3563          vki_size_t len;
3564          vki_size_t align;
3565          unsigned int heap_id_mask;
3566          unsigned int flags;
3567          vki_ion_user_handle_t handle;
3568  };
3569  
3570  struct vki_ion_fd_data {
3571          vki_ion_user_handle_t handle;
3572          int fd;
3573  };
3574  
3575  struct vki_ion_handle_data {
3576          vki_ion_user_handle_t handle;
3577  };
3578  
3579  struct vki_ion_custom_data {
3580          unsigned int cmd;
3581          unsigned long arg;
3582  };
3583  
3584  #define VKI_ION_IOC_MAGIC   'I'
3585  
3586  #define VKI_ION_IOC_ALLOC \
3587     _VKI_IOWR(VKI_ION_IOC_MAGIC, 0, struct vki_ion_allocation_data)
3588  
3589  #define VKI_ION_IOC_FREE \
3590     _VKI_IOWR(VKI_ION_IOC_MAGIC, 1, struct vki_ion_handle_data)
3591  
3592  #define VKI_ION_IOC_MAP \
3593     _VKI_IOWR(VKI_ION_IOC_MAGIC, 2, struct vki_ion_fd_data)
3594  
3595  #define VKI_ION_IOC_SHARE \
3596     _VKI_IOWR(VKI_ION_IOC_MAGIC, 4, struct vki_ion_fd_data)
3597  
3598  #define VKI_ION_IOC_IMPORT \
3599     _VKI_IOWR(VKI_ION_IOC_MAGIC, 5, struct vki_ion_fd_data)
3600  
3601  #define VKI_ION_IOC_SYNC \
3602     _VKI_IOWR(VKI_ION_IOC_MAGIC, 7, struct vki_ion_fd_data)
3603  
3604  #define VKI_ION_IOC_CUSTOM \
3605     _VKI_IOWR(VKI_ION_IOC_MAGIC, 6, struct vki_ion_custom_data)
3606  
3607  //----------------------------------------------------------------------
3608  // From linux-3.19-rc5/drivers/staging/android/uapi/sync.h
3609  //----------------------------------------------------------------------
3610  
3611  struct vki_sync_merge_data {
3612          __vki_s32 fd2;
3613          char      name[32];
3614          __vki_s32 fence;
3615  };
3616  
3617  struct vki_sync_pt_info {
3618          __vki_u32 len;
3619          char      obj_name[32];
3620          char      driver_name[32];
3621          __vki_s32 status;
3622          __vki_u64 timestamp_ns;
3623          __vki_u8  driver_data[0];
3624  };
3625  
3626  struct vki_sync_fence_info_data {
3627          __vki_u32 len;
3628          char      name[32];
3629          __vki_s32 status;
3630          __vki_u8  pt_info[0];
3631  };
3632  
3633  #define VKI_SYNC_IOC_MAGIC   '>'
3634  
3635  #define VKI_SYNC_IOC_WAIT \
3636     _VKI_IOW(VKI_SYNC_IOC_MAGIC, 0, __vki_s32)
3637  
3638  #define VKI_SYNC_IOC_MERGE \
3639     _VKI_IOWR(VKI_SYNC_IOC_MAGIC, 1, struct vki_sync_merge_data)
3640  
3641  #define VKI_SYNC_IOC_FENCE_INFO \
3642     _VKI_IOWR(VKI_SYNC_IOC_MAGIC, 2, struct vki_sync_fence_info_data)
3643  
3644  //----------------------------------------------------------------------
3645  // From drivers/staging/lustre/lustre/include/lustre/lustre_user.h
3646  //----------------------------------------------------------------------
3647  
3648  struct vki_lu_fid {
3649  	__vki_u64	f_seq;
3650  	__vki_u32	f_oid;
3651  	__vki_u32	f_ver;
3652  };
3653  
3654  //----------------------------------------------------------------------
3655  // From drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
3656  //----------------------------------------------------------------------
3657  
3658  struct vki_getinfo_fid2path {
3659  	struct vki_lu_fid	gf_fid;
3660  	__vki_u64		gf_recno;
3661  	__vki_u32		gf_linkno;
3662  	__vki_u32		gf_pathlen;
3663  	char			gf_path[0];
3664  } __attribute__((packed));
3665  
3666  //----------------------------------------------------------------------
3667  // From drivers/staging/lustre/lustre/include/linux/lustre_lib.h
3668  //----------------------------------------------------------------------
3669  
3670  #define VKI_OBD_IOC_DATA_TYPE               long
3671  
3672  //----------------------------------------------------------------------
3673  // From drivers/staging/lustre/lustre/include/lustre_lib.h
3674  //----------------------------------------------------------------------
3675  
3676  #define VKI_OBD_IOC_FID2PATH \
3677             _VKI_IOWR ('f', 150, VKI_OBD_IOC_DATA_TYPE)
3678  #define VKI_LL_IOC_PATH2FID \
3679             _VKI_IOR ('f', 173, long)
3680  
3681  //----------------------------------------------------------------------
3682  // From lustre/include/lustre/lustre_idl.h
3683  //----------------------------------------------------------------------
3684  
3685  struct vki_getparent {
3686      struct vki_lu_fid   gp_fid;
3687      __vki_u32       gp_linkno;
3688      __vki_u32       gp_name_size;
3689      char            gp_name[0];
3690  } __attribute__((packed));
3691  
3692  //----------------------------------------------------------------------
3693  // From Lustre's lustre/include/lustre/lustre_user.h
3694  //----------------------------------------------------------------------
3695  #define VKI_LL_IOC_GROUP_LOCK \
3696             _VKI_IOW('f', 158, long)
3697  #define VKI_LL_IOC_GROUP_UNLOCK \
3698             _VKI_IOW('f', 159, long)
3699  #define VKI_LL_IOC_GETPARENT \
3700             _VKI_IOWR('f', 249, struct vki_getparent)
3701  
3702  
3703  struct vki_v4l2_rect {
3704  	__vki_s32   left;
3705  	__vki_s32   top;
3706  	__vki_u32   width;
3707  	__vki_u32   height;
3708  };
3709  
3710  struct vki_v4l2_fract {
3711  	__vki_u32   numerator;
3712  	__vki_u32   denominator;
3713  };
3714  
3715  struct vki_v4l2_capability {
3716  	__vki_u8	driver[16];
3717  	__vki_u8	card[32];
3718  	__vki_u8	bus_info[32];
3719  	__vki_u32   version;
3720  	__vki_u32	capabilities;
3721  	__vki_u32	device_caps;
3722  	__vki_u32	reserved[3];
3723  };
3724  
3725  struct vki_v4l2_pix_format {
3726  	__vki_u32         		width;
3727  	__vki_u32			height;
3728  	__vki_u32			pixelformat;
3729  	__vki_u32			field;		/* enum vki_v4l2_field */
3730  	__vki_u32            	bytesperline;	/* for padding, zero if unused */
3731  	__vki_u32          		sizeimage;
3732  	__vki_u32			colorspace;	/* enum vki_v4l2_colorspace */
3733  	__vki_u32			priv;		/* private data, depends on pixelformat */
3734  	__vki_u32			flags;		/* format flags (VKI_V4L2_PIX_FMT_FLAG_*) */
3735  	__vki_u32			ycbcr_enc;
3736  	__vki_u32			quantization;
3737  };
3738  
3739  struct vki_v4l2_fmtdesc {
3740  	__vki_u32		    index;             /* Format number      */
3741  	__vki_u32		    type;              /* enum vki_v4l2_buf_type */
3742  	__vki_u32               flags;
3743  	__vki_u8		    description[32];   /* Description string */
3744  	__vki_u32		    pixelformat;       /* Format fourcc      */
3745  	__vki_u32		    reserved[4];
3746  };
3747  
3748  struct vki_v4l2_frmsize_discrete {
3749  	__vki_u32			width;		/* Frame width [pixel] */
3750  	__vki_u32			height;		/* Frame height [pixel] */
3751  };
3752  
3753  struct vki_v4l2_frmsize_stepwise {
3754  	__vki_u32			min_width;	/* Minimum frame width [pixel] */
3755  	__vki_u32			max_width;	/* Maximum frame width [pixel] */
3756  	__vki_u32			step_width;	/* Frame width step size [pixel] */
3757  	__vki_u32			min_height;	/* Minimum frame height [pixel] */
3758  	__vki_u32			max_height;	/* Maximum frame height [pixel] */
3759  	__vki_u32			step_height;	/* Frame height step size [pixel] */
3760  };
3761  
3762  struct vki_v4l2_frmsizeenum {
3763  	__vki_u32			index;		/* Frame size number */
3764  	__vki_u32			pixel_format;	/* Pixel format */
3765  	__vki_u32			type;		/* Frame size type the device supports. */
3766  
3767  	union {					/* Frame size */
3768  		struct vki_v4l2_frmsize_discrete	discrete;
3769  		struct vki_v4l2_frmsize_stepwise	stepwise;
3770  	};
3771  
3772  	__vki_u32   reserved[2];			/* Reserved space for future use */
3773  };
3774  
3775  struct vki_v4l2_frmival_stepwise {
3776  	struct vki_v4l2_fract	min;
3777  	struct vki_v4l2_fract	max;
3778  	struct vki_v4l2_fract	step;
3779  };
3780  
3781  struct vki_v4l2_frmivalenum {
3782  	__vki_u32			index;
3783  	__vki_u32			pixel_format;
3784  	__vki_u32			width;
3785  	__vki_u32			height;
3786  	__vki_u32			type;
3787  
3788  	union {
3789  		struct vki_v4l2_fract		discrete;
3790  		struct vki_v4l2_frmival_stepwise	stepwise;
3791  	};
3792  
3793  	__vki_u32	reserved[2];
3794  };
3795  
3796  struct vki_v4l2_timecode {
3797  	__vki_u32	type;
3798  	__vki_u32	flags;
3799  	__vki_u8	frames;
3800  	__vki_u8	seconds;
3801  	__vki_u8	minutes;
3802  	__vki_u8	hours;
3803  	__vki_u8	userbits[4];
3804  };
3805  
3806  struct vki_v4l2_jpegcompression {
3807  	int quality;
3808  	int  APPn;
3809  	int  APP_len;
3810  	char APP_data[60];
3811  	int  COM_len;
3812  	char COM_data[60];
3813  	__vki_u32 jpeg_markers;
3814  };
3815  
3816  struct vki_v4l2_requestbuffers {
3817  	__vki_u32			count;
3818  	__vki_u32			type;
3819  	__vki_u32			memory;
3820  	__vki_u32			reserved[2];
3821  };
3822  
3823  struct vki_v4l2_plane {
3824  	__vki_u32			bytesused;
3825  	__vki_u32			length;
3826  	union {
3827  		__vki_u32		mem_offset;
3828  		unsigned long	userptr;
3829  		__vki_s32		fd;
3830  	} m;
3831  	__vki_u32			data_offset;
3832  	__vki_u32			reserved[11];
3833  };
3834  
3835  #define VKI_V4L2_MEMORY_MMAP             1
3836  #define VKI_V4L2_MEMORY_DMABUF           4
3837  #define VKI_V4L2_BUF_FLAG_TIMESTAMP_MASK		0x0000e000
3838  #define VKI_V4L2_BUF_FLAG_TIMESTAMP_COPY		0x00004000
3839  struct vki_v4l2_buffer {
3840  	__vki_u32			index;
3841  	__vki_u32			type;
3842  	__vki_u32			bytesused;
3843  	__vki_u32			flags;
3844  	__vki_u32			field;
3845  	struct vki_timeval		timestamp;
3846  	struct vki_v4l2_timecode	timecode;
3847  	__vki_u32			sequence;
3848  
3849  	/* memory location */
3850  	__vki_u32			memory;
3851  	union {
3852  		__vki_u32           offset;
3853  		unsigned long   userptr;
3854  		struct vki_v4l2_plane *planes;
3855  		__vki_s32		fd;
3856  	} m;
3857  	__vki_u32			length;
3858  	__vki_u32			reserved2;
3859  	__vki_u32			reserved;
3860  };
3861  
3862  struct vki_v4l2_exportbuffer {
3863  	__vki_u32		type; /* enum vki_v4l2_buf_type */
3864  	__vki_u32		index;
3865  	__vki_u32		plane;
3866  	__vki_u32		flags;
3867  	__vki_s32		fd;
3868  	__vki_u32		reserved[11];
3869  };
3870  
3871  struct vki_v4l2_framebuffer {
3872  	__vki_u32			capability;
3873  	__vki_u32			flags;
3874  	void                    *base;
3875  	struct {
3876  		__vki_u32		width;
3877  		__vki_u32		height;
3878  		__vki_u32		pixelformat;
3879  		__vki_u32		field;		/* enum vki_v4l2_field */
3880  		__vki_u32		bytesperline;	/* for padding, zero if unused */
3881  		__vki_u32		sizeimage;
3882  		__vki_u32		colorspace;	/* enum vki_v4l2_colorspace */
3883  		__vki_u32		priv;		/* reserved field, set to 0 */
3884  	} fmt;
3885  };
3886  
3887  struct vki_v4l2_clip {
3888  	struct vki_v4l2_rect        c;
3889  	struct vki_v4l2_clip	__user *next;
3890  };
3891  
3892  struct vki_v4l2_window {
3893  	struct vki_v4l2_rect        w;
3894  	__vki_u32			field;	 /* enum vki_v4l2_field */
3895  	__vki_u32			chromakey;
3896  	struct vki_v4l2_clip	__user *clips;
3897  	__vki_u32			clipcount;
3898  	void			__user *bitmap;
3899  	__vki_u8                    global_alpha;
3900  };
3901  
3902  struct vki_v4l2_captureparm {
3903  	__vki_u32		   capability;	  /*  Supported modes */
3904  	__vki_u32		   capturemode;	  /*  Current mode */
3905  	struct vki_v4l2_fract  timeperframe;  /*  Time per frame in seconds */
3906  	__vki_u32		   extendedmode;  /*  Driver-specific extensions */
3907  	__vki_u32              readbuffers;   /*  # of buffers for read */
3908  	__vki_u32		   reserved[4];
3909  };
3910  
3911  struct vki_v4l2_outputparm {
3912  	__vki_u32		   capability;	 /*  Supported modes */
3913  	__vki_u32		   outputmode;	 /*  Current mode */
3914  	struct vki_v4l2_fract  timeperframe; /*  Time per frame in seconds */
3915  	__vki_u32		   extendedmode; /*  Driver-specific extensions */
3916  	__vki_u32              writebuffers; /*  # of buffers for write */
3917  	__vki_u32		   reserved[4];
3918  };
3919  
3920  struct vki_v4l2_cropcap {
3921  	__vki_u32			type;	/* enum vki_v4l2_buf_type */
3922  	struct vki_v4l2_rect        bounds;
3923  	struct vki_v4l2_rect        defrect;
3924  	struct vki_v4l2_fract       pixelaspect;
3925  };
3926  
3927  struct vki_v4l2_crop {
3928  	__vki_u32			type;	/* enum vki_v4l2_buf_type */
3929  	struct vki_v4l2_rect        c;
3930  };
3931  
3932  struct vki_v4l2_selection {
3933  	__vki_u32			type;
3934  	__vki_u32			target;
3935  	__vki_u32                   flags;
3936  	struct vki_v4l2_rect        r;
3937  	__vki_u32                   reserved[9];
3938  };
3939  
3940  typedef __vki_u64 vki_v4l2_std_id;
3941  
3942  struct vki_v4l2_standard {
3943  	__vki_u32		     index;
3944  	vki_v4l2_std_id          id;
3945  	__vki_u8		     name[24];
3946  	struct vki_v4l2_fract    frameperiod; /* Frames, not fields */
3947  	__vki_u32		     framelines;
3948  	__vki_u32		     reserved[4];
3949  };
3950  
3951  struct vki_v4l2_bt_timings {
3952  	__vki_u32	width;
3953  	__vki_u32	height;
3954  	__vki_u32	interlaced;
3955  	__vki_u32	polarities;
3956  	__vki_u64	pixelclock;
3957  	__vki_u32	hfrontporch;
3958  	__vki_u32	hsync;
3959  	__vki_u32	hbackporch;
3960  	__vki_u32	vfrontporch;
3961  	__vki_u32	vsync;
3962  	__vki_u32	vbackporch;
3963  	__vki_u32	il_vfrontporch;
3964  	__vki_u32	il_vsync;
3965  	__vki_u32	il_vbackporch;
3966  	__vki_u32	standards;
3967  	__vki_u32	flags;
3968  	__vki_u32	reserved[14];
3969  } __attribute__ ((packed));
3970  
3971  struct vki_v4l2_dv_timings {
3972  	__vki_u32 type;
3973  	union {
3974  		struct vki_v4l2_bt_timings	bt;
3975  		__vki_u32	reserved[32];
3976  	};
3977  } __attribute__ ((packed));
3978  
3979  struct vki_v4l2_enum_dv_timings {
3980  	__vki_u32 index;
3981  	__vki_u32 pad;
3982  	__vki_u32 reserved[2];
3983  	struct vki_v4l2_dv_timings timings;
3984  };
3985  
3986  struct vki_v4l2_bt_timings_cap {
3987  	__vki_u32	min_width;
3988  	__vki_u32	max_width;
3989  	__vki_u32	min_height;
3990  	__vki_u32	max_height;
3991  	__vki_u64	min_pixelclock;
3992  	__vki_u64	max_pixelclock;
3993  	__vki_u32	standards;
3994  	__vki_u32	capabilities;
3995  	__vki_u32	reserved[16];
3996  } __attribute__ ((packed));
3997  
3998  struct vki_v4l2_dv_timings_cap {
3999  	__vki_u32 type;
4000  	__vki_u32 pad;
4001  	__vki_u32 reserved[2];
4002  	union {
4003  		struct vki_v4l2_bt_timings_cap bt;
4004  		__vki_u32 raw_data[32];
4005  	};
4006  };
4007  
4008  struct vki_v4l2_input {
4009  	__vki_u32	     index;		/*  Which input */
4010  	__vki_u8	     name[32];		/*  Label */
4011  	__vki_u32	     type;		/*  Type of input */
4012  	__vki_u32	     audioset;		/*  Associated audios (bitfield) */
4013  	__vki_u32        tuner;             /*  enum vki_v4l2_tuner_type */
4014  	vki_v4l2_std_id  std;
4015  	__vki_u32	     status;
4016  	__vki_u32	     capabilities;
4017  	__vki_u32	     reserved[3];
4018  };
4019  
4020  struct vki_v4l2_output {
4021  	__vki_u32	     index;		/*  Which output */
4022  	__vki_u8	     name[32];		/*  Label */
4023  	__vki_u32	     type;		/*  Type of output */
4024  	__vki_u32	     audioset;		/*  Associated audios (bitfield) */
4025  	__vki_u32	     modulator;         /*  Associated modulator */
4026  	vki_v4l2_std_id  std;
4027  	__vki_u32	     capabilities;
4028  	__vki_u32	     reserved[3];
4029  };
4030  
4031  struct vki_v4l2_control {
4032  	__vki_u32		     id;
4033  	__vki_s32		     value;
4034  };
4035  
4036  struct vki_v4l2_ext_control {
4037  	__vki_u32 id;
4038  	__vki_u32 size;
4039  	__vki_u32 reserved2[1];
4040  	union {
4041  		__vki_s32 value;
4042  		__vki_s64 value64;
4043  		char *string;
4044  		__vki_u8 *p_u8;
4045  		__vki_u16 *p_u16;
4046  		__vki_u32 *p_u32;
4047  		void *ptr;
4048  	};
4049  } __attribute__ ((packed));
4050  
4051  struct vki_v4l2_ext_controls {
4052  	__vki_u32 ctrl_class;
4053  	__vki_u32 count;
4054  	__vki_u32 error_idx;
4055  	__vki_u32 reserved[2];
4056  	struct vki_v4l2_ext_control *controls;
4057  };
4058  
4059  struct vki_v4l2_queryctrl {
4060  	__vki_u32		     id;
4061  	__vki_u32		     type;	/* enum vki_v4l2_ctrl_type */
4062  	__vki_u8		     name[32];	/* Whatever */
4063  	__vki_s32		     minimum;	/* Note signedness */
4064  	__vki_s32		     maximum;
4065  	__vki_s32		     step;
4066  	__vki_s32		     default_value;
4067  	__vki_u32                flags;
4068  	__vki_u32		     reserved[2];
4069  };
4070  
4071  #define VKI_V4L2_CTRL_MAX_DIMS	  (4)
4072  struct vki_v4l2_query_ext_ctrl {
4073  	__vki_u32		     id;
4074  	__vki_u32		     type;
4075  	char		     name[32];
4076  	__vki_s64		     minimum;
4077  	__vki_s64		     maximum;
4078  	__vki_u64		     step;
4079  	__vki_s64		     default_value;
4080  	__vki_u32                flags;
4081  	__vki_u32                elem_size;
4082  	__vki_u32                elems;
4083  	__vki_u32                nr_of_dims;
4084  	__vki_u32                dims[VKI_V4L2_CTRL_MAX_DIMS];
4085  	__vki_u32		     reserved[32];
4086  };
4087  
4088  struct vki_v4l2_querymenu {
4089  	__vki_u32		id;
4090  	__vki_u32		index;
4091  	union {
4092  		__vki_u8	name[32];	/* Whatever */
4093  		__vki_s64	value;
4094  	};
4095  	__vki_u32		reserved;
4096  } __attribute__ ((packed));
4097  
4098  struct vki_v4l2_tuner {
4099  	__vki_u32                   index;
4100  	__vki_u8			name[32];
4101  	__vki_u32			type;	/* enum vki_v4l2_tuner_type */
4102  	__vki_u32			capability;
4103  	__vki_u32			rangelow;
4104  	__vki_u32			rangehigh;
4105  	__vki_u32			rxsubchans;
4106  	__vki_u32			audmode;
4107  	__vki_s32			signal;
4108  	__vki_s32			afc;
4109  	__vki_u32			reserved[4];
4110  };
4111  
4112  struct vki_v4l2_modulator {
4113  	__vki_u32			index;
4114  	__vki_u8			name[32];
4115  	__vki_u32			capability;
4116  	__vki_u32			rangelow;
4117  	__vki_u32			rangehigh;
4118  	__vki_u32			txsubchans;
4119  	__vki_u32			reserved[4];
4120  };
4121  
4122  struct vki_v4l2_frequency {
4123  	__vki_u32	tuner;
4124  	__vki_u32	type;	/* enum vki_v4l2_tuner_type */
4125  	__vki_u32	frequency;
4126  	__vki_u32	reserved[8];
4127  };
4128  
4129  struct vki_v4l2_frequency_band {
4130  	__vki_u32	tuner;
4131  	__vki_u32	type;	/* enum vki_v4l2_tuner_type */
4132  	__vki_u32	index;
4133  	__vki_u32	capability;
4134  	__vki_u32	rangelow;
4135  	__vki_u32	rangehigh;
4136  	__vki_u32	modulation;
4137  	__vki_u32	reserved[9];
4138  };
4139  
4140  struct vki_v4l2_hw_freq_seek {
4141  	__vki_u32	tuner;
4142  	__vki_u32	type;	/* enum vki_v4l2_tuner_type */
4143  	__vki_u32	seek_upward;
4144  	__vki_u32	wrap_around;
4145  	__vki_u32	spacing;
4146  	__vki_u32	rangelow;
4147  	__vki_u32	rangehigh;
4148  	__vki_u32	reserved[5];
4149  };
4150  
4151  struct vki_v4l2_audio {
4152  	__vki_u32	index;
4153  	__vki_u8	name[32];
4154  	__vki_u32	capability;
4155  	__vki_u32	mode;
4156  	__vki_u32	reserved[2];
4157  };
4158  
4159  struct vki_v4l2_audioout {
4160  	__vki_u32	index;
4161  	__vki_u8	name[32];
4162  	__vki_u32	capability;
4163  	__vki_u32	mode;
4164  	__vki_u32	reserved[2];
4165  };
4166  
4167  struct vki_v4l2_enc_idx_entry {
4168  	__vki_u64 offset;
4169  	__vki_u64 pts;
4170  	__vki_u32 length;
4171  	__vki_u32 flags;
4172  	__vki_u32 reserved[2];
4173  };
4174  
4175  #define VKI_V4L2_ENC_IDX_ENTRIES (64)
4176  struct vki_v4l2_enc_idx {
4177  	__vki_u32 entries;
4178  	__vki_u32 entries_cap;
4179  	__vki_u32 reserved[4];
4180  	struct vki_v4l2_enc_idx_entry entry[VKI_V4L2_ENC_IDX_ENTRIES];
4181  };
4182  
4183  struct vki_v4l2_encoder_cmd {
4184  	__vki_u32 cmd;
4185  	__vki_u32 flags;
4186  	union {
4187  		struct {
4188  			__vki_u32 data[8];
4189  		} raw;
4190  	};
4191  };
4192  
4193  struct vki_v4l2_decoder_cmd {
4194  	__vki_u32 cmd;
4195  	__vki_u32 flags;
4196  	union {
4197  		struct {
4198  			__vki_u64 pts;
4199  		} stop;
4200  
4201  		struct {
4202  			__vki_s32 speed;
4203  			__vki_u32 format;
4204  		} start;
4205  
4206  		struct {
4207  			__vki_u32 data[16];
4208  		} raw;
4209  	};
4210  };
4211  
4212  struct vki_v4l2_vbi_format {
4213  	__vki_u32	sampling_rate;		/* in 1 Hz */
4214  	__vki_u32	offset;
4215  	__vki_u32	samples_per_line;
4216  	__vki_u32	sample_format;		/* VKI_V4L2_PIX_FMT_* */
4217  	__vki_s32	start[2];
4218  	__vki_u32	count[2];
4219  	__vki_u32	flags;			/* VKI_V4L2_VBI_* */
4220  	__vki_u32	reserved[2];		/* must be zero */
4221  };
4222  
4223  struct vki_v4l2_sliced_vbi_format {
4224  	__vki_u16   service_set;
4225  	__vki_u16   service_lines[2][24];
4226  	__vki_u32   io_size;
4227  	__vki_u32   reserved[2];            /* must be zero */
4228  };
4229  
4230  struct vki_v4l2_sliced_vbi_cap {
4231  	__vki_u16   service_set;
4232  	__vki_u16   service_lines[2][24];
4233  	__vki_u32	type;		/* enum vki_v4l2_buf_type */
4234  	__vki_u32   reserved[3];    /* must be 0 */
4235  };
4236  
4237  struct vki_v4l2_sliced_vbi_data {
4238  	__vki_u32   id;
4239  	__vki_u32   field;          /* 0: first field, 1: second field */
4240  	__vki_u32   line;           /* 1-23 */
4241  	__vki_u32   reserved;       /* must be 0 */
4242  	__vki_u8    data[48];
4243  };
4244  
4245  struct vki_v4l2_plane_pix_format {
4246  	__vki_u32		sizeimage;
4247  	__vki_u32		bytesperline;
4248  	__vki_u16		reserved[6];
4249  } __attribute__ ((packed));
4250  
4251  #define VKI_VIDEO_MAX_PLANES               8
4252  
4253  struct vki_v4l2_pix_format_mplane {
4254  	__vki_u32				width;
4255  	__vki_u32				height;
4256  	__vki_u32				pixelformat;
4257  	__vki_u32				field;
4258  	__vki_u32				colorspace;
4259  
4260  	struct vki_v4l2_plane_pix_format	plane_fmt[VKI_VIDEO_MAX_PLANES];
4261  	__vki_u8				num_planes;
4262  	__vki_u8				flags;
4263  	__vki_u8				ycbcr_enc;
4264  	__vki_u8				quantization;
4265  	__vki_u8				reserved[8];
4266  } __attribute__ ((packed));
4267  
4268  struct vki_v4l2_sdr_format {
4269  	__vki_u32				pixelformat;
4270  	__vki_u32				buffersize;
4271  	__vki_u8				reserved[24];
4272  } __attribute__ ((packed));
4273  
4274  enum vki_v4l2_buf_type {
4275  	VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,
4276  	VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,
4277  	VKI_V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,
4278  	VKI_V4L2_BUF_TYPE_VBI_CAPTURE          = 4,
4279  	VKI_V4L2_BUF_TYPE_VBI_OUTPUT           = 5,
4280  	VKI_V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,
4281  	VKI_V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,
4282  	VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
4283  	VKI_V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9,
4284  	VKI_V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE  = 10,
4285  	VKI_V4L2_BUF_TYPE_SDR_CAPTURE          = 11,
4286  };
4287  
4288  struct vki_v4l2_format {
4289  	__vki_u32	 type;
4290  	union {
4291  		struct vki_v4l2_pix_format		pix;
4292  		struct vki_v4l2_pix_format_mplane	pix_mp;
4293  		struct vki_v4l2_window		win;
4294  		struct vki_v4l2_vbi_format		vbi;
4295  		struct vki_v4l2_sliced_vbi_format	sliced;
4296  		struct vki_v4l2_sdr_format		sdr;
4297  		__vki_u8	raw_data[200];
4298  	} fmt;
4299  };
4300  
4301  struct vki_v4l2_streamparm {
4302  	__vki_u32	 type;
4303  	union {
4304  		struct vki_v4l2_captureparm	capture;
4305  		struct vki_v4l2_outputparm	output;
4306  		__vki_u8	raw_data[200];  /* user-defined */
4307  	} parm;
4308  };
4309  
4310  struct vki_v4l2_event_vsync {
4311  	__vki_u8 field;
4312  } __attribute__ ((packed));
4313  
4314  struct vki_v4l2_event_ctrl {
4315  	__vki_u32 changes;
4316  	__vki_u32 type;
4317  	union {
4318  		__vki_s32 value;
4319  		__vki_s64 value64;
4320  	};
4321  	__vki_u32 flags;
4322  	__vki_s32 minimum;
4323  	__vki_s32 maximum;
4324  	__vki_s32 step;
4325  	__vki_s32 default_value;
4326  };
4327  
4328  struct vki_v4l2_event_frame_sync {
4329  	__vki_u32 frame_sequence;
4330  };
4331  
4332  struct vki_v4l2_event_src_change {
4333  	__vki_u32 changes;
4334  };
4335  
4336  struct vki_v4l2_event_motion_det {
4337  	__vki_u32 flags;
4338  	__vki_u32 frame_sequence;
4339  	__vki_u32 region_mask;
4340  };
4341  
4342  struct vki_v4l2_event {
4343  	__vki_u32				type;
4344  	union {
4345  		struct vki_v4l2_event_vsync		vsync;
4346  		struct vki_v4l2_event_ctrl		ctrl;
4347  		struct vki_v4l2_event_frame_sync	frame_sync;
4348  		struct vki_v4l2_event_src_change	src_change;
4349  		struct vki_v4l2_event_motion_det	motion_det;
4350  		__vki_u8				data[64];
4351  	} u;
4352  	__vki_u32				pending;
4353  	__vki_u32				sequence;
4354  	struct vki_timespec			timestamp;
4355  	__vki_u32				id;
4356  	__vki_u32				reserved[8];
4357  };
4358  
4359  struct vki_v4l2_event_subscription {
4360  	__vki_u32				type;
4361  	__vki_u32				id;
4362  	__vki_u32				flags;
4363  	__vki_u32				reserved[5];
4364  };
4365  
4366  struct vki_v4l2_dbg_match {
4367  	__vki_u32 type; /* Match type */
4368  	union {     /* Match this chip, meaning determined by type */
4369  		__vki_u32 addr;
4370  		char name[32];
4371  	};
4372  } __attribute__ ((packed));
4373  
4374  struct vki_v4l2_dbg_register {
4375  	struct vki_v4l2_dbg_match match;
4376  	__vki_u32 size;	/* register size in bytes */
4377  	__vki_u64 reg;
4378  	__vki_u64 val;
4379  } __attribute__ ((packed));
4380  
4381  struct vki_v4l2_dbg_chip_info {
4382  	struct vki_v4l2_dbg_match match;
4383  	char name[32];
4384  	__vki_u32 flags;
4385  	__vki_u32 reserved[32];
4386  } __attribute__ ((packed));
4387  
4388  struct vki_v4l2_create_buffers {
4389  	__vki_u32			index;
4390  	__vki_u32			count;
4391  	__vki_u32			memory;
4392  	struct vki_v4l2_format	format;
4393  	__vki_u32			reserved[8];
4394  };
4395  
4396  struct vki_v4l2_edid {
4397  	__vki_u32 pad;
4398  	__vki_u32 start_block;
4399  	__vki_u32 blocks;
4400  	__vki_u32 reserved[5];
4401  	__vki_u8  *edid;
4402  };
4403  
4404  #define VKI_V4L2_QUERYCAP		_VKI_IOR('V',  0, struct vki_v4l2_capability)
4405  #define VKI_V4L2_ENUM_FMT		_VKI_IOWR('V',  2, struct vki_v4l2_fmtdesc)
4406  #define VKI_V4L2_G_FMT			_VKI_IOWR('V',  4, struct vki_v4l2_format)
4407  #define VKI_V4L2_S_FMT			_VKI_IOWR('V',  5, struct vki_v4l2_format)
4408  #define VKI_V4L2_REQBUFS		_VKI_IOWR('V',  8, struct vki_v4l2_requestbuffers)
4409  #define VKI_V4L2_QUERYBUF		_VKI_IOWR('V',  9, struct vki_v4l2_buffer)
4410  #define VKI_V4L2_G_FBUF		 	_VKI_IOR('V', 10, struct vki_v4l2_framebuffer)
4411  #define VKI_V4L2_S_FBUF		 	_VKI_IOW('V', 11, struct vki_v4l2_framebuffer)
4412  #define VKI_V4L2_OVERLAY	 	_VKI_IOW('V', 14, int)
4413  #define VKI_V4L2_QBUF			_VKI_IOWR('V', 15, struct vki_v4l2_buffer)
4414  #define VKI_V4L2_EXPBUF			_VKI_IOWR('V', 16, struct vki_v4l2_exportbuffer)
4415  #define VKI_V4L2_DQBUF			_VKI_IOWR('V', 17, struct vki_v4l2_buffer)
4416  #define VKI_V4L2_STREAMON	 	_VKI_IOW('V', 18, int)
4417  #define VKI_V4L2_STREAMOFF	 	_VKI_IOW('V', 19, int)
4418  #define VKI_V4L2_G_PARM			_VKI_IOWR('V', 21, struct vki_v4l2_streamparm)
4419  #define VKI_V4L2_S_PARM			_VKI_IOWR('V', 22, struct vki_v4l2_streamparm)
4420  #define VKI_V4L2_G_STD			_VKI_IOR('V', 23, vki_v4l2_std_id)
4421  #define VKI_V4L2_S_STD			_VKI_IOW('V', 24, vki_v4l2_std_id)
4422  #define VKI_V4L2_ENUMSTD		_VKI_IOWR('V', 25, struct vki_v4l2_standard)
4423  #define VKI_V4L2_ENUMINPUT		_VKI_IOWR('V', 26, struct vki_v4l2_input)
4424  #define VKI_V4L2_G_CTRL			_VKI_IOWR('V', 27, struct vki_v4l2_control)
4425  #define VKI_V4L2_S_CTRL			_VKI_IOWR('V', 28, struct vki_v4l2_control)
4426  #define VKI_V4L2_G_TUNER		_VKI_IOWR('V', 29, struct vki_v4l2_tuner)
4427  #define VKI_V4L2_S_TUNER		_VKI_IOW('V', 30, struct vki_v4l2_tuner)
4428  #define VKI_V4L2_G_AUDIO		_VKI_IOR('V', 33, struct vki_v4l2_audio)
4429  #define VKI_V4L2_S_AUDIO		_VKI_IOW('V', 34, struct vki_v4l2_audio)
4430  #define VKI_V4L2_QUERYCTRL		_VKI_IOWR('V', 36, struct vki_v4l2_queryctrl)
4431  #define VKI_V4L2_QUERYMENU		_VKI_IOWR('V', 37, struct vki_v4l2_querymenu)
4432  #define VKI_V4L2_G_INPUT		_VKI_IOR('V', 38, int)
4433  #define VKI_V4L2_S_INPUT		_VKI_IOWR('V', 39, int)
4434  #define VKI_V4L2_G_EDID			_VKI_IOWR('V', 40, struct vki_v4l2_edid)
4435  #define VKI_V4L2_S_EDID			_VKI_IOWR('V', 41, struct vki_v4l2_edid)
4436  #define VKI_V4L2_G_OUTPUT		_VKI_IOR('V', 46, int)
4437  #define VKI_V4L2_S_OUTPUT		_VKI_IOWR('V', 47, int)
4438  #define VKI_V4L2_ENUMOUTPUT		_VKI_IOWR('V', 48, struct vki_v4l2_output)
4439  #define VKI_V4L2_G_AUDOUT		_VKI_IOR('V', 49, struct vki_v4l2_audioout)
4440  #define VKI_V4L2_S_AUDOUT		_VKI_IOW('V', 50, struct vki_v4l2_audioout)
4441  #define VKI_V4L2_G_MODULATOR		_VKI_IOWR('V', 54, struct vki_v4l2_modulator)
4442  #define VKI_V4L2_S_MODULATOR		_VKI_IOW('V', 55, struct vki_v4l2_modulator)
4443  #define VKI_V4L2_G_FREQUENCY		_VKI_IOWR('V', 56, struct vki_v4l2_frequency)
4444  #define VKI_V4L2_S_FREQUENCY		_VKI_IOW('V', 57, struct vki_v4l2_frequency)
4445  #define VKI_V4L2_CROPCAP		_VKI_IOWR('V', 58, struct vki_v4l2_cropcap)
4446  #define VKI_V4L2_G_CROP			_VKI_IOWR('V', 59, struct vki_v4l2_crop)
4447  #define VKI_V4L2_S_CROP			_VKI_IOW('V', 60, struct vki_v4l2_crop)
4448  #define VKI_V4L2_G_JPEGCOMP		_VKI_IOR('V', 61, struct vki_v4l2_jpegcompression)
4449  #define VKI_V4L2_S_JPEGCOMP		_VKI_IOW('V', 62, struct vki_v4l2_jpegcompression)
4450  #define VKI_V4L2_QUERYSTD      		_VKI_IOR('V', 63, vki_v4l2_std_id)
4451  #define VKI_V4L2_TRY_FMT      		_VKI_IOWR('V', 64, struct vki_v4l2_format)
4452  #define VKI_V4L2_ENUMAUDIO		_VKI_IOWR('V', 65, struct vki_v4l2_audio)
4453  #define VKI_V4L2_ENUMAUDOUT		_VKI_IOWR('V', 66, struct vki_v4l2_audioout)
4454  #define VKI_V4L2_G_PRIORITY		_VKI_IOR('V', 67, __vki_u32)
4455  #define VKI_V4L2_S_PRIORITY		_VKI_IOW('V', 68, __vki_u32)
4456  #define VKI_V4L2_G_SLICED_VBI_CAP 	_VKI_IOWR('V', 69, struct vki_v4l2_sliced_vbi_cap)
4457  #define VKI_V4L2_LOG_STATUS     	_VKI_IO('V', 70)
4458  #define VKI_V4L2_G_EXT_CTRLS		_VKI_IOWR('V', 71, struct vki_v4l2_ext_controls)
4459  #define VKI_V4L2_S_EXT_CTRLS		_VKI_IOWR('V', 72, struct vki_v4l2_ext_controls)
4460  #define VKI_V4L2_TRY_EXT_CTRLS		_VKI_IOWR('V', 73, struct vki_v4l2_ext_controls)
4461  #define VKI_V4L2_ENUM_FRAMESIZES	_VKI_IOWR('V', 74, struct vki_v4l2_frmsizeenum)
4462  #define VKI_V4L2_ENUM_FRAMEINTERVALS 	_VKI_IOWR('V', 75, struct vki_v4l2_frmivalenum)
4463  #define VKI_V4L2_G_ENC_INDEX    	_VKI_IOR('V', 76, struct vki_v4l2_enc_idx)
4464  #define VKI_V4L2_ENCODER_CMD    	_VKI_IOWR('V', 77, struct vki_v4l2_encoder_cmd)
4465  #define VKI_V4L2_TRY_ENCODER_CMD 	_VKI_IOWR('V', 78, struct vki_v4l2_encoder_cmd)
4466  #define	VKI_V4L2_DBG_S_REGISTER 	_VKI_IOW('V', 79, struct vki_v4l2_dbg_register)
4467  #define	VKI_V4L2_DBG_G_REGISTER 	_VKI_IOWR('V', 80, struct vki_v4l2_dbg_register)
4468  #define VKI_V4L2_S_HW_FREQ_SEEK		_VKI_IOW('V', 82, struct vki_v4l2_hw_freq_seek)
4469  #define	VKI_V4L2_S_DV_TIMINGS		_VKI_IOWR('V', 87, struct vki_v4l2_dv_timings)
4470  #define	VKI_V4L2_G_DV_TIMINGS		_VKI_IOWR('V', 88, struct vki_v4l2_dv_timings)
4471  #define	VKI_V4L2_DQEVENT		_VKI_IOR('V', 89, struct vki_v4l2_event)
4472  #define	VKI_V4L2_SUBSCRIBE_EVENT	_VKI_IOW('V', 90, struct vki_v4l2_event_subscription)
4473  #define	VKI_V4L2_UNSUBSCRIBE_EVENT 	_VKI_IOW('V', 91, struct vki_v4l2_event_subscription)
4474  #define VKI_V4L2_CREATE_BUFS		_VKI_IOWR('V', 92, struct vki_v4l2_create_buffers)
4475  #define VKI_V4L2_PREPARE_BUF		_VKI_IOWR('V', 93, struct vki_v4l2_buffer)
4476  #define VKI_V4L2_G_SELECTION		_VKI_IOWR('V', 94, struct vki_v4l2_selection)
4477  #define VKI_V4L2_S_SELECTION		_VKI_IOWR('V', 95, struct vki_v4l2_selection)
4478  #define VKI_V4L2_DECODER_CMD		_VKI_IOWR('V', 96, struct vki_v4l2_decoder_cmd)
4479  #define VKI_V4L2_TRY_DECODER_CMD	_VKI_IOWR('V', 97, struct vki_v4l2_decoder_cmd)
4480  #define VKI_V4L2_ENUM_DV_TIMINGS 	_VKI_IOWR('V', 98, struct vki_v4l2_enum_dv_timings)
4481  #define VKI_V4L2_QUERY_DV_TIMINGS 	_VKI_IOR('V', 99, struct vki_v4l2_dv_timings)
4482  #define VKI_V4L2_DV_TIMINGS_CAP   	_VKI_IOWR('V', 100, struct vki_v4l2_dv_timings_cap)
4483  #define VKI_V4L2_ENUM_FREQ_BANDS	_VKI_IOWR('V', 101, struct vki_v4l2_frequency_band)
4484  #define VKI_V4L2_DBG_G_CHIP_INFO 	_VKI_IOWR('V', 102, struct vki_v4l2_dbg_chip_info)
4485  #define VKI_V4L2_QUERY_EXT_CTRL		_VKI_IOWR('V', 103, struct vki_v4l2_query_ext_ctrl)
4486  
4487  struct vki_v4l2_mbus_framefmt {
4488  	__vki_u32			width;
4489  	__vki_u32			height;
4490  	__vki_u32			code;
4491  	__vki_u32			field;
4492  	__vki_u32			colorspace;
4493  	__vki_u16			ycbcr_enc;
4494  	__vki_u16			quantization;
4495  	__vki_u32			reserved[6];
4496  };
4497  
4498  struct vki_v4l2_subdev_format {
4499  	__vki_u32 which;
4500  	__vki_u32 pad;
4501  	struct vki_v4l2_mbus_framefmt format;
4502  	__vki_u32 reserved[8];
4503  };
4504  
4505  struct vki_v4l2_subdev_crop {
4506  	__vki_u32 which;
4507  	__vki_u32 pad;
4508  	struct vki_v4l2_rect rect;
4509  	__vki_u32 reserved[8];
4510  };
4511  
4512  struct vki_v4l2_subdev_mbus_code_enum {
4513  	__vki_u32 pad;
4514  	__vki_u32 index;
4515  	__vki_u32 code;
4516  	__vki_u32 which;
4517  	__vki_u32 reserved[8];
4518  };
4519  
4520  struct vki_v4l2_subdev_frame_size_enum {
4521  	__vki_u32 index;
4522  	__vki_u32 pad;
4523  	__vki_u32 code;
4524  	__vki_u32 min_width;
4525  	__vki_u32 max_width;
4526  	__vki_u32 min_height;
4527  	__vki_u32 max_height;
4528  	__vki_u32 which;
4529  	__vki_u32 reserved[8];
4530  };
4531  
4532  struct vki_v4l2_subdev_frame_interval {
4533  	__vki_u32 pad;
4534  	struct vki_v4l2_fract interval;
4535  	__vki_u32 reserved[9];
4536  };
4537  
4538  struct vki_v4l2_subdev_frame_interval_enum {
4539  	__vki_u32 index;
4540  	__vki_u32 pad;
4541  	__vki_u32 code;
4542  	__vki_u32 width;
4543  	__vki_u32 height;
4544  	struct vki_v4l2_fract interval;
4545  	__vki_u32 which;
4546  	__vki_u32 reserved[8];
4547  };
4548  
4549  struct vki_v4l2_subdev_selection {
4550  	__vki_u32 which;
4551  	__vki_u32 pad;
4552  	__vki_u32 target;
4553  	__vki_u32 flags;
4554  	struct vki_v4l2_rect r;
4555  	__vki_u32 reserved[8];
4556  };
4557  
4558  #define VKI_V4L2_SUBDEV_G_FMT			_VKI_IOWR('V',  4, struct vki_v4l2_subdev_format)
4559  #define VKI_V4L2_SUBDEV_S_FMT			_VKI_IOWR('V',  5, struct vki_v4l2_subdev_format)
4560  #define VKI_V4L2_SUBDEV_G_FRAME_INTERVAL	_VKI_IOWR('V', 21, struct vki_v4l2_subdev_frame_interval)
4561  #define VKI_V4L2_SUBDEV_S_FRAME_INTERVAL	_VKI_IOWR('V', 22, struct vki_v4l2_subdev_frame_interval)
4562  #define VKI_V4L2_SUBDEV_ENUM_MBUS_CODE		_VKI_IOWR('V',  2, struct vki_v4l2_subdev_mbus_code_enum)
4563  #define VKI_V4L2_SUBDEV_ENUM_FRAME_SIZE		_VKI_IOWR('V', 74, struct vki_v4l2_subdev_frame_size_enum)
4564  #define VKI_V4L2_SUBDEV_ENUM_FRAME_INTERVAL	_VKI_IOWR('V', 75, struct vki_v4l2_subdev_frame_interval_enum)
4565  #define VKI_V4L2_SUBDEV_G_CROP			_VKI_IOWR('V', 59, struct vki_v4l2_subdev_crop)
4566  #define VKI_V4L2_SUBDEV_S_CROP			_VKI_IOWR('V', 60, struct vki_v4l2_subdev_crop)
4567  #define VKI_V4L2_SUBDEV_G_SELECTION		_VKI_IOWR('V', 61, struct vki_v4l2_subdev_selection)
4568  #define VKI_V4L2_SUBDEV_S_SELECTION		_VKI_IOWR('V', 62, struct vki_v4l2_subdev_selection)
4569  
4570  struct vki_media_device_info {
4571  	char driver[16];
4572  	char model[32];
4573  	char serial[40];
4574  	char bus_info[32];
4575  	__vki_u32 media_version;
4576  	__vki_u32 hw_revision;
4577  	__vki_u32 driver_version;
4578  	__vki_u32 reserved[31];
4579  };
4580  
4581  struct vki_media_entity_desc {
4582  	__vki_u32 id;
4583  	char name[32];
4584  	__vki_u32 type;
4585  	__vki_u32 revision;
4586  	__vki_u32 flags;
4587  	__vki_u32 group_id;
4588  	__vki_u16 pads;
4589  	__vki_u16 links;
4590  
4591  	__vki_u32 reserved[4];
4592  
4593  	union {
4594  		/* Node specifications */
4595  		struct {
4596  			__vki_u32 major;
4597  			__vki_u32 minor;
4598  		} v4l;
4599  		struct {
4600  			__vki_u32 major;
4601  			__vki_u32 minor;
4602  		} fb;
4603  		struct {
4604  			__vki_u32 card;
4605  			__vki_u32 device;
4606  			__vki_u32 subdevice;
4607  		} alsa;
4608  		int dvb;
4609  
4610  		/* Sub-device specifications */
4611  		/* Nothing needed yet */
4612  		__vki_u8 raw[184];
4613  	};
4614  };
4615  
4616  struct vki_media_pad_desc {
4617  	__vki_u32 entity;		/* entity ID */
4618  	__vki_u16 index;		/* pad index */
4619  	__vki_u32 flags;		/* pad flags */
4620  	__vki_u32 reserved[2];
4621  };
4622  
4623  struct vki_media_link_desc {
4624  	struct vki_media_pad_desc source;
4625  	struct vki_media_pad_desc sink;
4626  	__vki_u32 flags;
4627  	__vki_u32 reserved[2];
4628  };
4629  
4630  struct vki_media_links_enum {
4631  	__vki_u32 entity;
4632  	struct vki_media_pad_desc __user *pads;
4633  	struct vki_media_link_desc __user *links;
4634  	__vki_u32 reserved[4];
4635  };
4636  
4637  #define VKI_MEDIA_IOC_DEVICE_INFO		_VKI_IOWR('|', 0x00, struct vki_media_device_info)
4638  #define VKI_MEDIA_IOC_ENUM_ENTITIES		_VKI_IOWR('|', 0x01, struct vki_media_entity_desc)
4639  #define VKI_MEDIA_IOC_ENUM_LINKS		_VKI_IOWR('|', 0x02, struct vki_media_links_enum)
4640  #define VKI_MEDIA_IOC_SETUP_LINK		_VKI_IOWR('|', 0x03, struct vki_media_link_desc)
4641  
4642  /* DVB demux API */
4643  #define	VKI_DMX_STOP	_VKI_IO('o', 42)
4644  
4645  /* Comparison type */
4646  enum vki_kcmp_type {
4647     VKI_KCMP_FILE,
4648     VKI_KCMP_VM,
4649     VKI_KCMP_FILES,
4650     VKI_KCMP_FS,
4651     VKI_KCMP_SIGHAND,
4652     VKI_KCMP_IO,
4653     VKI_KCMP_SYSVSEM,
4654  
4655     VKI_KCMP_TYPES
4656  };
4657  
4658  //----------------------------------------------------------------------
4659  // From linux-3.19-rc5/include/uapi/linux/seccomp.h
4660  //----------------------------------------------------------------------
4661  
4662  #define VKI_SECCOMP_MODE_FILTER 2
4663  
4664  //----------------------------------------------------------------------
4665  // From linux-3.19.3/include/uapi/linux/binfmts.h
4666  //----------------------------------------------------------------------
4667  #define VKI_BINPRM_BUF_SIZE 128
4668  
4669  //----------------------------------------------------------------------
4670  // From linux-3.19.0/include/linux/serial.h
4671  //----------------------------------------------------------------------
4672  
4673  struct vki_serial_struct {
4674  	int	type;
4675  	int	line;
4676  	unsigned int	port;
4677  	int	irq;
4678  	int	flags;
4679  	int	xmit_fifo_size;
4680  	int	custom_divisor;
4681  	int	baud_base;
4682  	unsigned short	close_delay;
4683  	char	io_type;
4684  	char	reserved_char[1];
4685  	int	hub6;
4686  	unsigned short	closing_wait; /* time to wait before closing */
4687  	unsigned short	closing_wait2; /* no longer used... */
4688  	unsigned char	*iomem_base;
4689  	unsigned short	iomem_reg_shift;
4690  	unsigned int	port_high;
4691  	unsigned long	iomap_base;	/* cookie passed into ioremap */
4692  };
4693  
4694  #endif // __VKI_LINUX_H
4695  
4696  /*--------------------------------------------------------------------*/
4697  /*--- end                                                          ---*/
4698  /*--------------------------------------------------------------------*/
4699