1
2 /*--------------------------------------------------------------------*/
3 /*--- Dragonfly-specific kernel interface. vki-dragonfly.h ---*/
4 /*--------------------------------------------------------------------*/
5
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
9
10 Copyright (C) 2000-2005 Julian Seward
11 jseward@acm.org
12
13 This program is free software; you can redistribute it and/or
14 modify it under the terms of the GNU General Public License as
15 published by the Free Software Foundation; either version 2 of the
16 License, or (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26 02111-1307, USA.
27
28 The GNU General Public License is contained in the file COPYING.
29 */
30
31 /* This file defines types and constants for the kernel interface, and to
32 make that clear everything is prefixed VKI_/vki_.
33
34 All code is copied verbatim from kernel source files, except that:
35 - VKI_/vki_ prefixes are added
36 - some extra explanatory comments are included; they are all within
37 "[[ ]]"
38 - for some types, we only care about the size; for a few of them (big
39 ones that are painful to fully drag in here), a VKI_SIZEOF_* constant
40 is used.
41
42 The files the code is taken from is indicated.
43
44 Note especially that the types are not the glibc versions, many of which
45 are different to those in here.
46
47 Also note that this file contains all the generic header info, ie. that
48 from linux/include/linux/ *.h. The arch-specific header info, eg. that
49 from linux/include/asm-i386/ *.h, is in vki-$PLATFORM.h and
50 vki_posixtypes-$PLATFORM.h. (Two files are required to avoid
51 circular dependencies between the generic VKI header and the
52 arch-specific VKI header. It's possible in the future, as more stuff
53 gets pulled in, that we might have to split files up some more to avoid
54 further circular dependencies.)
55
56 Finally, note that it is assumed that __KERNEL__ is set for all these
57 definitions, which affects some of them.
58 */
59
60 #ifndef __VKI_DRAGONFLY_H
61 #define __VKI_DRAGONFLY_H
62
63 //----------------------------------------------------------------------
64 // Arch-specific POSIX types
65 //----------------------------------------------------------------------
66
67 #if defined(VGA_x86)
68 # include "vki-machine-types-x86-dragonfly.h"
69 #elif defined(VGA_amd64)
70 # include "vki-machine-types-amd64-dragonfly.h"
71 #else
72 # error Unknown platform
73 #endif
74
75 #include <sys/fcntl.h>
76 #include <sys/param.h>
77
78 #define VKI_MAXPATHLEN MAXPATHLEN
79
80 //----------------------------------------------------------------------
81 // From machine/cpumask.h
82 //----------------------------------------------------------------------
83
84 typedef struct {
85 vki_uint64_t ary[4];
86 } vki_cpumask_t;
87
88 //----------------------------------------------------------------------
89 // From sys/lwp.h
90 //----------------------------------------------------------------------
91
92 struct vki_lwp_params {
93 void (*func)(void*);
94 void *arg;
95 void *stack;
96 lwpid_t *tid1;
97 lwpid_t *tid2;
98 };
99
100 //----------------------------------------------------------------------
101 // From sys/tls.h
102 //----------------------------------------------------------------------
103
104 struct vki_tls_info {
105 void *base;
106 long size; /* must be signed */
107 };
108
109 #define VKI_TLS_WHICH_FS 0
110 #define VKI_TLS_WHICH_GS 1
111
112 //----------------------------------------------------------------------
113 // From sys/select.h
114 //----------------------------------------------------------------------
115
116 typedef unsigned long __vki_fd_mask;
117
118 #undef __VKI_NFDBITS
119 #define __VKI_NFDBITS (8 * sizeof(__vki_fd_mask))
120
121 #undef __VKI_FD_SETSIZE
122 #define __VKI_FD_SETSIZE 1024U
123
124 #undef __VKI_FDSET_LONGS
125 #define __VKI_FDSET_LONGS (__VKI_FD_SETSIZE/__VKI_NFDBITS)
126
127 #undef __VKI_FDELT
128 #define __VKI_FDELT(d) ((d) / __VKI_NFDBITS)
129
130 #undef __VKI_FDMASK
131 #define __VKI_FDMASK(d) (1UL << ((d) % __VKI_NFDBITS))
132
133 typedef struct {
134 unsigned long fds_bits [__VKI_FDSET_LONGS];
135 } __vki_fd_set;
136
137 //----------------------------------------------------------------------
138 // sys/_types.h
139 //----------------------------------------------------------------------
140 /* MD QQQ 32 on 64 */
141 typedef long __vki_key_t;
142 typedef long __vki_suseconds_t;
143 typedef struct __timer *__vki_timer_t;
144 typedef struct __mq *__vki_mqd_t;
145
146 /* MI */
147 typedef vki_uint32_t __vki_blksize_t;
148 typedef vki_int64_t __vki_blkcnt_t;
149 typedef vki_int32_t __vki_clockid_t;
150 typedef vki_int32_t __vki_ct_rune_t;
151 typedef vki_uint32_t __vki_fflags_t;
152 typedef vki_uint64_t __vki_fsblkcnt_t;
153 typedef vki_uint64_t __vki_fsfilcnt_t;
154 typedef vki_uint32_t __vki_gid_t;
155 typedef vki_int64_t __vki_id_t;
156 typedef vki_uint64_t __vki_ino_t;
157 typedef vki_int32_t __vki_lwpid_t;
158 typedef vki_uint16_t __vki_mode_t;
159 typedef vki_uint16_t __vki_nlink_t;
160 typedef vki_int64_t __vki_off_t;
161 typedef vki_int32_t __vki_pid_t;
162 typedef vki_int64_t __vki_rlim_t;
163 typedef vki_uint8_t __vki_sa_family_t;
164 typedef vki_uint32_t __vki_socklen_t;
165 typedef vki_uint32_t __vki_uid_t;
166 typedef vki_int32_t __vki_useconds_t;
167 typedef __vki_ct_rune_t __vki_rune_t;
168 typedef __vki_ct_rune_t __vki_wchar_t;
169 typedef __vki_ct_rune_t __vki_wint_t;
170 typedef vki_uint32_t __vki_dev_t;
171 typedef vki_uint32_t __vki_fixpt_t;
172
173
174 //----------------------------------------------------------------------
175 // sys/types.h
176 //----------------------------------------------------------------------
177
178 typedef vki_uint8_t vki_u_int8_t;
179 typedef vki_uint16_t vki_u_int16_t;
180 typedef vki_uint32_t vki_u_int32_t;
181 typedef vki_uint64_t vki_u_int64_t;
182
183 typedef vki_uint64_t vki_u_quad_t;
184 typedef vki_int64_t vki_quad_t;
185 typedef __vki_caddr_t vki_caddr_t;
186 typedef __const __vki_caddr_t vki_c_caddr_t;
187 typedef __volatile __vki_caddr_t vki_v_caddr_t;
188
189 typedef __vki_blksize_t vki_blksize_t;
190 typedef __vki_blkcnt_t vki_blkcnt_t;
191 typedef __vki_clock_t vki_clock_t;
192 typedef __vki_clockid_t vki_clockid_t;
193 typedef __vki_dev_t vki_dev_t;
194 typedef __vki_fflags_t vki_fflags_t;
195 typedef __vki_fixpt_t vki_fixpt_t;
196 typedef __vki_fsblkcnt_t vki_fsblkcnt_t;
197 typedef __vki_fsfilcnt_t vki_fsfilcnt_t;
198 typedef __vki_gid_t vki_gid_t;
199 typedef vki_uint32_t vki_in_addr_t;
200 typedef vki_uint16_t vki_in_port_t;
201 typedef __vki_id_t vki_id_t;
202 typedef __vki_ino_t vki_ino_t;
203 typedef __vki_key_t vki_key_t;
204 typedef __vki_lwpid_t vki_lwpid_t;
205 typedef __vki_mode_t vki_mode_t;
206 typedef __vki_nlink_t vki_nlink_t;
207 typedef __vki_off_t vki_off_t;
208 typedef __vki_pid_t vki_pid_t;
209 typedef __vki_register_t vki_register_t;
210 typedef __vki_rlim_t vki_rlim_t;
211 typedef __vki_segsz_t vki_segsz_t;
212 typedef __vki_size_t vki_size_t;
213 typedef __vki_ssize_t vki_ssize_t;
214 typedef __vki_suseconds_t vki_suseconds_t;
215 typedef __vki_time_t vki_time_t;
216 typedef __vki_timer_t vki_timer_t;
217 typedef __vki_mqd_t vki_mqd_t;
218 typedef __vki_u_register_t vki_u_register_t;
219 typedef __vki_uid_t vki_uid_t;
220 typedef __vki_useconds_t vki_useconds_t;
221
222 typedef __vki_vm_offset_t vki_vm_offset_t;
223 typedef __vki_vm_ooffset_t vki_vm_ooffset_t;
224 typedef __vki_vm_paddr_t vki_vm_paddr_t;
225 typedef __vki_vm_pindex_t vki_vm_pindex_t;
226 typedef __vki_vm_size_t vki_vm_size_t;
227
228 //----------------------------------------------------------------------
229 // sys/select.h
230 //----------------------------------------------------------------------
231
232 typedef __vki_fd_set vki_fd_set;
233
234 //----------------------------------------------------------------------
235 // sys/aio.h
236 //----------------------------------------------------------------------
237
238 #include <sys/aio.h>
239
240 #define vki_aiocb aiocb
241
242 //----------------------------------------------------------------------
243 // sys/linker.h
244 //----------------------------------------------------------------------
245
246 struct vki_kld_file_stat {
247 int version; /* set to sizeof(linker_file_stat) */
248 char name[MAXPATHLEN];
249 int refs;
250 int id;
251 vki_caddr_t address; /* load address */
252 size_t size; /* size in bytes */
253 };
254
255 //----------------------------------------------------------------------
256 // Now the rest of the arch-specific stuff
257 //----------------------------------------------------------------------
258
259 #if defined(VGA_x86)
260 # include "vki-x86-dragonfly.h"
261 #elif defined(VGA_amd64)
262 # include "vki-amd64-dragonfly.h"
263 #elif defined(VGA_ppc32)
264 # include "vki-ppc32-dragonfly.h"
265 #elif defined(VGA_ppc64)
266 # include "vki-ppc64-dragonfly.h"
267 #else
268 # error Unknown platform
269 #endif
270
271 //----------------------------------------------------------------------
272 // linux and dragonfly version hacks
273 //----------------------------------------------------------------------
274 #ifndef ELFMAG
275 #define ELFMAG "\177ELF" /* magic string */
276 #endif
277 #ifndef SELFMAG
278 #define SELFMAG 4 /* magic string size */
279 #endif
280
281 //----------------------------------------------------------------------
282 // From sys/syslimits.h
283 //----------------------------------------------------------------------
284
285 #define VKI_PATH_MAX 1024
286
287
288 //----------------------------------------------------------------------
289 // From sys/timespec.h
290 //----------------------------------------------------------------------
291
292 struct vki_timespec {
293 vki_time_t tv_sec; /* seconds */
294 long tv_nsec; /* nanoseconds */
295 };
296
297 struct vki_itimerspec {
298 struct vki_timespec it_interval; /* timer period */
299 struct vki_timespec it_value; /* timer expiration */
300 };
301
302 //----------------------------------------------------------------------
303 // From sys/_time.h
304 //----------------------------------------------------------------------
305
306 struct vki_timeval {
307 vki_time_t tv_sec; /* seconds */
308 vki_suseconds_t tv_usec; /* microseconds */
309 };
310
311 //----------------------------------------------------------------------
312 // From sys/time.h
313 //----------------------------------------------------------------------
314
315 #define VKI_CLOCK_REALTIME 0
316 #define VKI_CLOCK_MONOTONIC 1
317 #define VKI_CLOCK_PROCESS_CPUTIME_ID 2
318 #define VKI_CLOCK_THREAD_CPUTIME_ID 3
319
320 struct vki_timezone {
321 int tz_minuteswest; /* minutes west of Greenwich */
322 int tz_dsttime; /* type of dst correction */
323 };
324
325 struct vki_itimerval {
326 struct vki_timeval it_interval; /* timer interval */
327 struct vki_timeval it_value; /* current value */
328 };
329
330 //----------------------------------------------------------------------
331 // From sys/timex.h
332 //----------------------------------------------------------------------
333
334 struct vki_ntptimeval {
335 struct vki_timespec time;
336 long maxerror;
337 long esterror;
338 long tai;
339 int time_state;
340 };
341
342 struct vki_timex {
343 unsigned int modes; /* mode selector */
344 long offset; /* time offset (usec) */
345 long freq; /* frequency offset (scaled ppm) */
346 long maxerror; /* maximum error (usec) */
347 long esterror; /* estimated error (usec) */
348 int status; /* clock command/status */
349 long constant; /* pll time constant */
350 long precision; /* clock precision (usec) (read only) */
351 long tolerance; /* clock frequency tolerance (ppm)
352 * (read only)
353 */
354 long ppsfreq; /* pps frequency (scaled ppm) (ro) */
355 long jitter; /* pps jitter (us) (ro) */
356 int shift; /* interval duration (s) (shift) (ro) */
357 long stabil; /* pps stability (scaled ppm) (ro) */
358 long jitcnt; /* jitter limit exceeded (ro) */
359 long calcnt; /* calibration intervals (ro) */
360 long errcnt; /* calibration errors (ro) */
361 long stbcnt; /* stability limit exceeded (ro) */
362 };
363
364 #define MOD_OFFSET 0x0001 /* time offset */
365 #define MOD_FREQUENCY 0x0002 /* frequency offset */
366 #define MOD_MAXERROR 0x0004 /* maximum time error */
367 #define MOD_ESTERROR 0x0008 /* estimated time error */
368 #define MOD_STATUS 0x0010 /* clock status */
369 #define MOD_TIMECONST 0x0020 /* pll time constant */
370 #define MOD_PPSMAX 0x0040
371 #define MOD_TAI 0x0080
372 #define MOD_MICRO 0x1000
373 #define MOD_NANO 0x2000
374 #define MOD_CLKB 0x4000
375 #define MOD_CLKA 0x8000
376
377 //----------------------------------------------------------------------
378 // From sys/times.h
379 //----------------------------------------------------------------------
380
381 struct vki_tms {
382 vki_clock_t tms_utime;
383 vki_clock_t tms_stime;
384 vki_clock_t tms_cutime;
385 vki_clock_t tms_cstime;
386 };
387
388 //----------------------------------------------------------------------
389 // From sys/stat.h
390 //----------------------------------------------------------------------
391
392 struct vki_stat {
393 vki_ino_t st_ino;
394 vki_nlink_t st_nlink;
395 vki_dev_t st_dev;
396 vki_mode_t st_mode;
397 vki_uint16_t st_padding1;
398 vki_uid_t st_uid;
399 vki_gid_t st_gid;
400 vki_dev_t st_rdev;
401 #if 0
402 struct vki_timespec st_atimespec;
403 struct vki_timespec st_mtimespec;
404 struct vki_timespec st_ctimespec;
405 #else
406 vki_time_t st_atime;
407 long st_atime_nsec;
408 vki_time_t st_mtime;
409 long st_mtime_nsec;
410 vki_time_t st_ctime;
411 long st_ctime_nsec;
412 #endif
413 vki_off_t st_size;
414 vki_blkcnt_t st_blocks;
415 vki_uint32_t __old_st_blksize;
416 vki_uint32_t st_flags;
417 vki_uint32_t st_gen;
418 vki_int32_t st_lspare;
419 vki_blksize_t st_blksize;
420 vki_int64_t st_qspare2;
421 };
422
423 //----------------------------------------------------------------------
424 // From sys/uuid.h
425 //----------------------------------------------------------------------
426
427 struct vki_uuid {
428 vki_uint32_t time_low;
429 vki_uint16_t time_mid;
430 vki_uint16_t time_hi_and_version;
431 vki_uint8_t clock_seq_hi_and_reserved;
432 vki_uint8_t clock_seq_low;
433 vki_uint8_t node[6];
434 };
435
436 #define vki_uuid_t struct vki_uuid
437
438 //----------------------------------------------------------------------
439 // From sys/statvfs.h
440 //----------------------------------------------------------------------
441
442 struct vki_statvfs {
443 unsigned long f_bsize; /* file system block size */
444 unsigned long f_frsize; /* fundamental file system block size */
445 vki_fsblkcnt_t f_blocks; /* total number of blocks on fs */
446 vki_fsblkcnt_t f_bfree; /* total number of free blocks */
447 vki_fsblkcnt_t f_bavail; /* total number of available blocks */
448 vki_fsfilcnt_t f_files; /* total number of file serial num */
449 vki_fsfilcnt_t f_ffree; /* total number of free file ser num */
450 vki_fsfilcnt_t f_favail; /* total number of avail file ser num */
451 unsigned long f_fsid; /* file system ID */
452 unsigned long f_flag; /* bit mask of f_flag values */
453 unsigned long f_namemax; /* maximum filename length */
454 vki_uid_t f_owner; /* user that mounted the filesystem */
455 unsigned int f_type; /* filesystem type */
456
457 __uint64_t f_syncreads; /* count of sync reads since mount */
458 __uint64_t f_syncwrites; /* count of sync writes since mount */
459
460 __uint64_t f_asyncreads; /* count of async reads since mount */
461 __uint64_t f_asyncwrites; /* count of async writes since mount */
462
463 vki_uuid_t f_fsid_uuid;
464 vki_uuid_t f_uid_uuid;
465 };
466
467 //----------------------------------------------------------------------
468 // From linux-2.6.8.1/include/linux/sched.h
469 //----------------------------------------------------------------------
470
471 struct vki_sched_param {
472 int sched_priority;
473 };
474
475 //----------------------------------------------------------------------
476 // From sys/signal.h
477 //----------------------------------------------------------------------
478
479 #define VKI_SIG_BLOCK 1 /* block specified signal set */
480 #define VKI_SIG_UNBLOCK 2 /* unblock specified signal set */
481 #define VKI_SIG_SETMASK 3 /* set specified signal set */
482
483 #define VKI_SIG_DFL ((__vki_sighandler_t)0)
484 #define VKI_SIG_IGN ((__vki_sighandler_t)1)
485 #define VKI_SIG_ERR ((__vki_sighandler_t)-1)
486
487 typedef void __vki_signalfn_t(int);
488 typedef __vki_signalfn_t *__vki_sighandler_t;
489
490 #define VKI_SIGHUP 1
491 #define VKI_SIGINT 2
492 #define VKI_SIGQUIT 3
493 #define VKI_SIGILL 4
494 #define VKI_SIGTRAP 5
495 #define VKI_SIGABRT 6
496 #define VKI_SIGEMT 7
497 #define VKI_SIGFPE 8
498 #define VKI_SIGKILL 9
499 #define VKI_SIGBUS 10
500 #define VKI_SIGSEGV 11
501 #define VKI_SIGSYS 12
502 #define VKI_SIGPIPE 13
503 #define VKI_SIGALRM 14
504 #define VKI_SIGTERM 15
505 #define VKI_SIGURG 16
506 #define VKI_SIGSTOP 17
507 #define VKI_SIGTSTP 18
508 #define VKI_SIGCONT 19
509 #define VKI_SIGCHLD 20
510 #define VKI_SIGTTIN 21
511 #define VKI_SIGTTOU 22
512 #define VKI_SIGIO 23
513 #define VKI_SIGXCPU 24
514 #define VKI_SIGXFSZ 25
515 #define VKI_SIGVTALRM 26
516 #define VKI_SIGPROF 27
517 #define VKI_SIGWINCH 28
518 #define VKI_SIGINFO 29
519 #define VKI_SIGUSR1 30
520 #define VKI_SIGUSR2 31
521 #define VKI_SIGTHR 32
522
523 #define VKI_SIGRTMIN 65
524 #define VKI_SIGRTMAX 126
525
526 #define VKI_SA_ONSTACK 0x0001
527 #define VKI_SA_RESTART 0x0002
528 #define VKI_SA_RESETHAND 0x0004
529 #define VKI_SA_NOCLDSTOP 0x0008
530 #define VKI_SA_NODEFER 0x0010
531 #define VKI_SA_NOCLDWAIT 0x0020
532 #define VKI_SA_SIGINFO 0x0040
533
534 #define VKI_SS_ONSTACK 0x0001
535 #define VKI_SS_DISABLE 0x0004
536
537 #define VKI_SA_ONESHOT VKI_SA_RESETHAND
538 #define VKI_SA_NOMASK VKI_SA_NODEFER
539
540 struct vki_sigaction {
541 __vki_sighandler_t ksa_handler;
542 int sa_flags;
543 vki_sigset_t sa_mask;
544 };
545
546 typedef struct vki_sigaltstack {
547 void *ss_sp;
548 vki_size_t ss_size;
549 int ss_flags;
550 } vki_stack_t;
551
552 typedef union vki_sigval {
553 int sival_int;
554 void *sival_ptr;
555 } vki_sigval_t;
556
557 #if 0 /* dragonfly6 */
558 typedef struct vki_siginfo {
559 int si_signo;
560 int si_errno;
561 int si_code;
562 vki_pid_t si_pid;
563 vki_uid_t si_uid;
564 int si_status;
565 void *si_addr;
566 vki_sigval_t si_value;
567
568 union {
569
570 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
571 struct {
572 int _trapno; /* TRAP # which caused the signal */
573 } _sigfault;
574
575 /* POSIX.1b timers */
576 struct {
577 int _timerid; /* timer id */
578 int _overrun; /* overrun count */
579 } _timer;
580
581 struct {
582 int _mqd;
583 } _mesgq;
584
585 /* SIGPOLL */
586 struct {
587 long _band; /* POLL_IN, POLL_OUT, POLL_MSG */
588 } _sigpoll;
589
590 struct {
591 long __spare1__;
592 int __spare2[7];
593 } __spare__;
594 } _sifields;
595 } vki_siginfo_t;
596 #endif
597 typedef struct vki_siginfo {
598 int si_signo;
599 int si_errno;
600 int si_code;
601 vki_pid_t si_pid;
602 vki_uid_t si_uid;
603 int si_status;
604 void *si_addr;
605 vki_sigval_t si_value;
606 // 666: not valid. switch to above def
607 #ifdef si_band
608 #undef si_band
609 #endif
610 long si_band;
611 int __spare__[7];
612 } vki_siginfo_t;
613
614 /*
615 * si_code values
616 */
617 #define VKI_SI_USER 0x10001 /* sent by kill, sigsend, raise */
618 #define VKI_SI_QUEUE 0x10002
619 #define VKI_SI_TIMER 0x10003
620 #define VKI_SI_ASYNCIO 0x10004
621 #define VKI_SI_MESGQ 0x10005
622
623 /*
624 * SIGILL si_codes
625 */
626 #define VKI_ILL_ILLOPC 1 /* illegal opcode */
627 #define VKI_ILL_ILLOPN 2 /* illegal operand */
628 #define VKI_ILL_ILLADR 3 /* illegal addressing mode */
629 #define VKI_ILL_ILLTRP 4 /* illegal trap */
630 #define VKI_ILL_PRVOPC 5 /* privileged opcode */
631 #define VKI_ILL_PRVREG 6 /* privileged register */
632 #define VKI_ILL_COPROC 7 /* coprocessor error */
633 #define VKI_ILL_BADSTK 8 /* internal stack error */
634
635 /*
636 * SIGFPE si_codes
637 */
638 #define VKI_FPE_INTOVF 1 /* integer overflow */
639 #define VKI_FPE_INTDIV 2 /* integer divide by zero */
640 #define VKI_FPE_FLTDIV 3 /* floating point divide by zero */
641 #define VKI_FPE_FLTOVF 4 /* floating point overflow */
642 #define VKI_FPE_FLTUND 5 /* floating point underflow */
643 #define VKI_FPE_FLTRES 6 /* floating point inexact result */
644 #define VKI_FPE_FLTINV 7 /* floating point invalid operation */
645 #define VKI_FPE_FLTSUB 8 /* subscript out of range */
646
647 /*
648 * SIGSEGV si_codes
649 */
650 #define VKI_SEGV_MAPERR 1 /* address not mapped to object */
651 #define VKI_SEGV_ACCERR 2 /* invalid permissions for mapped object */
652 /* XXX i386 and amd64 specific */
653 #define VKI_SEGV_PAGE_FAULT 12
654
655 /*
656 * SIGBUS si_codes
657 */
658 #define VKI_BUS_ADRALN 1 /* invalid address alignment */
659 #define VKI_BUS_ADRERR 2 /* non-existant physical address */
660 #define VKI_BUS_OBJERR 3 /* object specific hardware error */
661
662 /*
663 * SIGTRAP si_codes
664 */
665 #define VKI_TRAP_BRKPT 1 /* process breakpoint */
666 #define VKI_TRAP_TRACE 2 /* process trace trap */
667
668
669 #if 0 /* dragonfly-6 */
670 typedef struct vki_sigevent {
671 int sigev_notify;
672 int sigev_signo;
673 vki_sigval_t sigev_value;
674 union {
675 int _threadid;
676
677 struct {
678 void (*_function)(vki_sigval_t);
679 void *_attribute; /* really pthread_attr_t */
680 } _sigev_thread;
681 long __spare__[8];
682 } _sigev_un;
683 } vki_sigevent_t;
684 #endif
685
686 struct vki_sigevent {
687 int sigev_notify; /* Notification type */
688 union {
689 int __sigev_signo; /* Signal number */
690 int __sigev_notify_kqueue;
691 } __sigev_u;
692 vki_sigval_t sigev_value; /* Signal value */
693 };
694 #if 0
695 #define sigev_signo __sigev_u.__sigev_signo
696 #define sigev_notify_kqueue __sigev_u.__sigev_notify_kqueue
697 #endif
698
699 //----------------------------------------------------------------------
700 // From sys/_iovec.h
701 //----------------------------------------------------------------------
702
703 struct vki_iovec
704 {
705 void *iov_base;
706 __vki_size_t iov_len;
707 };
708
709 //----------------------------------------------------------------------
710 // From sys/socket.h
711 //----------------------------------------------------------------------
712
713 typedef __vki_sa_family_t vki_sa_family_t;
714 typedef __vki_socklen_t vki_socklen_t;
715
716 struct vki_sockaddr {
717 vki_uint8_t sa_len;
718 vki_sa_family_t sa_family; /* address family, AF_xxx */
719 char sa_data[14]; /* 14 bytes of protocol address */
720 };
721
722 struct vki_msghdr {
723 void * msg_name; /* Socket name */
724 vki_socklen_t msg_namelen; /* Length of name */
725 struct vki_iovec * msg_iov; /* Data blocks */
726 int msg_iovlen; /* Number of blocks */
727 void * msg_control; /* Per protocol magic (eg BSD file descriptor passing) */
728 vki_socklen_t msg_controllen; /* Length of cmsg list */
729 int msg_flags;
730 };
731
732 struct vki_cmsghdr {
733 vki_socklen_t cmsg_len; /* data byte count, including hdr */
734 int cmsg_level; /* originating protocol */
735 int cmsg_type; /* protocol-specific type */
736 };
737
738 #define __VKI_CMSG_NXTHDR(ctl, len, cmsg) __vki_cmsg_nxthdr((ctl),(len),(cmsg))
739 #define VKI_CMSG_NXTHDR(mhdr, cmsg) vki_cmsg_nxthdr((mhdr), (cmsg))
740
741 #define VKI_CMSG_ALIGN(len) ( ((len)+sizeof(long)-1) & ~(sizeof(long)-1) )
742
743 #define VKI_CMSG_DATA(cmsg) ((void *)((char *)(cmsg) + VKI_CMSG_ALIGN(sizeof(struct vki_cmsghdr))))
744
745 #define __VKI_CMSG_FIRSTHDR(ctl,len) ((len) >= sizeof(struct vki_cmsghdr) ? \
746 (struct vki_cmsghdr *)(ctl) : \
747 (struct vki_cmsghdr *)NULL)
748 #define VKI_CMSG_FIRSTHDR(msg) __VKI_CMSG_FIRSTHDR((msg)->msg_control, (msg)->msg_controllen)
749
750 // [[Urgh, this is revolting...]
751 // QQQ check
__vki_cmsg_nxthdr(void * __ctl,vki_socklen_t __size,struct vki_cmsghdr * __cmsg)752 static __inline struct vki_cmsghdr * __vki_cmsg_nxthdr(void *__ctl, vki_socklen_t __size,
753 struct vki_cmsghdr *__cmsg)
754 {
755 struct vki_cmsghdr * __ptr;
756
757 __ptr = (struct vki_cmsghdr*)(((unsigned char *) __cmsg) + VKI_CMSG_ALIGN(__cmsg->cmsg_len));
758 if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
759 return (struct vki_cmsghdr *)0;
760
761 return __ptr;
762 }
763
vki_cmsg_nxthdr(struct vki_msghdr * __msg,struct vki_cmsghdr * __cmsg)764 static __inline struct vki_cmsghdr * vki_cmsg_nxthdr (struct vki_msghdr *__msg, struct vki_cmsghdr *__cmsg)
765 {
766 return __vki_cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
767 }
768
769 #define VKI_SCM_RIGHTS 0x01 /* rw: access rights (array of int) */
770
771 #define VKI_AF_UNIX 1 /* Unix domain sockets */
772 #define VKI_AF_INET 2 /* Internet IP Protocol */
773 #define VKI_AF_INET6 28 /* IP version 6 */
774
775 #define VKI_MSG_NOSIGNAL 0x20000 /* Do not generate SIGPIPE */
776
777 #define VKI_SOL_SOCKET 0xffff
778
779 #define VKI_SO_TYPE 0x1008
780
781 #define VKI_SOCK_STREAM 1
782
783 #include <netinet/tcp.h>
784
785 #define VKI_TCP_NODELAY TCP_NODELAY
786
787 #include <netinet/in.h>
788
789 #define VKI_IPPROTO_TCP IPPROTO_TCP
790
791 //----------------------------------------------------------------------
792 // From netinet/in.h
793 //----------------------------------------------------------------------
794
795 struct vki_in_addr {
796 vki_in_addr_t s_addr;
797 };
798
799 /* Structure describing an Internet (IP) socket address. */
800 #define __VKI_SOCK_SIZE__ 16 /* sizeof(struct sockaddr) */
801 struct vki_sockaddr_in {
802 vki_uint8_t sin_len;
803 vki_sa_family_t sin_family; /* Address family */
804 vki_in_port_t sin_port; /* Port number */
805 struct vki_in_addr sin_addr; /* Internet address */
806 char sin_zero[8];
807 };
808
809 //----------------------------------------------------------------------
810 // From netinet6/in6.h
811 //----------------------------------------------------------------------
812
813 struct vki_in6_addr
814 {
815 union
816 {
817 vki_uint8_t u6_addr8[16];
818 vki_uint16_t u6_addr16[8];
819 vki_uint32_t u6_addr32[4];
820 } vki_in6_u;
821 #define vki_s6_addr vki_in6_u.u6_addr8
822 #define vki_s6_addr16 vki_in6_u.u6_addr16
823 #define vki_s6_addr32 vki_in6_u.u6_addr32
824 };
825
826 struct vki_sockaddr_in6 {
827 vki_uint8_t sin6_len;
828 vki_sa_family_t sin6_family; /* AF_INET6 */
829 vki_uint16_t sin6_port; /* Transport layer port # */
830 vki_uint32_t sin6_flowinfo; /* IPv6 flow information */
831 struct vki_in6_addr sin6_addr; /* IPv6 address */
832 vki_uint32_t sin6_scope_id; /* scope id (new in RFC2553) */
833 };
834
835 //----------------------------------------------------------------------
836 // From sys/un.h
837 //----------------------------------------------------------------------
838
839 #define VKI_UNIX_PATH_MAX 104 /* QQQ overridden by sun_len */
840
841 struct vki_sockaddr_un {
842 unsigned char sun_len;
843 vki_sa_family_t sun_family; /* AF_UNIX */
844 char sun_path[VKI_UNIX_PATH_MAX]; /* pathname */
845 };
846
847 #if 0
848 //----------------------------------------------------------------------
849 // From linux-2.6.8.1/include/linux/if.h
850 //----------------------------------------------------------------------
851
852 #define VKI_IFNAMSIZ 16
853
854 struct vki_ifmap
855 {
856 unsigned long mem_start;
857 unsigned long mem_end;
858 unsigned short base_addr;
859 unsigned char irq;
860 unsigned char dma;
861 unsigned char port;
862 /* 3 bytes spare */
863 };
864
865 struct vki_if_settings
866 {
867 unsigned int type; /* Type of physical device or protocol */
868 unsigned int size; /* Size of the data allocated by the caller */
869 union {
870 // [[Nb: converted these all to void* to avoid pulling in
871 // unnecessary headers]]]
872 /* {atm/eth/dsl}_settings anyone ? */
873 void /*raw_hdlc_proto */__user *raw_hdlc;
874 void /*cisco_proto */__user *cisco;
875 void /*fr_proto */__user *fr;
876 void /*fr_proto_pvc */__user *fr_pvc;
877 void /*fr_proto_pvc_info */__user *fr_pvc_info;
878
879 /* interface settings */
880 void /*sync_serial_settings */__user *sync;
881 void /*te1_settings */__user *te1;
882 } ifs_ifsu;
883 };
884
885 struct vki_ifreq
886 {
887 #define VKI_IFHWADDRLEN 6
888 union
889 {
890 char ifrn_name[VKI_IFNAMSIZ]; /* if name, e.g. "en0" */
891 } ifr_ifrn;
892
893 union {
894 struct vki_sockaddr ifru_addr;
895 struct vki_sockaddr ifru_dstaddr;
896 struct vki_sockaddr ifru_broadaddr;
897 struct vki_sockaddr ifru_netmask;
898 struct vki_sockaddr ifru_hwaddr;
899 short ifru_flags;
900 int ifru_ivalue;
901 int ifru_mtu;
902 struct vki_ifmap ifru_map;
903 char ifru_slave[VKI_IFNAMSIZ]; /* Just fits the size */
904 char ifru_newname[VKI_IFNAMSIZ];
905 void __user * ifru_data;
906 struct vki_if_settings ifru_settings;
907 } ifr_ifru;
908 };
909
910 #define vki_ifr_name ifr_ifrn.ifrn_name /* interface name */
911 #define ifr_hwaddr ifr_ifru.ifru_hwaddr /* MAC address */
912 #define ifr_addr ifr_ifru.ifru_addr /* address */
913 #define ifr_dstaddr ifr_ifru.ifru_dstaddr /* other end of p-p lnk */
914 #define ifr_broadaddr ifr_ifru.ifru_broadaddr /* broadcast address */
915 #define ifr_netmask ifr_ifru.ifru_netmask /* interface net mask */
916 #define vki_ifr_flags ifr_ifru.ifru_flags /* flags */
917 #define vki_ifr_metric ifr_ifru.ifru_ivalue /* metric */
918 #define vki_ifr_mtu ifr_ifru.ifru_mtu /* mtu */
919 #define ifr_map ifr_ifru.ifru_map /* device map */
920 #define ifr_slave ifr_ifru.ifru_slave /* slave device */
921 #define vki_ifr_data ifr_ifru.ifru_data /* for use by interface */
922 #define vki_ifr_ifindex ifr_ifru.ifru_ivalue /* interface index */
923 #define ifr_bandwidth ifr_ifru.ifru_ivalue /* link bandwidth */
924 #define ifr_qlen ifr_ifru.ifru_ivalue /* Queue length */
925 #define ifr_newname ifr_ifru.ifru_newname /* New name */
926 #define ifr_settings ifr_ifru.ifru_settings /* Device/proto settings*/
927
928 struct vki_ifconf
929 {
930 int ifc_len; /* size of buffer */
931 union
932 {
933 char __user *ifcu_buf;
934 struct vki_ifreq __user *ifcu_req;
935 } ifc_ifcu;
936 };
937 #define vki_ifc_buf ifc_ifcu.ifcu_buf /* buffer address */
938
939 //----------------------------------------------------------------------
940 // From linux-2.6.8.1/include/linux/if_arp.h
941 //----------------------------------------------------------------------
942
943 struct vki_arpreq {
944 struct vki_sockaddr arp_pa; /* protocol address */
945 struct vki_sockaddr arp_ha; /* hardware address */
946 int arp_flags; /* flags */
947 struct vki_sockaddr arp_netmask; /* netmask (only for proxy arps) */
948 char arp_dev[16];
949 };
950
951 //----------------------------------------------------------------------
952 // From linux-2.6.8.1/include/linux/route.h
953 //----------------------------------------------------------------------
954
955 struct vki_rtentry
956 {
957 unsigned long rt_pad1;
958 struct vki_sockaddr rt_dst; /* target address */
959 struct vki_sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */
960 struct vki_sockaddr rt_genmask; /* target network mask (IP) */
961 unsigned short rt_flags;
962 short rt_pad2;
963 unsigned long rt_pad3;
964 void *rt_pad4;
965 short rt_metric; /* +1 for binary compatibility! */
966 char __user *rt_dev; /* forcing the device at add */
967 unsigned long rt_mtu; /* per route MTU/Window */
968 // [[Not important for Valgrind]]
969 //#ifndef __KERNEL__
970 //#define rt_mss rt_mtu /* Compatibility :-( */
971 //#endif
972 unsigned long rt_window; /* Window clamping */
973 unsigned short rt_irtt; /* Initial RTT */
974 };
975 #endif
976
977 // QQQ sort
978
979 //----------------------------------------------------------------------
980 // From sys/mount.h
981 //----------------------------------------------------------------------
982
983 typedef struct vki_fsid { vki_int32_t val[2]; } vki_fsid_t;
984 #define VKI_OMFSNAMELEN 16
985 #define VKI_OMNAMELEN (88 - 2 * sizeof(long))
986 #define VKI_MFSNAMELEN 16
987 #define VKI_MNAMELEN 88
988
989 struct vki_statfs4 {
990 long f_spare2;
991 long f_bsize;
992 long f_iosize;
993 long f_blocks;
994 long f_bfree;
995 long f_bavail;
996 long f_files;
997 long f_ffree;
998 vki_fsid_t f_fsid;
999 vki_uid_t f_owner;
1000 vki_int32_t f_type;
1001 vki_int32_t f_flags;
1002 long f_syncwrites;
1003 long f_asyncwrites;
1004 char f_fstypename[VKI_OMFSNAMELEN];
1005 char f_mntonname[VKI_OMNAMELEN];
1006 long f_syncreads;
1007 long f_asyncreads;
1008 vki_int16_t f_spares1;
1009 char f_mntfromnname[VKI_OMNAMELEN];
1010 vki_int16_t f_spares2;
1011 long f_spare[2];
1012 };
1013
1014 struct vki_statfs {
1015 vki_uint32_t f_version;
1016 vki_uint32_t f_type;
1017 vki_uint64_t f_flags;
1018 vki_uint64_t f_bsize;
1019 vki_uint64_t f_iosize;
1020 vki_uint64_t f_blocks;
1021 vki_uint64_t f_bfree;
1022 vki_int64_t f_bavail;
1023 vki_uint64_t f_files;
1024 vki_int64_t f_ffree;
1025 vki_uint64_t f_syncwrites;
1026 vki_uint64_t f_asyncwrites;
1027 vki_uint64_t f_syncreads;
1028 vki_uint64_t f_asyncreads;
1029 vki_uint64_t f_spare[10];
1030 vki_uint32_t f_namemax;
1031 vki_uid_t f_owner;
1032 vki_fsid_t f_fsid;
1033 char f_charspare[80];
1034 char f_fstypename[VKI_MFSNAMELEN];
1035 char f_mntfromnname[VKI_MNAMELEN];
1036 char f_mntonname[VKI_MNAMELEN];
1037 };
1038
1039 #define MAXFIDSZ 16
1040
1041 struct vki_fid {
1042 vki_uint16_t fid_len;
1043 vki_uint16_t fid_reserved;
1044 char fid_data[MAXFIDSZ];
1045 };
1046
1047 struct vki_fhandle {
1048 vki_fsid_t fh_fsid;
1049 struct vki_fid fh_fid;
1050 };
1051
1052 #define VKI_MNAMELEN6 88
1053 struct vki_statfs6 {
1054 vki_uint32_t f_version;
1055 vki_uint32_t f_type;
1056 vki_uint64_t f_flags;
1057 vki_uint64_t f_bsize;
1058 vki_uint64_t f_iosize;
1059 vki_uint64_t f_blocks;
1060 vki_uint64_t f_bfree;
1061 vki_int64_t f_bavail;
1062 vki_uint64_t f_files;
1063 vki_int64_t f_ffree;
1064 vki_int64_t f_syncwrites;
1065 vki_int64_t f_asyncwrites;
1066 vki_int64_t f_syncreads;
1067 vki_int64_t f_asyncreads;
1068 vki_uint64_t f_spare[10];
1069 vki_uint32_t f_namemax;
1070 vki_uid_t f_owner;
1071 vki_fsid_t f_fsid;
1072 char f_charspare[80];
1073 char f_fstypename[VKI_MFSNAMELEN];
1074 char f_mntfromnname[VKI_MNAMELEN6];
1075 char f_mntonname[VKI_MNAMELEN6];
1076 };
1077
1078 //----------------------------------------------------------------------
1079 // From sys/ttycom.h
1080 //----------------------------------------------------------------------
1081
1082 struct vki_winsize {
1083 unsigned short ws_row;
1084 unsigned short ws_col;
1085 unsigned short ws_xpixel;
1086 unsigned short ws_ypixel;
1087 };
1088
1089
1090 //----------------------------------------------------------------------
1091 // From sys/termios.h
1092 //----------------------------------------------------------------------
1093
1094 typedef unsigned int vki_tcflag_t;
1095 typedef unsigned char vki_cc_t;
1096 typedef unsigned int vki_speed_t;
1097
1098 #define VKI_NCCS 20
1099 struct vki_termios {
1100 vki_tcflag_t c_iflag; /* input mode flags */
1101 vki_tcflag_t c_oflag; /* output mode flags */
1102 vki_tcflag_t c_cflag; /* control mode flags */
1103 vki_tcflag_t c_lflag; /* local mode flags */
1104 vki_cc_t c_cc[VKI_NCCS]; /* control characters */
1105 vki_speed_t c_ispeed;
1106 vki_speed_t c_ospeed;
1107 };
1108
1109 //----------------------------------------------------------------------
1110 // From sys/ioccom.h
1111 //----------------------------------------------------------------------
1112
1113 /* QQQ keep linux's naming, but use our layout */
1114
1115 /*
1116 * We actually have a 16 bit "base" ioctl, which may or may not be decoded
1117 * into number/group
1118 */
1119 #define _VKI_IOC_BASEBITS 16
1120 #define _VKI_IOC_NRBITS 8 /* "num" on dragonfly */
1121 #define _VKI_IOC_TYPEBITS 8 /* "group" on dragonfly */
1122
1123 #define _VKI_IOC_SIZEBITS 13
1124 #define _VKI_IOC_DIRBITS 3
1125
1126 #define _VKI_IOC_BASEMASK ((1ul << _VKI_IOC_BASEBITS)-1)
1127 #define _VKI_IOC_NRMASK ((1ul << _VKI_IOC_NRBITS)-1)
1128 #define _VKI_IOC_TYPEMASK ((1ul << _VKI_IOC_TYPEBITS)-1)
1129 #define _VKI_IOC_SIZEMASK ((1ul << _VKI_IOC_SIZEBITS)-1)
1130 #define _VKI_IOC_DIRMASK ((1ul << _VKI_IOC_DIRBITS)-1)
1131
1132 #define _VKI_IOC_BASESHIFT 0
1133 #define _VKI_IOC_NRSHIFT 0
1134 #define _VKI_IOC_TYPESHIFT (_VKI_IOC_NRSHIFT+_VKI_IOC_NRBITS)
1135 #define _VKI_IOC_SIZESHIFT (_VKI_IOC_TYPESHIFT+_VKI_IOC_TYPEBITS)
1136 #define _VKI_IOC_DIRSHIFT (_VKI_IOC_SIZESHIFT+_VKI_IOC_SIZEBITS)
1137
1138 #define _VKI_IOC_NONE 1U /* "void" on dragonfly, as a specific mode */
1139 #define _VKI_IOC_READ 2U /* "out", copyout in reversed linux terminology */
1140 #define _VKI_IOC_WRITE 4U /* "in", copyin in reversed linux terminology */
1141 #define _VKI_IOC_RDWR 6U /* "inout", copyin and copyout */
1142
1143 #define _VKI_IOC(dir,type,nr,size) \
1144 (((dir) << _VKI_IOC_DIRSHIFT) | \
1145 ((type) << _VKI_IOC_TYPESHIFT) | \
1146 ((nr) << _VKI_IOC_NRSHIFT) | \
1147 ((size) << _VKI_IOC_SIZESHIFT))
1148
1149 /* provoke compile error for invalid uses of size argument */
1150 extern unsigned int __vki_invalid_size_argument_for_IOC;
1151 #define _VKI_IOC_TYPECHECK(t) \
1152 ((sizeof(t) == sizeof(t[1]) && \
1153 sizeof(t) < (1 << _VKI_IOC_SIZEBITS)) ? \
1154 sizeof(t) : __vki_invalid_size_argument_for_IOC)
1155
1156 /* used to create numbers */
1157 #define _VKI_IO(type,nr) _VKI_IOC(_VKI_IOC_NONE,(type),(nr),0)
1158 #define _VKI_IOR(type,nr,size) _VKI_IOC(_VKI_IOC_READ,(type),(nr),(_VKI_IOC_TYPECHECK(size)))
1159 #define _VKI_IOW(type,nr,size) _VKI_IOC(_VKI_IOC_WRITE,(type),(nr),(_VKI_IOC_TYPECHECK(size)))
1160 #define _VKI_IOWR(type,nr,size) _VKI_IOC(_VKI_IOC_READ|_VKI_IOC_WRITE,(type),(nr),(_VKI_IOC_TYPECHECK(size)))
1161
1162 /* used to decode ioctl numbers.. */
1163 #define _VKI_IOC_DIR(nr) (((nr) >> _VKI_IOC_DIRSHIFT) & _VKI_IOC_DIRMASK)
1164 #define _VKI_IOC_TYPE(nr) (((nr) >> _VKI_IOC_TYPESHIFT) & _VKI_IOC_TYPEMASK)
1165 #define _VKI_IOC_NR(nr) (((nr) >> _VKI_IOC_NRSHIFT) & _VKI_IOC_NRMASK)
1166 #define _VKI_IOC_SIZE(nr) (((nr) >> _VKI_IOC_SIZESHIFT) & _VKI_IOC_SIZEMASK)
1167 #define _VKI_IOC_BASE(nr) (((nr) >> _VKI_IOC_BASESHIFT) & _VKI_IOC_BASEMASK)
1168
1169
1170 //----------------------------------------------------------------------
1171 // From sys/termios.h
1172 //----------------------------------------------------------------------
1173
1174 #if 0
1175 #define VKI_TCGETS 0x5401
1176 #define VKI_TCSETS 0x5402 /* Clashes with SNDCTL_TMR_START sound ioctl */
1177 #define VKI_TCSETSW 0x5403
1178 #define VKI_TCSETSF 0x5404
1179 #define VKI_TCGETA 0x5405 y
1180 #define VKI_TCSETA 0x5406 y
1181 #define VKI_TCSETAW 0x5407 y
1182 #define VKI_TCSETAF 0x5408 y
1183 #define VKI_TCSBRK 0x5409
1184 #define VKI_TCXONC 0x540A
1185 #define VKI_TCFLSH 0x540B y
1186 #define VKI_TIOCSCTTY 0x540E
1187 #define VKI_TIOCGPGRP 0x540F y
1188 #define VKI_TIOCSPGRP 0x5410 y
1189 #define VKI_TIOCOUTQ 0x5411
1190 #define VKI_TIOCGWINSZ 0x5413 y
1191 #define VKI_TIOCSWINSZ 0x5414 y
1192 #define VKI_TIOCMGET 0x5415 y
1193 #define VKI_TIOCMBIS 0x5416 y
1194 #define VKI_TIOCMBIC 0x5417 y
1195 #define VKI_TIOCMSET 0x5418 y
1196 #define VKI_FIONREAD 0x541B
1197 #define VKI_TIOCLINUX 0x541C
1198 #define VKI_FIONBIO 0x5421
1199 #define VKI_TCSBRKP 0x5425 /* Needed for POSIX tcsendbreak() */
1200 #define VKI_TIOCGPTN _VKI_IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
1201 #define VKI_TIOCSPTLCK _VKI_IOW('T',0x31, int) /* Lock/unlock Pty */
1202
1203 #define VKI_FIOASYNC 0x5452
1204 #define VKI_TIOCSERGETLSR 0x5459 /* Get line status register */
1205
1206 #define VKI_TIOCGICOUNT 0x545D /* read serial port inline interrupt counts */
1207 #endif
1208
1209 #define VKI_TIOCFLUSH _VKI_IOW('t', 16, int);
1210 #define VKI_TIOCGETA _VKI_IOR('t', 19, struct vki_termios) /* get termios */
1211 #define VKI_TIOCSETA _VKI_IOR('t', 20, struct vki_termios) /* set termios */
1212 #define VKI_TIOCSETAW _VKI_IOR('t', 21, struct vki_termios) /* drain,set */
1213 #define VKI_TIOCSETAF _VKI_IOR('t', 22, struct vki_termios) /* flush,set */
1214
1215 #define VKI_TIOCSBRK _VKI_IO('t', 123)
1216 #define VKI_TIOCCBRK _VKI_IO('t', 122)
1217 #define VKI_TIOCGPGRP _VKI_IOR('t', 119, int) /* get pgrp */
1218 #define VKI_TIOCSPGRP _VKI_IOW('t', 118, int) /* set pgrp */
1219
1220 #define VKI_TIOCGWINSZ _VKI_IOR('t', 104, struct vki_winsize) /* get window size */
1221 #define VKI_TIOCSWINSZ _VKI_IOW('t', 103, struct vki_winsize) /* set window size */
1222
1223 #define VKI_TIOCMGET _VKI_IOR('t', 106, int) /* get all modem bits */
1224 #define VKI_TIOCMBIS _VKI_IOW('t', 108, int) /* bis modem bits */
1225 #define VKI_TIOCMBIC _VKI_IOW('t', 107, int) /* bic modem bits */
1226 #define VKI_TIOCMSET _VKI_IOW('t', 109, int) /* set all modem bits */
1227
1228
1229 //----------------------------------------------------------------------
1230 // From sys/filio.h
1231 //----------------------------------------------------------------------
1232
1233 #define VKI_FIOCLEX _VKI_IO('f', 1) /* close on exec */
1234 #define VKI_FIONCLEX _VKI_IO('f', 2) /* no close on exec */
1235 #define VKI_FIONREAD _VKI_IOR('f', 127, int)
1236 #define VKI_FIONBIO _VKI_IOW('f', 126, int)
1237 #define VKI_FIOASYNC _VKI_IOW('f', 125, int)
1238 #define VKI_FIOSETOWN _VKI_IOW('f', 124, int)
1239 #define VKI_FIOGETOWN _VKI_IOW('f', 123, int)
1240
1241 //----------------------------------------------------------------------
1242 // From sys/poll.h
1243 //----------------------------------------------------------------------
1244
1245 #define VKI_POLLIN 0x0001
1246
1247 struct vki_pollfd {
1248 int fd;
1249 short events;
1250 short revents;
1251 };
1252
1253 //----------------------------------------------------------------------
1254 // From sys/kevent.h
1255 //----------------------------------------------------------------------
1256 struct vki_kevent {
1257 vki_uintptr_t ident;
1258 vki_int16_t filter;
1259 vki_uint16_t flags;
1260 vki_uint32_t fflags;
1261 vki_intptr_t data;
1262 void *udata;
1263 };
1264
1265
1266 // QQQ sort
1267
1268 //----------------------------------------------------------------------
1269 // From sys/resource.h
1270 //----------------------------------------------------------------------
1271
1272 struct vki_rusage {
1273 struct vki_timeval ru_utime; /* user time used */
1274 struct vki_timeval ru_stime; /* system time used */
1275 long ru_maxrss; /* maximum resident set size */
1276 long ru_ixrss; /* integral shared memory size */
1277 long ru_idrss; /* integral unshared data size */
1278 long ru_isrss; /* integral unshared stack size */
1279 long ru_minflt; /* page reclaims */
1280 long ru_majflt; /* page faults */
1281 long ru_nswap; /* swaps */
1282 long ru_inblock; /* block input operations */
1283 long ru_oublock; /* block output operations */
1284 long ru_msgsnd; /* messages sent */
1285 long ru_msgrcv; /* messages received */
1286 long ru_nsignals; /* signals received */
1287 long ru_nvcsw; /* voluntary context switches */
1288 long ru_nivcsw; /* involuntary " */
1289 };
1290
1291 struct vki_rlimit {
1292 vki_rlim_t rlim_cur;
1293 vki_rlim_t rlim_max;
1294 };
1295
1296 struct vki___wrusage {
1297 struct vki_rusage wru_self;
1298 struct vki_rusage wru_children;
1299 };
1300
1301 #define VKI_RLIMIT_DATA 2 /* max data size */
1302 #define VKI_RLIMIT_STACK 3 /* max stack size */
1303 #define VKI_RLIMIT_CORE 4 /* max core file size */
1304 #define VKI_RLIMIT_NOFILE 8 /* max number of open files */
1305
1306 //----------------------------------------------------------------------
1307 // From sys/procfs.h
1308 //----------------------------------------------------------------------
1309
1310 #define VKI_PRSTATUS_VERSION 1
1311 struct vki_elf_prstatus
1312 {
1313 int pr_version; /* version of struct - PRSTATUS_VERSION */
1314 vki_size_t pr_statussz;
1315 vki_size_t pr_gregsetsz;
1316 vki_size_t pr_fpregsetsz;
1317 int pr_osreldate;
1318 short pr_cursig; /* Current signal */
1319 vki_pid_t pr_pid;
1320 vki_elf_gregset_t pr_reg; /* GP registers */
1321 };
1322
1323 #define VKI_ELF_PRARGSZ (80) /* Number of chars for args */
1324 #define VKI_MAXCOMLEN (16)
1325
1326 #define VKI_PRPSINFO_VERSION 1
1327 struct vki_elf_prpsinfo
1328 {
1329 int pr_version; /* version of struct - PRPSINFO_VERSION */
1330 vki_size_t pr_psinfosz;
1331 char pr_fname[VKI_MAXCOMLEN+1]; /* filename of executable */
1332 char pr_psargs[VKI_ELF_PRARGSZ]; /* initial part of arg list */
1333 };
1334
1335 //----------------------------------------------------------------------
1336 // From posix4/mqueue.h
1337 //----------------------------------------------------------------------
1338
1339 struct vki_mq_attr {
1340 long mq_flags; /* message queue flags */
1341 long mq_maxmsg; /* maximum number of messages */
1342 long mq_msgsize; /* maximum message size */
1343 long mq_curmsgs; /* number of messages currently queued */
1344 };
1345
1346 //----------------------------------------------------------------------
1347 // From sys/ucontext.h
1348 //----------------------------------------------------------------------
1349
1350 #define VKI_UCF_SWAPPED 1
1351
1352 struct vki_ucontext {
1353 vki_sigset_t uc_sigmask;
1354 struct vki_mcontext uc_mcontext;
1355 struct vki_ucontext *uc_link;
1356 vki_stack_t uc_stack;
1357 int uc_flags;
1358 unsigned int __spare__[4];
1359 };
1360
1361 //----------------------------------------------------------------------
1362 // From sys/utsname.h
1363 //----------------------------------------------------------------------
1364
1365 #define VKI_SYS_NMLN 32
1366
1367 struct vki_utsname {
1368 char sysname[VKI_SYS_NMLN]; /* Name of this OS. */
1369 char nodename[VKI_SYS_NMLN]; /* Name of this network node. */
1370 char release[VKI_SYS_NMLN]; /* Release level. */
1371 char version[VKI_SYS_NMLN]; /* Version level. */
1372 char machine[VKI_SYS_NMLN]; /* Hardware type. */
1373 };
1374
1375 #define VKI_IPC_CREAT 00001000 /* create if key is nonexistent */
1376 #define VKI_IPC_EXCL 00002000 /* fail if key exists */
1377 #define VKI_IPC_NOWAIT 00004000 /* return error on wait */
1378
1379 #define VKI_IPC_RMID 0 /* remove resource */
1380 #define VKI_IPC_SET 1 /* set ipc_perm options */
1381 #define VKI_IPC_STAT 2 /* get ipc_perm options */
1382 #define VKI_IPC_INFO 3 /* see ipcs */
1383
1384 struct vki_ipc_perm
1385 {
1386 vki_uid_t cuid;
1387 vki_gid_t cgid;
1388 vki_uid_t uid;
1389 vki_gid_t gid;
1390 vki_mode_t mode;
1391 unsigned short seq;
1392 vki_key_t key;
1393 };
1394
1395 struct vki_ipc_perm7
1396 {
1397 unsigned short cuid;
1398 unsigned short cgid;
1399 unsigned short uid;
1400 unsigned short gid;
1401 unsigned short mode;
1402 unsigned short seq;
1403 vki_key_t key;
1404 };
1405
1406 //----------------------------------------------------------------------
1407 // From sys/sem.h
1408 //----------------------------------------------------------------------
1409
1410 #if 0
1411 #define VKI_SEMOP 1
1412 #define VKI_SEMGET 2
1413 #define VKI_SEMCTL 3
1414 #define VKI_SEMTIMEDOP 4
1415 #endif
1416
1417 #define VKI_GETALL 6 /* get all semval's */
1418 #define VKI_SETVAL 8 /* set semval */
1419 #define VKI_SETALL 9 /* set all semval's */
1420 #define VKI_SEM_STAT 10
1421 #define VKI_SEM_INFO 11
1422
1423 /* Obsolete, used only for backwards compatibility and libc5 compiles */
1424 struct vki_semid_ds {
1425 struct vki_ipc_perm sem_perm; /* permissions .. see ipc.h */
1426 // [[Use void* to avoid excess header copying]]
1427 void/*struct sem */*sem_base; /* ptr to first semaphore in array */
1428 unsigned short sem_nsems; /* no. of semaphores in array */
1429 vki_time_t sem_otime; /* last semop time */
1430 vki_time_t sem_ctime; /* last change time */
1431 long sem_pad2;
1432 long sem_pad3[4];
1433 };
1434
1435 struct vki_sembuf {
1436 vki_uint16_t sem_num; /* semaphore index in array */
1437 vki_int16_t sem_op; /* semaphore operation */
1438 vki_int16_t sem_flg; /* operation flags */
1439 };
1440
1441 union vki_semun {
1442 int val; /* value for SETVAL */
1443 struct vki_semid_ds *buf; /* buffer for IPC_STAT & IPC_SET */
1444 vki_uint16_t *array; /* array for GETALL & SETALL */
1445 };
1446
1447
1448 //----------------------------------------------------------------------
1449 // From sys/errno.h
1450 //----------------------------------------------------------------------
1451
1452 #define VKI_ERESTART -1
1453 #define VKI_EPERM 1 /* Operation not permitted */
1454 #define VKI_ENOENT 2 /* No such file or directory */
1455 #define VKI_ESRCH 3 /* No such process */
1456 #define VKI_EINTR 4 /* Interrupted system call */
1457 #define VKI_EIO 5 /* Input/output error */
1458 #define VKI_ENXIO 6 /* Device not configured */
1459 #define VKI_E2BIG 7 /* Argument list too long */
1460 #define VKI_ENOEXEC 8 /* Exec format error */
1461 #define VKI_EBADF 9 /* Bad file descriptor */
1462 #define VKI_ECHILD 10 /* No child processes */
1463 #define VKI_EDEADLK 11 /* Resource deadlock avoided */
1464 #define VKI_ENOMEM 12 /* Cannot allocate memory */
1465 #define VKI_EACCES 13 /* Permission denied */
1466 #define VKI_EFAULT 14 /* Bad address */
1467 #define VKI_ENOTBLK 15 /* Block device required */
1468 #define VKI_EBUSY 16 /* Device busy */
1469 #define VKI_EEXIST 17 /* File exists */
1470 #define VKI_EXDEV 18 /* Cross-device link */
1471 #define VKI_ENODEV 19 /* Operation not supported by device */
1472 #define VKI_ENOTDIR 20 /* Not a directory */
1473 #define VKI_EISDIR 21 /* Is a directory */
1474 #define VKI_EINVAL 22 /* Invalid argument */
1475 #define VKI_ENFILE 23 /* Too many open files in system */
1476 #define VKI_EMFILE 24 /* Too many open files */
1477 #define VKI_ENOTTY 25 /* Inappropriate ioctl for device */
1478 #define VKI_ETXTBSY 26 /* Text file busy */
1479 #define VKI_EFBIG 27 /* File too large */
1480 #define VKI_ENOSPC 28 /* No space left on device */
1481 #define VKI_ESPIPE 29 /* Illegal seek */
1482 #define VKI_EROFS 30 /* Read-only filesystem */
1483 #define VKI_EMLINK 31 /* Too many links */
1484 #define VKI_EPIPE 32 /* Broken pipe */
1485 #define VKI_EDOM 33 /* Numerical argument out of domain */
1486 #define VKI_ERANGE 34 /* Result too large */
1487 #define VKI_EAGAIN 35 /* Resource temporarily unavailable */
1488 #define VKI_EWOULDBLOCK VKI_EAGAIN /* Operation would block */
1489 #define VKI_EINPROGRESS 36 /* Operation now in progress */
1490 #define VKI_EALREADY 37 /* Operation already in progress */
1491 #define VKI_ENOTSOCK 38 /* Socket operation on non-socket */
1492 #define VKI_EDESTADDRREQ 39 /* Destination address required */
1493 #define VKI_EMSGSIZE 40 /* Message too long */
1494 #define VKI_EPROTOTYPE 41 /* Protocol wrong type for socket */
1495 #define VKI_ENOPROTOOPT 42 /* Protocol not available */
1496 #define VKI_EPROTONOSUPPORT 43 /* Protocol not supported */
1497 #define VKI_ESOCKTNOSUPPORT 44 /* Socket type not supported */
1498 #define VKI_EOPNOTSUPP 45 /* Operation not supported */
1499 #define VKI_ENOTSUP VKI_EOPNOTSUPP /* Operation not supported */
1500 #define VKI_EPFNOSUPPORT 46 /* Protocol family not supported */
1501 #define VKI_EAFNOSUPPORT 47 /* Address family not supported by protocol family */
1502 #define VKI_EADDRINUSE 48 /* Address already in use */
1503 #define VKI_EADDRNOTAVAIL 49
1504 #define VKI_ENETDOWN 50 /* Network is down */
1505 #define VKI_ENETUNREACH 51 /* Network is unreachable */
1506 #define VKI_ENETRESET 52 /* Network dropped connection on reset */
1507 #define VKI_ECONNABORTED 53 /* Software caused connection abort */
1508 #define VKI_ECONNRESET 54 /* Connection reset by peer */
1509 #define VKI_ENOBUFS 55 /* No buffer space available */
1510 #define VKI_EISCONN 56 /* Socket is already connected */
1511 #define VKI_ENOTCONN 57 /* Socket is not connected */
1512 #define VKI_ESHUTDOWN 58 /* Can't send after socket shutdown */
1513 #define VKI_ETOOMANYREFS 59 /* Too many references: can't splice */
1514 #define VKI_ETIMEDOUT 60 /* Operation timed out */
1515 #define VKI_ECONNREFUSED 61 /* Connection refused */
1516 #define VKI_ELOOP 62 /* Too many levels of symbolic links */
1517 #define VKI_ENAMETOOLONG 63 /* File name too long */
1518 #define VKI_EHOSTDOWN 64 /* Host is down */
1519 #define VKI_EHOSTUNREACH 65 /* No route to host */
1520 #define VKI_ENOTEMPTY 66 /* Directory not empty */
1521 #define VKI_EPROCLIM 67 /* Too many processes */
1522 #define VKI_EUSERS 68 /* Too many users */
1523 #define VKI_EDQUOT 69 /* Disc quota exceeded */
1524 #define VKI_ESTALE 70 /* Stale NFS file handle */
1525 #define VKI_EREMOTE 71 /* Too many levels of remote in path */
1526 #define VKI_EBADRPC 72 /* RPC struct is bad */
1527 #define VKI_ERPCMISMATCH 73 /* RPC version wrong */
1528 #define VKI_EPROGUNAVAIL 74 /* RPC prog. not avail */
1529 #define VKI_EPROGMISMATCH 75 /* Program version wrong */
1530 #define VKI_EPROCUNAVAIL 76 /* Bad procedure for program */
1531 #define VKI_ENOLCK 77 /* No locks available */
1532 #define VKI_ENOSYS 78 /* Function not implemented */
1533 #define VKI_EFTYPE 79 /* Inappropriate file type or format */
1534 #define VKI_EAUTH 80 /* Authentication error */
1535 #define VKI_ENEEDAUTH 81 /* Need authenticator */
1536 #define VKI_EIDRM 82 /* Identifier removed */
1537 #define VKI_ENOMSG 83 /* No message of desired type */
1538 #define VKI_EOVERFLOW 84 /* Value too large to be stored in data type */
1539 #define VKI_ECANCELED 85 /* Operation canceled */
1540 #define VKI_EILSEQ 86 /* Illegal byte sequence */
1541 #define VKI_ENOATTR 87 /* Attribute not found */
1542 #define VKI_EDOOFUS 88 /* Programming error */
1543 #define VKI_EBADMSG 89 /* Bad message */
1544 #define VKI_EMULTIHOP 90 /* Multihop attempted */
1545 #define VKI_ENOLINK 91 /* Link has been severed */
1546 #define VKI_EPROTO 92 /* Protocol error */
1547 #define VKI_ENOTCAPABLE 93 /* Capabilities insufficient */
1548 #define VKI_ECAPMODE 94 /* Not permitted in capability mode */
1549
1550 //----------------------------------------------------------------------
1551 // From sys/wait.h
1552 //----------------------------------------------------------------------
1553
1554 #define VKI_WNOHANG 0x00000001
1555
1556 //----------------------------------------------------------------------
1557 // From sys/mman.h
1558 //----------------------------------------------------------------------
1559
1560 #define VKI_PROT_NONE 0x00 /* No page permissions */
1561 #define VKI_PROT_READ 0x01 /* page can be read */
1562 #define VKI_PROT_WRITE 0x02 /* page can be written */
1563 #define VKI_PROT_EXEC 0x04 /* page can be executed */
1564
1565 #define VKI_MAP_SHARED 0x01 /* Share changes */
1566 #define VKI_MAP_PRIVATE 0x02 /* Changes are private */
1567 #define VKI_MAP_FIXED 0x10 /* Interpret addr exactly */
1568 #define VKI_MAP_NORESERVE 0x0040 /* don't check for reservations */
1569 #define VKI_MAP_STACK 0x400
1570 #define VKI_MAP_ANON 0x1000 /* don't use a file */
1571 #define VKI_MAP_ANONYMOUS VKI_MAP_ANON
1572
1573 //----------------------------------------------------------------------
1574 // From sys/stat.h
1575 //----------------------------------------------------------------------
1576
1577 #define VKI_S_IFMT 00170000
1578
1579 #define VKI_S_IFWHT 0160000
1580 #define VKI_S_IFSOCK 0140000
1581 #define VKI_S_IFLNK 0120000
1582 #define VKI_S_IFREG 0100000
1583 #define VKI_S_IFBLK 0060000
1584 #define VKI_S_IFDIR 0040000
1585 #define VKI_S_IFCHR 0020000
1586 #define VKI_S_IFIFO 0010000
1587 #define VKI_S_ISUID 0004000
1588 #define VKI_S_ISGID 0002000
1589 #define VKI_S_ISTXT 0001000
1590
1591 #define VKI_S_ISLNK(m) (((m) & VKI_S_IFMT) == VKI_S_IFLNK)
1592 #define VKI_S_ISREG(m) (((m) & VKI_S_IFMT) == VKI_S_IFREG)
1593 #define VKI_S_ISDIR(m) (((m) & VKI_S_IFMT) == VKI_S_IFDIR)
1594 #define VKI_S_ISCHR(m) (((m) & VKI_S_IFMT) == VKI_S_IFCHR)
1595 #define VKI_S_ISBLK(m) (((m) & VKI_S_IFMT) == VKI_S_IFBLK)
1596 #define VKI_S_ISFIFO(m) (((m) & VKI_S_IFMT) == VKI_S_IFIFO)
1597 #define VKI_S_ISSOCK(m) (((m) & VKI_S_IFMT) == VKI_S_IFSOCK)
1598 #define VKI_S_ISWHT(m) (((m) & VKI_S_IFMT) == VKI_S_IFWHT)
1599
1600 #define VKI_S_IRWXU 00700
1601 #define VKI_S_IRUSR 00400
1602 #define VKI_S_IWUSR 00200
1603 #define VKI_S_IXUSR 00100
1604
1605 #define VKI_S_IRWXG 00070
1606 #define VKI_S_IRGRP 00040
1607 #define VKI_S_IWGRP 00020
1608 #define VKI_S_IXGRP 00010
1609
1610 #define VKI_S_IRWXO 00007
1611 #define VKI_S_IROTH 00004
1612 #define VKI_S_IWOTH 00002
1613 #define VKI_S_IXOTH 00001
1614
1615
1616 //----------------------------------------------------------------------
1617 // From sys/dirent.h
1618 //----------------------------------------------------------------------
1619
1620 struct vki_dirent {
1621 vki_uint32_t d_fileno;
1622 vki_uint16_t d_reclen;
1623 vki_uint8_t d_type;
1624 vki_uint8_t d_namelen;
1625 char d_name[256]; /* We must not include limits.h! */
1626 };
1627
1628 //----------------------------------------------------------------------
1629 // From sys/fcntl.h
1630 //----------------------------------------------------------------------
1631
1632 #define VKI_O_RDONLY O_RDONLY
1633 #define VKI_O_WRONLY O_WRONLY
1634 #define VKI_O_RDWR O_RDWR
1635
1636 #define VKI_O_NONBLOCK O_NONBLOCK
1637 #define VKI_O_APPEND O_APPEND
1638 #define VKI_O_CREAT O_CREAT
1639 #define VKI_O_TRUNC O_TRUNC
1640 #define VKI_O_EXCL O_EXCL
1641
1642 #define VKI_AT_FDCWD AT_FDCWD
1643
1644 #define VKI_F_DUPFD 0 /* dup */
1645 #define VKI_F_GETFD 1 /* get close_on_exec */
1646 #define VKI_F_SETFD 2 /* set/clear close_on_exec */
1647 #define VKI_F_GETFL 3 /* get file->f_flags */
1648 #define VKI_F_SETFL 4 /* set file->f_flags */
1649 #define VKI_F_SETOWN 5 /* for sockets. */
1650 #define VKI_F_GETOWN 6 /* for sockets. */
1651 #define VKI_F_OGETLK 7 /* get record locking information */
1652 #define VKI_F_OSETLK 8 /* set record locking information */
1653 #define VKI_F_OSETLKW 9 /* F_SETLK; wait if blocked */
1654 #define VKI_F_DUP2FD 10 /* duplicate file descriptor to arg */
1655 #define VKI_F_GETLK 11 /* get record locking information */
1656 #define VKI_F_SETLK 12 /* set record locking information */
1657 #define VKI_F_SETLKW 13 /* F_SETLK; wait if blocked */
1658 #define VKI_F_SETLK_REMOTE 14 /* debugging support for remote locks */
1659 #define VKI_F_DUPFD_CLOEXEC 17 /* dup close_on_exec */
1660 #define VKI_F_GETPATH 19 /* retrieve path to file associated with fd */
1661
1662 /* for F_[GET|SET]FL */
1663 #define VKI_FD_CLOEXEC 1 /* actually anything with low bit set goes */
1664
1665 //----------------------------------------------------------------------
1666 // From sys/unistd.h
1667 //----------------------------------------------------------------------
1668
1669 #define VKI_EXTEXIT_SIMPLE 0
1670 #define VKI_EXTEXIT_SETINT 1
1671 #define VKI_EXTEXIT_ACTION(f) ((f) & 0xffff)
1672 #define VKI_EXTEXIT_PROC (0<<16)
1673 #define VKI_EXTEXIT_LWP (1<<16)
1674 #define VKI_EXTEXIT_WHO(f) ((f) & (0xffff<<16))
1675
1676 #define VKI_SEEK_SET 0
1677 #define VKI_SEEK_CUR 1
1678 #define VKI_SEEK_END 2
1679
1680 #define VKI_F_OK 0 /* test for existence of file */
1681 #define VKI_X_OK 0x01 /* test for execute or search permission */
1682 #define VKI_W_OK 0x02 /* test for write permission */
1683 #define VKI_R_OK 0x04 /* test for read permission */
1684
1685 #define VKI_EXTEXIT_LWP (1<<16)
1686
1687 //----------------------------------------------------------------------
1688 // From sys/msg.h
1689 //----------------------------------------------------------------------
1690
1691 #if 0 /* not in dragonfly */
1692 #define VKI_MSGSND 11
1693 #define VKI_MSGRCV 12
1694 #define VKI_MSGGET 13
1695 #define VKI_MSGCTL 14
1696 #endif
1697
1698 typedef unsigned long vki_msglen_t;
1699 typedef unsigned long vki_msgqnum_t;
1700
1701 struct vki_msqid_ds {
1702 struct vki_ipc_perm msg_perm; /* msg queue permission bits */
1703 struct vki_msg *msg_first; /* first message in the queue. */
1704 struct vki_msg *msg_last; /* last message in the queue. */
1705 vki_msglen_t msg_cbytes; /* number of bytes in use on the queue */
1706 vki_msgqnum_t msg_qnum; /* number of msgs in the queue */
1707 vki_msglen_t msg_qbytes; /* max # of bytes on the queue */
1708 vki_pid_t msg_lspid; /* pid of last msgsnd() */
1709 vki_pid_t msg_lrpid; /* pid of last msgrcv() */
1710 vki_time_t msg_stime; /* time of last msgsnd() */
1711 long msg_pad1;
1712 vki_time_t msg_rtime; /* time of last msgrcv() */
1713 long msg_pad2;
1714 vki_time_t msg_ctime; /* time of last msgctl() */
1715 long msg_pad3;
1716 long msg_pad4[4];
1717 };
1718
1719 struct vki_msgbuf {
1720 long mtype; /* type of message */
1721 char mtext[1]; /* message text */
1722 };
1723
1724 struct vki_msginfo {
1725 int msgmax, /* max chars in a message */
1726 msgmni, /* max message queue identifiers */
1727 msgmnb, /* max chars in a queue */
1728 msgtql, /* max messages in system */
1729 msgssz, /* size of a message segment (see notes above) */
1730 msgseg; /* number of message segments */
1731 };
1732
1733 //----------------------------------------------------------------------
1734 // From sys/shm.h
1735 //----------------------------------------------------------------------
1736
1737 struct vki_shmid_ds {
1738 struct vki_ipc_perm shm_perm; /* operation perms */
1739 vki_size_t shm_segsz; /* size of segment (bytes) */
1740 vki_pid_t shm_lpid; /* pid of last operator */
1741 vki_pid_t shm_cpid; /* pid of creator */
1742 int shm_nattch; /* no. of current attaches */
1743 vki_time_t shm_atime; /* last attach time */
1744 vki_time_t shm_dtime; /* last detach time */
1745 vki_time_t shm_ctime; /* last change time */
1746 };
1747
1748 struct vki_shmid_ds7 {
1749 struct vki_ipc_perm7 shm_perm; /* operation perms */
1750 int shm_segsz; /* size of segment (bytes) */
1751 vki_pid_t shm_lpid; /* pid of last operator */
1752 vki_pid_t shm_cpid; /* pid of creator */
1753 short shm_nattch; /* no. of current attaches */
1754 vki_time_t shm_atime; /* last attach time */
1755 vki_time_t shm_dtime; /* last detach time */
1756 vki_time_t shm_ctime; /* last change time */
1757 void *shm_internal; /* sysv stupidity */
1758 };
1759
1760 #define VKI_SHMLBA VKI_PAGE_SIZE
1761 #define VKI_SHM_RDONLY 010000 /* read-only access */
1762 #define VKI_SHM_ANON (1UL)
1763
1764 #if 0 /* not in dragonfly abi */
1765 #define VKI_SHMAT 21
1766 #define VKI_SHMDT 22
1767 #define VKI_SHMGET 23
1768 #define VKI_SHMCTL 24
1769 #endif
1770
1771 #if 0
1772 //----------------------------------------------------------------------
1773 // From linux-2.6.8.1/include/linux/sockios.h
1774 //----------------------------------------------------------------------
1775
1776 #define VKI_SIOCOUTQ VKI_TIOCOUTQ
1777
1778 #define VKI_SIOCADDRT 0x890B /* add routing table entry */
1779 #define VKI_SIOCDELRT 0x890C /* delete routing table entry */
1780
1781 #define VKI_SIOCGIFNAME 0x8910 /* get iface name */
1782 #define VKI_SIOCGIFCONF 0x8912 /* get iface list */
1783 #define VKI_SIOCGIFFLAGS 0x8913 /* get flags */
1784 #define VKI_SIOCSIFFLAGS 0x8914 /* set flags */
1785 #define VKI_SIOCGIFADDR 0x8915 /* get PA address */
1786 #define VKI_SIOCSIFADDR 0x8916 /* set PA address */
1787 #define VKI_SIOCGIFDSTADDR 0x8917 /* get remote PA address */
1788 #define VKI_SIOCSIFDSTADDR 0x8918 /* set remote PA address */
1789 #define VKI_SIOCGIFBRDADDR 0x8919 /* get broadcast PA address */
1790 #define VKI_SIOCSIFBRDADDR 0x891a /* set broadcast PA address */
1791 #define VKI_SIOCGIFNETMASK 0x891b /* get network PA mask */
1792 #define VKI_SIOCSIFNETMASK 0x891c /* set network PA mask */
1793 #define VKI_SIOCGIFMETRIC 0x891d /* get metric */
1794 #define VKI_SIOCSIFMETRIC 0x891e /* set metric */
1795 #define VKI_SIOCGIFMTU 0x8921 /* get MTU size */
1796 #define VKI_SIOCSIFMTU 0x8922 /* set MTU size */
1797 #define VKI_SIOCSIFHWADDR 0x8924 /* set hardware address */
1798 #define VKI_SIOCGIFHWADDR 0x8927 /* Get hardware address */
1799 #define VKI_SIOCGIFINDEX 0x8933 /* name -> if_index mapping */
1800
1801 #define VKI_SIOCGIFTXQLEN 0x8942 /* Get the tx queue length */
1802 #define VKI_SIOCSIFTXQLEN 0x8943 /* Set the tx queue length */
1803
1804 #define VKI_SIOCGMIIPHY 0x8947 /* Get address of MII PHY in use. */
1805 #define VKI_SIOCGMIIREG 0x8948 /* Read MII PHY register. */
1806 #define VKI_SIOCSMIIREG 0x8949 /* Write MII PHY register. */
1807
1808 #define VKI_SIOCDARP 0x8953 /* delete ARP table entry */
1809 #define VKI_SIOCGARP 0x8954 /* get ARP table entry */
1810 #define VKI_SIOCSARP 0x8955 /* set ARP table entry */
1811
1812 #define VKI_SIOCDRARP 0x8960 /* delete RARP table entry */
1813 #define VKI_SIOCGRARP 0x8961 /* get RARP table entry */
1814 #define VKI_SIOCSRARP 0x8962 /* set RARP table entry */
1815
1816 #define VKI_SIOCGIFMAP 0x8970 /* Get device parameters */
1817 #define VKI_SIOCSIFMAP 0x8971 /* Set device parameters */
1818
1819 //----------------------------------------------------------------------
1820 // From linux-2.6.9/include/linux/kb.h
1821 //----------------------------------------------------------------------
1822
1823 #define VKI_GIO_FONT 0x4B60 /* gets font in expanded form */
1824 #define VKI_PIO_FONT 0x4B61 /* use font in expanded form */
1825
1826 #define VKI_GIO_FONTX 0x4B6B /* get font using struct consolefontdesc */
1827 #define VKI_PIO_FONTX 0x4B6C /* set font using struct consolefontdesc */
1828 struct vki_consolefontdesc {
1829 unsigned short charcount; /* characters in font (256 or 512) */
1830 unsigned short charheight; /* scan lines per character (1-32) */
1831 char __user *chardata; /* font data in expanded form */
1832 };
1833
1834 #define VKI_PIO_FONTRESET 0x4B6D /* reset to default font */
1835
1836 #define VKI_GIO_CMAP 0x4B70 /* gets colour palette on VGA+ */
1837 #define VKI_PIO_CMAP 0x4B71 /* sets colour palette on VGA+ */
1838
1839 #define VKI_KIOCSOUND 0x4B2F /* start sound generation (0 for off) */
1840 #define VKI_KDMKTONE 0x4B30 /* generate tone */
1841
1842 #define VKI_KDGETLED 0x4B31 /* return current led state */
1843 #define VKI_KDSETLED 0x4B32 /* set led state [lights, not flags] */
1844
1845 #define VKI_KDGKBTYPE 0x4B33 /* get keyboard type */
1846
1847 #define VKI_KDADDIO 0x4B34 /* add i/o port as valid */
1848 #define VKI_KDDELIO 0x4B35 /* del i/o port as valid */
1849 #define VKI_KDENABIO 0x4B36 /* enable i/o to video board */
1850 #define VKI_KDDISABIO 0x4B37 /* disable i/o to video board */
1851
1852 #define VKI_KDSETMODE 0x4B3A /* set text/graphics mode */
1853 #define VKI_KDGETMODE 0x4B3B /* get current mode */
1854
1855 #define VKI_KDMAPDISP 0x4B3C /* map display into address space */
1856 #define VKI_KDUNMAPDISP 0x4B3D /* unmap display from address space */
1857
1858 #define VKI_E_TABSZ 256
1859 #define VKI_GIO_SCRNMAP 0x4B40 /* get screen mapping from kernel */
1860 #define VKI_PIO_SCRNMAP 0x4B41 /* put screen mapping table in kernel */
1861 #define VKI_GIO_UNISCRNMAP 0x4B69 /* get full Unicode screen mapping */
1862 #define VKI_PIO_UNISCRNMAP 0x4B6A /* set full Unicode screen mapping */
1863
1864 #define VKI_GIO_UNIMAP 0x4B66 /* get unicode-to-font mapping from kernel */
1865 #define VKI_PIO_UNIMAP 0x4B67 /* put unicode-to-font mapping in kernel */
1866 #define VKI_PIO_UNIMAPCLR 0x4B68 /* clear table, possibly advise hash algorithm */
1867
1868 #define VKI_KDGKBMODE 0x4B44 /* gets current keyboard mode */
1869 #define VKI_KDSKBMODE 0x4B45 /* sets current keyboard mode */
1870
1871 #define VKI_KDGKBMETA 0x4B62 /* gets meta key handling mode */
1872 #define VKI_KDSKBMETA 0x4B63 /* sets meta key handling mode */
1873
1874 #define VKI_KDGKBLED 0x4B64 /* get led flags (not lights) */
1875 #define VKI_KDSKBLED 0x4B65 /* set led flags (not lights) */
1876
1877 struct vki_kbentry {
1878 unsigned char kb_table;
1879 unsigned char kb_index;
1880 unsigned short kb_value;
1881 };
1882 #define VKI_KDGKBENT 0x4B46 /* gets one entry in translation table */
1883 #define VKI_KDSKBENT 0x4B47 /* sets one entry in translation table */
1884
1885 struct vki_kbsentry {
1886 unsigned char kb_func;
1887 unsigned char kb_string[512];
1888 };
1889 #define VKI_KDGKBSENT 0x4B48 /* gets one function key string entry */
1890 #define VKI_KDSKBSENT 0x4B49 /* sets one function key string entry */
1891
1892 struct vki_kbdiacr {
1893 unsigned char diacr, base, result;
1894 };
1895 struct vki_kbdiacrs {
1896 unsigned int kb_cnt; /* number of entries in following array */
1897 struct vki_kbdiacr kbdiacr[256]; /* MAX_DIACR from keyboard.h */
1898 };
1899 #define VKI_KDGKBDIACR 0x4B4A /* read kernel accent table */
1900 #define VKI_KDSKBDIACR 0x4B4B /* write kernel accent table */
1901
1902 struct vki_kbkeycode {
1903 unsigned int scancode, keycode;
1904 };
1905 #define VKI_KDGETKEYCODE 0x4B4C /* read kernel keycode table entry */
1906 #define VKI_KDSETKEYCODE 0x4B4D /* write kernel keycode table entry */
1907
1908 #define VKI_KDSIGACCEPT 0x4B4E /* accept kbd generated signals */
1909
1910 struct vki_kbd_repeat {
1911 int delay; /* in msec; <= 0: don't change */
1912 int period; /* in msec; <= 0: don't change */
1913 /* earlier this field was misnamed "rate" */
1914 };
1915 #define VKI_KDKBDREP 0x4B52 /* set keyboard delay/repeat rate;
1916 * actually used values are returned */
1917
1918 #define VKI_KDFONTOP 0x4B72 /* font operations */
1919
1920 //----------------------------------------------------------------------
1921 // From linux-2.6.9/include/linux/kb.h
1922 //----------------------------------------------------------------------
1923
1924 typedef __vki_kernel_uid32_t vki_qid_t; /* Type in which we store ids in memory */
1925
1926 #endif
1927
1928 //----------------------------------------------------------------------
1929 // From sys/ptrace.h
1930 //----------------------------------------------------------------------
1931
1932 #define VKI_PTRACE_TRACEME 0
1933 #define VKI_PTRACE_READ_I 1
1934 #define VKI_PTRACE_READ_D 2
1935 /* 3 - read user struct */
1936 #define VKI_PTRACE_WRITE_I 4
1937 #define VKI_PTRACE_WRITE_D 5
1938 /* 6 - write user struct */
1939 #define VKI_PTRACE_CONTINUE 7
1940 #define VKI_PTRACE_KILL 8
1941 #define VKI_PTRACE_STEP 9
1942 #define VKI_PTRACE_ATTACH 10
1943 #define VKI_PTRACE_DETACH 11
1944 #define VKI_PTRACE_IO 12
1945 #define VKI_PTRACE_LWPINFO 13
1946 #define VKI_PTRACE_GETNUMLWPS 14
1947 #define VKI_PTRACE_GETLWPLIST 15
1948 #define VKI_PTRACE_CLEARSTEP 16
1949 #define VKI_PTRACE_SETSTEP 17
1950 #define VKI_PTRACE_SUSPEND 18
1951 #define VKI_PTRACE_RESUME 19
1952 #define VKI_PTRACE_TO_SCE 20
1953 #define VKI_PTRACE_TO_SCX 21
1954 #define VKI_PTRACE_SYSCALL 22
1955 /* md */
1956 #define VKI_PTRACE_GETREGS 33
1957 #define VKI_PTRACE_SETREGS 34
1958 #define VKI_PTRACE_GETFPREGS 35
1959 #define VKI_PTRACE_SETFPREGS 36
1960 #define VKI_PTRACE_GETDBREGS 37
1961 #define VKI_PTRACE_SETDBREGS 38
1962
1963 #define VKI_PTRACE_VM_TIMESTAMP 40
1964 #define VKI_PTRACE_VM_ENTRY 41
1965
1966 #define VKI_PTRACE_FIRSTMACH 64
1967
1968 struct vki_ptrace_io_desc {
1969 int piod_op;
1970 void * piod_offs;
1971 void * piod_addr;
1972 vki_size_t piod_len;
1973 };
1974 #define VKI_PIOD_READ_D 1
1975 #define VKI_PIOD_WRITE_D 2
1976 #define VKI_PIOD_READ_I 3
1977 #define VKI_PIOD_WRITE_I 4
1978
1979 struct vki_ptrace_lwpinfo {
1980 vki_lwpid_t pl_lwpid;
1981 int pl_event;
1982 #define VKI_PL_EVENT_NONE 0
1983 #define VKI_PL_EVENT_SIGNAL 1
1984 int pl_flags;
1985 #define VKI_FLAG_SA 0x01
1986 #define VKI_FLAG_BOUND 0x02
1987 vki_sigset_t pl_sigmask;
1988 vki_sigset_t pl_siglist;
1989 };
1990
1991 struct vki_ptrace_vm_entry {
1992 int pve_entry; /* Entry number used for iteration. */
1993 int pve_timestamp; /* Generation number of VM map. */
1994 unsigned long pve_start; /* Start VA of range. */
1995 unsigned long pve_end; /* End VA of range (incl). */
1996 unsigned long pve_offset; /* Offset in backing object. */
1997 unsigned int pve_prot; /* Protection of memory range. */
1998 unsigned int pve_pathlen; /* Size of path. */
1999 long pve_fileid; /* File ID. */
2000 vki_uint32_t pve_fsid; /* File system ID. */
2001 char *pve_path; /* Path name of object. */
2002 };
2003
2004 #endif // __VKI_DRAGONFLY_H
2005
2006 //----------------------------------------------------------------------
2007 // From i386/include/sysarch.h and amd64/include/sysarch.h (interchangeable)
2008 //----------------------------------------------------------------------
2009
2010 #define VKI_I386_GET_FSBASE 7
2011 #define VKI_I386_SET_FSBASE 8
2012 #define VKI_I386_GET_GSBASE 9
2013 #define VKI_I386_SET_GSBASE 10
2014 #define VKI_I386_GET_XFPUSTATE 11
2015
2016 #define VKI_AMD64_GET_FSBASE 128
2017 #define VKI_AMD64_SET_FSBASE 129
2018 #define VKI_AMD64_GET_GSBASE 130
2019 #define VKI_AMD64_SET_GSBASE 131
2020 #define VKI_AMD64_GET_XFPUSTATE 132
2021
2022 //----------------------------------------------------------------------
2023 // From sys/module.h
2024 //----------------------------------------------------------------------
2025
2026 #define VKI_MAXMODNAME 32
2027
2028 typedef union vki_modspecific {
2029 vki_int32_t intval;
2030 vki_uint32_t u_intval;
2031 #if defined(VGP_x86_dragonfly)
2032 vki_int32_t longval;
2033 vki_uint32_t u_longval;
2034 #elif defined(VGP_amd64_dragonfly)
2035 vki_int64_t longval;
2036 vki_uint64_t u_longval;
2037 #else
2038 #error Unknown platform
2039 #endif
2040 } vki_modspecific_t;
2041
2042 struct vki_module_stat {
2043 int version;
2044 char name[VKI_MAXMODNAME];
2045 int refs;
2046 int id;
2047 vki_modspecific_t data;
2048 };
2049
2050 //----------------------------------------------------------------------
2051 // From sys/rtprio.h
2052 //----------------------------------------------------------------------
2053
2054 struct vki_rtprio {
2055 vki_uint16_t type;
2056 vki_uint16_t prio;
2057 };
2058
2059 #define VKI_RTP_LOOKUP 0
2060 #define VKI_RTP_SET 1
2061
2062 //----------------------------------------------------------------------
2063 // From sys/umtx.h
2064 //----------------------------------------------------------------------
2065
2066 struct vki_umtx {
2067 unsigned long u_owner;
2068 };
2069
2070 struct vki_umutex {
2071 vki_lwpid_t m_owner;
2072 vki_uint32_t m_flags;
2073 vki_uint32_t m_ceilings[2];
2074 vki_uint32_t m_spare[4];
2075 };
2076
2077 struct vki_ucond {
2078 vki_uint32_t c_has_waiters;
2079 vki_uint32_t c_flags;
2080 vki_uint32_t c_spare[2];
2081 };
2082
2083 struct vki_urwlock {
2084 vki_uint32_t rw_state;
2085 vki_uint32_t rw_flags;
2086 vki_uint32_t rw_blocked_readers;
2087 vki_uint32_t rw_blocked_writers;
2088 vki_uint32_t rw_spare[4];
2089 };
2090
2091 struct vki_usem {
2092 vki_uint32_t has_waiters;
2093 vki_uint32_t count;
2094 vki_uint32_t flags;
2095 };
2096
2097 struct vki_umtx_time {
2098 struct vki_timespec timeout;
2099 vki_uint32_t flags;
2100 vki_uint32_t clockid;
2101 };
2102
2103 #define VKI_UMTX_OP_LOCK 0
2104 #define VKI_UMTX_OP_UNLOCK 1
2105 #define VKI_UMTX_OP_WAIT 2
2106 #define VKI_UMTX_OP_WAKE 3
2107 #define VKI_UMTX_OP_MUTEX_TRYLOCK 4
2108 #define VKI_UMTX_OP_MUTEX_LOCK 5
2109 #define VKI_UMTX_OP_MUTEX_UNLOCK 6
2110 #define VKI_UMTX_OP_SET_CEILING 7
2111 #define VKI_UMTX_OP_CV_WAIT 8
2112 #define VKI_UMTX_OP_CV_SIGNAL 9
2113 #define VKI_UMTX_OP_CV_BROADCAST 10
2114 #define VKI_UMTX_OP_WAIT_UINT 11
2115 #define VKI_UMTX_OP_RW_RDLOCK 12
2116 #define VKI_UMTX_OP_RW_WRLOCK 13
2117 #define VKI_UMTX_OP_RW_UNLOCK 14
2118 #define VKI_UMTX_OP_WAIT_UINT_PRIVATE 15
2119 #define VKI_UMTX_OP_WAKE_PRIVATE 16
2120 #define VKI_UMTX_OP_MUTEX_WAIT 17
2121 #define VKI_UMTX_OP_MUTEX_WAKE 18 /* deprecated */
2122 #define VKI_UMTX_OP_SEM_WAIT 19
2123 #define VKI_UMTX_OP_SEM_WAKE 20
2124 #define VKI_UMTX_OP_NWAKE_PRIVATE 21
2125 #define VKI_UMTX_OP_MUTEX_WAKE2 22
2126 #define VKI_UMTX_OP_MAX 23
2127
2128
2129 //----------------------------------------------------------------------
2130 // From sys/acl.h
2131 //----------------------------------------------------------------------
2132
2133 struct vki_acl_entry {
2134 int ae_tag;
2135 vki_uid_t ae_uid;
2136 vki_mode_t ae_perm;
2137 };
2138
2139 #define VKI_ACL_MAX_ENTRIES 32
2140 struct vki_acl {
2141 int acl_cnt;
2142 struct vki_acl_entry acl_entry[VKI_ACL_MAX_ENTRIES];
2143 };
2144
2145 //----------------------------------------------------------------------
2146 // From sys/user.h
2147 //----------------------------------------------------------------------
2148
2149 #define VKI_KVME_TYPE_NONE 0
2150 #define VKI_KVME_TYPE_DEFAULT 1
2151 #define VKI_KVME_TYPE_VNODE 2
2152 #define VKI_KVME_TYPE_SWAP 3
2153 #define VKI_KVME_TYPE_DEVICE 4
2154 #define VKI_KVME_TYPE_PHYS 5
2155 #define VKI_KVME_TYPE_DEAD 6
2156 #define VKI_KVME_TYPE_UNKNOWN 255
2157
2158 #define VKI_KVME_PROT_READ 0x00000001
2159 #define VKI_KVME_PROT_WRITE 0x00000002
2160 #define VKI_KVME_PROT_EXEC 0x00000004
2161
2162 #define VKI_KVME_FLAG_COW 0x00000001
2163 #define VKI_KVME_FLAG_NEEDS_COPY 0x00000002
2164
2165 struct vki_kinfo_vmentry {
2166 int kve_structsize;
2167 int kve_type;
2168 ULong kve_start;
2169 ULong kve_end;
2170 Off64T kve_offset;
2171 ULong kve_fileid;
2172 UInt kve_fsid;
2173 int kve_flags;
2174 int kve_resident;
2175 int kve_private_resident;
2176 int kve_protection;
2177 int kve_ref_count;
2178 int kve_shadow_count;
2179 int _kve_pad0;
2180 int kve_ispare[16];
2181 char kve_path[VKI_PATH_MAX];
2182 };
2183
2184 struct vki_kinfo_file {
2185 int kf_structsize; /* Variable size of record. */
2186 int kf_type; /* Descriptor type. */
2187 int kf_fd; /* Array index. */
2188 int kf_ref_count; /* Reference count. */
2189 int kf_flags; /* Flags. */
2190 int _kf_pad0; /* Round to 64 bit alignment */
2191 Off64T kf_offset; /* Seek location. */
2192 int kf_vnode_type; /* Vnode type. */
2193 int kf_sock_domain; /* Socket domain. */
2194 int kf_sock_type; /* Socket type. */
2195 int kf_sock_protocol; /* Socket protocol. */
2196 char kf_sa_local[128]; /* Socket address. */
2197 char kf_sa_peer[128]; /* Peer address. */
2198 int _kf_ispare[16]; /* Space for more stuff. */
2199 /* Truncated before copyout in sysctl */
2200 char kf_path[VKI_PATH_MAX]; /* Path to file, if any. */
2201 };
2202
2203 //----------------------------------------------------------------------
2204 // From sys/kenv.h
2205 //----------------------------------------------------------------------
2206 #define VKI_KENV_GET 0
2207 #define VKI_KENV_SET 1
2208 #define VKI_KENV_UNSET 2
2209 #define VKI_KENV_DUMP 3
2210
2211 //----------------------------------------------------------------------
2212 // From sys/sysctl.h (and related)
2213 //----------------------------------------------------------------------
2214
2215 #include <sys/types.h>
2216 #include <sys/sysctl.h>
2217
2218 #define VKI_CTL_KERN CTL_KERN
2219 #define VKI_CTL_HW CTL_HW
2220 #define VKI_KERN_PROC KERN_PROC
2221 #define VKI_KERN_PROC_VMMAP KERN_PROC_VMMAP
2222 #define VKI_KERN_PROC_FILEDESC KERN_PROC_FILEDESC
2223 #define VKI_HW_MACHINE HW_MACHINE
2224
2225 //----------------------------------------------------------------------
2226 // From sys/thr.h
2227 //----------------------------------------------------------------------
2228
2229 struct vki_thr_param {
2230 void (*start_func)(void *);
2231 void *arg;
2232 char *stack_base;
2233 vki_size_t stack_size;
2234 char *tls_base;
2235 vki_size_t tls_size;
2236 long *child_tid;
2237 long *parent_tid;
2238 int flags;
2239 struct vki_rtprio *rtp;
2240 void *spare[3];
2241 };
2242
2243 //----------------------------------------------------------------------
2244 // From sys/linker.h
2245 //----------------------------------------------------------------------
2246
2247 struct vki_kld_sym_lookup {
2248 int version; /* set to sizeof(struct kld_sym_lookup) */
2249 char *symname; /* Symbol name we are looking up */
2250 unsigned long symvalue;
2251 vki_size_t symsize;
2252 };
2253
2254 #if !defined(VKI_INIT_ARCH_ELF_STATE)
2255 /* This structure is used to preserve architecture specific data during
2256 the loading of an ELF file, throughout the checking of architecture
2257 specific ELF headers & through to the point where the ELF load is
2258 known to be proceeding. This implementation is a dummy for
2259 architectures which require no specific state. */
2260 struct vki_arch_elf_state {
2261 };
2262
2263 # define VKI_INIT_ARCH_ELF_STATE { }
2264
2265 #endif
2266
2267 //----------------------------------------------------------------------
2268 // From sys/procctl.h
2269 //----------------------------------------------------------------------
2270
2271 typedef enum vki_idtype {
2272 /*
2273 * These names were mostly lifted from Solaris source code and
2274 * still use Solaris style naming to avoid breaking any
2275 * OpenSolaris code which has been ported to FreeBSD/DragonFly.
2276 * There is no clear DragonFly counterpart for all of the names, but
2277 * some have a clear correspondence to DragonFly entities.
2278 *
2279 * The numerical values are kept synchronized with the Solaris
2280 * values.
2281 */
2282 P_PID, /* A process identifier. */
2283 P_PPID, /* A parent process identifier. */
2284 P_PGID, /* A process group identifier. */
2285 P_SID, /* A session identifier. */
2286 P_CID, /* A scheduling class identifier. */
2287 P_UID, /* A user identifier. */
2288 P_GID, /* A group identifier. */
2289 P_ALL, /* All processes. */
2290 P_LWPID, /* An LWP identifier. */
2291 P_TASKID, /* A task identifier. */
2292 P_PROJID, /* A project identifier. */
2293 P_POOLID, /* A pool identifier. */
2294 P_JAILID, /* A zone identifier. */
2295 P_CTID, /* A (process) contract identifier. */
2296 P_CPUID, /* CPU identifier. */
2297 P_PSETID /* Processor set identifier. */
2298 } vki_idtype_t; /* The type of id_t we are using. */
2299
2300 struct vki_reaper_status {
2301 uint32_t flags;
2302 uint32_t refs;
2303 long reserved1[15];
2304 pid_t pid_head;
2305 int reserved2[15];
2306 };
2307
2308 union vki_reaper_info {
2309 struct vki_reaper_status status;
2310 };
2311
2312 #define VKI_PROC_REAP_ACQUIRE 0x0001
2313 #define VKI_PROC_REAP_RELEASE 0x0002
2314 #define VKI_PROC_REAP_STATUS 0x0003
2315 #define VKI_REAPER_STAT_OWNED 0x00000001
2316 #define VKI_REAPER_STAT_REALINIT 0x00000002
2317
2318 /*--------------------------------------------------------------------*/
2319 /*--- end ---*/
2320 /*--------------------------------------------------------------------*/
2321