/*
 * 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);
        }
}