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