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/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/dirent.h>
  35 #include <sys/fcntl.h>
  36 #include <sys/file.h>
  37 #include <sys/filedesc.h>
  38 #include <sys/lock.h>
  39 #include <sys/mman.h>
  40 #include <sys/selinfo.h>
  41 #include <sys/pipe.h>
  42 #include <sys/proc.h>
  43 #include <sys/stat.h>
  44 #include <sys/sx.h>
  45 #include <sys/syscallsubr.h>
  46 #include <sys/tty.h>
  47 #include <sys/unistd.h>
  48 #include <sys/vnode.h>
  49
  50 #ifdef COMPAT_LINUX32
  51 #include <compat/freebsd32/freebsd32_misc.h>
  52 #include <machine/../linux32/linux.h>
  53 #include <machine/../linux32/linux32_proto.h>
  54 #else
  55 #include <machine/../linux/linux.h>
  56 #include <machine/../linux/linux_proto.h>
  57 #endif
  58 #include <compat/linux/linux_misc.h>
  59 #include <compat/linux/linux_util.h>
  60 #include <compat/linux/linux_file.h>
  61
  62 static int      linux_common_open(struct thread *, int, const char *, int, int,
  63                     enum uio_seg);
  64 static int      linux_do_accessat(struct thread *t, int, const char *, int, int);
  65 static int      linux_getdents_error(struct thread *, int, int);
  66
  67 static struct bsd_to_linux_bitmap seal_bitmap[] = {
  68         BITMAP_1t1_LINUX(F_SEAL_SEAL),
  69         BITMAP_1t1_LINUX(F_SEAL_SHRINK),
  70         BITMAP_1t1_LINUX(F_SEAL_GROW),
  71         BITMAP_1t1_LINUX(F_SEAL_WRITE),
  72 };
  73
  74 #define MFD_HUGETLB_ENTRY(_size)                                        \
  75         {                                                               \
  76                 .bsd_value = MFD_HUGE_##_size,                          \
  77                 .linux_value = LINUX_HUGETLB_FLAG_ENCODE_##_size        \
  78         }
  79 static struct bsd_to_linux_bitmap mfd_bitmap[] = {
  80         BITMAP_1t1_LINUX(MFD_CLOEXEC),
  81         BITMAP_1t1_LINUX(MFD_ALLOW_SEALING),
  82         BITMAP_1t1_LINUX(MFD_HUGETLB),
  83         MFD_HUGETLB_ENTRY(64KB),
  84         MFD_HUGETLB_ENTRY(512KB),
  85         MFD_HUGETLB_ENTRY(1MB),
  86         MFD_HUGETLB_ENTRY(2MB),
  87         MFD_HUGETLB_ENTRY(8MB),
  88         MFD_HUGETLB_ENTRY(16MB),
  89         MFD_HUGETLB_ENTRY(32MB),
  90         MFD_HUGETLB_ENTRY(256MB),
  91         MFD_HUGETLB_ENTRY(512MB),
  92         MFD_HUGETLB_ENTRY(1GB),
  93         MFD_HUGETLB_ENTRY(2GB),
  94         MFD_HUGETLB_ENTRY(16GB),
  95 };
  96 #undef MFD_HUGETLB_ENTRY
  97
  98 #ifdef LINUX_LEGACY_SYSCALLS
  99 int
 100 linux_creat(struct thread *td, struct linux_creat_args *args)
 101 {
 102
 103         return (kern_openat(td, AT_FDCWD, args->path, UIO_USERSPACE,
 104             O_WRONLY | O_CREAT | O_TRUNC, args->mode));
 105 }
 106 #endif
 107
 108 static int
 109 linux_common_openflags(int l_flags)
 110 {
 111         int bsd_flags;
 112
 113         bsd_flags = 0;
 114         switch (l_flags & LINUX_O_ACCMODE) {
 115         case LINUX_O_WRONLY:
 116                 bsd_flags |= O_WRONLY;
 117                 break;
 118         case LINUX_O_RDWR:
 119                 bsd_flags |= O_RDWR;
 120                 break;
 121         default:
 122                 bsd_flags |= O_RDONLY;
 123         }
 124         if (l_flags & LINUX_O_NDELAY)
 125                 bsd_flags |= O_NONBLOCK;
 126         if (l_flags & LINUX_O_APPEND)
 127                 bsd_flags |= O_APPEND;
 128         if (l_flags & LINUX_O_SYNC)
 129                 bsd_flags |= O_FSYNC;
 130         if (l_flags & LINUX_O_CLOEXEC)
 131                 bsd_flags |= O_CLOEXEC;
 132         if (l_flags & LINUX_O_NONBLOCK)
 133                 bsd_flags |= O_NONBLOCK;
 134         if (l_flags & LINUX_O_ASYNC)
 135                 bsd_flags |= O_ASYNC;
 136         if (l_flags & LINUX_O_CREAT)
 137                 bsd_flags |= O_CREAT;
 138         if (l_flags & LINUX_O_TRUNC)
 139                 bsd_flags |= O_TRUNC;
 140         if (l_flags & LINUX_O_EXCL)
 141                 bsd_flags |= O_EXCL;
 142         if (l_flags & LINUX_O_NOCTTY)
 143                 bsd_flags |= O_NOCTTY;
 144         if (l_flags & LINUX_O_DIRECT)
 145                 bsd_flags |= O_DIRECT;
 146         if (l_flags & LINUX_O_NOFOLLOW)
 147                 bsd_flags |= O_NOFOLLOW;
 148         if (l_flags & LINUX_O_DIRECTORY)
 149                 bsd_flags |= O_DIRECTORY;
 150         if (l_flags & LINUX_O_PATH)
 151                 bsd_flags |= O_PATH;
 152         /* XXX LINUX_O_NOATIME: unable to be easily implemented. */
 153         return (bsd_flags);
 154 }
 155
 156 static int
 157 linux_common_open(struct thread *td, int dirfd, const char *path, int l_flags,
 158     int mode, enum uio_seg seg)
 159 {
 160         struct proc *p = td->td_proc;
 161         struct file *fp;
 162         int fd;
 163         int bsd_flags, error;
 164
 165         bsd_flags = linux_common_openflags(l_flags);
 166         error = kern_openat(td, dirfd, path, seg, bsd_flags, mode);
 167         if (error != 0) {
 168                 if (error == EMLINK)
 169                         error = ELOOP;
 170                 goto done;
 171         }
 172         if (p->p_flag & P_CONTROLT)
 173                 goto done;
 174         if (bsd_flags & O_NOCTTY)
 175                 goto done;
 176
 177         /*
 178          * XXX In between kern_openat() and fget(), another process
 179          * having the same filedesc could use that fd without
 180          * checking below.
 181         */
 182         fd = td->td_retval[0];
 183         if (fget(td, fd, &cap_ioctl_rights, &fp) == 0) {
 184                 if (fp->f_type != DTYPE_VNODE) {
 185                         fdrop(fp, td);
 186                         goto done;
 187                 }
 188                 sx_slock(&proctree_lock);
 189                 PROC_LOCK(p);
 190                 if (SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
 191                         PROC_UNLOCK(p);
 192                         sx_sunlock(&proctree_lock);
 193                         /* XXXPJD: Verify if TIOCSCTTY is allowed. */
 194                         (void) fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0,
 195                             td->td_ucred, td);
 196                 } else {
 197                         PROC_UNLOCK(p);
 198                         sx_sunlock(&proctree_lock);
 199                 }
 200                 fdrop(fp, td);
 201         }
 202
 203 done:
 204         return (error);
 205 }
 206
 207 int
 208 linux_openat(struct thread *td, struct linux_openat_args *args)
 209 {
 210         int dfd;
 211
 212         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 213         return (linux_common_open(td, dfd, args->filename, args->flags,
 214             args->mode, UIO_USERSPACE));
 215 }
 216
 217 #ifdef LINUX_LEGACY_SYSCALLS
 218 int
 219 linux_open(struct thread *td, struct linux_open_args *args)
 220 {
 221
 222         return (linux_common_open(td, AT_FDCWD, args->path, args->flags,
 223             args->mode, UIO_USERSPACE));
 224 }
 225 #endif
 226
 227 int
 228 linux_name_to_handle_at(struct thread *td,
 229     struct linux_name_to_handle_at_args *args)
 230 {
 231         static const l_int valid_flags = (LINUX_AT_SYMLINK_FOLLOW |
 232             LINUX_AT_EMPTY_PATH);
 233         static const l_uint fh_size = sizeof(fhandle_t);
 234
 235         fhandle_t fh;
 236         l_uint fh_bytes;
 237         l_int mount_id;
 238         int error, fd, bsd_flags;
 239
 240         if (args->flags & ~valid_flags)
 241                 return (EINVAL);
 242
 243         fd = args->dirfd;
 244         if (fd == LINUX_AT_FDCWD)
 245                 fd = AT_FDCWD;
 246
 247         bsd_flags = 0;
 248         if (!(args->flags & LINUX_AT_SYMLINK_FOLLOW))
 249                 bsd_flags |= AT_SYMLINK_NOFOLLOW;
 250         if ((args->flags & LINUX_AT_EMPTY_PATH) != 0)
 251                 bsd_flags |= AT_EMPTY_PATH;
 252
 253         error = kern_getfhat(td, bsd_flags, fd, args->name,
 254             UIO_USERSPACE, &fh, UIO_SYSSPACE);
 255         if (error != 0)
 256                 return (error);
 257
 258         /* Emit mount_id -- required before EOVERFLOW case. */
 259         mount_id = (fh.fh_fsid.val[0] ^ fh.fh_fsid.val[1]);
 260         error = copyout(&mount_id, args->mnt_id, sizeof(mount_id));
 261         if (error != 0)
 262                 return (error);
 263
 264         /* Check if there is room for handle. */
 265         error = copyin(&args->handle->handle_bytes, &fh_bytes,
 266             sizeof(fh_bytes));
 267         if (error != 0)
 268                 return (error);
 269
 270         if (fh_bytes < fh_size) {
 271                 error = copyout(&fh_size, &args->handle->handle_bytes,
 272                     sizeof(fh_size));
 273                 if (error == 0)
 274                         error = EOVERFLOW;
 275                 return (error);
 276         }
 277
 278         /* Emit handle. */
 279         mount_id = 0;
 280         /*
 281          * We don't use handle_type for anything yet, but initialize a known
 282          * value.
 283          */
 284         error = copyout(&mount_id, &args->handle->handle_type,
 285             sizeof(mount_id));
 286         if (error != 0)
 287                 return (error);
 288
 289         error = copyout(&fh, &args->handle->f_handle,
 290             sizeof(fh));
 291         return (error);
 292 }
 293
 294 int
 295 linux_open_by_handle_at(struct thread *td,
 296     struct linux_open_by_handle_at_args *args)
 297 {
 298         l_uint fh_bytes;
 299         int bsd_flags, error;
 300
 301         error = copyin(&args->handle->handle_bytes, &fh_bytes,
 302             sizeof(fh_bytes));
 303         if (error != 0)
 304                 return (error);
 305
 306         if (fh_bytes < sizeof(fhandle_t))
 307                 return (EINVAL);
 308
 309         bsd_flags = linux_common_openflags(args->flags);
 310         return (kern_fhopen(td, (void *)&args->handle->f_handle, bsd_flags));
 311 }
 312
 313 int
 314 linux_lseek(struct thread *td, struct linux_lseek_args *args)
 315 {
 316
 317         return (kern_lseek(td, args->fdes, args->off, args->whence));
 318 }
 319
 320 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 321 int
 322 linux_llseek(struct thread *td, struct linux_llseek_args *args)
 323 {
 324         int error;
 325         off_t off;
 326
 327         off = (args->olow) | (((off_t) args->ohigh) << 32);
 328
 329         error = kern_lseek(td, args->fd, off, args->whence);
 330         if (error != 0)
 331                 return (error);
 332
 333         error = copyout(td->td_retval, args->res, sizeof(off_t));
 334         if (error != 0)
 335                 return (error);
 336
 337         td->td_retval[0] = 0;
 338         return (0);
 339 }
 340 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 341
 342 /*
 343  * Note that linux_getdents(2) and linux_getdents64(2) have the same
 344  * arguments. They only differ in the definition of struct dirent they
 345  * operate on.
 346  * Note that linux_readdir(2) is a special case of linux_getdents(2)
 347  * where count is always equals 1, meaning that the buffer is one
 348  * dirent-structure in size and that the code can't handle more anyway.
 349  * Note that linux_readdir(2) can't be implemented by means of linux_getdents(2)
 350  * as in case when the *dent buffer size is equal to 1 linux_getdents(2) will
 351  * trash user stack.
 352  */
 353
 354 static int
 355 linux_getdents_error(struct thread *td, int fd, int err)
 356 {
 357         struct vnode *vp;
 358         struct file *fp;
 359         int error;
 360
 361         /* Linux return ENOTDIR in case when fd is not a directory. */
 362         error = getvnode(td, fd, &cap_read_rights, &fp);
 363         if (error != 0)
 364                 return (error);
 365         vp = fp->f_vnode;
 366         if (vp->v_type != VDIR) {
 367                 fdrop(fp, td);
 368                 return (ENOTDIR);
 369         }
 370         fdrop(fp, td);
 371         return (err);
 372 }
 373
 374 struct l_dirent {
 375         l_ulong         d_ino;
 376         l_off_t         d_off;
 377         l_ushort        d_reclen;
 378         char            d_name[LINUX_NAME_MAX + 1];
 379 };
 380
 381 struct l_dirent64 {
 382         uint64_t        d_ino;
 383         int64_t         d_off;
 384         l_ushort        d_reclen;
 385         u_char          d_type;
 386         char            d_name[LINUX_NAME_MAX + 1];
 387 };
 388
 389 /*
 390  * Linux uses the last byte in the dirent buffer to store d_type,
 391  * at least glibc-2.7 requires it. That is why l_dirent is padded with 2 bytes.
 392  */
 393 #define LINUX_RECLEN(namlen)                                            \
 394     roundup(offsetof(struct l_dirent, d_name) + (namlen) + 2, sizeof(l_ulong))
 395
 396 #define LINUX_RECLEN64(namlen)                                          \
 397     roundup(offsetof(struct l_dirent64, d_name) + (namlen) + 1,         \
 398     sizeof(uint64_t))
 399
 400 #ifdef LINUX_LEGACY_SYSCALLS
 401 int
 402 linux_getdents(struct thread *td, struct linux_getdents_args *args)
 403 {
 404         struct dirent *bdp;
 405         caddr_t inp, buf;               /* BSD-format */
 406         int len, reclen;                /* BSD-format */
 407         caddr_t outp;                   /* Linux-format */
 408         int resid, linuxreclen;         /* Linux-format */
 409         caddr_t lbuf;                   /* Linux-format */
 410         off_t base;
 411         struct l_dirent *linux_dirent;
 412         int buflen, error;
 413         size_t retval;
 414
 415         buflen = min(args->count, MAXBSIZE);
 416         buf = malloc(buflen, M_LINUX, M_WAITOK);
 417
 418         error = kern_getdirentries(td, args->fd, buf, buflen,
 419             &base, NULL, UIO_SYSSPACE);
 420         if (error != 0) {
 421                 error = linux_getdents_error(td, args->fd, error);
 422                 goto out1;
 423         }
 424
 425         lbuf = malloc(LINUX_RECLEN(LINUX_NAME_MAX), M_LINUX, M_WAITOK | M_ZERO);
 426
 427         len = td->td_retval[0];
 428         inp = buf;
 429         outp = (caddr_t)args->dent;
 430         resid = args->count;
 431         retval = 0;
 432
 433         while (len > 0) {
 434                 bdp = (struct dirent *) inp;
 435                 reclen = bdp->d_reclen;
 436                 linuxreclen = LINUX_RECLEN(bdp->d_namlen);
 437                 /*
 438                  * No more space in the user supplied dirent buffer.
 439                  * Return EINVAL.
 440                  */
 441                 if (resid < linuxreclen) {
 442                         error = EINVAL;
 443                         goto out;
 444                 }
 445
 446                 linux_dirent = (struct l_dirent*)lbuf;
 447                 linux_dirent->d_ino = bdp->d_fileno;
 448                 linux_dirent->d_off = bdp->d_off;
 449                 linux_dirent->d_reclen = linuxreclen;
 450                 /*
 451                  * Copy d_type to last byte of l_dirent buffer
 452                  */
 453                 lbuf[linuxreclen - 1] = bdp->d_type;
 454                 strlcpy(linux_dirent->d_name, bdp->d_name,
 455                     linuxreclen - offsetof(struct l_dirent, d_name)-1);
 456                 error = copyout(linux_dirent, outp, linuxreclen);
 457                 if (error != 0)
 458                         goto out;
 459
 460                 inp += reclen;
 461                 base += reclen;
 462                 len -= reclen;
 463
 464                 retval += linuxreclen;
 465                 outp += linuxreclen;
 466                 resid -= linuxreclen;
 467         }
 468         td->td_retval[0] = retval;
 469
 470 out:
 471         free(lbuf, M_LINUX);
 472 out1:
 473         free(buf, M_LINUX);
 474         return (error);
 475 }
 476 #endif
 477
 478 int
 479 linux_getdents64(struct thread *td, struct linux_getdents64_args *args)
 480 {
 481         struct dirent *bdp;
 482         caddr_t inp, buf;               /* BSD-format */
 483         int len, reclen;                /* BSD-format */
 484         caddr_t outp;                   /* Linux-format */
 485         int resid, linuxreclen;         /* Linux-format */
 486         off_t base;
 487         struct l_dirent64 *linux_dirent64;
 488         int buflen, error;
 489         size_t retval;
 490
 491         buflen = min(args->count, MAXBSIZE);
 492         buf = malloc(buflen, M_LINUX, M_WAITOK);
 493
 494         error = kern_getdirentries(td, args->fd, buf, buflen,
 495             &base, NULL, UIO_SYSSPACE);
 496         if (error != 0) {
 497                 error = linux_getdents_error(td, args->fd, error);
 498                 goto out1;
 499         }
 500
 501         linux_dirent64 = malloc(LINUX_RECLEN64(LINUX_NAME_MAX), M_LINUX,
 502             M_WAITOK | M_ZERO);
 503
 504         len = td->td_retval[0];
 505         inp = buf;
 506         outp = (caddr_t)args->dirent;
 507         resid = args->count;
 508         retval = 0;
 509
 510         while (len > 0) {
 511                 bdp = (struct dirent *) inp;
 512                 reclen = bdp->d_reclen;
 513                 linuxreclen = LINUX_RECLEN64(bdp->d_namlen);
 514                 /*
 515                  * No more space in the user supplied dirent buffer.
 516                  * Return EINVAL.
 517                  */
 518                 if (resid < linuxreclen) {
 519                         error = EINVAL;
 520                         goto out;
 521                 }
 522
 523                 linux_dirent64->d_ino = bdp->d_fileno;
 524                 linux_dirent64->d_off = bdp->d_off;
 525                 linux_dirent64->d_reclen = linuxreclen;
 526                 linux_dirent64->d_type = bdp->d_type;
 527                 strlcpy(linux_dirent64->d_name, bdp->d_name,
 528                     linuxreclen - offsetof(struct l_dirent64, d_name));
 529                 error = copyout(linux_dirent64, outp, linuxreclen);
 530                 if (error != 0)
 531                         goto out;
 532
 533                 inp += reclen;
 534                 base += reclen;
 535                 len -= reclen;
 536
 537                 retval += linuxreclen;
 538                 outp += linuxreclen;
 539                 resid -= linuxreclen;
 540         }
 541         td->td_retval[0] = retval;
 542
 543 out:
 544         free(linux_dirent64, M_LINUX);
 545 out1:
 546         free(buf, M_LINUX);
 547         return (error);
 548 }
 549
 550 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 551 int
 552 linux_readdir(struct thread *td, struct linux_readdir_args *args)
 553 {
 554         struct dirent *bdp;
 555         caddr_t buf;                    /* BSD-format */
 556         int linuxreclen;                /* Linux-format */
 557         off_t base;
 558         struct l_dirent *linux_dirent;  /* Linux-format */
 559         int buflen, error;
 560
 561         buflen = sizeof(*bdp);
 562         buf = malloc(buflen, M_LINUX, M_WAITOK);
 563
 564         error = kern_getdirentries(td, args->fd, buf, buflen,
 565             &base, NULL, UIO_SYSSPACE);
 566         if (error != 0) {
 567                 error = linux_getdents_error(td, args->fd, error);
 568                 goto out;
 569         }
 570         if (td->td_retval[0] == 0)
 571                 goto out;
 572
 573         linux_dirent = malloc(LINUX_RECLEN(LINUX_NAME_MAX), M_LINUX,
 574             M_WAITOK | M_ZERO);
 575
 576         bdp = (struct dirent *) buf;
 577         linuxreclen = LINUX_RECLEN(bdp->d_namlen);
 578
 579         linux_dirent->d_ino = bdp->d_fileno;
 580         linux_dirent->d_off = bdp->d_off;
 581         linux_dirent->d_reclen = bdp->d_namlen;
 582         strlcpy(linux_dirent->d_name, bdp->d_name,
 583             linuxreclen - offsetof(struct l_dirent, d_name));
 584         error = copyout(linux_dirent, args->dent, linuxreclen);
 585         if (error == 0)
 586                 td->td_retval[0] = linuxreclen;
 587
 588         free(linux_dirent, M_LINUX);
 589 out:
 590         free(buf, M_LINUX);
 591         return (error);
 592 }
 593 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 594
 595 /*
 596  * These exist mainly for hooks for doing /compat/linux translation.
 597  */
 598
 599 #ifdef LINUX_LEGACY_SYSCALLS
 600 int
 601 linux_access(struct thread *td, struct linux_access_args *args)
 602 {
 603
 604         /* Linux convention. */
 605         if (args->amode & ~(F_OK | X_OK | W_OK | R_OK))
 606                 return (EINVAL);
 607
 608         return (kern_accessat(td, AT_FDCWD, args->path, UIO_USERSPACE, 0,
 609             args->amode));
 610 }
 611 #endif
 612
 613 static int
 614 linux_do_accessat(struct thread *td, int ldfd, const char *filename,
 615     int amode, int flags)
 616 {
 617         int dfd;
 618
 619         /* Linux convention. */
 620         if (amode & ~(F_OK | X_OK | W_OK | R_OK))
 621                 return (EINVAL);
 622
 623         dfd = (ldfd == LINUX_AT_FDCWD) ? AT_FDCWD : ldfd;
 624         return (kern_accessat(td, dfd, filename, UIO_USERSPACE, flags, amode));
 625 }
 626
 627 int
 628 linux_faccessat(struct thread *td, struct linux_faccessat_args *args)
 629 {
 630
 631         return (linux_do_accessat(td, args->dfd, args->filename, args->amode,
 632             0));
 633 }
 634
 635 int
 636 linux_faccessat2(struct thread *td, struct linux_faccessat2_args *args)
 637 {
 638         int flags, unsupported;
 639
 640         /* XXX. AT_SYMLINK_NOFOLLOW is not supported by kern_accessat */
 641         unsupported = args->flags & ~(LINUX_AT_EACCESS | LINUX_AT_EMPTY_PATH);
 642         if (unsupported != 0) {
 643                 linux_msg(td, "faccessat2 unsupported flag 0x%x", unsupported);
 644                 return (EINVAL);
 645         }
 646
 647         flags = (args->flags & LINUX_AT_EACCESS) == 0 ? 0 :
 648             AT_EACCESS;
 649         flags |= (args->flags & LINUX_AT_EMPTY_PATH) == 0 ? 0 :
 650             AT_EMPTY_PATH;
 651         return (linux_do_accessat(td, args->dfd, args->filename, args->amode,
 652             flags));
 653 }
 654
 655
 656 #ifdef LINUX_LEGACY_SYSCALLS
 657 int
 658 linux_unlink(struct thread *td, struct linux_unlink_args *args)
 659 {
 660         int error;
 661         struct stat st;
 662
 663         error = kern_funlinkat(td, AT_FDCWD, args->path, FD_NONE,
 664             UIO_USERSPACE, 0, 0);
 665         if (error == EPERM) {
 666                 /* Introduce POSIX noncompliant behaviour of Linux */
 667                 if (kern_statat(td, 0, AT_FDCWD, args->path,
 668                     UIO_USERSPACE, &st) == 0) {
 669                         if (S_ISDIR(st.st_mode))
 670                                 error = EISDIR;
 671                 }
 672         }
 673
 674         return (error);
 675 }
 676 #endif
 677
 678 static int
 679 linux_unlinkat_impl(struct thread *td, enum uio_seg pathseg, const char *path,
 680     int dfd, struct linux_unlinkat_args *args)
 681 {
 682         struct stat st;
 683         int error;
 684
 685         if (args->flag & LINUX_AT_REMOVEDIR)
 686                 error = kern_frmdirat(td, dfd, path, FD_NONE, pathseg, 0);
 687         else
 688                 error = kern_funlinkat(td, dfd, path, FD_NONE, pathseg, 0, 0);
 689         if (error == EPERM && !(args->flag & LINUX_AT_REMOVEDIR)) {
 690                 /* Introduce POSIX noncompliant behaviour of Linux */
 691                 if (kern_statat(td, AT_SYMLINK_NOFOLLOW, dfd, path,
 692                     pathseg, &st) == 0 && S_ISDIR(st.st_mode))
 693                         error = EISDIR;
 694         }
 695         return (error);
 696 }
 697
 698 int
 699 linux_unlinkat(struct thread *td, struct linux_unlinkat_args *args)
 700 {
 701         int dfd;
 702
 703         if (args->flag & ~LINUX_AT_REMOVEDIR)
 704                 return (EINVAL);
 705         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 706         return (linux_unlinkat_impl(td, UIO_USERSPACE, args->pathname,
 707             dfd, args));
 708 }
 709
 710 int
 711 linux_chdir(struct thread *td, struct linux_chdir_args *args)
 712 {
 713
 714         return (kern_chdir(td, args->path, UIO_USERSPACE));
 715 }
 716
 717 #ifdef LINUX_LEGACY_SYSCALLS
 718 int
 719 linux_chmod(struct thread *td, struct linux_chmod_args *args)
 720 {
 721
 722         return (kern_fchmodat(td, AT_FDCWD, args->path, UIO_USERSPACE,
 723             args->mode, 0));
 724 }
 725 #endif
 726
 727 int
 728 linux_fchmodat(struct thread *td, struct linux_fchmodat_args *args)
 729 {
 730         int dfd;
 731
 732         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 733         return (kern_fchmodat(td, dfd, args->filename, UIO_USERSPACE,
 734             args->mode, 0));
 735 }
 736
 737 #ifdef LINUX_LEGACY_SYSCALLS
 738 int
 739 linux_mkdir(struct thread *td, struct linux_mkdir_args *args)
 740 {
 741
 742         return (kern_mkdirat(td, AT_FDCWD, args->path, UIO_USERSPACE, args->mode));
 743 }
 744 #endif
 745
 746 int
 747 linux_mkdirat(struct thread *td, struct linux_mkdirat_args *args)
 748 {
 749         int dfd;
 750
 751         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 752         return (kern_mkdirat(td, dfd, args->pathname, UIO_USERSPACE, args->mode));
 753 }
 754
 755 #ifdef LINUX_LEGACY_SYSCALLS
 756 int
 757 linux_rmdir(struct thread *td, struct linux_rmdir_args *args)
 758 {
 759
 760         return (kern_frmdirat(td, AT_FDCWD, args->path, FD_NONE,
 761             UIO_USERSPACE, 0));
 762 }
 763
 764 int
 765 linux_rename(struct thread *td, struct linux_rename_args *args)
 766 {
 767
 768         return (kern_renameat(td, AT_FDCWD, args->from, AT_FDCWD,
 769             args->to, UIO_USERSPACE));
 770 }
 771 #endif
 772
 773 int
 774 linux_renameat(struct thread *td, struct linux_renameat_args *args)
 775 {
 776         struct linux_renameat2_args renameat2_args = {
 777             .olddfd = args->olddfd,
 778             .oldname = args->oldname,
 779             .newdfd = args->newdfd,
 780             .newname = args->newname,
 781             .flags = 0
 782         };
 783
 784         return (linux_renameat2(td, &renameat2_args));
 785 }
 786
 787 int
 788 linux_renameat2(struct thread *td, struct linux_renameat2_args *args)
 789 {
 790         int olddfd, newdfd;
 791
 792         if (args->flags != 0) {
 793                 if (args->flags & ~(LINUX_RENAME_EXCHANGE |
 794                     LINUX_RENAME_NOREPLACE | LINUX_RENAME_WHITEOUT))
 795                         return (EINVAL);
 796                 if (args->flags & LINUX_RENAME_EXCHANGE &&
 797                     args->flags & (LINUX_RENAME_NOREPLACE |
 798                     LINUX_RENAME_WHITEOUT))
 799                         return (EINVAL);
 800 #if 0
 801                 /*
 802                  * This spams the console on Ubuntu Focal.
 803                  *
 804                  * What's needed here is a general mechanism to let users know
 805                  * about missing features without hogging the system.
 806                  */
 807                 linux_msg(td, "renameat2 unsupported flags 0x%x",
 808                     args->flags);
 809 #endif
 810                 return (EINVAL);
 811         }
 812
 813         olddfd = (args->olddfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->olddfd;
 814         newdfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd;
 815         return (kern_renameat(td, olddfd, args->oldname, newdfd,
 816             args->newname, UIO_USERSPACE));
 817 }
 818
 819 #ifdef LINUX_LEGACY_SYSCALLS
 820 int
 821 linux_symlink(struct thread *td, struct linux_symlink_args *args)
 822 {
 823
 824         return (kern_symlinkat(td, args->path, AT_FDCWD, args->to,
 825             UIO_USERSPACE));
 826 }
 827 #endif
 828
 829 int
 830 linux_symlinkat(struct thread *td, struct linux_symlinkat_args *args)
 831 {
 832         int dfd;
 833
 834         dfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd;
 835         return (kern_symlinkat(td, args->oldname, dfd, args->newname,
 836             UIO_USERSPACE));
 837 }
 838
 839 #ifdef LINUX_LEGACY_SYSCALLS
 840 int
 841 linux_readlink(struct thread *td, struct linux_readlink_args *args)
 842 {
 843
 844         if (args->count <= 0)
 845                 return (EINVAL);
 846
 847         return (kern_readlinkat(td, AT_FDCWD, args->name, UIO_USERSPACE,
 848             args->buf, UIO_USERSPACE, args->count));
 849 }
 850 #endif
 851
 852 int
 853 linux_readlinkat(struct thread *td, struct linux_readlinkat_args *args)
 854 {
 855         int dfd;
 856
 857         if (args->bufsiz <= 0)
 858                 return (EINVAL);
 859
 860         dfd = (args->dfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->dfd;
 861         return (kern_readlinkat(td, dfd, args->path, UIO_USERSPACE,
 862             args->buf, UIO_USERSPACE, args->bufsiz));
 863 }
 864
 865 int
 866 linux_truncate(struct thread *td, struct linux_truncate_args *args)
 867 {
 868
 869         return (kern_truncate(td, args->path, UIO_USERSPACE, args->length));
 870 }
 871
 872 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 873 int
 874 linux_truncate64(struct thread *td, struct linux_truncate64_args *args)
 875 {
 876         off_t length;
 877
 878 #if defined(__amd64__) && defined(COMPAT_LINUX32)
 879         length = PAIR32TO64(off_t, args->length);
 880 #else
 881         length = args->length;
 882 #endif
 883
 884         return (kern_truncate(td, args->path, UIO_USERSPACE, length));
 885 }
 886 #endif /* __i386__ || (__amd64__ && COMPAT_LINUX32) */
 887
 888 int
 889 linux_ftruncate(struct thread *td, struct linux_ftruncate_args *args)
 890 {
 891
 892         return (kern_ftruncate(td, args->fd, args->length));
 893 }
 894
 895 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32))
 896 int
 897 linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args)
 898 {
 899         off_t length;
 900
 901 #if defined(__amd64__) && defined(COMPAT_LINUX32)
 902         length = PAIR32TO64(off_t, args->length);
 903 #else
 904         length = args->length;
 905 #endif
 906
 907         return (kern_ftruncate(td, args->fd, length));
 908 }
 909 #endif
 910
 911 #ifdef LINUX_LEGACY_SYSCALLS
 912 int
 913 linux_link(struct thread *td, struct linux_link_args *args)
 914 {
 915
 916         return (kern_linkat(td, AT_FDCWD, AT_FDCWD, args->path, args->to,
 917             UIO_USERSPACE, AT_SYMLINK_FOLLOW));
 918 }
 919 #endif
 920
 921 int
 922 linux_linkat(struct thread *td, struct linux_linkat_args *args)
 923 {
 924         int olddfd, newdfd, flag;
 925
 926         if (args->flag & ~(LINUX_AT_SYMLINK_FOLLOW | LINUX_AT_EMPTY_PATH))
 927                 return (EINVAL);
 928
 929         flag = (args->flag & LINUX_AT_SYMLINK_FOLLOW) != 0 ? AT_SYMLINK_FOLLOW :
 930             0;
 931         flag |= (args->flag & LINUX_AT_EMPTY_PATH) != 0 ? AT_EMPTY_PATH : 0;
 932
 933         olddfd = (args->olddfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->olddfd;
 934         newdfd = (args->newdfd == LINUX_AT_FDCWD) ? AT_FDCWD : args->newdfd;
 935         return (kern_linkat(td, olddfd, newdfd, args->oldname,
 936             args->newname, UIO_USERSPACE, flag));
 937 }
 938
 939 int
 940 linux_fdatasync(struct thread *td, struct linux_fdatasync_args *uap)
 941 {
 942
 943         return (kern_fsync(td, uap->fd, false));
 944 }
 945
 946 int
 947 linux_sync_file_range(struct thread *td, struct linux_sync_file_range_args *uap)
 948 {
 949         off_t nbytes, offset;
 950
 951 #if defined(__amd64__) && defined(COMPAT_LINUX32)
 952         nbytes = PAIR32TO64(off_t, uap->nbytes);
 953         offset = PAIR32TO64(off_t, uap->offset);
 954 #else
 955         nbytes = uap->nbytes;
 956         offset = uap->offset;
 957 #endif
 958
 959         if (offset < 0 || nbytes < 0 ||
 960             (uap->flags & ~(LINUX_SYNC_FILE_RANGE_WAIT_BEFORE |
 961             LINUX_SYNC_FILE_RANGE_WRITE |
 962             LINUX_SYNC_FILE_RANGE_WAIT_AFTER)) != 0) {
 963                 return (EINVAL);
 964         }
 965
 966         return (kern_fsync(td, uap->fd, false));
 967 }
 968
 969 int
 970 linux_pread(struct thread *td, struct linux_pread_args *uap)
 971 {
 972         struct vnode *vp;
 973         off_t offset;
 974         int error;
 975
 976 #if defined(__amd64__) && defined(COMPAT_LINUX32)
 977         offset = PAIR32TO64(off_t, uap->offset);
 978 #else
 979         offset = uap->offset;
 980 #endif
 981
 982         error = kern_pread(td, uap->fd, uap->buf, uap->nbyte, offset);
 983         if (error == 0) {
 984                 /* This seems to violate POSIX but Linux does it. */
 985                 error = fgetvp(td, uap->fd, &cap_pread_rights, &vp);
 986                 if (error != 0)
 987                         return (error);
 988                 if (vp->v_type == VDIR)
 989                         error = EISDIR;
 990                 vrele(vp);
 991         }
 992         return (error);
 993 }
 994
 995 int
 996 linux_pwrite(struct thread *td, struct linux_pwrite_args *uap)
 997 {
 998         off_t offset;
 999
1000 #if defined(__amd64__) && defined(COMPAT_LINUX32)
1001         offset = PAIR32TO64(off_t, uap->offset);
1002 #else
1003         offset = uap->offset;
1004 #endif
1005
1006         return (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 = linux32_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 = linux32_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 (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 }