/*      $NetBSD: sys_memfd.c,v 1.11 2023/08/12 23:22:49 christos Exp $  */

/*-
* Copyright (c) 2023 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Theodore Preduta.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sys_memfd.c,v 1.11 2023/08/12 23:22:49 christos Exp $");

#include <sys/param.h>
#include <sys/types.h>

#include <sys/fcntl.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/memfd.h>
#include <sys/mman.h>
#include <sys/syscallargs.h>

#include <uvm/uvm_extern.h>
#include <uvm/uvm_object.h>

#define F_SEAL_ANY_WRITE        (F_SEAL_WRITE|F_SEAL_FUTURE_WRITE)
#define MFD_KNOWN_SEALS         (F_SEAL_SEAL|F_SEAL_SHRINK|F_SEAL_GROW \
                               |F_SEAL_WRITE|F_SEAL_FUTURE_WRITE)

static const char memfd_prefix[] = "memfd:";

static int memfd_read(file_t *, off_t *, struct uio *, kauth_cred_t, int);
static int memfd_write(file_t *, off_t *, struct uio *, kauth_cred_t, int);
static int memfd_ioctl(file_t *, u_long, void *);
static int memfd_fcntl(file_t *, u_int, void *);
static int memfd_stat(file_t *, struct stat *);
static int memfd_close(file_t *);
static int memfd_mmap(file_t *, off_t *, size_t, int, int *, int *,
   struct uvm_object **, int *);
static int memfd_seek(file_t *, off_t, int, off_t *, int);
static int memfd_truncate_locked(file_t *, off_t);
static int memfd_truncate(file_t *, off_t);

static const struct fileops memfd_fileops = {
       .fo_name = "memfd",
       .fo_read = memfd_read,
       .fo_write = memfd_write,
       .fo_ioctl = memfd_ioctl,
       .fo_fcntl = memfd_fcntl,
       .fo_poll = fnullop_poll,
       .fo_stat = memfd_stat,
       .fo_close = memfd_close,
       .fo_kqfilter = fnullop_kqfilter,
       .fo_restart = fnullop_restart,
       .fo_mmap = memfd_mmap,
       .fo_seek = memfd_seek,
       .fo_fpathconf = (void *)eopnotsupp,
       .fo_posix_fadvise = (void *)eopnotsupp,
       .fo_truncate = memfd_truncate,
};

/*
* memfd_create(2).  Creat a file descriptor associated with anonymous
* memory.
*/
int
sys_memfd_create(struct lwp *l, const struct sys_memfd_create_args *uap,
   register_t *retval)
{
       /* {
               syscallarg(const char *) name;
               syscallarg(unsigned int) flags;
       } */
       int error, fd;
       file_t *fp;
       struct memfd *mfd;
       struct proc *p = l->l_proc;
       const unsigned int flags = SCARG(uap, flags);

       if (flags & ~(MFD_CLOEXEC|MFD_ALLOW_SEALING))
               return EINVAL;

       mfd = kmem_zalloc(sizeof(*mfd), KM_SLEEP);
       mfd->mfd_size = 0;
       mfd->mfd_uobj = uao_create(INT64_MAX - PAGE_SIZE, 0); /* same as tmpfs */

       CTASSERT(sizeof(memfd_prefix) < NAME_MAX); /* sanity check */
       strcpy(mfd->mfd_name, memfd_prefix);
       error = copyinstr(SCARG(uap, name),
           &mfd->mfd_name[sizeof(memfd_prefix) - 1],
           sizeof(mfd->mfd_name) - sizeof(memfd_prefix), NULL);
       if (error != 0)
               goto leave;

       getnanotime(&mfd->mfd_btime);

       if ((flags & MFD_ALLOW_SEALING) == 0)
               mfd->mfd_seals |= F_SEAL_SEAL;

       error = fd_allocfile(&fp, &fd);
       if (error != 0)
               goto leave;

       fp->f_flag = FREAD|FWRITE;
       fp->f_type = DTYPE_MEMFD;
       fp->f_ops = &memfd_fileops;
       fp->f_memfd = mfd;
       fd_set_exclose(l, fd, (flags & MFD_CLOEXEC) != 0);
       fd_affix(p, fp, fd);

       *retval = fd;
       return 0;

leave:
       uao_detach(mfd->mfd_uobj);
       kmem_free(mfd, sizeof(*mfd));
       return error;
}

static int
memfd_read(file_t *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
   int flags)
{
       int error;
       vsize_t todo;
       struct memfd *mfd = fp->f_memfd;

       mutex_enter(&fp->f_lock);

       if (*offp < 0) {
               error = EINVAL;
               goto leave;
       }

       /* Trying to read past the end does nothing. */
       if (*offp >= mfd->mfd_size) {
               error = 0;
               goto leave;
       }

       uio->uio_offset = *offp;
       todo = MIN(uio->uio_resid, mfd->mfd_size - *offp);
       error = ubc_uiomove(mfd->mfd_uobj, uio, todo, UVM_ADV_SEQUENTIAL,
           UBC_READ|UBC_PARTIALOK);
       if (flags & FOF_UPDATE_OFFSET)
               *offp = uio->uio_offset;

leave:
       getnanotime(&mfd->mfd_atime);


       mutex_exit(&fp->f_lock);

       return error;
}

static int
memfd_write(file_t *fp, off_t *offp, struct uio *uio, kauth_cred_t cred,
   int flags)
{
       int error;
       vsize_t todo;
       struct memfd *mfd = fp->f_memfd;

       mutex_enter(&fp->f_lock);

       if (mfd->mfd_seals & F_SEAL_ANY_WRITE) {
               error = EPERM;
               goto leave;
       }

       if (*offp < 0) {
               error = EINVAL;
               goto leave;
       }

       uio->uio_offset = *offp;
       todo = uio->uio_resid;

       if (mfd->mfd_seals & F_SEAL_GROW) {
               if (*offp >= mfd->mfd_size) {
                       error = EPERM;
                       goto leave;
               }

               /* Truncate the write to fit in mfd_size */
               if (*offp + uio->uio_resid >= mfd->mfd_size)
                       todo = mfd->mfd_size - *offp;
       } else if (*offp + uio->uio_resid >= mfd->mfd_size) {
               /* Grow to accommodate the write request. */
               error = memfd_truncate_locked(fp, *offp + uio->uio_resid);
               if (error != 0)
                       goto leave;
       }

       error = ubc_uiomove(mfd->mfd_uobj, uio, todo, UVM_ADV_SEQUENTIAL,
           UBC_WRITE|UBC_PARTIALOK);
       if (flags & FOF_UPDATE_OFFSET)
               *offp = uio->uio_offset;

       getnanotime(&mfd->mfd_mtime);

leave:
       mutex_exit(&fp->f_lock);

       return error;
}

static int
memfd_ioctl(file_t *fp, u_long cmd, void *data)
{

       return EINVAL;
}

static int
memfd_fcntl(file_t *fp, u_int cmd, void *data)
{
       struct memfd *mfd = fp->f_memfd;
       int error = 0;

       switch (cmd) {
       case F_GETPATH:
               strncpy(data, mfd->mfd_name, MAXPATHLEN);
               return 0;

       case F_ADD_SEALS:
               mutex_enter(&fp->f_lock);

               if (mfd->mfd_seals & F_SEAL_SEAL) {
                       error = EPERM;
                       goto leave_add_seals;
               }

               if (*(int *)data & ~MFD_KNOWN_SEALS) {
                       error = EINVAL;
                       goto leave_add_seals;
               }

               /*
                * Can only add F_SEAL_WRITE if there are no currently
                * open mmaps.
                *
                * XXX should only disallow if there are no currently
                * open mmaps with PROT_WRITE.
                */
               if ((mfd->mfd_seals & F_SEAL_WRITE) == 0 &&
                   (*(int *)data & F_SEAL_WRITE) != 0 &&
                   mfd->mfd_uobj->uo_refs > 1)
               {
                       error = EBUSY;
                       goto leave_add_seals;
               }

               mfd->mfd_seals |= *(int *)data;

       leave_add_seals:
               mutex_exit(&fp->f_lock);
               return error;

       case F_GET_SEALS:
               mutex_enter(&fp->f_lock);
               *(int *)data = mfd->mfd_seals;
               mutex_exit(&fp->f_lock);
               return 0;

       default:
               return EINVAL;
       }
}

static int
memfd_stat(file_t *fp, struct stat *st)
{
       struct memfd *mfd = fp->f_memfd;

       mutex_enter(&fp->f_lock);

       memset(st, 0, sizeof(*st));
       st->st_uid = kauth_cred_geteuid(fp->f_cred);
       st->st_gid = kauth_cred_getegid(fp->f_cred);
       st->st_size = mfd->mfd_size;

       st->st_mode = S_IREAD;
       if ((mfd->mfd_seals & F_SEAL_ANY_WRITE) == 0)
               st->st_mode |= S_IWRITE;

       st->st_birthtimespec = mfd->mfd_btime;
       st->st_ctimespec = mfd->mfd_mtime;
       st->st_atimespec = mfd->mfd_atime;
       st->st_mtimespec = mfd->mfd_mtime;

       mutex_exit(&fp->f_lock);

       return 0;
}

static int
memfd_close(file_t *fp)
{
       struct memfd *mfd = fp->f_memfd;

       uao_detach(mfd->mfd_uobj);

       kmem_free(mfd, sizeof(*mfd));
       fp->f_memfd = NULL;

       return 0;
}

static int
memfd_mmap(file_t *fp, off_t *offp, size_t size, int prot, int *flagsp,
   int *advicep, struct uvm_object **uobjp, int *maxprotp)
{
       struct memfd *mfd = fp->f_memfd;
       int error = 0;

       /* uvm_mmap guarantees page-aligned offset and size.  */
       KASSERT(*offp == round_page(*offp));
       KASSERT(size == round_page(size));
       KASSERT(size > 0);

       mutex_enter(&fp->f_lock);

       if (*offp < 0) {
               error = EINVAL;
               goto leave;
       }
       if (*offp + size > mfd->mfd_size) {
               error = EINVAL;
               goto leave;
       }

       if ((mfd->mfd_seals & F_SEAL_ANY_WRITE) &&
           (prot & VM_PROT_WRITE) && (*flagsp & MAP_PRIVATE) == 0) {
               error = EPERM;
               goto leave;
       }

       uao_reference(fp->f_memfd->mfd_uobj);
       *uobjp = fp->f_memfd->mfd_uobj;

       *maxprotp = prot;
       *advicep = UVM_ADV_RANDOM;

leave:
       mutex_exit(&fp->f_lock);

       return error;
}

static int
memfd_seek(file_t *fp, off_t delta, int whence, off_t *newoffp,
   int flags)
{
       off_t newoff;
       int error = 0;

       mutex_enter(&fp->f_lock);

       switch (whence) {
       case SEEK_CUR:
               newoff = fp->f_offset + delta;
               break;

       case SEEK_END:
               newoff = fp->f_memfd->mfd_size + delta;
               break;

       case SEEK_SET:
               newoff = delta;
               break;

       default:
               error = EINVAL;
               goto leave;
       }

       if (newoffp)
               *newoffp = newoff;
       if (flags & FOF_UPDATE_OFFSET)
               fp->f_offset = newoff;

leave:
       mutex_exit(&fp->f_lock);

       return error;
}

static int
memfd_truncate_locked(file_t *fp, off_t length)
{
       struct memfd *mfd = fp->f_memfd;
       voff_t start, end;
       int error = 0;

       KASSERT(mutex_owned(&fp->f_lock));

       if (length < 0)
               return EINVAL;
       if (length == mfd->mfd_size)
               return 0;

       if ((mfd->mfd_seals & F_SEAL_SHRINK) && length < mfd->mfd_size)
               return EPERM;
       if ((mfd->mfd_seals & F_SEAL_GROW) && length > mfd->mfd_size)
               return EPERM;

       if (length > mfd->mfd_size)
               ubc_zerorange(mfd->mfd_uobj, mfd->mfd_size,
                   length - mfd->mfd_size, 0);
       else {
               /* length < mfd->mfd_size, so try to get rid of excess pages */
               start = round_page(length);
               end = round_page(mfd->mfd_size);

               if (start < end) { /* we actually have pages to remove */
                       rw_enter(mfd->mfd_uobj->vmobjlock, RW_WRITER);
                       error = (*mfd->mfd_uobj->pgops->pgo_put)(mfd->mfd_uobj,
                           start, end, PGO_FREE);
                       /* pgo_put drops vmobjlock */
               }
       }

       getnanotime(&mfd->mfd_mtime);
       mfd->mfd_size = length;

       return error;
}

static int
memfd_truncate(file_t *fp, off_t length)
{
       int error;

       mutex_enter(&fp->f_lock);
       error = memfd_truncate_locked(fp, length);
       mutex_exit(&fp->f_lock);
       return error;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.