sys/contrib/cloudabi/cloudabi64_types.h

   1 // Copyright (c) 2016 Nuxi (https://nuxi.nl/) and contributors.
   2 //
   3 // Redistribution and use in source and binary forms, with or without
   4 // modification, are permitted provided that the following conditions
   5 // are met:
   6 // 1. Redistributions of source code must retain the above copyright
   7 //    notice, this list of conditions and the following disclaimer.
   8 // 2. Redistributions in binary form must reproduce the above copyright
   9 //    notice, this list of conditions and the following disclaimer in the
  10 //    documentation and/or other materials provided with the distribution.
  11 //
  12 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  13 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  14 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  15 // ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  16 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  17 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  18 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  19 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  20 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  21 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  22 // SUCH DAMAGE.
  23 //
  24 // This file is automatically generated. Do not edit.
  25 //
  26 // Source: https://github.com/NuxiNL/cloudabi
  27
  28 #ifndef CLOUDABI64_TYPES_H
  29 #define CLOUDABI64_TYPES_H
  30
  31 #include "cloudabi_types_common.h"
  32
  33 typedef struct {
  34   _Alignas(4) cloudabi_auxtype_t a_type;
  35   union {
  36     _Alignas(8) uint64_t a_val;
  37     _Alignas(8) uint64_t a_ptr;
  38   };
  39 } cloudabi64_auxv_t;
  40 _Static_assert(offsetof(cloudabi64_auxv_t, a_type) == 0, "Incorrect layout");
  41 _Static_assert(offsetof(cloudabi64_auxv_t, a_val) == 8, "Incorrect layout");
  42 _Static_assert(offsetof(cloudabi64_auxv_t, a_ptr) == 8, "Incorrect layout");
  43 _Static_assert(sizeof(cloudabi64_auxv_t) == 16, "Incorrect layout");
  44 _Static_assert(_Alignof(cloudabi64_auxv_t) == 8, "Incorrect layout");
  45
  46 typedef struct {
  47   _Alignas(8) uint64_t iov_base;
  48   _Alignas(8) uint64_t iov_len;
  49 } cloudabi64_ciovec_t;
  50 _Static_assert(offsetof(cloudabi64_ciovec_t, iov_base) == 0,
  51                "Incorrect layout");
  52 _Static_assert(offsetof(cloudabi64_ciovec_t, iov_len) == 8, "Incorrect layout");
  53 _Static_assert(sizeof(cloudabi64_ciovec_t) == 16, "Incorrect layout");
  54 _Static_assert(_Alignof(cloudabi64_ciovec_t) == 8, "Incorrect layout");
  55
  56 typedef struct {
  57   _Alignas(8) cloudabi_userdata_t userdata;
  58   _Alignas(2) cloudabi_errno_t error;
  59   _Alignas(1) cloudabi_eventtype_t type;
  60   union {
  61     struct {
  62       _Alignas(8) cloudabi_userdata_t identifier;
  63     } clock;
  64     struct {
  65       _Alignas(8) uint64_t condvar;
  66     } condvar;
  67     struct {
  68       _Alignas(8) cloudabi_filesize_t nbytes;
  69       _Alignas(4) cloudabi_fd_t fd;
  70       _Alignas(2) cloudabi_eventrwflags_t flags;
  71     } fd_readwrite;
  72     struct {
  73       _Alignas(8) uint64_t lock;
  74     } lock;
  75     struct {
  76       _Alignas(4) cloudabi_fd_t fd;
  77       _Alignas(1) cloudabi_signal_t signal;
  78       _Alignas(4) cloudabi_exitcode_t exitcode;
  79     } proc_terminate;
  80   };
  81 } cloudabi64_event_t;
  82 _Static_assert(offsetof(cloudabi64_event_t, userdata) == 0, "Incorrect layout");
  83 _Static_assert(offsetof(cloudabi64_event_t, error) == 8, "Incorrect layout");
  84 _Static_assert(offsetof(cloudabi64_event_t, type) == 10, "Incorrect layout");
  85 _Static_assert(offsetof(cloudabi64_event_t, clock.identifier) == 16,
  86                "Incorrect layout");
  87 _Static_assert(offsetof(cloudabi64_event_t, condvar.condvar) == 16,
  88                "Incorrect layout");
  89 _Static_assert(offsetof(cloudabi64_event_t, fd_readwrite.nbytes) == 16,
  90                "Incorrect layout");
  91 _Static_assert(offsetof(cloudabi64_event_t, fd_readwrite.fd) == 24,
  92                "Incorrect layout");
  93 _Static_assert(offsetof(cloudabi64_event_t, fd_readwrite.flags) == 28,
  94                "Incorrect layout");
  95 _Static_assert(offsetof(cloudabi64_event_t, lock.lock) == 16,
  96                "Incorrect layout");
  97 _Static_assert(offsetof(cloudabi64_event_t, proc_terminate.fd) == 16,
  98                "Incorrect layout");
  99 _Static_assert(offsetof(cloudabi64_event_t, proc_terminate.signal) == 20,
 100                "Incorrect layout");
 101 _Static_assert(offsetof(cloudabi64_event_t, proc_terminate.exitcode) == 24,
 102                "Incorrect layout");
 103 _Static_assert(sizeof(cloudabi64_event_t) == 32, "Incorrect layout");
 104 _Static_assert(_Alignof(cloudabi64_event_t) == 8, "Incorrect layout");
 105
 106 typedef struct {
 107   _Alignas(8) uint64_t iov_base;
 108   _Alignas(8) uint64_t iov_len;
 109 } cloudabi64_iovec_t;
 110 _Static_assert(offsetof(cloudabi64_iovec_t, iov_base) == 0, "Incorrect layout");
 111 _Static_assert(offsetof(cloudabi64_iovec_t, iov_len) == 8, "Incorrect layout");
 112 _Static_assert(sizeof(cloudabi64_iovec_t) == 16, "Incorrect layout");
 113 _Static_assert(_Alignof(cloudabi64_iovec_t) == 8, "Incorrect layout");
 114
 115 typedef void cloudabi64_processentry_t(uint64_t auxv);
 116
 117 typedef struct {
 118   _Alignas(8) uint64_t ri_data;
 119   _Alignas(8) uint64_t ri_datalen;
 120   _Alignas(8) uint64_t ri_fds;
 121   _Alignas(8) uint64_t ri_fdslen;
 122   _Alignas(2) cloudabi_msgflags_t ri_flags;
 123 } cloudabi64_recv_in_t;
 124 _Static_assert(offsetof(cloudabi64_recv_in_t, ri_data) == 0,
 125                "Incorrect layout");
 126 _Static_assert(offsetof(cloudabi64_recv_in_t, ri_datalen) == 8,
 127                "Incorrect layout");
 128 _Static_assert(offsetof(cloudabi64_recv_in_t, ri_fds) == 16,
 129                "Incorrect layout");
 130 _Static_assert(offsetof(cloudabi64_recv_in_t, ri_fdslen) == 24,
 131                "Incorrect layout");
 132 _Static_assert(offsetof(cloudabi64_recv_in_t, ri_flags) == 32,
 133                "Incorrect layout");
 134 _Static_assert(sizeof(cloudabi64_recv_in_t) == 40, "Incorrect layout");
 135 _Static_assert(_Alignof(cloudabi64_recv_in_t) == 8, "Incorrect layout");
 136
 137 typedef struct {
 138   _Alignas(8) uint64_t si_data;
 139   _Alignas(8) uint64_t si_datalen;
 140   _Alignas(8) uint64_t si_fds;
 141   _Alignas(8) uint64_t si_fdslen;
 142   _Alignas(2) cloudabi_msgflags_t si_flags;
 143 } cloudabi64_send_in_t;
 144 _Static_assert(offsetof(cloudabi64_send_in_t, si_data) == 0,
 145                "Incorrect layout");
 146 _Static_assert(offsetof(cloudabi64_send_in_t, si_datalen) == 8,
 147                "Incorrect layout");
 148 _Static_assert(offsetof(cloudabi64_send_in_t, si_fds) == 16,
 149                "Incorrect layout");
 150 _Static_assert(offsetof(cloudabi64_send_in_t, si_fdslen) == 24,
 151                "Incorrect layout");
 152 _Static_assert(offsetof(cloudabi64_send_in_t, si_flags) == 32,
 153                "Incorrect layout");
 154 _Static_assert(sizeof(cloudabi64_send_in_t) == 40, "Incorrect layout");
 155 _Static_assert(_Alignof(cloudabi64_send_in_t) == 8, "Incorrect layout");
 156
 157 typedef struct { _Alignas(8) uint64_t so_datalen; } cloudabi64_send_out_t;
 158 _Static_assert(offsetof(cloudabi64_send_out_t, so_datalen) == 0,
 159                "Incorrect layout");
 160 _Static_assert(sizeof(cloudabi64_send_out_t) == 8, "Incorrect layout");
 161 _Static_assert(_Alignof(cloudabi64_send_out_t) == 8, "Incorrect layout");
 162
 163 typedef struct {
 164   _Alignas(8) cloudabi_userdata_t userdata;
 165   _Alignas(2) cloudabi_subflags_t flags;
 166   _Alignas(1) cloudabi_eventtype_t type;
 167   union {
 168     struct {
 169       _Alignas(8) cloudabi_userdata_t identifier;
 170       _Alignas(4) cloudabi_clockid_t clock_id;
 171       _Alignas(8) cloudabi_timestamp_t timeout;
 172       _Alignas(8) cloudabi_timestamp_t precision;
 173       _Alignas(2) cloudabi_subclockflags_t flags;
 174     } clock;
 175     struct {
 176       _Alignas(8) uint64_t condvar;
 177       _Alignas(8) uint64_t lock;
 178       _Alignas(1) cloudabi_scope_t condvar_scope;
 179       _Alignas(1) cloudabi_scope_t lock_scope;
 180     } condvar;
 181     struct {
 182       _Alignas(4) cloudabi_fd_t fd;
 183       _Alignas(2) cloudabi_subrwflags_t flags;
 184     } fd_readwrite;
 185     struct {
 186       _Alignas(8) uint64_t lock;
 187       _Alignas(1) cloudabi_scope_t lock_scope;
 188     } lock;
 189     struct {
 190       _Alignas(4) cloudabi_fd_t fd;
 191     } proc_terminate;
 192   };
 193 } cloudabi64_subscription_t;
 194 _Static_assert(offsetof(cloudabi64_subscription_t, userdata) == 0,
 195                "Incorrect layout");
 196 _Static_assert(offsetof(cloudabi64_subscription_t, flags) == 8,
 197                "Incorrect layout");
 198 _Static_assert(offsetof(cloudabi64_subscription_t, type) == 10,
 199                "Incorrect layout");
 200 _Static_assert(offsetof(cloudabi64_subscription_t, clock.identifier) == 16,
 201                "Incorrect layout");
 202 _Static_assert(offsetof(cloudabi64_subscription_t, clock.clock_id) == 24,
 203                "Incorrect layout");
 204 _Static_assert(offsetof(cloudabi64_subscription_t, clock.timeout) == 32,
 205                "Incorrect layout");
 206 _Static_assert(offsetof(cloudabi64_subscription_t, clock.precision) == 40,
 207                "Incorrect layout");
 208 _Static_assert(offsetof(cloudabi64_subscription_t, clock.flags) == 48,
 209                "Incorrect layout");
 210 _Static_assert(offsetof(cloudabi64_subscription_t, condvar.condvar) == 16,
 211                "Incorrect layout");
 212 _Static_assert(offsetof(cloudabi64_subscription_t, condvar.lock) == 24,
 213                "Incorrect layout");
 214 _Static_assert(offsetof(cloudabi64_subscription_t, condvar.condvar_scope) == 32,
 215                "Incorrect layout");
 216 _Static_assert(offsetof(cloudabi64_subscription_t, condvar.lock_scope) == 33,
 217                "Incorrect layout");
 218 _Static_assert(offsetof(cloudabi64_subscription_t, fd_readwrite.fd) == 16,
 219                "Incorrect layout");
 220 _Static_assert(offsetof(cloudabi64_subscription_t, fd_readwrite.flags) == 20,
 221                "Incorrect layout");
 222 _Static_assert(offsetof(cloudabi64_subscription_t, lock.lock) == 16,
 223                "Incorrect layout");
 224 _Static_assert(offsetof(cloudabi64_subscription_t, lock.lock_scope) == 24,
 225                "Incorrect layout");
 226 _Static_assert(offsetof(cloudabi64_subscription_t, proc_terminate.fd) == 16,
 227                "Incorrect layout");
 228 _Static_assert(sizeof(cloudabi64_subscription_t) == 56, "Incorrect layout");
 229 _Static_assert(_Alignof(cloudabi64_subscription_t) == 8, "Incorrect layout");
 230
 231 typedef struct { _Alignas(8) uint64_t parent; } cloudabi64_tcb_t;
 232 _Static_assert(offsetof(cloudabi64_tcb_t, parent) == 0, "Incorrect layout");
 233 _Static_assert(sizeof(cloudabi64_tcb_t) == 8, "Incorrect layout");
 234 _Static_assert(_Alignof(cloudabi64_tcb_t) == 8, "Incorrect layout");
 235
 236 typedef void cloudabi64_threadentry_t(cloudabi_tid_t tid, uint64_t aux);
 237
 238 typedef struct {
 239   _Alignas(8) uint64_t ro_datalen;
 240   _Alignas(8) uint64_t ro_fdslen;
 241   _Alignas(2) cloudabi_sockaddr_t ro_sockname;
 242   _Alignas(2) cloudabi_sockaddr_t ro_peername;
 243   _Alignas(2) cloudabi_msgflags_t ro_flags;
 244 } cloudabi64_recv_out_t;
 245 _Static_assert(offsetof(cloudabi64_recv_out_t, ro_datalen) == 0,
 246                "Incorrect layout");
 247 _Static_assert(offsetof(cloudabi64_recv_out_t, ro_fdslen) == 8,
 248                "Incorrect layout");
 249 _Static_assert(offsetof(cloudabi64_recv_out_t, ro_sockname) == 16,
 250                "Incorrect layout");
 251 _Static_assert(offsetof(cloudabi64_recv_out_t, ro_peername) == 36,
 252                "Incorrect layout");
 253 _Static_assert(offsetof(cloudabi64_recv_out_t, ro_flags) == 56,
 254                "Incorrect layout");
 255 _Static_assert(sizeof(cloudabi64_recv_out_t) == 64, "Incorrect layout");
 256 _Static_assert(_Alignof(cloudabi64_recv_out_t) == 8, "Incorrect layout");
 257
 258 typedef struct {
 259   _Alignas(8) uint64_t entry_point;
 260   _Alignas(8) uint64_t stack;
 261   _Alignas(8) uint64_t stack_size;
 262   _Alignas(8) uint64_t argument;
 263 } cloudabi64_threadattr_t;
 264 _Static_assert(offsetof(cloudabi64_threadattr_t, entry_point) == 0,
 265                "Incorrect layout");
 266 _Static_assert(offsetof(cloudabi64_threadattr_t, stack) == 8,
 267                "Incorrect layout");
 268 _Static_assert(offsetof(cloudabi64_threadattr_t, stack_size) == 16,
 269                "Incorrect layout");
 270 _Static_assert(offsetof(cloudabi64_threadattr_t, argument) == 24,
 271                "Incorrect layout");
 272 _Static_assert(sizeof(cloudabi64_threadattr_t) == 32, "Incorrect layout");
 273 _Static_assert(_Alignof(cloudabi64_threadattr_t) == 8, "Incorrect layout");
 274
 275 #endif