sys/contrib/cloudabi/syscalls32.master

   1  $FreeBSD$
   2
   3 ; Copyright (c) 2016 Nuxi (https://nuxi.nl/) and contributors.
   4 ;
   5 ; Redistribution and use in source and binary forms, with or without
   6 ; modification, are permitted provided that the following conditions
   7 ; are met:
   8 ; 1. Redistributions of source code must retain the above copyright
   9 ;    notice, this list of conditions and the following disclaimer.
  10 ; 2. Redistributions in binary form must reproduce the above copyright
  11 ;    notice, this list of conditions and the following disclaimer in the
  12 ;    documentation and/or other materials provided with the distribution.
  13 ;
  14 ; THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15 ; ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16 ; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17 ; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18 ; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19 ; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20 ; OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21 ; HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22 ; LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23 ; OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24 ; SUCH DAMAGE.
  25 ;
  26 ; This file is automatically generated. Do not edit.
  27 ;
  28 ; Source: https://github.com/NuxiNL/cloudabi
  29
  30 #include <sys/sysent.h>
  31 #include <sys/sysproto.h>
  32
  33 #include <contrib/cloudabi/cloudabi32_types.h>
  34
  35 #include <compat/cloudabi32/cloudabi32_proto.h>
  36
  37 0       AUE_NULL        STD     { cloudabi_timestamp_t \
  38                                         cloudabi_sys_clock_res_get( \
  39                                         cloudabi_clockid_t clock_id); }
  40
  41 1       AUE_NULL        STD     { cloudabi_timestamp_t \
  42                                         cloudabi_sys_clock_time_get( \
  43                                         cloudabi_clockid_t clock_id, \
  44                                         cloudabi_timestamp_t precision); }
  45
  46 2       AUE_NULL        STD     { void cloudabi_sys_condvar_signal( \
  47                                         cloudabi_condvar_t *condvar, \
  48                                         cloudabi_scope_t scope, \
  49                                         cloudabi_nthreads_t nwaiters); }
  50
  51 3       AUE_NULL        STD     { void cloudabi_sys_fd_close( \
  52                                         cloudabi_fd_t fd); }
  53
  54 4       AUE_NULL        STD     { cloudabi_fd_t cloudabi_sys_fd_create1( \
  55                                         cloudabi_filetype_t type); }
  56
  57 5       AUE_NULL        STD     { void cloudabi_sys_fd_create2( \
  58                                         cloudabi_filetype_t type); }
  59
  60 6       AUE_NULL        STD     { void cloudabi_sys_fd_datasync( \
  61                                         cloudabi_fd_t fd); }
  62
  63 7       AUE_NULL        STD     { cloudabi_fd_t cloudabi_sys_fd_dup( \
  64                                         cloudabi_fd_t from); }
  65
  66 8       AUE_NULL        STD     { size_t cloudabi32_sys_fd_pread( \
  67                                         cloudabi_fd_t fd, \
  68                                         const cloudabi32_iovec_t *iovs, \
  69                                         size_t iovs_len, \
  70                                         cloudabi_filesize_t offset); }
  71
  72 9       AUE_NULL        STD     { size_t cloudabi32_sys_fd_pwrite( \
  73                                         cloudabi_fd_t fd, \
  74                                         const cloudabi32_ciovec_t *iovs, \
  75                                         size_t iovs_len, \
  76                                         cloudabi_filesize_t offset); }
  77
  78 10      AUE_NULL        STD     { size_t cloudabi32_sys_fd_read( \
  79                                         cloudabi_fd_t fd, \
  80                                         const cloudabi32_iovec_t *iovs, \
  81                                         size_t iovs_len); }
  82
  83 11      AUE_NULL        STD     { void cloudabi_sys_fd_replace( \
  84                                         cloudabi_fd_t from, \
  85                                         cloudabi_fd_t to); }
  86
  87 12      AUE_NULL        STD     { cloudabi_filesize_t \
  88                                         cloudabi_sys_fd_seek( \
  89                                         cloudabi_fd_t fd, \
  90                                         cloudabi_filedelta_t offset, \
  91                                         cloudabi_whence_t whence); }
  92
  93 13      AUE_NULL        STD     { void cloudabi_sys_fd_stat_get( \
  94                                         cloudabi_fd_t fd, \
  95                                         cloudabi_fdstat_t *buf); }
  96
  97 14      AUE_NULL        STD     { void cloudabi_sys_fd_stat_put( \
  98                                         cloudabi_fd_t fd, \
  99                                         const cloudabi_fdstat_t *buf, \
 100                                         cloudabi_fdsflags_t flags); }
 101
 102 15      AUE_NULL        STD     { void cloudabi_sys_fd_sync( \
 103                                         cloudabi_fd_t fd); }
 104
 105 16      AUE_NULL        STD     { size_t cloudabi32_sys_fd_write( \
 106                                         cloudabi_fd_t fd, \
 107                                         const cloudabi32_ciovec_t *iovs, \
 108                                         size_t iovs_len); }
 109
 110 17      AUE_NULL        STD     { void cloudabi_sys_file_advise( \
 111                                         cloudabi_fd_t fd, \
 112                                         cloudabi_filesize_t offset, \
 113                                         cloudabi_filesize_t len, \
 114                                         cloudabi_advice_t advice); }
 115
 116 18      AUE_NULL        STD     { void cloudabi_sys_file_allocate( \
 117                                         cloudabi_fd_t fd, \
 118                                         cloudabi_filesize_t offset, \
 119                                         cloudabi_filesize_t len); }
 120
 121 19      AUE_NULL        STD     { void cloudabi_sys_file_create( \
 122                                         cloudabi_fd_t fd, \
 123                                         const char *path, \
 124                                         size_t path_len, \
 125                                         cloudabi_filetype_t type); }
 126
 127 20      AUE_NULL        STD     { void cloudabi_sys_file_link( \
 128                                         cloudabi_lookup_t fd1, \
 129                                         const char *path1, \
 130                                         size_t path1_len, \
 131                                         cloudabi_fd_t fd2, \
 132                                         const char *path2, \
 133                                         size_t path2_len); }
 134
 135 21      AUE_NULL        STD     { cloudabi_fd_t cloudabi_sys_file_open( \
 136                                         cloudabi_lookup_t dirfd, \
 137                                         const char *path, \
 138                                         size_t path_len, \
 139                                         cloudabi_oflags_t oflags, \
 140                                         const cloudabi_fdstat_t *fds); }
 141
 142 22      AUE_NULL        STD     { size_t cloudabi_sys_file_readdir( \
 143                                         cloudabi_fd_t fd, \
 144                                         void *buf, \
 145                                         size_t buf_len, \
 146                                         cloudabi_dircookie_t cookie); }
 147
 148 23      AUE_NULL        STD     { size_t cloudabi_sys_file_readlink( \
 149                                         cloudabi_fd_t fd, \
 150                                         const char *path, \
 151                                         size_t path_len, \
 152                                         char *buf, \
 153                                         size_t buf_len); }
 154
 155 24      AUE_NULL        STD     { void cloudabi_sys_file_rename( \
 156                                         cloudabi_fd_t fd1, \
 157                                         const char *path1, \
 158                                         size_t path1_len, \
 159                                         cloudabi_fd_t fd2, \
 160                                         const char *path2, \
 161                                         size_t path2_len); }
 162
 163 25      AUE_NULL        STD     { void cloudabi_sys_file_stat_fget( \
 164                                         cloudabi_fd_t fd, \
 165                                         cloudabi_filestat_t *buf); }
 166
 167 26      AUE_NULL        STD     { void cloudabi_sys_file_stat_fput( \
 168                                         cloudabi_fd_t fd, \
 169                                         const cloudabi_filestat_t *buf, \
 170                                         cloudabi_fsflags_t flags); }
 171
 172 27      AUE_NULL        STD     { void cloudabi_sys_file_stat_get( \
 173                                         cloudabi_lookup_t fd, \
 174                                         const char *path, \
 175                                         size_t path_len, \
 176                                         cloudabi_filestat_t *buf); }
 177
 178 28      AUE_NULL        STD     { void cloudabi_sys_file_stat_put( \
 179                                         cloudabi_lookup_t fd, \
 180                                         const char *path, \
 181                                         size_t path_len, \
 182                                         const cloudabi_filestat_t *buf, \
 183                                         cloudabi_fsflags_t flags); }
 184
 185 29      AUE_NULL        STD     { void cloudabi_sys_file_symlink( \
 186                                         const char *path1, \
 187                                         size_t path1_len, \
 188                                         cloudabi_fd_t fd, \
 189                                         const char *path2, \
 190                                         size_t path2_len); }
 191
 192 30      AUE_NULL        STD     { void cloudabi_sys_file_unlink( \
 193                                         cloudabi_fd_t fd, \
 194                                         const char *path, \
 195                                         size_t path_len, \
 196                                         cloudabi_ulflags_t flags); }
 197
 198 31      AUE_NULL        STD     { void cloudabi_sys_lock_unlock( \
 199                                         cloudabi_lock_t *lock, \
 200                                         cloudabi_scope_t scope); }
 201
 202 32      AUE_NULL        STD     { void cloudabi_sys_mem_advise( \
 203                                         void *mapping, \
 204                                         size_t mapping_len, \
 205                                         cloudabi_advice_t advice); }
 206
 207 33      AUE_NULL        STD     { void cloudabi_sys_mem_map( \
 208                                         void *addr, \
 209                                         size_t len, \
 210                                         cloudabi_mprot_t prot, \
 211                                         cloudabi_mflags_t flags, \
 212                                         cloudabi_fd_t fd, \
 213                                         cloudabi_filesize_t off); }
 214
 215 34      AUE_NULL        STD     { void cloudabi_sys_mem_protect( \
 216                                         void *mapping, \
 217                                         size_t mapping_len, \
 218                                         cloudabi_mprot_t prot); }
 219
 220 35      AUE_NULL        STD     { void cloudabi_sys_mem_sync( \
 221                                         void *mapping, \
 222                                         size_t mapping_len, \
 223                                         cloudabi_msflags_t flags); }
 224
 225 36      AUE_NULL        STD     { void cloudabi_sys_mem_unmap( \
 226                                         void *mapping, \
 227                                         size_t mapping_len); }
 228
 229 37      AUE_NULL        STD     { size_t cloudabi32_sys_poll( \
 230                                         const cloudabi32_subscription_t *in, \
 231                                         cloudabi_event_t *out, \
 232                                         size_t nsubscriptions); }
 233
 234 38      AUE_NULL        STD     { void cloudabi_sys_proc_exec( \
 235                                         cloudabi_fd_t fd, \
 236                                         const void *data, \
 237                                         size_t data_len, \
 238                                         const cloudabi_fd_t *fds, \
 239                                         size_t fds_len); }
 240
 241 39      AUE_NULL        STD     { void cloudabi_sys_proc_exit( \
 242                                         cloudabi_exitcode_t rval); }
 243
 244 40      AUE_NULL        STD     { void cloudabi_sys_proc_fork(); }
 245
 246 41      AUE_NULL        STD     { void cloudabi_sys_proc_raise( \
 247                                         cloudabi_signal_t sig); }
 248
 249 42      AUE_NULL        STD     { void cloudabi_sys_random_get( \
 250                                         void *buf, \
 251                                         size_t buf_len); }
 252
 253 43      AUE_NULL        STD     { void cloudabi32_sys_sock_recv( \
 254                                         cloudabi_fd_t sock, \
 255                                         const cloudabi32_recv_in_t *in, \
 256                                         cloudabi32_recv_out_t *out); }
 257
 258 44      AUE_NULL        STD     { void cloudabi32_sys_sock_send( \
 259                                         cloudabi_fd_t sock, \
 260                                         const cloudabi32_send_in_t *in, \
 261                                         cloudabi32_send_out_t *out); }
 262
 263 45      AUE_NULL        STD     { void cloudabi_sys_sock_shutdown( \
 264                                         cloudabi_fd_t sock, \
 265                                         cloudabi_sdflags_t how); }
 266
 267 46      AUE_NULL        STD     { cloudabi_tid_t cloudabi32_sys_thread_create( \
 268                                         cloudabi32_threadattr_t *attr); }
 269
 270 47      AUE_NULL        STD     { void cloudabi_sys_thread_exit( \
 271                                         cloudabi_lock_t *lock, \
 272                                         cloudabi_scope_t scope); }
 273
 274 48      AUE_NULL        STD     { void cloudabi_sys_thread_yield(); }