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/filedesc.h>
  32 #include <sys/proc.h>
  33 #include <sys/mman.h>
  34 #include <sys/socketvar.h>
  35 #include <sys/syscallsubr.h>
  36 #include <sys/sysproto.h>
  37 #include <sys/systm.h>
  38 #include <sys/unistd.h>
  39 #include <sys/vnode.h>
  40
  41 #include <contrib/cloudabi/cloudabi_types_common.h>
  42
  43 #include <compat/cloudabi/cloudabi_proto.h>
  44 #include <compat/cloudabi/cloudabi_util.h>
  45
  46 /* Translation between CloudABI and Capsicum rights. */
  47 #define RIGHTS_MAPPINGS \
  48         MAPPING(CLOUDABI_RIGHT_FD_DATASYNC, CAP_FSYNC)                  \
  49         MAPPING(CLOUDABI_RIGHT_FD_READ, CAP_READ)                       \
  50         MAPPING(CLOUDABI_RIGHT_FD_SEEK, CAP_SEEK)                       \
  51         MAPPING(CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS, CAP_FCNTL)            \
  52         MAPPING(CLOUDABI_RIGHT_FD_SYNC, CAP_FSYNC)                      \
  53         MAPPING(CLOUDABI_RIGHT_FD_TELL, CAP_SEEK_TELL)                  \
  54         MAPPING(CLOUDABI_RIGHT_FD_WRITE, CAP_WRITE)                     \
  55         MAPPING(CLOUDABI_RIGHT_FILE_ADVISE)                             \
  56         MAPPING(CLOUDABI_RIGHT_FILE_ALLOCATE, CAP_WRITE)                \
  57         MAPPING(CLOUDABI_RIGHT_FILE_CREATE_DIRECTORY, CAP_MKDIRAT)      \
  58         MAPPING(CLOUDABI_RIGHT_FILE_CREATE_FILE, CAP_CREATE)            \
  59         MAPPING(CLOUDABI_RIGHT_FILE_CREATE_FIFO, CAP_MKFIFOAT)          \
  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_MODIFY, CAP_KQUEUE_CHANGE)          \
  78         MAPPING(CLOUDABI_RIGHT_POLL_PROC_TERMINATE, CAP_EVENT)          \
  79         MAPPING(CLOUDABI_RIGHT_POLL_WAIT, CAP_KQUEUE_EVENT)             \
  80         MAPPING(CLOUDABI_RIGHT_PROC_EXEC, CAP_FEXECVE)                  \
  81         MAPPING(CLOUDABI_RIGHT_SOCK_ACCEPT, CAP_ACCEPT)                 \
  82         MAPPING(CLOUDABI_RIGHT_SOCK_BIND_DIRECTORY, CAP_BINDAT)         \
  83         MAPPING(CLOUDABI_RIGHT_SOCK_BIND_SOCKET, CAP_BIND)              \
  84         MAPPING(CLOUDABI_RIGHT_SOCK_CONNECT_DIRECTORY, CAP_CONNECTAT)   \
  85         MAPPING(CLOUDABI_RIGHT_SOCK_CONNECT_SOCKET, CAP_CONNECT)        \
  86         MAPPING(CLOUDABI_RIGHT_SOCK_LISTEN, CAP_LISTEN)                 \
  87         MAPPING(CLOUDABI_RIGHT_SOCK_SHUTDOWN, CAP_SHUTDOWN)             \
  88         MAPPING(CLOUDABI_RIGHT_SOCK_STAT_GET, CAP_GETPEERNAME,          \
  89             CAP_GETSOCKNAME, CAP_GETSOCKOPT)
  90
  91 int
  92 cloudabi_sys_fd_close(struct thread *td, struct cloudabi_sys_fd_close_args *uap)
  93 {
  94
  95         return (kern_close(td, uap->fd));
  96 }
  97
  98 int
  99 cloudabi_sys_fd_create1(struct thread *td,
 100     struct cloudabi_sys_fd_create1_args *uap)
 101 {
 102         struct filecaps fcaps = {};
 103
 104         switch (uap->type) {
 105         case CLOUDABI_FILETYPE_POLL:
 106                 cap_rights_init(&fcaps.fc_rights, CAP_FSTAT, CAP_KQUEUE);
 107                 return (kern_kqueue(td, 0, &fcaps));
 108         case CLOUDABI_FILETYPE_SHARED_MEMORY:
 109                 cap_rights_init(&fcaps.fc_rights, CAP_FSTAT, CAP_FTRUNCATE,
 110                     CAP_MMAP_RWX);
 111                 return (kern_shm_open(td, SHM_ANON, O_RDWR, 0, &fcaps));
 112         case CLOUDABI_FILETYPE_SOCKET_DGRAM:
 113                 return (kern_socket(td, AF_UNIX, SOCK_DGRAM, 0));
 114         case CLOUDABI_FILETYPE_SOCKET_STREAM:
 115                 return (kern_socket(td, AF_UNIX, SOCK_STREAM, 0));
 116         default:
 117                 return (EINVAL);
 118         }
 119 }
 120
 121 int
 122 cloudabi_sys_fd_create2(struct thread *td,
 123     struct cloudabi_sys_fd_create2_args *uap)
 124 {
 125         struct filecaps fcaps1 = {}, fcaps2 = {};
 126         int fds[2];
 127         int error;
 128
 129         switch (uap->type) {
 130         case CLOUDABI_FILETYPE_FIFO:
 131                 /*
 132                  * CloudABI pipes are unidirectional. Restrict rights on
 133                  * the pipe to simulate this.
 134                  */
 135                 cap_rights_init(&fcaps1.fc_rights, CAP_EVENT, CAP_FCNTL,
 136                     CAP_FSTAT, CAP_READ);
 137                 fcaps1.fc_fcntls = CAP_FCNTL_SETFL;
 138                 cap_rights_init(&fcaps2.fc_rights, CAP_EVENT, CAP_FCNTL,
 139                     CAP_FSTAT, CAP_WRITE);
 140                 fcaps2.fc_fcntls = CAP_FCNTL_SETFL;
 141                 error = kern_pipe(td, fds, 0, &fcaps1, &fcaps2);
 142                 break;
 143         case CLOUDABI_FILETYPE_SOCKET_DGRAM:
 144                 error = kern_socketpair(td, AF_UNIX, SOCK_DGRAM, 0, fds);
 145                 break;
 146         case CLOUDABI_FILETYPE_SOCKET_STREAM:
 147                 error = kern_socketpair(td, AF_UNIX, SOCK_STREAM, 0, fds);
 148                 break;
 149         default:
 150                 return (EINVAL);
 151         }
 152
 153         if (error == 0) {
 154                 td->td_retval[0] = fds[0];
 155                 td->td_retval[1] = fds[1];
 156         }
 157         return (0);
 158 }
 159
 160 int
 161 cloudabi_sys_fd_datasync(struct thread *td,
 162     struct cloudabi_sys_fd_datasync_args *uap)
 163 {
 164
 165         return (kern_fsync(td, uap->fd, false));
 166 }
 167
 168 int
 169 cloudabi_sys_fd_dup(struct thread *td, struct cloudabi_sys_fd_dup_args *uap)
 170 {
 171
 172         return (kern_dup(td, FDDUP_NORMAL, 0, uap->from, 0));
 173 }
 174
 175 int
 176 cloudabi_sys_fd_replace(struct thread *td,
 177     struct cloudabi_sys_fd_replace_args *uap)
 178 {
 179         int error;
 180
 181         /*
 182          * CloudABI's equivalent to dup2(). CloudABI processes should
 183          * not depend on hardcoded file descriptor layouts, but simply
 184          * use the file descriptor numbers that are allocated by the
 185          * kernel. Duplicating file descriptors to arbitrary numbers
 186          * should not be done.
 187          *
 188          * Invoke kern_dup() with FDDUP_MUSTREPLACE, so that we return
 189          * EBADF when duplicating to a nonexistent file descriptor. Also
 190          * clear the return value, as this system call yields no return
 191          * value.
 192          */
 193         error = kern_dup(td, FDDUP_MUSTREPLACE, 0, uap->from, uap->to);
 194         td->td_retval[0] = 0;
 195         return (error);
 196 }
 197
 198 int
 199 cloudabi_sys_fd_seek(struct thread *td, struct cloudabi_sys_fd_seek_args *uap)
 200 {
 201         int whence;
 202
 203         switch (uap->whence) {
 204         case CLOUDABI_WHENCE_CUR:
 205                 whence = SEEK_CUR;
 206                 break;
 207         case CLOUDABI_WHENCE_END:
 208                 whence = SEEK_END;
 209                 break;
 210         case CLOUDABI_WHENCE_SET:
 211                 whence = SEEK_SET;
 212                 break;
 213         default:
 214                 return (EINVAL);
 215         }
 216
 217         return (kern_lseek(td, uap->fd, uap->offset, whence));
 218 }
 219
 220 /* Converts a file descriptor to a CloudABI file descriptor type. */
 221 cloudabi_filetype_t
 222 cloudabi_convert_filetype(const struct file *fp)
 223 {
 224         struct socket *so;
 225         struct vnode *vp;
 226
 227         switch (fp->f_type) {
 228         case DTYPE_FIFO:
 229                 return (CLOUDABI_FILETYPE_FIFO);
 230         case DTYPE_KQUEUE:
 231                 return (CLOUDABI_FILETYPE_POLL);
 232         case DTYPE_PIPE:
 233                 return (CLOUDABI_FILETYPE_FIFO);
 234         case DTYPE_PROCDESC:
 235                 return (CLOUDABI_FILETYPE_PROCESS);
 236         case DTYPE_SHM:
 237                 return (CLOUDABI_FILETYPE_SHARED_MEMORY);
 238         case DTYPE_SOCKET:
 239                 so = fp->f_data;
 240                 switch (so->so_type) {
 241                 case SOCK_DGRAM:
 242                         return (CLOUDABI_FILETYPE_SOCKET_DGRAM);
 243                 case SOCK_STREAM:
 244                         return (CLOUDABI_FILETYPE_SOCKET_STREAM);
 245                 default:
 246                         return (CLOUDABI_FILETYPE_UNKNOWN);
 247                 }
 248         case DTYPE_VNODE:
 249                 vp = fp->f_vnode;
 250                 switch (vp->v_type) {
 251                 case VBLK:
 252                         return (CLOUDABI_FILETYPE_BLOCK_DEVICE);
 253                 case VCHR:
 254                         return (CLOUDABI_FILETYPE_CHARACTER_DEVICE);
 255                 case VDIR:
 256                         return (CLOUDABI_FILETYPE_DIRECTORY);
 257                 case VFIFO:
 258                         return (CLOUDABI_FILETYPE_FIFO);
 259                 case VLNK:
 260                         return (CLOUDABI_FILETYPE_SYMBOLIC_LINK);
 261                 case VREG:
 262                         return (CLOUDABI_FILETYPE_REGULAR_FILE);
 263                 case VSOCK:
 264                         return (CLOUDABI_FILETYPE_SOCKET_STREAM);
 265                 default:
 266                         return (CLOUDABI_FILETYPE_UNKNOWN);
 267                 }
 268         default:
 269                 return (CLOUDABI_FILETYPE_UNKNOWN);
 270         }
 271 }
 272
 273 /* Removes rights that conflict with the file descriptor type. */
 274 void
 275 cloudabi_remove_conflicting_rights(cloudabi_filetype_t filetype,
 276     cloudabi_rights_t *base, cloudabi_rights_t *inheriting)
 277 {
 278
 279         /*
 280          * CloudABI has a small number of additional rights bits to
 281          * disambiguate between multiple purposes. Remove the bits that
 282          * don't apply to the type of the file descriptor.
 283          *
 284          * As file descriptor access modes (O_ACCMODE) has been fully
 285          * replaced by rights bits, CloudABI distinguishes between
 286          * rights that apply to the file descriptor itself (base) versus
 287          * rights of new file descriptors derived from them
 288          * (inheriting). The code below approximates the pair by
 289          * decomposing depending on the file descriptor type.
 290          *
 291          * We need to be somewhat accurate about which actions can
 292          * actually be performed on the file descriptor, as functions
 293          * like fcntl(fd, F_GETFL) are emulated on top of this.
 294          */
 295         switch (filetype) {
 296         case CLOUDABI_FILETYPE_DIRECTORY:
 297                 *base &= CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS |
 298                     CLOUDABI_RIGHT_FD_SYNC | CLOUDABI_RIGHT_FILE_ADVISE |
 299                     CLOUDABI_RIGHT_FILE_CREATE_DIRECTORY |
 300                     CLOUDABI_RIGHT_FILE_CREATE_FILE |
 301                     CLOUDABI_RIGHT_FILE_CREATE_FIFO |
 302                     CLOUDABI_RIGHT_FILE_LINK_SOURCE |
 303                     CLOUDABI_RIGHT_FILE_LINK_TARGET |
 304                     CLOUDABI_RIGHT_FILE_OPEN |
 305                     CLOUDABI_RIGHT_FILE_READDIR |
 306                     CLOUDABI_RIGHT_FILE_READLINK |
 307                     CLOUDABI_RIGHT_FILE_RENAME_SOURCE |
 308                     CLOUDABI_RIGHT_FILE_RENAME_TARGET |
 309                     CLOUDABI_RIGHT_FILE_STAT_FGET |
 310                     CLOUDABI_RIGHT_FILE_STAT_FPUT_TIMES |
 311                     CLOUDABI_RIGHT_FILE_STAT_GET |
 312                     CLOUDABI_RIGHT_FILE_STAT_PUT_TIMES |
 313                     CLOUDABI_RIGHT_FILE_SYMLINK |
 314                     CLOUDABI_RIGHT_FILE_UNLINK |
 315                     CLOUDABI_RIGHT_POLL_FD_READWRITE |
 316                     CLOUDABI_RIGHT_SOCK_BIND_DIRECTORY |
 317                     CLOUDABI_RIGHT_SOCK_CONNECT_DIRECTORY;
 318                 *inheriting &= CLOUDABI_RIGHT_FD_DATASYNC |
 319                     CLOUDABI_RIGHT_FD_READ |
 320                     CLOUDABI_RIGHT_FD_SEEK |
 321                     CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS |
 322                     CLOUDABI_RIGHT_FD_SYNC |
 323                     CLOUDABI_RIGHT_FD_TELL |
 324                     CLOUDABI_RIGHT_FD_WRITE |
 325                     CLOUDABI_RIGHT_FILE_ADVISE |
 326                     CLOUDABI_RIGHT_FILE_ALLOCATE |
 327                     CLOUDABI_RIGHT_FILE_CREATE_DIRECTORY |
 328                     CLOUDABI_RIGHT_FILE_CREATE_FILE |
 329                     CLOUDABI_RIGHT_FILE_CREATE_FIFO |
 330                     CLOUDABI_RIGHT_FILE_LINK_SOURCE |
 331                     CLOUDABI_RIGHT_FILE_LINK_TARGET |
 332                     CLOUDABI_RIGHT_FILE_OPEN |
 333                     CLOUDABI_RIGHT_FILE_READDIR |
 334                     CLOUDABI_RIGHT_FILE_READLINK |
 335                     CLOUDABI_RIGHT_FILE_RENAME_SOURCE |
 336                     CLOUDABI_RIGHT_FILE_RENAME_TARGET |
 337                     CLOUDABI_RIGHT_FILE_STAT_FGET |
 338                     CLOUDABI_RIGHT_FILE_STAT_FPUT_SIZE |
 339                     CLOUDABI_RIGHT_FILE_STAT_FPUT_TIMES |
 340                     CLOUDABI_RIGHT_FILE_STAT_GET |
 341                     CLOUDABI_RIGHT_FILE_STAT_PUT_TIMES |
 342                     CLOUDABI_RIGHT_FILE_SYMLINK |
 343                     CLOUDABI_RIGHT_FILE_UNLINK |
 344                     CLOUDABI_RIGHT_MEM_MAP |
 345                     CLOUDABI_RIGHT_MEM_MAP_EXEC |
 346                     CLOUDABI_RIGHT_POLL_FD_READWRITE |
 347                     CLOUDABI_RIGHT_PROC_EXEC |
 348                     CLOUDABI_RIGHT_SOCK_BIND_DIRECTORY |
 349                     CLOUDABI_RIGHT_SOCK_CONNECT_DIRECTORY;
 350                 break;
 351         case CLOUDABI_FILETYPE_FIFO:
 352                 *base &= CLOUDABI_RIGHT_FD_READ |
 353                     CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS |
 354                     CLOUDABI_RIGHT_FD_WRITE |
 355                     CLOUDABI_RIGHT_FILE_STAT_FGET |
 356                     CLOUDABI_RIGHT_POLL_FD_READWRITE;
 357                 *inheriting = 0;
 358                 break;
 359         case CLOUDABI_FILETYPE_POLL:
 360                 *base &= ~CLOUDABI_RIGHT_FILE_ADVISE;
 361                 *inheriting = 0;
 362                 break;
 363         case CLOUDABI_FILETYPE_PROCESS:
 364                 *base &= ~(CLOUDABI_RIGHT_FILE_ADVISE |
 365                     CLOUDABI_RIGHT_POLL_FD_READWRITE);
 366                 *inheriting = 0;
 367                 break;
 368         case CLOUDABI_FILETYPE_REGULAR_FILE:
 369                 *base &= CLOUDABI_RIGHT_FD_DATASYNC |
 370                     CLOUDABI_RIGHT_FD_READ |
 371                     CLOUDABI_RIGHT_FD_SEEK |
 372                     CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS |
 373                     CLOUDABI_RIGHT_FD_SYNC |
 374                     CLOUDABI_RIGHT_FD_TELL |
 375                     CLOUDABI_RIGHT_FD_WRITE |
 376                     CLOUDABI_RIGHT_FILE_ADVISE |
 377                     CLOUDABI_RIGHT_FILE_ALLOCATE |
 378                     CLOUDABI_RIGHT_FILE_STAT_FGET |
 379                     CLOUDABI_RIGHT_FILE_STAT_FPUT_SIZE |
 380                     CLOUDABI_RIGHT_FILE_STAT_FPUT_TIMES |
 381                     CLOUDABI_RIGHT_MEM_MAP |
 382                     CLOUDABI_RIGHT_MEM_MAP_EXEC |
 383                     CLOUDABI_RIGHT_POLL_FD_READWRITE |
 384                     CLOUDABI_RIGHT_PROC_EXEC;
 385                 *inheriting = 0;
 386                 break;
 387         case CLOUDABI_FILETYPE_SHARED_MEMORY:
 388                 *base &= ~(CLOUDABI_RIGHT_FD_SEEK |
 389                     CLOUDABI_RIGHT_FD_TELL |
 390                     CLOUDABI_RIGHT_FILE_ADVISE |
 391                     CLOUDABI_RIGHT_FILE_ALLOCATE |
 392                     CLOUDABI_RIGHT_FILE_READDIR);
 393                 *inheriting = 0;
 394                 break;
 395         case CLOUDABI_FILETYPE_SOCKET_DGRAM:
 396         case CLOUDABI_FILETYPE_SOCKET_STREAM:
 397                 *base &= CLOUDABI_RIGHT_FD_READ |
 398                     CLOUDABI_RIGHT_FD_STAT_PUT_FLAGS |
 399                     CLOUDABI_RIGHT_FD_WRITE |
 400                     CLOUDABI_RIGHT_FILE_STAT_FGET |
 401                     CLOUDABI_RIGHT_POLL_FD_READWRITE |
 402                     CLOUDABI_RIGHT_SOCK_ACCEPT |
 403                     CLOUDABI_RIGHT_SOCK_BIND_SOCKET |
 404                     CLOUDABI_RIGHT_SOCK_CONNECT_SOCKET |
 405                     CLOUDABI_RIGHT_SOCK_LISTEN |
 406                     CLOUDABI_RIGHT_SOCK_SHUTDOWN |
 407                     CLOUDABI_RIGHT_SOCK_STAT_GET;
 408                 break;
 409         default:
 410                 *inheriting = 0;
 411                 break;
 412         }
 413 }
 414
 415 /* Converts FreeBSD's Capsicum rights to CloudABI's set of rights. */
 416 static void
 417 convert_capabilities(const cap_rights_t *capabilities,
 418     cloudabi_filetype_t filetype, cloudabi_rights_t *base,
 419     cloudabi_rights_t *inheriting)
 420 {
 421         cloudabi_rights_t rights;
 422
 423         /* Convert FreeBSD bits to CloudABI bits. */
 424         rights = 0;
 425 #define MAPPING(cloudabi, ...) do {                             \
 426         if (cap_rights_is_set(capabilities, ##__VA_ARGS__))     \
 427                 rights |= (cloudabi);                           \
 428 } while (0);
 429         RIGHTS_MAPPINGS
 430 #undef MAPPING
 431
 432         *base = rights;
 433         *inheriting = rights;
 434         cloudabi_remove_conflicting_rights(filetype, base, inheriting);
 435 }
 436
 437 int
 438 cloudabi_sys_fd_stat_get(struct thread *td,
 439     struct cloudabi_sys_fd_stat_get_args *uap)
 440 {
 441         cloudabi_fdstat_t fsb = {};
 442         struct file *fp;
 443         cap_rights_t rights;
 444         struct filecaps fcaps;
 445         int error, oflags;
 446
 447         /* Obtain file descriptor properties. */
 448         error = fget_cap(td, uap->fd, cap_rights_init(&rights), &fp,
 449             &fcaps);
 450         if (error != 0)
 451                 return (error);
 452         oflags = OFLAGS(fp->f_flag);
 453         fsb.fs_filetype = cloudabi_convert_filetype(fp);
 454         fdrop(fp, td);
 455
 456         /* Convert file descriptor flags. */
 457         if (oflags & O_APPEND)
 458                 fsb.fs_flags |= CLOUDABI_FDFLAG_APPEND;
 459         if (oflags & O_NONBLOCK)
 460                 fsb.fs_flags |= CLOUDABI_FDFLAG_NONBLOCK;
 461         if (oflags & O_SYNC)
 462                 fsb.fs_flags |= CLOUDABI_FDFLAG_SYNC;
 463
 464         /* Convert capabilities to CloudABI rights. */
 465         convert_capabilities(&fcaps.fc_rights, fsb.fs_filetype,
 466             &fsb.fs_rights_base, &fsb.fs_rights_inheriting);
 467         filecaps_free(&fcaps);
 468         return (copyout(&fsb, (void *)uap->buf, sizeof(fsb)));
 469 }
 470
 471 /* Converts CloudABI rights to a set of Capsicum capabilities. */
 472 int
 473 cloudabi_convert_rights(cloudabi_rights_t in, cap_rights_t *out)
 474 {
 475
 476         cap_rights_init(out);
 477 #define MAPPING(cloudabi, ...) do {                     \
 478         if (in & (cloudabi)) {                          \
 479                 cap_rights_set(out, ##__VA_ARGS__);     \
 480                 in &= ~(cloudabi);                      \
 481         }                                               \
 482 } while (0);
 483         RIGHTS_MAPPINGS
 484 #undef MAPPING
 485         if (in != 0)
 486                 return (ENOTCAPABLE);
 487         return (0);
 488 }
 489
 490 int
 491 cloudabi_sys_fd_stat_put(struct thread *td,
 492     struct cloudabi_sys_fd_stat_put_args *uap)
 493 {
 494         cloudabi_fdstat_t fsb;
 495         cap_rights_t rights;
 496         int error, oflags;
 497
 498         error = copyin(uap->buf, &fsb, sizeof(fsb));
 499         if (error != 0)
 500                 return (error);
 501
 502         if (uap->flags == CLOUDABI_FDSTAT_FLAGS) {
 503                 /* Convert flags. */
 504                 oflags = 0;
 505                 if (fsb.fs_flags & CLOUDABI_FDFLAG_APPEND)
 506                         oflags |= O_APPEND;
 507                 if (fsb.fs_flags & CLOUDABI_FDFLAG_NONBLOCK)
 508                         oflags |= O_NONBLOCK;
 509                 if (fsb.fs_flags & (CLOUDABI_FDFLAG_SYNC |
 510                     CLOUDABI_FDFLAG_DSYNC | CLOUDABI_FDFLAG_RSYNC))
 511                         oflags |= O_SYNC;
 512                 return (kern_fcntl(td, uap->fd, F_SETFL, oflags));
 513         } else if (uap->flags == CLOUDABI_FDSTAT_RIGHTS) {
 514                 /* Convert rights. */
 515                 error = cloudabi_convert_rights(
 516                     fsb.fs_rights_base | fsb.fs_rights_inheriting, &rights);
 517                 if (error != 0)
 518                         return (error);
 519                 return (kern_cap_rights_limit(td, uap->fd, &rights));
 520         }
 521         return (EINVAL);
 522 }
 523
 524 int
 525 cloudabi_sys_fd_sync(struct thread *td, struct cloudabi_sys_fd_sync_args *uap)
 526 {
 527
 528         return (kern_fsync(td, uap->fd, true));
 529 }