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