common/syscall/mmapobjsys.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <sys/errno.h>
#include <sys/mman.h>
#include <sys/cred.h>
#include <sys/model.h>
#include <sys/vnode.h>
#include <sys/systm.h>
#include <sys/kmem.h>
#include <sys/file.h>
#include <sys/vfs.h>
#include <sys/sysmacros.h>
#include <sys/mmapobj.h>

/*
 * We will "allocate" this many mmapobj_result_t segments on the stack
 * in an attempt to avoid the need to call kmem_alloc. This value should
 * cover 99% of the known ELF libraries as well as AOUT (4.x) libraries.
 */
#define	MOBJ_STACK_SEGS	6

static void
mmapobj_copy_64to32(mmapobj_result_t *source, mmapobj_result32_t *dest, int num)
{
	int i;

	for (i = 0; i < num; i++) {
		dest[i].mr_addr = (caddr32_t)(uintptr_t)source[i].mr_addr;
		dest[i].mr_msize = (size32_t)source[i].mr_msize;
		dest[i].mr_fsize = (size32_t)source[i].mr_fsize;
		dest[i].mr_offset = (size32_t)source[i].mr_offset;
		dest[i].mr_prot = source[i].mr_prot;
		dest[i].mr_flags = source[i].mr_flags;
	}
}

int
mmapobjsys(int fd, uint_t flags, mmapobj_result_t *storage,
    uint_t *elements, void *arg)
{
	uint_t num_mapped;
	uint_t num_in;
	int error;
	int old_error;
	size_t padding = 0;
	mmapobj_result_t stack_mr[MOBJ_STACK_SEGS];
	mmapobj_result_t *mrp = stack_mr;
	struct file *fp;
	struct vnode *vp;
	model_t model;
	int convert_64to32 = 0;
	uint_t alloc_num = 0;


	/* Verify flags */
	if ((flags & ~MMOBJ_ALL_FLAGS) != 0) {
		return (set_errno(EINVAL));
	}

	if (((flags & MMOBJ_PADDING) == 0) && arg != NULL) {
		return (set_errno(EINVAL));
	}

	fp = getf(fd);
	if (fp == NULL) {
		return (set_errno(EBADF));
	}
	vp = fp->f_vnode;

	if ((fp->f_flag & FREAD) == 0) {
		error = EACCES;
		goto out;
	}

	error = copyin(elements, &num_mapped, sizeof (uint_t));
	if (error) {
		error = EFAULT;
		goto out;
	}

	num_in = num_mapped;
	model = get_udatamodel();
	if (model != DATAMODEL_NATIVE) {
		ASSERT(model == DATAMODEL_ILP32);
		convert_64to32 = 1;
	}

	if (flags & MMOBJ_PADDING) {
		if (convert_64to32) {
			size32_t padding32;
			error = copyin(arg, &padding32, sizeof (padding32));
			padding = padding32;
		} else {
			error = copyin(arg, &padding, sizeof (padding));
		}
		if (error) {
			error = EFAULT;
			goto out;
		}

		/*
		 * Need to catch overflow here for the 64 bit case.  For the
		 * 32 bit case, overflow would round up to 4G which would
		 * not be able to fit in any address space and thus ENOMEM
		 * would be returned after calling into mmapobj.
		 */
		if (padding) {
			padding = P2ROUNDUP(padding, PAGESIZE);
			if (padding == 0) {
				error = ENOMEM;
				goto out;
			}
		}
		/* turn off padding if no bytes were requested */
		if (padding == 0) {
			flags = flags & (~MMOBJ_PADDING);
		}
	}

	if (num_mapped > MOBJ_STACK_SEGS) {
		num_mapped = MOBJ_STACK_SEGS;
	}
retry:
	error = mmapobj(vp, flags, mrp, &num_mapped, padding, fp->f_cred);

	if (error == E2BIG && alloc_num == 0) {
		if (num_mapped > MOBJ_STACK_SEGS && num_mapped <= num_in) {
			mrp = kmem_alloc(sizeof (mmapobj_result_t) * num_mapped,
			    KM_SLEEP);
			alloc_num = num_mapped;
			goto retry;
		}
	}

	old_error = error;
	if (error == 0 || error == E2BIG) {
		error = copyout(&num_mapped, elements, sizeof (uint_t));
		if (error) {
			error = EFAULT;
			/*
			 * We only mapped in segments if the mmapobj call
			 * succeeded, so only unmap for that case.
			 */
			if (old_error == 0) {
				mmapobj_unmap(mrp, num_mapped, num_mapped, 0);
			}
		} else if (num_in < num_mapped) {
			ASSERT(old_error == E2BIG);
			error = E2BIG;
		} else {
			if (convert_64to32) {
				mmapobj_result32_t *mrp32;
				/* Need to translate from 64bit to 32bit */
				mrp32 = kmem_alloc(num_mapped * sizeof (*mrp32),
				    KM_SLEEP);
				mmapobj_copy_64to32(mrp, mrp32, num_mapped);
				error = copyout(mrp32, (void *)storage,
				    num_mapped * sizeof (mmapobj_result32_t));
				kmem_free(mrp32, num_mapped * sizeof (*mrp32));
			} else {
				error = copyout(mrp, (void *)storage,
				    num_mapped * sizeof (mmapobj_result_t));
			}
			if (error) {
				error = EFAULT;
				mmapobj_unmap(mrp, num_mapped, num_mapped, 0);
			}
		}
	}

	/*
	 * If stack_mr was not large enough, then we had to allocate
	 * a larger piece of memory to hold the mmapobj_result array.
	 */
	if (alloc_num != 0) {
		ASSERT(mrp != stack_mr);
		ASSERT(num_mapped > MOBJ_STACK_SEGS);
		kmem_free(mrp,
		    alloc_num * sizeof (mmapobj_result_t));
	}

out:
	releasef(fd);
	if (error) {
		return (set_errno(error));
	} else {
		return (0);
	}
}