sys/compat/linux/linux_file.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 1994-1995 Søren Schmidt
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/dirent.h>
  32 #include <sys/fcntl.h>
  33 #include <sys/file.h>
  34 #include <sys/filedesc.h>
  35 #include <sys/lock.h>
  36 #include <sys/mman.h>
  37 #include <sys/selinfo.h>
  38 #include <sys/pipe.h>
  39 #include <sys/proc.h>
  40 #include <sys/stat.h>
  41 #include <sys/sx.h>
  42 #include <sys/syscallsubr.h>
  43 #include <sys/sysproto.h>
  44 #include <sys/tty.h>
  45 #include <sys/unistd.h>
  46 #include <sys/vnode.h>
  47
  48 #ifdef COMPAT_LINUX32
  49 #include <compat/freebsd32/freebsd32_misc.h>
  50 #include <compat/freebsd32/freebsd32_util.h>
  51 #include <machine/../linux32/linux.h>
  52 #include <machine/../linux32/linux32_proto.h>
  53 #else
  54 #include <machine/../linux/linux.h>
  55 #include <machine/../linux/linux_proto.h>
  56 #endif
  57 #include <compat/linux/linux_misc.h>
  58 #include <compat/linux/linux_util.h>
  59 #include <compat/linux/linux_file.h>
  60
  61 static int      linux_common_open(struct thread *, int, const char *, int, int,
  62                     enum uio_seg);
  63 static int      linux_do_accessat(struct thread *t, int, const char *, int, int);
  64 static int      linux_getdents_error(struct thread *, int, int);
  65
  66 static struct bsd_to_linux_bitmap seal_bitmap[] = {
  67         BITMAP_1t1_LINUX(F_SEAL_SEAL),
  68         BITMAP_1t1_LINUX(F_SEAL_SHRINK),
  69         BITMAP_1t1_LINUX(F_SEAL_GROW),
  70         BITMAP_1t1_LINUX(F_SEAL_WRITE),
  71 };
  72
  73 #define MFD_HUGETLB_ENTRY(_size)                                        \
  74         {                                                               \
  75                 .bsd_value = MFD_HUGE_##_size,                          \
  76                 .linux_value = LINUX_HUGETLB_FLAG_ENCODE_##_size        \
  77         }
  78 static struct bsd_to_linux_bitmap mfd_bitmap[] = {
  79         BITMAP_1t1_LINUX(MFD_CLOEXEC),
  80         BITMAP_1t1_LINUX(MFD_ALLOW_SEALING),
  81         BITMAP_1t1_LINUX(MFD_HUGETLB),
  82         MFD_HUGETLB_ENTRY(64KB),
  83         MFD_HUGETLB_ENTRY(512KB),
  84         MFD_HUGETLB_ENTRY(1MB),
  85         MFD_HUGETLB_ENTRY(2MB),
  86         MFD_HUGETLB_ENTRY(8MB),
  87         MFD_HUGETLB_ENTRY(16MB),
  88         MFD_HUGETLB_ENTRY(32MB),
  89         MFD_HUGETLB_ENTRY(256MB),
  90         MFD_HUGETLB_ENTRY(512MB),
  91         MFD_HUGETLB_ENTRY(1GB),
  92         MFD_HUGETLB_ENTRY(2GB),
  93         MFD_HUGETLB_ENTRY(16GB),
  94 };
  95 #undef MFD_HUGETLB_ENTRY
  96
  97 #ifdef LINUX_LEGACY_SYSCALLS
  98 int
  99 linux_creat(struct thread *td, struct linux_creat_args *args)
 100 {
 101
 102         return (kern_openat(td, AT_FDCWD, args->path, UIO_USERSPACE,
 103             O_WRONLY | O_CREAT | O_TRUNC, args->mode));
 104 }
 105 #endif
 106
 107 static int
 108 linux_common_openflags(int l_flags)
 109 {
 110         int bsd_flags;
 111
 112         bsd_flags = 0;
 113         switch (l_flags & LINUX_O_ACCMODE) {
 114         case LINUX_O_WRONLY:
 115                 bsd_flags |= O_WRONLY;
 116                 break;
 117         case LINUX_O_RDWR:
 118                 bsd_flags |= O_RDWR;
 119                 break;
 120         default:
 121                 bsd_flags |= O_RDONLY;
 122         }
 123         if (l_flags & LINUX_O_NDELAY)
 124                 bsd_flags |= O_NONBLOCK;
 125         if (l_flags & LINUX_O_APPEND)
 126                 bsd_flags |= O_APPEND;
 127         if (l_flags & LINUX_O_SYNC)
 128                 bsd_flags |= O_FSYNC;
 129         if (l_flags & LINUX_O_CLOEXEC)
 130                 bsd_flags |= O_CLOEXEC;
 131         if (l_flags & LINUX_O_NONBLOCK)
 132                 bsd_flags |= O_NONBLOCK;
 133         if (l_flags & LINUX_O_ASYNC)
 134                 bsd_flags |= O_ASYNC;
 135         if (l_flags & LINUX_O_CREAT)
 136                 bsd_flags |= O_CREAT;
 137         if (l_flags & LINUX_O_TRUNC)
 138                 bsd_flags |= O_TRUNC;
 139         if (l_flags & LINUX_O_EXCL)
 140                 bsd_flags |= O_EXCL;
 141         if (l_flags & LINUX_O_NOCTTY)
 142                 bsd_flags |= O_NOCTTY;
 143         if (l_flags & LINUX_O_DIRECT)
 144                 bsd_flags |= O_DIRECT;
 145         if (l_flags & LINUX_O_NOFOLLOW)
 146                 bsd_flags |= O_NOFOLLOW;
 147         if (l_flags & LINUX_O_DIRECTORY)
 148                 bsd_flags |= O_DIRECTORY;
 149         if (l_flags & LINUX_O_PATH)
 150                 bsd_flags |= O_PATH;
 151         /* XXX LINUX_O_NOATIME: unable to be easily implemented. */
 152         return (bsd_flags);
 153 }
 154
 155 static int
 156 linux_common_open(struct thread *td, int dirfd, const char *path, int l_flags,
 157     int mode, enum uio_seg seg)
 158 {
 159         struct proc *p = td->td_proc;
 160         struct file *fp;
 161         int fd;
 162         int bsd_flags, error;
 163
 164         bsd_flags = linux_common_openflags(l_flags);
 165         error = kern_openat(td, dirfd, path, seg, bsd_flags, mode);
 166         if (error != 0) {
 167                 if (error == EMLINK)
 168                         error = ELOOP;
 169                 goto done;
 170         }
 171         if (p->p_flag & P_CONTROLT)
 172                 goto done;
 173         if (bsd_flags & O_NOCTTY)
 174                 goto done;
 175
 176         /*
 177          * XXX In between kern_openat() and fget(), another process
 178          * having the same filedesc could use that fd without
 179          * checking below.
 180         */
 181         fd = td->td_retval[0];
 182         if (fget(td, fd, &cap_ioctl_rights, &fp) == 0) {
 183                 if (fp->f_type != DTYPE_VNODE) {
 184                         fdrop(fp, td);
 185                         goto done;
 186                 }
 187                 sx_slock(&proctree_lock);
 188                 PROC_LOCK(p);
 189                 if (SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
 190                         PROC_UNLOCK(p);
 191                         sx_sunlock(&proctree_lock);
 192                         /* XXXPJD: Verify if TIOCSCTTY is allowed. */
 193                         (void) fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0,
 194                             td->td_ucred, td);
 195                 } else {
 196                         PROC_UNLOCK(p);
 197                         sx_sunlock(&proctree_lock);
 198                 }
 199                 fdrop(fp, td);
 200         }
 201
 202 done:
 203         return (error);
 204 }
 205
 206 int
 207 linux_openat(struct thread *td, struct linux_openat_args *args)
 208 {
 209         int dfd;
 210
 211         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 212         return (linux_common_open(td, dfd, args->filename, args->flags,
 213             args->mode, UIO_USERSPACE));
 214 }
 215
 216 #ifdef LINUX_LEGACY_SYSCALLS
 217 int
 218 linux_open(struct thread *td, struct linux_open_args *args)
 219 {
 220
 221         return (linux_common_open(td, AT_FDCWD, args->path, args->flags,
 222             args->mode, UIO_USERSPACE));
 223 }
 224 #endif
 225
 226 int
 227 linux_name_to_handle_at(struct thread *td,
 228     struct linux_name_to_handle_at_args *args)
 229 {
 230         static const l_int valid_flags = (LINUX_AT_SYMLINK_FOLLOW |
 231             LINUX_AT_EMPTY_PATH);
 232         static const l_uint fh_size = sizeof(fhandle_t);
 233
 234         fhandle_t fh;
 235         l_uint fh_bytes;
 236         l_int mount_id;
 237         int error, fd, bsd_flags;
 238
 239         if (args->flags & ~valid_flags)
 240                 return (EINVAL);
 241
 242         fd = args->dirfd;
 243         if (fd == LINUX_AT_FDCWD)
 244                 fd = AT_FDCWD;
 245
 246         bsd_flags = 0;
 247         if (!(args->flags & LINUX_AT_SYMLINK_FOLLOW))
 248                 bsd_flags |= AT_SYMLINK_NOFOLLOW;
 249         if ((args->flags & LINUX_AT_EMPTY_PATH) != 0)
 250                 bsd_flags |= AT_EMPTY_PATH;
 251
 252         error = kern_getfhat(td, bsd_flags, fd, args->name,
 253             UIO_USERSPACE, &fh, UIO_SYSSPACE);
 254         if (error != 0)
 255                 return (error);
 256
 257         /* Emit mount_id -- required before EOVERFLOW case. */
 258         mount_id = (fh.fh_fsid.val[0] ^ fh.fh_fsid.val[1]);
 259         error = copyout(&mount_id, args->mnt_id, sizeof(mount_id));
 260         if (error != 0)
 261                 return (error);
 262
 263         /* Check if there is room for handle. */
 264         error = copyin(&args->handle->handle_bytes, &fh_bytes,
 265             sizeof(fh_bytes));
 266         if (error != 0)
 267                 return (error);
 268
 269         if (fh_bytes < fh_size) {
 270                 error = copyout(&fh_size, &args->handle->handle_bytes,
 271                     sizeof(fh_size));
 272                 if (error == 0)
 273                         error = EOVERFLOW;
 274                 return (error);
 275         }
 276
 277         /* Emit handle. */
 278         mount_id = 0;
 279         /*
 280          * We don't use handle_type for anything yet, but initialize a known
 281          * value.
 282          */
 283         error = copyout(&mount_id, &args->handle->handle_type,
 284             sizeof(mount_id));
 285         if (error != 0)
 286                 return (error);
 287
 288         error = copyout(&fh, &args->handle->f_handle,
 289             sizeof(fh));
 290         return (error);
 291 }
 292
 293 int
 294 linux_open_by_handle_at(struct thread *td,
 295     struct linux_open_by_handle_at_args *args)
 296 {
 297         l_uint fh_bytes;
 298         int bsd_flags, error;
 299
 300         error = copyin(&args->handle->handle_bytes, &fh_bytes,
 301             sizeof(fh_bytes));
 302         if (error != 0)
 303                 return (error);
 304
 305         if (fh_bytes < sizeof(fhandle_t))
 306                 return (EINVAL);
 307
 308         bsd_flags = linux_common_openflags(args->flags);
 309         return (kern_fhopen(td, (void *)&args->handle->f_handle, bsd_flags));
 310 }
 311
 312 int
 313 linux_lseek(struct thread *td, struct linux_lseek_args *args)
 314 {
 315
 316         return (kern_lseek(td, args->fdes, args->off, args->whence));
 317 }
 318
 319 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 320 int
 321 linux_llseek(struct thread *td, struct linux_llseek_args *args)
 322 {
 323         int error;
 324         off_t off;
 325
 326         off = (args->olow) | (((off_t) args->ohigh) << 32);
 327
 328         error = kern_lseek(td, args->fd, off, args->whence);
 329         if (error != 0)
 330                 return (error);
 331
 332         error = copyout(td->td_retval, args->res, sizeof(off_t));
 333         if (error != 0)
 334                 return (error);
 335
 336         td->td_retval[0] = 0;
 337         return (0);
 338 }
 339 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 340
 341 /*
 342  * Note that linux_getdents(2) and linux_getdents64(2) have the same
 343  * arguments. They only differ in the definition of struct dirent they
 344  * operate on.
 345  * Note that linux_readdir(2) is a special case of linux_getdents(2)
 346  * where count is always equals 1, meaning that the buffer is one
 347  * dirent-structure in size and that the code can't handle more anyway.
 348  * Note that linux_readdir(2) can't be implemented by means of linux_getdents(2)
 349  * as in case when the *dent buffer size is equal to 1 linux_getdents(2) will
 350  * trash user stack.
 351  */
 352
 353 static int
 354 linux_getdents_error(struct thread *td, int fd, int err)
 355 {
 356         struct vnode *vp;
 357         struct file *fp;
 358         int error;
 359
 360         /* Linux return ENOTDIR in case when fd is not a directory. */
 361         error = getvnode(td, fd, &cap_read_rights, &fp);
 362         if (error != 0)
 363                 return (error);
 364         vp = fp->f_vnode;
 365         if (vp->v_type != VDIR) {
 366                 fdrop(fp, td);
 367                 return (ENOTDIR);
 368         }
 369         fdrop(fp, td);
 370         return (err);
 371 }
 372
 373 struct l_dirent {
 374         l_ulong         d_ino;
 375         l_off_t         d_off;
 376         l_ushort        d_reclen;
 377         char            d_name[LINUX_NAME_MAX + 1];
 378 };
 379
 380 struct l_dirent64 {
 381         uint64_t        d_ino;
 382         int64_t         d_off;
 383         l_ushort        d_reclen;
 384         u_char          d_type;
 385         char            d_name[LINUX_NAME_MAX + 1];
 386 };
 387
 388 /*
 389  * Linux uses the last byte in the dirent buffer to store d_type,
 390  * at least glibc-2.7 requires it. That is why l_dirent is padded with 2 bytes.
 391  */
 392 #define LINUX_RECLEN(namlen)                                            \
 393     roundup(offsetof(struct l_dirent, d_name) + (namlen) + 2, sizeof(l_ulong))
 394
 395 #define LINUX_RECLEN64(namlen)                                          \
 396     roundup(offsetof(struct l_dirent64, d_name) + (namlen) + 1,         \
 397     sizeof(uint64_t))
 398
 399 #ifdef LINUX_LEGACY_SYSCALLS
 400 int
 401 linux_getdents(struct thread *td, struct linux_getdents_args *args)
 402 {
 403         struct dirent *bdp;
 404         caddr_t inp, buf;               /* BSD-format */
 405         int len, reclen;                /* BSD-format */
 406         caddr_t outp;                   /* Linux-format */
 407         int resid, linuxreclen;         /* Linux-format */
 408         caddr_t lbuf;                   /* Linux-format */
 409         off_t base;
 410         struct l_dirent *linux_dirent;
 411         int buflen, error;
 412         size_t retval;
 413
 414         buflen = min(args->count, MAXBSIZE);
 415         buf = malloc(buflen, M_LINUX, M_WAITOK);
 416
 417         error = kern_getdirentries(td, args->fd, buf, buflen,
 418             &base, NULL, UIO_SYSSPACE);
 419         if (error != 0) {
 420                 error = linux_getdents_error(td, args->fd, error);
 421                 goto out1;
 422         }
 423
 424         lbuf = malloc(LINUX_RECLEN(LINUX_NAME_MAX), M_LINUX, M_WAITOK | M_ZERO);
 425
 426         len = td->td_retval[0];
 427         inp = buf;
 428         outp = (caddr_t)args->dent;
 429         resid = args->count;
 430         retval = 0;
 431
 432         while (len > 0) {
 433                 bdp = (struct dirent *) inp;
 434                 reclen = bdp->d_reclen;
 435                 linuxreclen = LINUX_RECLEN(bdp->d_namlen);
 436                 /*
 437                  * No more space in the user supplied dirent buffer.
 438                  * Return EINVAL.
 439                  */
 440                 if (resid < linuxreclen) {
 441                         error = EINVAL;
 442                         goto out;
 443                 }
 444
 445                 linux_dirent = (struct l_dirent*)lbuf;
 446                 linux_dirent->d_ino = bdp->d_fileno;
 447                 linux_dirent->d_off = bdp->d_off;
 448                 linux_dirent->d_reclen = linuxreclen;
 449                 /*
 450                  * Copy d_type to last byte of l_dirent buffer
 451                  */
 452                 lbuf[linuxreclen - 1] = bdp->d_type;
 453                 strlcpy(linux_dirent->d_name, bdp->d_name,
 454                     linuxreclen - offsetof(struct l_dirent, d_name)-1);
 455                 error = copyout(linux_dirent, outp, linuxreclen);
 456                 if (error != 0)
 457                         goto out;
 458
 459                 inp += reclen;
 460                 base += reclen;
 461                 len -= reclen;
 462
 463                 retval += linuxreclen;
 464                 outp += linuxreclen;
 465                 resid -= linuxreclen;
 466         }
 467         td->td_retval[0] = retval;
 468
 469 out:
 470         free(lbuf, M_LINUX);
 471 out1:
 472         free(buf, M_LINUX);
 473         return (error);
 474 }
 475 #endif
 476
 477 int
 478 linux_getdents64(struct thread *td, struct linux_getdents64_args *args)
 479 {
 480         struct dirent *bdp;
 481         caddr_t inp, buf;               /* BSD-format */
 482         int len, reclen;                /* BSD-format */
 483         caddr_t outp;                   /* Linux-format */
 484         int resid, linuxreclen;         /* Linux-format */
 485         off_t base;
 486         struct l_dirent64 *linux_dirent64;
 487         int buflen, error;
 488         size_t retval;
 489
 490         buflen = min(args->count, MAXBSIZE);
 491         buf = malloc(buflen, M_LINUX, M_WAITOK);
 492
 493         error = kern_getdirentries(td, args->fd, buf, buflen,
 494             &base, NULL, UIO_SYSSPACE);
 495         if (error != 0) {
 496                 error = linux_getdents_error(td, args->fd, error);
 497                 goto out1;
 498         }
 499
 500         linux_dirent64 = malloc(LINUX_RECLEN64(LINUX_NAME_MAX), M_LINUX,
 501             M_WAITOK | M_ZERO);
 502
 503         len = td->td_retval[0];
 504         inp = buf;
 505         outp = (caddr_t)args->dirent;
 506         resid = args->count;
 507         retval = 0;
 508
 509         while (len > 0) {
 510                 bdp = (struct dirent *) inp;
 511                 reclen = bdp->d_reclen;
 512                 linuxreclen = LINUX_RECLEN64(bdp->d_namlen);
 513                 /*
 514                  * No more space in the user supplied dirent buffer.
 515                  * Return EINVAL.
 516                  */
 517                 if (resid < linuxreclen) {
 518                         error = EINVAL;
 519                         goto out;
 520                 }
 521
 522                 linux_dirent64->d_ino = bdp->d_fileno;
 523                 linux_dirent64->d_off = bdp->d_off;
 524                 linux_dirent64->d_reclen = linuxreclen;
 525                 linux_dirent64->d_type = bdp->d_type;
 526                 strlcpy(linux_dirent64->d_name, bdp->d_name,
 527                     linuxreclen - offsetof(struct l_dirent64, d_name));
 528                 error = copyout(linux_dirent64, outp, linuxreclen);
 529                 if (error != 0)
 530                         goto out;
 531
 532                 inp += reclen;
 533                 base += reclen;
 534                 len -= reclen;
 535
 536                 retval += linuxreclen;
 537                 outp += linuxreclen;
 538                 resid -= linuxreclen;
 539         }
 540         td->td_retval[0] = retval;
 541
 542 out:
 543         free(linux_dirent64, M_LINUX);
 544 out1:
 545         free(buf, M_LINUX);
 546         return (error);
 547 }
 548
 549 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 550 int
 551 linux_readdir(struct thread *td, struct linux_readdir_args *args)
 552 {
 553         struct dirent *bdp;
 554         caddr_t buf;                    /* BSD-format */
 555         int linuxreclen;                /* Linux-format */
 556         off_t base;
 557         struct l_dirent *linux_dirent;  /* Linux-format */
 558         int buflen, error;
 559
 560         buflen = sizeof(*bdp);
 561         buf = malloc(buflen, M_LINUX, M_WAITOK);
 562
 563         error = kern_getdirentries(td, args->fd, buf, buflen,
 564             &base, NULL, UIO_SYSSPACE);
 565         if (error != 0) {
 566                 error = linux_getdents_error(td, args->fd, error);
 567                 goto out;
 568         }
 569         if (td->td_retval[0] == 0)
 570                 goto out;
 571
 572         linux_dirent = malloc(LINUX_RECLEN(LINUX_NAME_MAX), M_LINUX,
 573             M_WAITOK | M_ZERO);
 574
 575         bdp = (struct dirent *) buf;
 576         linuxreclen = LINUX_RECLEN(bdp->d_namlen);
 577
 578         linux_dirent->d_ino = bdp->d_fileno;
 579         linux_dirent->d_off = bdp->d_off;
 580         linux_dirent->d_reclen = bdp->d_namlen;
 581         strlcpy(linux_dirent->d_name, bdp->d_name,
 582             linuxreclen - offsetof(struct l_dirent, d_name));
 583         error = copyout(linux_dirent, args->dent, linuxreclen);
 584         if (error == 0)
 585                 td->td_retval[0] = linuxreclen;
 586
 587         free(linux_dirent, M_LINUX);
 588 out:
 589         free(buf, M_LINUX);
 590         return (error);
 591 }
 592 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 593
 594 /*
 595  * These exist mainly for hooks for doing /compat/linux translation.
 596  */
 597
 598 #ifdef LINUX_LEGACY_SYSCALLS
 599 int
 600 linux_access(struct thread *td, struct linux_access_args *args)
 601 {
 602
 603         /* Linux convention. */
 604         if (args->amode & ~(F_OK | X_OK | W_OK | R_OK))
 605                 return (EINVAL);
 606
 607         return (kern_accessat(td, AT_FDCWD, args->path, UIO_USERSPACE, 0,
 608             args->amode));
 609 }
 610 #endif
 611
 612 static int
 613 linux_do_accessat(struct thread *td, int ldfd, const char *filename,
 614     int amode, int flags)
 615 {
 616         int dfd;
 617
 618         /* Linux convention. */
 619         if (amode & ~(F_OK | X_OK | W_OK | R_OK))
 620                 return (EINVAL);
 621
 622         dfd = (ldfd == LINUX_AT_FDCWD) ? AT_FDCWD : ldfd;
 623         return (kern_accessat(td, dfd, filename, UIO_USERSPACE, flags, amode));
 624 }
 625
 626 int
 627 linux_faccessat(struct thread *td, struct linux_faccessat_args *args)
 628 {
 629
 630         return (linux_do_accessat(td, args->dfd, args->filename, args->amode,
 631             0));
 632 }
 633
 634 int
 635 linux_faccessat2(struct thread *td, struct linux_faccessat2_args *args)
 636 {
 637         int flags, unsupported;
 638
 639         /* XXX. AT_SYMLINK_NOFOLLOW is not supported by kern_accessat */
 640         unsupported = args->flags & ~(LINUX_AT_EACCESS | LINUX_AT_EMPTY_PATH);
 641         if (unsupported != 0) {
 642                 linux_msg(td, "faccessat2 unsupported flag 0x%x", unsupported);
 643                 return (EINVAL);
 644         }
 645
 646         flags = (args->flags & LINUX_AT_EACCESS) == 0 ? 0 :
 647             AT_EACCESS;
 648         flags |= (args->flags & LINUX_AT_EMPTY_PATH) == 0 ? 0 :
 649             AT_EMPTY_PATH;
 650         return (linux_do_accessat(td, args->dfd, args->filename, args->amode,
 651             flags));
 652 }
 653
 654
 655 #ifdef LINUX_LEGACY_SYSCALLS
 656 int
 657 linux_unlink(struct thread *td, struct linux_unlink_args *args)
 658 {
 659         int error;
 660         struct stat st;
 661
 662         error = kern_funlinkat(td, AT_FDCWD, args->path, FD_NONE,
 663             UIO_USERSPACE, 0, 0);
 664         if (error == EPERM) {
 665                 /* Introduce POSIX noncompliant behaviour of Linux */
 666                 if (kern_statat(td, 0, AT_FDCWD, args->path,
 667                     UIO_USERSPACE, &st) == 0) {
 668                         if (S_ISDIR(st.st_mode))
 669                                 error = EISDIR;
 670                 }
 671         }
 672
 673         return (error);
 674 }
 675 #endif
 676
 677 static int
 678 linux_unlinkat_impl(struct thread *td, enum uio_seg pathseg, const char *path,
 679     int dfd, struct linux_unlinkat_args *args)
 680 {
 681         struct stat st;
 682         int error;
 683
 684         if (args->flag & LINUX_AT_REMOVEDIR)
 685                 error = kern_frmdirat(td, dfd, path, FD_NONE, pathseg, 0);
 686         else
 687                 error = kern_funlinkat(td, dfd, path, FD_NONE, pathseg, 0, 0);
 688         if (error == EPERM && !(args->flag & LINUX_AT_REMOVEDIR)) {
 689                 /* Introduce POSIX noncompliant behaviour of Linux */
 690                 if (kern_statat(td, AT_SYMLINK_NOFOLLOW, dfd, path,
 691                     pathseg, &st) == 0 && S_ISDIR(st.st_mode))
 692                         error = EISDIR;
 693         }
 694         return (error);
 695 }
 696
 697 int
 698 linux_unlinkat(struct thread *td, struct linux_unlinkat_args *args)
 699 {
 700         int dfd;
 701
 702         if (args->flag & ~LINUX_AT_REMOVEDIR)
 703                 return (EINVAL);
 704         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 705         return (linux_unlinkat_impl(td, UIO_USERSPACE, args->pathname,
 706             dfd, args));
 707 }
 708
 709 int
 710 linux_chdir(struct thread *td, struct linux_chdir_args *args)
 711 {
 712
 713         return (kern_chdir(td, args->path, UIO_USERSPACE));
 714 }
 715
 716 #ifdef LINUX_LEGACY_SYSCALLS
 717 int
 718 linux_chmod(struct thread *td, struct linux_chmod_args *args)
 719 {
 720
 721         return (kern_fchmodat(td, AT_FDCWD, args->path, UIO_USERSPACE,
 722             args->mode, 0));
 723 }
 724 #endif
 725
 726 int
 727 linux_fchmodat(struct thread *td, struct linux_fchmodat_args *args)
 728 {
 729         int dfd;
 730
 731         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 732         return (kern_fchmodat(td, dfd, args->filename, UIO_USERSPACE,
 733             args->mode, 0));
 734 }
 735
 736 #ifdef LINUX_LEGACY_SYSCALLS
 737 int
 738 linux_mkdir(struct thread *td, struct linux_mkdir_args *args)
 739 {
 740
 741         return (kern_mkdirat(td, AT_FDCWD, args->path, UIO_USERSPACE, args->mode));
 742 }
 743 #endif
 744
 745 int
 746 linux_mkdirat(struct thread *td, struct linux_mkdirat_args *args)
 747 {
 748         int dfd;
 749
 750         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 751         return (kern_mkdirat(td, dfd, args->pathname, UIO_USERSPACE, args->mode));
 752 }
 753
 754 #ifdef LINUX_LEGACY_SYSCALLS
 755 int
 756 linux_rmdir(struct thread *td, struct linux_rmdir_args *args)
 757 {
 758
 759         return (kern_frmdirat(td, AT_FDCWD, args->path, FD_NONE,
 760             UIO_USERSPACE, 0));
 761 }
 762
 763 int
 764 linux_rename(struct thread *td, struct linux_rename_args *args)
 765 {
 766
 767         return (kern_renameat(td, AT_FDCWD, args->from, AT_FDCWD,
 768             args->to, UIO_USERSPACE));
 769 }
 770 #endif
 771
 772 int
 773 linux_renameat(struct thread *td, struct linux_renameat_args *args)
 774 {
 775         struct linux_renameat2_args renameat2_args = {
 776             .olddfd = args->olddfd,
 777             .oldname = args->oldname,
 778             .newdfd = args->newdfd,
 779             .newname = args->newname,
 780             .flags = 0
 781         };
 782
 783         return (linux_renameat2(td, &renameat2_args));
 784 }
 785
 786 int
 787 linux_renameat2(struct thread *td, struct linux_renameat2_args *args)
 788 {
 789         int olddfd, newdfd;
 790
 791         if (args->flags != 0) {
 792                 if (args->flags & ~(LINUX_RENAME_EXCHANGE |
 793                     LINUX_RENAME_NOREPLACE | LINUX_RENAME_WHITEOUT))
 794                         return (EINVAL);
 795                 if (args->flags & LINUX_RENAME_EXCHANGE &&
 796                     args->flags & (LINUX_RENAME_NOREPLACE |
 797                     LINUX_RENAME_WHITEOUT))
 798                         return (EINVAL);
 799 #if 0
 800                 /*
 801                  * This spams the console on Ubuntu Focal.
 802                  *
 803                  * What's needed here is a general mechanism to let users know
 804                  * about missing features without hogging the system.
 805                  */
 806                 linux_msg(td, "renameat2 unsupported flags 0x%x",
 807                     args->flags);
 808 #endif
 809                 return (EINVAL);
 810         }
 811
 812         olddfd = (args->olddfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->olddfd;
 813         newdfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd;
 814         return (kern_renameat(td, olddfd, args->oldname, newdfd,
 815             args->newname, UIO_USERSPACE));
 816 }
 817
 818 #ifdef LINUX_LEGACY_SYSCALLS
 819 int
 820 linux_symlink(struct thread *td, struct linux_symlink_args *args)
 821 {
 822
 823         return (kern_symlinkat(td, args->path, AT_FDCWD, args->to,
 824             UIO_USERSPACE));
 825 }
 826 #endif
 827
 828 int
 829 linux_symlinkat(struct thread *td, struct linux_symlinkat_args *args)
 830 {
 831         int dfd;
 832
 833         dfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd;
 834         return (kern_symlinkat(td, args->oldname, dfd, args->newname,
 835             UIO_USERSPACE));
 836 }
 837
 838 #ifdef LINUX_LEGACY_SYSCALLS
 839 int
 840 linux_readlink(struct thread *td, struct linux_readlink_args *args)
 841 {
 842
 843         if (args->count <= 0)
 844                 return (EINVAL);
 845
 846         return (kern_readlinkat(td, AT_FDCWD, args->name, UIO_USERSPACE,
 847             args->buf, UIO_USERSPACE, args->count));
 848 }
 849 #endif
 850
 851 int
 852 linux_readlinkat(struct thread *td, struct linux_readlinkat_args *args)
 853 {
 854         int dfd;
 855
 856         if (args->bufsiz <= 0)
 857                 return (EINVAL);
 858
 859         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 860         return (kern_readlinkat(td, dfd, args->path, UIO_USERSPACE,
 861             args->buf, UIO_USERSPACE, args->bufsiz));
 862 }
 863
 864 int
 865 linux_truncate(struct thread *td, struct linux_truncate_args *args)
 866 {
 867
 868         return (kern_truncate(td, args->path, UIO_USERSPACE, args->length));
 869 }
 870
 871 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 872 int
 873 linux_truncate64(struct thread *td, struct linux_truncate64_args *args)
 874 {
 875         off_t length;
 876
 877 #if defined(__amd64__) && defined(COMPAT_LINUX32)
 878         length = PAIR32TO64(off_t, args->length);
 879 #else
 880         length = args->length;
 881 #endif
 882
 883         return (kern_truncate(td, args->path, UIO_USERSPACE, length));
 884 }
 885 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 886
 887 int
 888 linux_ftruncate(struct thread *td, struct linux_ftruncate_args *args)
 889 {
 890
 891         return (kern_ftruncate(td, args->fd, args->length));
 892 }
 893
 894 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 895 int
 896 linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args)
 897 {
 898         off_t length;
 899
 900 #if defined(__amd64__) && defined(COMPAT_LINUX32)
 901         length = PAIR32TO64(off_t, args->length);
 902 #else
 903         length = args->length;
 904 #endif
 905
 906         return (kern_ftruncate(td, args->fd, length));
 907 }
 908 #endif
 909
 910 #ifdef LINUX_LEGACY_SYSCALLS
 911 int
 912 linux_link(struct thread *td, struct linux_link_args *args)
 913 {
 914
 915         return (kern_linkat(td, AT_FDCWD, AT_FDCWD, args->path, args->to,
 916             UIO_USERSPACE, AT_SYMLINK_FOLLOW));
 917 }
 918 #endif
 919
 920 int
 921 linux_linkat(struct thread *td, struct linux_linkat_args *args)
 922 {
 923         int olddfd, newdfd, flag;
 924
 925         if (args->flag & ~(LINUX_AT_SYMLINK_FOLLOW | LINUX_AT_EMPTY_PATH))
 926                 return (EINVAL);
 927
 928         flag = (args->flag & LINUX_AT_SYMLINK_FOLLOW) != 0 ? AT_SYMLINK_FOLLOW :
 929             0;
 930         flag |= (args->flag & LINUX_AT_EMPTY_PATH) != 0 ? AT_EMPTY_PATH : 0;
 931
 932         olddfd = (args->olddfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->olddfd;
 933         newdfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd;
 934         return (kern_linkat(td, olddfd, newdfd, args->oldname,
 935             args->newname, UIO_USERSPACE, flag));
 936 }
 937
 938 int
 939 linux_fdatasync(struct thread *td, struct linux_fdatasync_args *uap)
 940 {
 941
 942         return (kern_fsync(td, uap->fd, false));
 943 }
 944
 945 int
 946 linux_sync_file_range(struct thread *td, struct linux_sync_file_range_args *uap)
 947 {
 948         off_t nbytes, offset;
 949
 950 #if defined(__amd64__) && defined(COMPAT_LINUX32)
 951         nbytes = PAIR32TO64(off_t, uap->nbytes);
 952         offset = PAIR32TO64(off_t, uap->offset);
 953 #else
 954         nbytes = uap->nbytes;
 955         offset = uap->offset;
 956 #endif
 957
 958         if (offset < 0 || nbytes < 0 ||
 959             (uap->flags & ~(LINUX_SYNC_FILE_RANGE_WAIT_BEFORE |
 960             LINUX_SYNC_FILE_RANGE_WRITE |
 961             LINUX_SYNC_FILE_RANGE_WAIT_AFTER)) != 0) {
 962                 return (EINVAL);
 963         }
 964
 965         return (kern_fsync(td, uap->fd, false));
 966 }
 967
 968 int
 969 linux_pread(struct thread *td, struct linux_pread_args *uap)
 970 {
 971         struct vnode *vp;
 972         off_t offset;
 973         int error;
 974
 975 #if defined(__amd64__) && defined(COMPAT_LINUX32)
 976         offset = PAIR32TO64(off_t, uap->offset);
 977 #else
 978         offset = uap->offset;
 979 #endif
 980
 981         error = kern_pread(td, uap->fd, uap->buf, uap->nbyte, offset);
 982         if (error == 0) {
 983                 /* This seems to violate POSIX but Linux does it. */
 984                 error = fgetvp(td, uap->fd, &cap_pread_rights, &vp);
 985                 if (error != 0)
 986                         return (error);
 987                 if (vp->v_type == VDIR)
 988                         error = EISDIR;
 989                 vrele(vp);
 990         }
 991         return (error);
 992 }
 993
 994 int
 995 linux_pwrite(struct thread *td, struct linux_pwrite_args *uap)
 996 {
 997         off_t offset;
 998
 999 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1000         offset = PAIR32TO64(off_t, uap->offset);
1001 #else
1002         offset = uap->offset;
1003 #endif
1004
1005         return (linux_enobufs2eagain(td, uap->fd,
1006             kern_pwrite(td, uap->fd, uap->buf, uap->nbyte, offset)));
1007 }
1008
1009 #define HALF_LONG_BITS ((sizeof(l_long) * NBBY / 2))
1010
1011 static inline off_t
1012 pos_from_hilo(unsigned long high, unsigned long low)
1013 {
1014
1015         return (((off_t)high << HALF_LONG_BITS) << HALF_LONG_BITS) | low;
1016 }
1017
1018 int
1019 linux_preadv(struct thread *td, struct linux_preadv_args *uap)
1020 {
1021         struct uio *auio;
1022         int error;
1023         off_t offset;
1024
1025         /*
1026          * According http://man7.org/linux/man-pages/man2/preadv.2.html#NOTES
1027          * pos_l and pos_h, respectively, contain the
1028          * low order and high order 32 bits of offset.
1029          */
1030         offset = pos_from_hilo(uap->pos_h, uap->pos_l);
1031         if (offset < 0)
1032                 return (EINVAL);
1033 #ifdef COMPAT_LINUX32
1034         error = freebsd32_copyinuio(PTRIN(uap->vec), uap->vlen, &auio);
1035 #else
1036         error = copyinuio(uap->vec, uap->vlen, &auio);
1037 #endif
1038         if (error != 0)
1039                 return (error);
1040         error = kern_preadv(td, uap->fd, auio, offset);
1041         free(auio, M_IOV);
1042         return (error);
1043 }
1044
1045 int
1046 linux_pwritev(struct thread *td, struct linux_pwritev_args *uap)
1047 {
1048         struct uio *auio;
1049         int error;
1050         off_t offset;
1051
1052         /*
1053          * According http://man7.org/linux/man-pages/man2/pwritev.2.html#NOTES
1054          * pos_l and pos_h, respectively, contain the
1055          * low order and high order 32 bits of offset.
1056          */
1057         offset = pos_from_hilo(uap->pos_h, uap->pos_l);
1058         if (offset < 0)
1059                 return (EINVAL);
1060 #ifdef COMPAT_LINUX32
1061         error = freebsd32_copyinuio(PTRIN(uap->vec), uap->vlen, &auio);
1062 #else
1063         error = copyinuio(uap->vec, uap->vlen, &auio);
1064 #endif
1065         if (error != 0)
1066                 return (error);
1067         error = kern_pwritev(td, uap->fd, auio, offset);
1068         free(auio, M_IOV);
1069         return (linux_enobufs2eagain(td, uap->fd, error));
1070 }
1071
1072 int
1073 linux_mount(struct thread *td, struct linux_mount_args *args)
1074 {
1075         struct mntarg *ma = NULL;
1076         char *fstypename, *mntonname, *mntfromname, *data;
1077         int error, fsflags;
1078
1079         fstypename = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1080         mntonname = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1081         mntfromname = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1082         data = NULL;
1083         error = copyinstr(args->filesystemtype, fstypename, MNAMELEN - 1,
1084             NULL);
1085         if (error != 0)
1086                 goto out;
1087         if (args->specialfile != NULL) {
1088                 error = copyinstr(args->specialfile, mntfromname, MNAMELEN - 1, NULL);
1089                 if (error != 0)
1090                         goto out;
1091         } else {
1092                 mntfromname[0] = '\0';
1093         }
1094         error = copyinstr(args->dir, mntonname, MNAMELEN - 1, NULL);
1095         if (error != 0)
1096                 goto out;
1097
1098         if (strcmp(fstypename, "ext2") == 0) {
1099                 strcpy(fstypename, "ext2fs");
1100         } else if (strcmp(fstypename, "proc") == 0) {
1101                 strcpy(fstypename, "linprocfs");
1102         } else if (strcmp(fstypename, "vfat") == 0) {
1103                 strcpy(fstypename, "msdosfs");
1104         } else if (strcmp(fstypename, "fuse") == 0 ||
1105             strncmp(fstypename, "fuse.", 5) == 0) {
1106                 char *fuse_options, *fuse_option, *fuse_name;
1107
1108                 strcpy(mntfromname, "/dev/fuse");
1109                 strcpy(fstypename, "fusefs");
1110                 data = malloc(MNAMELEN, M_TEMP, M_WAITOK);
1111                 error = copyinstr(args->data, data, MNAMELEN - 1, NULL);
1112                 if (error != 0)
1113                         goto out;
1114
1115                 fuse_options = data;
1116                 while ((fuse_option = strsep(&fuse_options, ",")) != NULL) {
1117                         fuse_name = strsep(&fuse_option, "=");
1118                         if (fuse_name == NULL || fuse_option == NULL)
1119                                 goto out;
1120                         ma = mount_arg(ma, fuse_name, fuse_option, -1);
1121                 }
1122
1123                 /*
1124                  * The FUSE server uses Linux errno values instead of FreeBSD
1125                  * ones; add a flag to tell fuse(4) to do errno translation.
1126                  */
1127                 ma = mount_arg(ma, "linux_errnos", "1", -1);
1128         }
1129
1130         fsflags = 0;
1131
1132         /*
1133          * Linux SYNC flag is not included; the closest equivalent
1134          * FreeBSD has is !ASYNC, which is our default.
1135          */
1136         if (args->rwflag & LINUX_MS_RDONLY)
1137                 fsflags |= MNT_RDONLY;
1138         if (args->rwflag & LINUX_MS_NOSUID)
1139                 fsflags |= MNT_NOSUID;
1140         if (args->rwflag & LINUX_MS_NOEXEC)
1141                 fsflags |= MNT_NOEXEC;
1142         if (args->rwflag & LINUX_MS_REMOUNT)
1143                 fsflags |= MNT_UPDATE;
1144
1145         ma = mount_arg(ma, "fstype", fstypename, -1);
1146         ma = mount_arg(ma, "fspath", mntonname, -1);
1147         ma = mount_arg(ma, "from", mntfromname, -1);
1148         error = kernel_mount(ma, fsflags);
1149 out:
1150         free(fstypename, M_TEMP);
1151         free(mntonname, M_TEMP);
1152         free(mntfromname, M_TEMP);
1153         free(data, M_TEMP);
1154         return (error);
1155 }
1156
1157 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1158 int
1159 linux_oldumount(struct thread *td, struct linux_oldumount_args *args)
1160 {
1161
1162         return (kern_unmount(td, args->path, 0));
1163 }
1164 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
1165
1166 #ifdef LINUX_LEGACY_SYSCALLS
1167 int
1168 linux_umount(struct thread *td, struct linux_umount_args *args)
1169 {
1170         int flags;
1171
1172         flags = 0;
1173         if ((args->flags & LINUX_MNT_FORCE) != 0) {
1174                 args->flags &= ~LINUX_MNT_FORCE;
1175                 flags |= MNT_FORCE;
1176         }
1177         if (args->flags != 0) {
1178                 linux_msg(td, "unsupported umount2 flags %#x", args->flags);
1179                 return (EINVAL);
1180         }
1181
1182         return (kern_unmount(td, args->path, flags));
1183 }
1184 #endif
1185
1186 /*
1187  * fcntl family of syscalls
1188  */
1189
1190 struct l_flock {
1191         l_short         l_type;
1192         l_short         l_whence;
1193         l_off_t         l_start;
1194         l_off_t         l_len;
1195         l_pid_t         l_pid;
1196 }
1197 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1198 __packed
1199 #endif
1200 ;
1201
1202 static void
1203 linux_to_bsd_flock(struct l_flock *linux_flock, struct flock *bsd_flock)
1204 {
1205         switch (linux_flock->l_type) {
1206         case LINUX_F_RDLCK:
1207                 bsd_flock->l_type = F_RDLCK;
1208                 break;
1209         case LINUX_F_WRLCK:
1210                 bsd_flock->l_type = F_WRLCK;
1211                 break;
1212         case LINUX_F_UNLCK:
1213                 bsd_flock->l_type = F_UNLCK;
1214                 break;
1215         default:
1216                 bsd_flock->l_type = -1;
1217                 break;
1218         }
1219         bsd_flock->l_whence = linux_flock->l_whence;
1220         bsd_flock->l_start = (off_t)linux_flock->l_start;
1221         bsd_flock->l_len = (off_t)linux_flock->l_len;
1222         bsd_flock->l_pid = (pid_t)linux_flock->l_pid;
1223         bsd_flock->l_sysid = 0;
1224 }
1225
1226 static void
1227 bsd_to_linux_flock(struct flock *bsd_flock, struct l_flock *linux_flock)
1228 {
1229         switch (bsd_flock->l_type) {
1230         case F_RDLCK:
1231                 linux_flock->l_type = LINUX_F_RDLCK;
1232                 break;
1233         case F_WRLCK:
1234                 linux_flock->l_type = LINUX_F_WRLCK;
1235                 break;
1236         case F_UNLCK:
1237                 linux_flock->l_type = LINUX_F_UNLCK;
1238                 break;
1239         }
1240         linux_flock->l_whence = bsd_flock->l_whence;
1241         linux_flock->l_start = (l_off_t)bsd_flock->l_start;
1242         linux_flock->l_len = (l_off_t)bsd_flock->l_len;
1243         linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid;
1244 }
1245
1246 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1247 struct l_flock64 {
1248         l_short         l_type;
1249         l_short         l_whence;
1250         l_loff_t        l_start;
1251         l_loff_t        l_len;
1252         l_pid_t         l_pid;
1253 }
1254 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1255 __packed
1256 #endif
1257 ;
1258
1259 static void
1260 linux_to_bsd_flock64(struct l_flock64 *linux_flock, struct flock *bsd_flock)
1261 {
1262         switch (linux_flock->l_type) {
1263         case LINUX_F_RDLCK:
1264                 bsd_flock->l_type = F_RDLCK;
1265                 break;
1266         case LINUX_F_WRLCK:
1267                 bsd_flock->l_type = F_WRLCK;
1268                 break;
1269         case LINUX_F_UNLCK:
1270                 bsd_flock->l_type = F_UNLCK;
1271                 break;
1272         default:
1273                 bsd_flock->l_type = -1;
1274                 break;
1275         }
1276         bsd_flock->l_whence = linux_flock->l_whence;
1277         bsd_flock->l_start = (off_t)linux_flock->l_start;
1278         bsd_flock->l_len = (off_t)linux_flock->l_len;
1279         bsd_flock->l_pid = (pid_t)linux_flock->l_pid;
1280         bsd_flock->l_sysid = 0;
1281 }
1282
1283 static void
1284 bsd_to_linux_flock64(struct flock *bsd_flock, struct l_flock64 *linux_flock)
1285 {
1286         switch (bsd_flock->l_type) {
1287         case F_RDLCK:
1288                 linux_flock->l_type = LINUX_F_RDLCK;
1289                 break;
1290         case F_WRLCK:
1291                 linux_flock->l_type = LINUX_F_WRLCK;
1292                 break;
1293         case F_UNLCK:
1294                 linux_flock->l_type = LINUX_F_UNLCK;
1295                 break;
1296         }
1297         linux_flock->l_whence = bsd_flock->l_whence;
1298         linux_flock->l_start = (l_loff_t)bsd_flock->l_start;
1299         linux_flock->l_len = (l_loff_t)bsd_flock->l_len;
1300         linux_flock->l_pid = (l_pid_t)bsd_flock->l_pid;
1301 }
1302 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
1303
1304 static int
1305 fcntl_common(struct thread *td, struct linux_fcntl_args *args)
1306 {
1307         struct l_flock linux_flock;
1308         struct flock bsd_flock;
1309         struct pipe *fpipe;
1310         struct file *fp;
1311         long arg;
1312         int error, result;
1313
1314         switch (args->cmd) {
1315         case LINUX_F_DUPFD:
1316                 return (kern_fcntl(td, args->fd, F_DUPFD, args->arg));
1317
1318         case LINUX_F_GETFD:
1319                 return (kern_fcntl(td, args->fd, F_GETFD, 0));
1320
1321         case LINUX_F_SETFD:
1322                 return (kern_fcntl(td, args->fd, F_SETFD, args->arg));
1323
1324         case LINUX_F_GETFL:
1325                 error = kern_fcntl(td, args->fd, F_GETFL, 0);
1326                 result = td->td_retval[0];
1327                 td->td_retval[0] = 0;
1328                 if (result & O_RDONLY)
1329                         td->td_retval[0] |= LINUX_O_RDONLY;
1330                 if (result & O_WRONLY)
1331                         td->td_retval[0] |= LINUX_O_WRONLY;
1332                 if (result & O_RDWR)
1333                         td->td_retval[0] |= LINUX_O_RDWR;
1334                 if (result & O_NDELAY)
1335                         td->td_retval[0] |= LINUX_O_NONBLOCK;
1336                 if (result & O_APPEND)
1337                         td->td_retval[0] |= LINUX_O_APPEND;
1338                 if (result & O_FSYNC)
1339                         td->td_retval[0] |= LINUX_O_SYNC;
1340                 if (result & O_ASYNC)
1341                         td->td_retval[0] |= LINUX_O_ASYNC;
1342 #ifdef LINUX_O_NOFOLLOW
1343                 if (result & O_NOFOLLOW)
1344                         td->td_retval[0] |= LINUX_O_NOFOLLOW;
1345 #endif
1346 #ifdef LINUX_O_DIRECT
1347                 if (result & O_DIRECT)
1348                         td->td_retval[0] |= LINUX_O_DIRECT;
1349 #endif
1350                 return (error);
1351
1352         case LINUX_F_SETFL:
1353                 arg = 0;
1354                 if (args->arg & LINUX_O_NDELAY)
1355                         arg |= O_NONBLOCK;
1356                 if (args->arg & LINUX_O_APPEND)
1357                         arg |= O_APPEND;
1358                 if (args->arg & LINUX_O_SYNC)
1359                         arg |= O_FSYNC;
1360                 if (args->arg & LINUX_O_ASYNC)
1361                         arg |= O_ASYNC;
1362 #ifdef LINUX_O_NOFOLLOW
1363                 if (args->arg & LINUX_O_NOFOLLOW)
1364                         arg |= O_NOFOLLOW;
1365 #endif
1366 #ifdef LINUX_O_DIRECT
1367                 if (args->arg & LINUX_O_DIRECT)
1368                         arg |= O_DIRECT;
1369 #endif
1370                 return (kern_fcntl(td, args->fd, F_SETFL, arg));
1371
1372         case LINUX_F_GETLK:
1373                 error = copyin((void *)args->arg, &linux_flock,
1374                     sizeof(linux_flock));
1375                 if (error)
1376                         return (error);
1377                 linux_to_bsd_flock(&linux_flock, &bsd_flock);
1378                 error = kern_fcntl(td, args->fd, F_GETLK, (intptr_t)&bsd_flock);
1379                 if (error)
1380                         return (error);
1381                 bsd_to_linux_flock(&bsd_flock, &linux_flock);
1382                 return (copyout(&linux_flock, (void *)args->arg,
1383                     sizeof(linux_flock)));
1384
1385         case LINUX_F_SETLK:
1386                 error = copyin((void *)args->arg, &linux_flock,
1387                     sizeof(linux_flock));
1388                 if (error)
1389                         return (error);
1390                 linux_to_bsd_flock(&linux_flock, &bsd_flock);
1391                 return (kern_fcntl(td, args->fd, F_SETLK,
1392                     (intptr_t)&bsd_flock));
1393
1394         case LINUX_F_SETLKW:
1395                 error = copyin((void *)args->arg, &linux_flock,
1396                     sizeof(linux_flock));
1397                 if (error)
1398                         return (error);
1399                 linux_to_bsd_flock(&linux_flock, &bsd_flock);
1400                 return (kern_fcntl(td, args->fd, F_SETLKW,
1401                      (intptr_t)&bsd_flock));
1402
1403         case LINUX_F_GETOWN:
1404                 return (kern_fcntl(td, args->fd, F_GETOWN, 0));
1405
1406         case LINUX_F_SETOWN:
1407                 /*
1408                  * XXX some Linux applications depend on F_SETOWN having no
1409                  * significant effect for pipes (SIGIO is not delivered for
1410                  * pipes under Linux-2.2.35 at least).
1411                  */
1412                 error = fget(td, args->fd,
1413                     &cap_fcntl_rights, &fp);
1414                 if (error)
1415                         return (error);
1416                 if (fp->f_type == DTYPE_PIPE) {
1417                         fdrop(fp, td);
1418                         return (EINVAL);
1419                 }
1420                 fdrop(fp, td);
1421
1422                 return (kern_fcntl(td, args->fd, F_SETOWN, args->arg));
1423
1424         case LINUX_F_DUPFD_CLOEXEC:
1425                 return (kern_fcntl(td, args->fd, F_DUPFD_CLOEXEC, args->arg));
1426         /*
1427          * Our F_SEAL_* values match Linux one for maximum compatibility.  So we
1428          * only needed to account for different values for fcntl(2) commands.
1429          */
1430         case LINUX_F_GET_SEALS:
1431                 error = kern_fcntl(td, args->fd, F_GET_SEALS, 0);
1432                 if (error != 0)
1433                         return (error);
1434                 td->td_retval[0] = bsd_to_linux_bits(td->td_retval[0],
1435                     seal_bitmap, 0);
1436                 return (0);
1437
1438         case LINUX_F_ADD_SEALS:
1439                 return (kern_fcntl(td, args->fd, F_ADD_SEALS,
1440                     linux_to_bsd_bits(args->arg, seal_bitmap, 0)));
1441
1442         case LINUX_F_GETPIPE_SZ:
1443                 error = fget(td, args->fd,
1444                     &cap_fcntl_rights, &fp);
1445                 if (error != 0)
1446                         return (error);
1447                 if (fp->f_type != DTYPE_PIPE) {
1448                         fdrop(fp, td);
1449                         return (EINVAL);
1450                 }
1451                 fpipe = fp->f_data;
1452                 td->td_retval[0] = fpipe->pipe_buffer.size;
1453                 fdrop(fp, td);
1454                 return (0);
1455
1456         default:
1457                 linux_msg(td, "unsupported fcntl cmd %d", args->cmd);
1458                 return (EINVAL);
1459         }
1460 }
1461
1462 int
1463 linux_fcntl(struct thread *td, struct linux_fcntl_args *args)
1464 {
1465
1466         return (fcntl_common(td, args));
1467 }
1468
1469 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1470 int
1471 linux_fcntl64(struct thread *td, struct linux_fcntl64_args *args)
1472 {
1473         struct l_flock64 linux_flock;
1474         struct flock bsd_flock;
1475         struct linux_fcntl_args fcntl_args;
1476         int error;
1477
1478         switch (args->cmd) {
1479         case LINUX_F_GETLK64:
1480                 error = copyin((void *)args->arg, &linux_flock,
1481                     sizeof(linux_flock));
1482                 if (error)
1483                         return (error);
1484                 linux_to_bsd_flock64(&linux_flock, &bsd_flock);
1485                 error = kern_fcntl(td, args->fd, F_GETLK, (intptr_t)&bsd_flock);
1486                 if (error)
1487                         return (error);
1488                 bsd_to_linux_flock64(&bsd_flock, &linux_flock);
1489                 return (copyout(&linux_flock, (void *)args->arg,
1490                             sizeof(linux_flock)));
1491
1492         case LINUX_F_SETLK64:
1493                 error = copyin((void *)args->arg, &linux_flock,
1494                     sizeof(linux_flock));
1495                 if (error)
1496                         return (error);
1497                 linux_to_bsd_flock64(&linux_flock, &bsd_flock);
1498                 return (kern_fcntl(td, args->fd, F_SETLK,
1499                     (intptr_t)&bsd_flock));
1500
1501         case LINUX_F_SETLKW64:
1502                 error = copyin((void *)args->arg, &linux_flock,
1503                     sizeof(linux_flock));
1504                 if (error)
1505                         return (error);
1506                 linux_to_bsd_flock64(&linux_flock, &bsd_flock);
1507                 return (kern_fcntl(td, args->fd, F_SETLKW,
1508                     (intptr_t)&bsd_flock));
1509         }
1510
1511         fcntl_args.fd = args->fd;
1512         fcntl_args.cmd = args->cmd;
1513         fcntl_args.arg = args->arg;
1514         return (fcntl_common(td, &fcntl_args));
1515 }
1516 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
1517
1518 #ifdef LINUX_LEGACY_SYSCALLS
1519 int
1520 linux_chown(struct thread *td, struct linux_chown_args *args)
1521 {
1522
1523         return (kern_fchownat(td, AT_FDCWD, args->path, UIO_USERSPACE,
1524             args->uid, args->gid, 0));
1525 }
1526 #endif
1527
1528 int
1529 linux_fchownat(struct thread *td, struct linux_fchownat_args *args)
1530 {
1531         int dfd, flag, unsupported;
1532
1533         unsupported = args->flag & ~(LINUX_AT_SYMLINK_NOFOLLOW | LINUX_AT_EMPTY_PATH);
1534         if (unsupported != 0) {
1535                 linux_msg(td, "fchownat unsupported flag 0x%x", unsupported);
1536                 return (EINVAL);
1537         }
1538
1539         flag = (args->flag & LINUX_AT_SYMLINK_NOFOLLOW) == 0 ? 0 :
1540             AT_SYMLINK_NOFOLLOW;
1541         flag |= (args->flag & LINUX_AT_EMPTY_PATH) == 0 ? 0 :
1542             AT_EMPTY_PATH;
1543
1544         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD :  args->dfd;
1545         return (kern_fchownat(td, dfd, args->filename, UIO_USERSPACE,
1546             args->uid, args->gid, flag));
1547 }
1548
1549 #ifdef LINUX_LEGACY_SYSCALLS
1550 int
1551 linux_lchown(struct thread *td, struct linux_lchown_args *args)
1552 {
1553
1554         return (kern_fchownat(td, AT_FDCWD, args->path, UIO_USERSPACE, args->uid,
1555             args->gid, AT_SYMLINK_NOFOLLOW));
1556 }
1557 #endif
1558
1559 static int
1560 convert_fadvice(int advice)
1561 {
1562         switch (advice) {
1563         case LINUX_POSIX_FADV_NORMAL:
1564                 return (POSIX_FADV_NORMAL);
1565         case LINUX_POSIX_FADV_RANDOM:
1566                 return (POSIX_FADV_RANDOM);
1567         case LINUX_POSIX_FADV_SEQUENTIAL:
1568                 return (POSIX_FADV_SEQUENTIAL);
1569         case LINUX_POSIX_FADV_WILLNEED:
1570                 return (POSIX_FADV_WILLNEED);
1571         case LINUX_POSIX_FADV_DONTNEED:
1572                 return (POSIX_FADV_DONTNEED);
1573         case LINUX_POSIX_FADV_NOREUSE:
1574                 return (POSIX_FADV_NOREUSE);
1575         default:
1576                 return (-1);
1577         }
1578 }
1579
1580 int
1581 linux_fadvise64(struct thread *td, struct linux_fadvise64_args *args)
1582 {
1583         off_t offset;
1584         int advice;
1585
1586 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1587         offset = PAIR32TO64(off_t, args->offset);
1588 #else
1589         offset = args->offset;
1590 #endif
1591
1592         advice = convert_fadvice(args->advice);
1593         if (advice == -1)
1594                 return (EINVAL);
1595         return (kern_posix_fadvise(td, args->fd, offset, args->len, advice));
1596 }
1597
1598 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
1599 int
1600 linux_fadvise64_64(struct thread *td, struct linux_fadvise64_64_args *args)
1601 {
1602         off_t len, offset;
1603         int advice;
1604
1605 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1606         len = PAIR32TO64(off_t, args->len);
1607         offset = PAIR32TO64(off_t, args->offset);
1608 #else
1609         len = args->len;
1610         offset = args->offset;
1611 #endif
1612
1613         advice = convert_fadvice(args->advice);
1614         if (advice == -1)
1615                 return (EINVAL);
1616         return (kern_posix_fadvise(td, args->fd, offset, len, advice));
1617 }
1618 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
1619
1620 #ifdef LINUX_LEGACY_SYSCALLS
1621 int
1622 linux_pipe(struct thread *td, struct linux_pipe_args *args)
1623 {
1624         int fildes[2];
1625         int error;
1626
1627         error = kern_pipe(td, fildes, 0, NULL, NULL);
1628         if (error != 0)
1629                 return (error);
1630
1631         error = copyout(fildes, args->pipefds, sizeof(fildes));
1632         if (error != 0) {
1633                 (void)kern_close(td, fildes[0]);
1634                 (void)kern_close(td, fildes[1]);
1635         }
1636
1637         return (error);
1638 }
1639 #endif
1640
1641 int
1642 linux_pipe2(struct thread *td, struct linux_pipe2_args *args)
1643 {
1644         int fildes[2];
1645         int error, flags;
1646
1647         if ((args->flags & ~(LINUX_O_NONBLOCK | LINUX_O_CLOEXEC)) != 0)
1648                 return (EINVAL);
1649
1650         flags = 0;
1651         if ((args->flags & LINUX_O_NONBLOCK) != 0)
1652                 flags |= O_NONBLOCK;
1653         if ((args->flags & LINUX_O_CLOEXEC) != 0)
1654                 flags |= O_CLOEXEC;
1655         error = kern_pipe(td, fildes, flags, NULL, NULL);
1656         if (error != 0)
1657                 return (error);
1658
1659         error = copyout(fildes, args->pipefds, sizeof(fildes));
1660         if (error != 0) {
1661                 (void)kern_close(td, fildes[0]);
1662                 (void)kern_close(td, fildes[1]);
1663         }
1664
1665         return (error);
1666 }
1667
1668 int
1669 linux_dup3(struct thread *td, struct linux_dup3_args *args)
1670 {
1671         int cmd;
1672         intptr_t newfd;
1673
1674         if (args->oldfd == args->newfd)
1675                 return (EINVAL);
1676         if ((args->flags & ~LINUX_O_CLOEXEC) != 0)
1677                 return (EINVAL);
1678         if (args->flags & LINUX_O_CLOEXEC)
1679                 cmd = F_DUP2FD_CLOEXEC;
1680         else
1681                 cmd = F_DUP2FD;
1682
1683         newfd = args->newfd;
1684         return (kern_fcntl(td, args->oldfd, cmd, newfd));
1685 }
1686
1687 int
1688 linux_fallocate(struct thread *td, struct linux_fallocate_args *args)
1689 {
1690         off_t len, offset;
1691
1692         /*
1693          * We emulate only posix_fallocate system call for which
1694          * mode should be 0.
1695          */
1696         if (args->mode != 0)
1697                 return (EOPNOTSUPP);
1698
1699 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1700         len = PAIR32TO64(off_t, args->len);
1701         offset = PAIR32TO64(off_t, args->offset);
1702 #else
1703         len = args->len;
1704         offset = args->offset;
1705 #endif
1706
1707         return (kern_posix_fallocate(td, args->fd, offset, len));
1708 }
1709
1710 int
1711 linux_copy_file_range(struct thread *td, struct linux_copy_file_range_args
1712     *args)
1713 {
1714         l_loff_t inoff, outoff, *inoffp, *outoffp;
1715         int error, flags;
1716
1717         /*
1718          * copy_file_range(2) on Linux doesn't define any flags (yet), so is
1719          * the native implementation.  Enforce it.
1720          */
1721         if (args->flags != 0) {
1722                 linux_msg(td, "copy_file_range unsupported flags 0x%x",
1723                     args->flags);
1724                 return (EINVAL);
1725         }
1726         flags = 0;
1727         inoffp = outoffp = NULL;
1728         if (args->off_in != NULL) {
1729                 error = copyin(args->off_in, &inoff, sizeof(l_loff_t));
1730                 if (error != 0)
1731                         return (error);
1732                 inoffp = &inoff;
1733         }
1734         if (args->off_out != NULL) {
1735                 error = copyin(args->off_out, &outoff, sizeof(l_loff_t));
1736                 if (error != 0)
1737                         return (error);
1738                 outoffp = &outoff;
1739         }
1740
1741         error = kern_copy_file_range(td, args->fd_in, inoffp, args->fd_out,
1742             outoffp, args->len, flags);
1743         if (error == 0 && args->off_in != NULL)
1744                 error = copyout(inoffp, args->off_in, sizeof(l_loff_t));
1745         if (error == 0 && args->off_out != NULL)
1746                 error = copyout(outoffp, args->off_out, sizeof(l_loff_t));
1747         return (error);
1748 }
1749
1750 #define LINUX_MEMFD_PREFIX      "memfd:"
1751
1752 int
1753 linux_memfd_create(struct thread *td, struct linux_memfd_create_args *args)
1754 {
1755         char memfd_name[LINUX_NAME_MAX + 1];
1756         int error, flags, shmflags, oflags;
1757
1758         /*
1759          * This is our clever trick to avoid the heap allocation to copy in the
1760          * uname.  We don't really need to go this far out of our way, but it
1761          * does keep the rest of this function fairly clean as they don't have
1762          * to worry about cleanup on the way out.
1763          */
1764         error = copyinstr(args->uname_ptr,
1765             memfd_name + sizeof(LINUX_MEMFD_PREFIX) - 1,
1766             LINUX_NAME_MAX - sizeof(LINUX_MEMFD_PREFIX) - 1, NULL);
1767         if (error != 0) {
1768                 if (error == ENAMETOOLONG)
1769                         error = EINVAL;
1770                 return (error);
1771         }
1772
1773         memcpy(memfd_name, LINUX_MEMFD_PREFIX, sizeof(LINUX_MEMFD_PREFIX) - 1);
1774         flags = linux_to_bsd_bits(args->flags, mfd_bitmap, 0);
1775         if ((flags & ~(MFD_CLOEXEC | MFD_ALLOW_SEALING | MFD_HUGETLB |
1776             MFD_HUGE_MASK)) != 0)
1777                 return (EINVAL);
1778         /* Size specified but no HUGETLB. */
1779         if ((flags & MFD_HUGE_MASK) != 0 && (flags & MFD_HUGETLB) == 0)
1780                 return (EINVAL);
1781         /* We don't actually support HUGETLB. */
1782         if ((flags & MFD_HUGETLB) != 0)
1783                 return (ENOSYS);
1784         oflags = O_RDWR;
1785         shmflags = SHM_GROW_ON_WRITE;
1786         if ((flags & MFD_CLOEXEC) != 0)
1787                 oflags |= O_CLOEXEC;
1788         if ((flags & MFD_ALLOW_SEALING) != 0)
1789                 shmflags |= SHM_ALLOW_SEALING;
1790         return (kern_shm_open2(td, SHM_ANON, oflags, 0, shmflags, NULL,
1791             memfd_name));
1792 }
1793
1794 int
1795 linux_splice(struct thread *td, struct linux_splice_args *args)
1796 {
1797
1798         linux_msg(td, "syscall splice not really implemented");
1799
1800         /*
1801          * splice(2) is documented to return EINVAL in various circumstances;
1802          * returning it instead of ENOSYS should hint the caller to use fallback
1803          * instead.
1804          */
1805         return (EINVAL);
1806 }
1807
1808 int
1809 linux_close_range(struct thread *td, struct linux_close_range_args *args)
1810 {
1811         u_int flags = 0;
1812
1813         /*
1814          * Implementing close_range(CLOSE_RANGE_UNSHARE) allows Linux to
1815          * unshare filedesc table of the calling thread from others threads
1816          * in a thread group (i.e., process in the FreeBSD) or others processes,
1817          * which shares the same table, before closing the files. FreeBSD does
1818          * not have compatible unsharing mechanism due to the fact that sharing
1819          * process resources, including filedesc table, is at thread level in the
1820          * Linux, while in the FreeBSD it is at the process level.
1821          * Return EINVAL for now if the CLOSE_RANGE_UNSHARE flag is specified
1822          * until this new Linux API stabilizes.
1823          */
1824
1825         if ((args->flags & ~(LINUX_CLOSE_RANGE_CLOEXEC)) != 0)
1826                 return (EINVAL);
1827         if (args->first > args->last)
1828                 return (EINVAL);
1829         if ((args->flags & LINUX_CLOSE_RANGE_CLOEXEC) != 0)
1830                 flags |= CLOSE_RANGE_CLOEXEC;
1831         return (kern_close_range(td, flags, args->first, args->last));
1832 }
1833
1834 int
1835 linux_enobufs2eagain(struct thread *td, int fd, int error)
1836 {
1837         struct file *fp;
1838
1839         if (error != ENOBUFS)
1840                 return (error);
1841         if (fget(td, fd, &cap_no_rights, &fp) != 0)
1842                 return (error);
1843         if (fp->f_type == DTYPE_SOCKET && (fp->f_flag & FNONBLOCK) != 0)
1844                 error = EAGAIN;
1845         fdrop(fp, td);
1846         return (error);
1847 }
1848
1849 int
1850 linux_write(struct thread *td, struct linux_write_args *args)
1851 {
1852         struct write_args bargs = {
1853                 .fd     = args->fd,
1854                 .buf    = args->buf,
1855                 .nbyte  = args->nbyte,
1856         };
1857
1858         return (linux_enobufs2eagain(td, args->fd, sys_write(td, &bargs)));
1859 }
1860
1861 int
1862 linux_writev(struct thread *td, struct linux_writev_args *args)
1863 {
1864         struct uio *auio;
1865         int error;
1866
1867 #ifdef COMPAT_LINUX32
1868         error = freebsd32_copyinuio(PTRIN(args->iovp), args->iovcnt, &auio);
1869 #else
1870         error = copyinuio(args->iovp, args->iovcnt, &auio);
1871 #endif
1872         if (error != 0)
1873                 return (error);
1874         error = kern_writev(td, args->fd, auio);
1875         free(auio, M_IOV);
1876         return (linux_enobufs2eagain(td, args->fd, error));
1877 }