sys/compat/cloudabi/cloudabi_fd.c

   1 /*-
   2  * Copyright (c) 2015 Nuxi, https://nuxi.nl/
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 #include <sys/param.h>
  30 #include <sys/capsicum.h>
  31 #include <sys/fcntl.h>
  32 #include <sys/filedesc.h>
  33 #include <sys/proc.h>
  34 #include <sys/mman.h>
  35 #include <sys/socketvar.h>
  36 #include <sys/syscallsubr.h>
  37 #include <sys/sysproto.h>
  38 #include <sys/systm.h>
  39 #include <sys/unistd.h>
  40 #include <sys/vnode.h>
  41
  42 #include <contrib/cloudabi/cloudabi_types_common.h>
  43
  44 #include <compat/cloudabi/cloudabi_proto.h>
  45 #include <compat/cloudabi/cloudabi_util.h>
  46
  47 /* Translation between CloudABI and Capsicum rights. */
  48 #define RIGHTS_MAPPINGS \
  49         MAPPING(CLOUDABI_RIGHT_FD_DATASYNC, CAP_FSYNC)                  \
  50         MAPPING(CLOUDABI_RIGHT_FD_READ, CAP_READ)                       \
  51         MAPPING(CLOUDABI_RIGHT_FD_SEEK, CAP_SEEK)                       \
  52         MAPPING(CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS, CAP_FCNTL)            \
  53         MAPPING(CLOUDABI_RIGHT_FD_SYNC, CAP_FSYNC)                      \
  54         MAPPING(CLOUDABI_RIGHT_FD_TELL, CAP_SEEK_TELL)                  \
  55         MAPPING(CLOUDABI_RIGHT_FD_WRITE, CAP_WRITE)                     \
  56         MAPPING(CLOUDABI_RIGHT_FILE_ADVISE)                             \
  57         MAPPING(CLOUDABI_RIGHT_FILE_ALLOCATE, CAP_WRITE)                \
  58         MAPPING(CLOUDABI_RIGHT_FILE_CREATE_DIRECTORY, CAP_MKDIRAT)      \
  59         MAPPING(CLOUDABI_RIGHT_FILE_CREATE_FILE, CAP_CREATE)            \
  60         MAPPING(CLOUDABI_RIGHT_FILE_LINK_SOURCE, CAP_LINKAT_SOURCE)     \
  61         MAPPING(CLOUDABI_RIGHT_FILE_LINK_TARGET, CAP_LINKAT_TARGET)     \
  62         MAPPING(CLOUDABI_RIGHT_FILE_OPEN, CAP_LOOKUP)                   \
  63         MAPPING(CLOUDABI_RIGHT_FILE_READDIR, CAP_READ)                  \
  64         MAPPING(CLOUDABI_RIGHT_FILE_READLINK, CAP_LOOKUP)               \
  65         MAPPING(CLOUDABI_RIGHT_FILE_RENAME_SOURCE, CAP_RENAMEAT_SOURCE) \
  66         MAPPING(CLOUDABI_RIGHT_FILE_RENAME_TARGET, CAP_RENAMEAT_TARGET) \
  67         MAPPING(CLOUDABI_RIGHT_FILE_STAT_FGET, CAP_FSTAT)               \
  68         MAPPING(CLOUDABI_RIGHT_FILE_STAT_FPUT_SIZE, CAP_FTRUNCATE)      \
  69         MAPPING(CLOUDABI_RIGHT_FILE_STAT_FPUT_TIMES, CAP_FUTIMES)       \
  70         MAPPING(CLOUDABI_RIGHT_FILE_STAT_GET, CAP_FSTATAT)              \
  71         MAPPING(CLOUDABI_RIGHT_FILE_STAT_PUT_TIMES, CAP_FUTIMESAT)      \
  72         MAPPING(CLOUDABI_RIGHT_FILE_SYMLINK, CAP_SYMLINKAT)             \
  73         MAPPING(CLOUDABI_RIGHT_FILE_UNLINK, CAP_UNLINKAT)               \
  74         MAPPING(CLOUDABI_RIGHT_MEM_MAP, CAP_MMAP)                       \
  75         MAPPING(CLOUDABI_RIGHT_MEM_MAP_EXEC, CAP_MMAP_X)                \
  76         MAPPING(CLOUDABI_RIGHT_POLL_FD_READWRITE, CAP_EVENT)            \
  77         MAPPING(CLOUDABI_RIGHT_POLL_PROC_TERMINATE, CAP_EVENT)          \
  78         MAPPING(CLOUDABI_RIGHT_PROC_EXEC, CAP_FEXECVE)                  \
  79         MAPPING(CLOUDABI_RIGHT_SOCK_SHUTDOWN, CAP_SHUTDOWN)             \
  80
  81 int
  82 cloudabi_sys_fd_close(struct thread *td, struct cloudabi_sys_fd_close_args *uap)
  83 {
  84
  85         return (kern_close(td, uap->fd));
  86 }
  87
  88 int
  89 cloudabi_sys_fd_create1(struct thread *td,
  90     struct cloudabi_sys_fd_create1_args *uap)
  91 {
  92         struct filecaps fcaps = {};
  93
  94         switch (uap->type) {
  95         case CLOUDABI_FILETYPE_SHARED_MEMORY:
  96                 cap_rights_init(&fcaps.fc_rights, CAP_FSTAT, CAP_FTRUNCATE,
  97                     CAP_MMAP_RWX);
  98                 return (kern_shm_open(td, SHM_ANON, O_RDWR | O_CLOEXEC, 0,
  99                     &fcaps));
 100         default:
 101                 return (EINVAL);
 102         }
 103 }
 104
 105 int
 106 cloudabi_sys_fd_create2(struct thread *td,
 107     struct cloudabi_sys_fd_create2_args *uap)
 108 {
 109         int fds[2];
 110         int error, type;
 111
 112         switch (uap->type) {
 113         case CLOUDABI_FILETYPE_SOCKET_DGRAM:
 114                 type = SOCK_DGRAM;
 115                 break;
 116         case CLOUDABI_FILETYPE_SOCKET_STREAM:
 117                 type = SOCK_STREAM;
 118                 break;
 119         default:
 120                 return (EINVAL);
 121         }
 122
 123         error = kern_socketpair(td, AF_UNIX, type, 0, fds);
 124         if (error == 0) {
 125                 td->td_retval[0] = fds[0];
 126                 td->td_retval[1] = fds[1];
 127         }
 128         return (0);
 129 }
 130
 131 int
 132 cloudabi_sys_fd_datasync(struct thread *td,
 133     struct cloudabi_sys_fd_datasync_args *uap)
 134 {
 135
 136         return (kern_fsync(td, uap->fd, false));
 137 }
 138
 139 int
 140 cloudabi_sys_fd_dup(struct thread *td, struct cloudabi_sys_fd_dup_args *uap)
 141 {
 142
 143         return (kern_dup(td, FDDUP_NORMAL, 0, uap->from, 0));
 144 }
 145
 146 int
 147 cloudabi_sys_fd_replace(struct thread *td,
 148     struct cloudabi_sys_fd_replace_args *uap)
 149 {
 150         int error;
 151
 152         /*
 153          * CloudABI's equivalent to dup2(). CloudABI processes should
 154          * not depend on hardcoded file descriptor layouts, but simply
 155          * use the file descriptor numbers that are allocated by the
 156          * kernel. Duplicating file descriptors to arbitrary numbers
 157          * should not be done.
 158          *
 159          * Invoke kern_dup() with FDDUP_MUSTREPLACE, so that we return
 160          * EBADF when duplicating to a nonexistent file descriptor. Also
 161          * clear the return value, as this system call yields no return
 162          * value.
 163          */
 164         error = kern_dup(td, FDDUP_MUSTREPLACE, 0, uap->from, uap->to);
 165         td->td_retval[0] = 0;
 166         return (error);
 167 }
 168
 169 int
 170 cloudabi_sys_fd_seek(struct thread *td, struct cloudabi_sys_fd_seek_args *uap)
 171 {
 172         int whence;
 173
 174         switch (uap->whence) {
 175         case CLOUDABI_WHENCE_CUR:
 176                 whence = SEEK_CUR;
 177                 break;
 178         case CLOUDABI_WHENCE_END:
 179                 whence = SEEK_END;
 180                 break;
 181         case CLOUDABI_WHENCE_SET:
 182                 whence = SEEK_SET;
 183                 break;
 184         default:
 185                 return (EINVAL);
 186         }
 187
 188         return (kern_lseek(td, uap->fd, uap->offset, whence));
 189 }
 190
 191 /* Converts a file descriptor to a CloudABI file descriptor type. */
 192 cloudabi_filetype_t
 193 cloudabi_convert_filetype(const struct file *fp)
 194 {
 195         struct socket *so;
 196         struct vnode *vp;
 197
 198         switch (fp->f_type) {
 199         case DTYPE_FIFO:
 200                 return (CLOUDABI_FILETYPE_SOCKET_STREAM);
 201         case DTYPE_PIPE:
 202                 return (CLOUDABI_FILETYPE_SOCKET_STREAM);
 203         case DTYPE_PROCDESC:
 204                 return (CLOUDABI_FILETYPE_PROCESS);
 205         case DTYPE_SHM:
 206                 return (CLOUDABI_FILETYPE_SHARED_MEMORY);
 207         case DTYPE_SOCKET:
 208                 so = fp->f_data;
 209                 switch (so->so_type) {
 210                 case SOCK_DGRAM:
 211                         return (CLOUDABI_FILETYPE_SOCKET_DGRAM);
 212                 case SOCK_STREAM:
 213                         return (CLOUDABI_FILETYPE_SOCKET_STREAM);
 214                 default:
 215                         return (CLOUDABI_FILETYPE_UNKNOWN);
 216                 }
 217         case DTYPE_VNODE:
 218                 vp = fp->f_vnode;
 219                 switch (vp->v_type) {
 220                 case VBLK:
 221                         return (CLOUDABI_FILETYPE_BLOCK_DEVICE);
 222                 case VCHR:
 223                         return (CLOUDABI_FILETYPE_CHARACTER_DEVICE);
 224                 case VDIR:
 225                         return (CLOUDABI_FILETYPE_DIRECTORY);
 226                 case VFIFO:
 227                         return (CLOUDABI_FILETYPE_SOCKET_STREAM);
 228                 case VLNK:
 229                         return (CLOUDABI_FILETYPE_SYMBOLIC_LINK);
 230                 case VREG:
 231                         return (CLOUDABI_FILETYPE_REGULAR_FILE);
 232                 case VSOCK:
 233                         return (CLOUDABI_FILETYPE_SOCKET_STREAM);
 234                 default:
 235                         return (CLOUDABI_FILETYPE_UNKNOWN);
 236                 }
 237         default:
 238                 return (CLOUDABI_FILETYPE_UNKNOWN);
 239         }
 240 }
 241
 242 /* Removes rights that conflict with the file descriptor type. */
 243 void
 244 cloudabi_remove_conflicting_rights(cloudabi_filetype_t filetype,
 245     cloudabi_rights_t *base, cloudabi_rights_t *inheriting)
 246 {
 247
 248         /*
 249          * CloudABI has a small number of additional rights bits to
 250          * disambiguate between multiple purposes. Remove the bits that
 251          * don't apply to the type of the file descriptor.
 252          *
 253          * As file descriptor access modes (O_ACCMODE) has been fully
 254          * replaced by rights bits, CloudABI distinguishes between
 255          * rights that apply to the file descriptor itself (base) versus
 256          * rights of new file descriptors derived from them
 257          * (inheriting). The code below approximates the pair by
 258          * decomposing depending on the file descriptor type.
 259          *
 260          * We need to be somewhat accurate about which actions can
 261          * actually be performed on the file descriptor, as functions
 262          * like fcntl(fd, F_GETFL) are emulated on top of this.
 263          */
 264         switch (filetype) {
 265         case CLOUDABI_FILETYPE_DIRECTORY:
 266                 *base &= CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS |
 267                     CLOUDABI_RIGHT_FD_SYNC | CLOUDABI_RIGHT_FILE_ADVISE |
 268                     CLOUDABI_RIGHT_FILE_CREATE_DIRECTORY |
 269                     CLOUDABI_RIGHT_FILE_CREATE_FILE |
 270                     CLOUDABI_RIGHT_FILE_LINK_SOURCE |
 271                     CLOUDABI_RIGHT_FILE_LINK_TARGET |
 272                     CLOUDABI_RIGHT_FILE_OPEN |
 273                     CLOUDABI_RIGHT_FILE_READDIR |
 274                     CLOUDABI_RIGHT_FILE_READLINK |
 275                     CLOUDABI_RIGHT_FILE_RENAME_SOURCE |
 276                     CLOUDABI_RIGHT_FILE_RENAME_TARGET |
 277                     CLOUDABI_RIGHT_FILE_STAT_FGET |
 278                     CLOUDABI_RIGHT_FILE_STAT_FPUT_TIMES |
 279                     CLOUDABI_RIGHT_FILE_STAT_GET |
 280                     CLOUDABI_RIGHT_FILE_STAT_PUT_TIMES |
 281                     CLOUDABI_RIGHT_FILE_SYMLINK |
 282                     CLOUDABI_RIGHT_FILE_UNLINK |
 283                     CLOUDABI_RIGHT_POLL_FD_READWRITE;
 284                 *inheriting &= CLOUDABI_RIGHT_FD_DATASYNC |
 285                     CLOUDABI_RIGHT_FD_READ |
 286                     CLOUDABI_RIGHT_FD_SEEK |
 287                     CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS |
 288                     CLOUDABI_RIGHT_FD_SYNC |
 289                     CLOUDABI_RIGHT_FD_TELL |
 290                     CLOUDABI_RIGHT_FD_WRITE |
 291                     CLOUDABI_RIGHT_FILE_ADVISE |
 292                     CLOUDABI_RIGHT_FILE_ALLOCATE |
 293                     CLOUDABI_RIGHT_FILE_CREATE_DIRECTORY |
 294                     CLOUDABI_RIGHT_FILE_CREATE_FILE |
 295                     CLOUDABI_RIGHT_FILE_LINK_SOURCE |
 296                     CLOUDABI_RIGHT_FILE_LINK_TARGET |
 297                     CLOUDABI_RIGHT_FILE_OPEN |
 298                     CLOUDABI_RIGHT_FILE_READDIR |
 299                     CLOUDABI_RIGHT_FILE_READLINK |
 300                     CLOUDABI_RIGHT_FILE_RENAME_SOURCE |
 301                     CLOUDABI_RIGHT_FILE_RENAME_TARGET |
 302                     CLOUDABI_RIGHT_FILE_STAT_FGET |
 303                     CLOUDABI_RIGHT_FILE_STAT_FPUT_SIZE |
 304                     CLOUDABI_RIGHT_FILE_STAT_FPUT_TIMES |
 305                     CLOUDABI_RIGHT_FILE_STAT_GET |
 306                     CLOUDABI_RIGHT_FILE_STAT_PUT_TIMES |
 307                     CLOUDABI_RIGHT_FILE_SYMLINK |
 308                     CLOUDABI_RIGHT_FILE_UNLINK |
 309                     CLOUDABI_RIGHT_MEM_MAP |
 310                     CLOUDABI_RIGHT_MEM_MAP_EXEC |
 311                     CLOUDABI_RIGHT_POLL_FD_READWRITE |
 312                     CLOUDABI_RIGHT_PROC_EXEC;
 313                 break;
 314         case CLOUDABI_FILETYPE_PROCESS:
 315                 *base &= ~(CLOUDABI_RIGHT_FILE_ADVISE |
 316                     CLOUDABI_RIGHT_POLL_FD_READWRITE);
 317                 *inheriting = 0;
 318                 break;
 319         case CLOUDABI_FILETYPE_REGULAR_FILE:
 320                 *base &= CLOUDABI_RIGHT_FD_DATASYNC |
 321                     CLOUDABI_RIGHT_FD_READ |
 322                     CLOUDABI_RIGHT_FD_SEEK |
 323                     CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS |
 324                     CLOUDABI_RIGHT_FD_SYNC |
 325                     CLOUDABI_RIGHT_FD_TELL |
 326                     CLOUDABI_RIGHT_FD_WRITE |
 327                     CLOUDABI_RIGHT_FILE_ADVISE |
 328                     CLOUDABI_RIGHT_FILE_ALLOCATE |
 329                     CLOUDABI_RIGHT_FILE_STAT_FGET |
 330                     CLOUDABI_RIGHT_FILE_STAT_FPUT_SIZE |
 331                     CLOUDABI_RIGHT_FILE_STAT_FPUT_TIMES |
 332                     CLOUDABI_RIGHT_MEM_MAP |
 333                     CLOUDABI_RIGHT_MEM_MAP_EXEC |
 334                     CLOUDABI_RIGHT_POLL_FD_READWRITE |
 335                     CLOUDABI_RIGHT_PROC_EXEC;
 336                 *inheriting = 0;
 337                 break;
 338         case CLOUDABI_FILETYPE_SHARED_MEMORY:
 339                 *base &= ~(CLOUDABI_RIGHT_FD_SEEK |
 340                     CLOUDABI_RIGHT_FD_TELL |
 341                     CLOUDABI_RIGHT_FILE_ADVISE |
 342                     CLOUDABI_RIGHT_FILE_ALLOCATE |
 343                     CLOUDABI_RIGHT_FILE_READDIR);
 344                 *inheriting = 0;
 345                 break;
 346         case CLOUDABI_FILETYPE_SOCKET_DGRAM:
 347         case CLOUDABI_FILETYPE_SOCKET_STREAM:
 348                 *base &= CLOUDABI_RIGHT_FD_READ |
 349                     CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS |
 350                     CLOUDABI_RIGHT_FD_WRITE |
 351                     CLOUDABI_RIGHT_FILE_STAT_FGET |
 352                     CLOUDABI_RIGHT_POLL_FD_READWRITE |
 353                     CLOUDABI_RIGHT_SOCK_SHUTDOWN;
 354                 break;
 355         default:
 356                 *inheriting = 0;
 357                 break;
 358         }
 359 }
 360
 361 /* Converts FreeBSD's Capsicum rights to CloudABI's set of rights. */
 362 static void
 363 convert_capabilities(const cap_rights_t *capabilities,
 364     cloudabi_filetype_t filetype, cloudabi_rights_t *base,
 365     cloudabi_rights_t *inheriting)
 366 {
 367         cloudabi_rights_t rights;
 368
 369         /* Convert FreeBSD bits to CloudABI bits. */
 370         rights = 0;
 371 #define MAPPING(cloudabi, ...) do {                             \
 372         if (cap_rights_is_set(capabilities, ##__VA_ARGS__))     \
 373                 rights |= (cloudabi);                           \
 374 } while (0);
 375         RIGHTS_MAPPINGS
 376 #undef MAPPING
 377
 378         *base = rights;
 379         *inheriting = rights;
 380         cloudabi_remove_conflicting_rights(filetype, base, inheriting);
 381 }
 382
 383 int
 384 cloudabi_sys_fd_stat_get(struct thread *td,
 385     struct cloudabi_sys_fd_stat_get_args *uap)
 386 {
 387         cloudabi_fdstat_t fsb = {0};
 388         struct file *fp;
 389         cap_rights_t rights;
 390         struct filecaps fcaps;
 391         int error, oflags;
 392
 393         /* Obtain file descriptor properties. */
 394         error = fget_cap(td, uap->fd, cap_rights_init(&rights), &fp,
 395             &fcaps);
 396         if (error != 0)
 397                 return (error);
 398         oflags = OFLAGS(fp->f_flag);
 399         fsb.fs_filetype = cloudabi_convert_filetype(fp);
 400         fdrop(fp, td);
 401
 402         /* Convert file descriptor flags. */
 403         if (oflags & O_APPEND)
 404                 fsb.fs_flags |= CLOUDABI_FDFLAG_APPEND;
 405         if (oflags & O_NONBLOCK)
 406                 fsb.fs_flags |= CLOUDABI_FDFLAG_NONBLOCK;
 407         if (oflags & O_SYNC)
 408                 fsb.fs_flags |= CLOUDABI_FDFLAG_SYNC;
 409
 410         /* Convert capabilities to CloudABI rights. */
 411         convert_capabilities(&fcaps.fc_rights, fsb.fs_filetype,
 412             &fsb.fs_rights_base, &fsb.fs_rights_inheriting);
 413         filecaps_free(&fcaps);
 414         return (copyout(&fsb, (void *)uap->buf, sizeof(fsb)));
 415 }
 416
 417 /* Converts CloudABI rights to a set of Capsicum capabilities. */
 418 int
 419 cloudabi_convert_rights(cloudabi_rights_t in, cap_rights_t *out)
 420 {
 421
 422         cap_rights_init(out);
 423 #define MAPPING(cloudabi, ...) do {                     \
 424         if (in & (cloudabi)) {                          \
 425                 cap_rights_set(out, ##__VA_ARGS__);     \
 426                 in &= ~(cloudabi);                      \
 427         }                                               \
 428 } while (0);
 429         RIGHTS_MAPPINGS
 430 #undef MAPPING
 431         if (in != 0)
 432                 return (ENOTCAPABLE);
 433         return (0);
 434 }
 435
 436 int
 437 cloudabi_sys_fd_stat_put(struct thread *td,
 438     struct cloudabi_sys_fd_stat_put_args *uap)
 439 {
 440         cloudabi_fdstat_t fsb;
 441         cap_rights_t rights;
 442         int error, oflags;
 443
 444         error = copyin(uap->buf, &fsb, sizeof(fsb));
 445         if (error != 0)
 446                 return (error);
 447
 448         if (uap->flags == CLOUDABI_FDSTAT_FLAGS) {
 449                 /* Convert flags. */
 450                 oflags = 0;
 451                 if (fsb.fs_flags & CLOUDABI_FDFLAG_APPEND)
 452                         oflags |= O_APPEND;
 453                 if (fsb.fs_flags & CLOUDABI_FDFLAG_NONBLOCK)
 454                         oflags |= O_NONBLOCK;
 455                 if (fsb.fs_flags & (CLOUDABI_FDFLAG_SYNC |
 456                     CLOUDABI_FDFLAG_DSYNC | CLOUDABI_FDFLAG_RSYNC))
 457                         oflags |= O_SYNC;
 458                 return (kern_fcntl(td, uap->fd, F_SETFL, oflags));
 459         } else if (uap->flags == CLOUDABI_FDSTAT_RIGHTS) {
 460                 /* Convert rights. */
 461                 error = cloudabi_convert_rights(
 462                     fsb.fs_rights_base | fsb.fs_rights_inheriting, &rights);
 463                 if (error != 0)
 464                         return (error);
 465                 return (kern_cap_rights_limit(td, uap->fd, &rights));
 466         }
 467         return (EINVAL);
 468 }
 469
 470 int
 471 cloudabi_sys_fd_sync(struct thread *td, struct cloudabi_sys_fd_sync_args *uap)
 472 {
 473
 474         return (kern_fsync(td, uap->fd, true));
 475 }