 @@ -1,458 +1,458 @@
-/*	$NetBSD: sys_memfd.c,v 1.6 2023/07/29 17:54:54 christos Exp $	*/
+/*	$NetBSD: sys_memfd.c,v 1.7 2023/07/29 23:51:29 rin 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.6 2023/07/29 17:54:54 christos Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sys_memfd.c,v 1.7 2023/07/29 23:51:29 rin 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 do_memfd_truncate(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;
+	}
-	if (flags & FOF_UPDATE_OFFSET)
+	uio->uio_offset = *offp;
 		*offp = uio->uio_offset;
 	todo = MIN(uio->uio_resid, mfd->mfd_size - *offp);
 	error = ubc_uiomove(mfd->mfd_uobj, uio, todo, UVM_ADV_SEQUENTIAL,
 	    UBC_READ|UBC_PARTIALOK);
-	*offp = uio->uio_offset;
+	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 = do_memfd_truncate(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_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
 do_memfd_truncate(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 = do_memfd_truncate(fp, length);
 	mutex_exit(&fp->f_lock);
 	return error;
+}