/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 1989 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * plock - lock "segments" in physical memory.
 *
 * Supports SVID-compatible plock, taking into account dynamically linked
 * objects (such as shared libraries).
 */

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/lock.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <machine/param.h>
#include <machine/vmparam.h>
#include <a.out.h>
#include <link.h>
#include <errno.h>

/*
 * Globals we reference.
 */
extern	struct link_dynamic _DYNAMIC;
extern	int mlock();
extern	int munlock();
extern	caddr_t sbrk();		/* find end of data segment */
extern	caddr_t etext;		/* end of text segment */

/*
 * Module-scope variables.
 */
static	int page_size = 0;		/* cached result of getpagesize() */
static	int lock_state = 0;		/* lock state */
static	int state_pid = -1;		/* pid to which state belongs */

/*
 * Local worker routine to lock text and data segments.  Handles
 * dynamically loaded objects.  This routine is highly dependent
 * on executable format and layout.
 *
 * Arguments:
 *	op:	desired operation
 *	f:	function to perform
 */
static int
apply_lock(int op, int (*f)(caddr_t, u_int))
{
	int	e = 0;			/* return value */
	caddr_t	a;			/* address of operation */
	u_int	l;			/* length of operation */
	struct	link_map *lmp;		/* link map walker */
	struct	exec *eh;		/* exec header */

	/*
	 * Operate on application segment first.
	 */
	switch (op) {
	case TXTLOCK:
		a = (caddr_t)USRTEXT;	/* note: old Sun-2 not handled */
		l = (u_int)&etext -  USRTEXT;
		break;
	case DATLOCK:
		a = (caddr_t)(((int)&etext + (SEGSIZ - 1)) & ~(SEGSIZ - 1));
		l = (u_int)(sbrk(0) - a);
		break;
	}
	l = (l + (page_size - 1)) & (u_int)~(page_size - 1);

	/*
	 * Perform the operation -- if failure, return immediately.
	 */
	if (e = (*f)(a, l))
		return (e);

	/*
	 * If we're not a dynamically linked program, we are finished.
	 */
	if (&_DYNAMIC == 0)
		return (0);

	/*
	 * Find the list of dynamically linked objects.  If we get
	 * dynamic linking formats we don't recognize, then punt.
	 */
	switch (_DYNAMIC.ld_version) {
	case 2:
#if	defined(__sparc)
	case 3:
#endif	/* __sparc */
		lmp = _DYNAMIC.ld_un.ld_2->ld_loaded;
		break;
	default:
		return (0);
	}

	/*
	 * Loop over all objects.  Extract the addresses and lengths as
	 * required, and perform the appropriate operation.
	 */

	while (lmp) {
		eh = (struct exec *)lmp->lm_addr;
		switch (op) {
		case TXTLOCK:
			a = (caddr_t)eh;
			l = (u_int)eh->a_text;
			break;
		case DATLOCK:
			a = (caddr_t)((u_int)eh + N_DATADDR(*eh) -
			    N_TXTADDR(*eh));
			l = (u_int)eh->a_data + (u_int)eh->a_bss;
			break;
		}
		l = (l + (page_size - 1)) & ~(page_size - 1);
		if (e = (*f)(a, l))
			return (e);
		lmp = lmp->lm_next;
	}
	return (0);
}

/*
 * plock
 *
 * Argument:
 *	op:	desired operation
 */
int
plock(int op)
{
	int 	e = 0;			/* return value */
	int	pid;			/* current pid */
	caddr_t	a1, a2;			/* loop variables */
	struct	rlimit rl;		/* resource limit */

	/*
	 * Initialize static caches.
	 */
	if (page_size == 0)
		page_size = getpagesize();

	/*
	 * Validate state of lock's.  If parent has forked, then
	 * the lock state needs to be reset (children do not inherit
	 * memory locks, and thus do not inherit their state).
	 */
	if ((pid = getpid()) != state_pid) {
		lock_state = 0;
		state_pid = pid;
	}

	/*
	 * Dispatch on operation.  Note: plock and its relatives depend
	 * upon "op" being bit encoded.
	 */
	switch (op) {

	/*
	 * UNLOCK: remove all memory locks.  Requires that some be set!
	 */
	case UNLOCK:
		if (lock_state == 0) {
			errno = EINVAL;
			return (-1);
		}
		if (e = munlockall())
			return (-1);
		else {
			lock_state = 0;
			return (0);
		}
		/*NOTREACHED*/

	/*
	 * TXTLOCK: locks text segments.  
	 */
	case TXTLOCK:

		/*
		 * If a text or process lock is already set, then fail.
		 */
		if ((lock_state & TXTLOCK) || (lock_state & PROCLOCK)) {
			errno = EINVAL;
			return (-1);
		}

		/*
		 * Try to apply the lock(s).  If a failure occurs,
		 * back them out.  On success, remember that a text
		 * lock was set.
		 */
		if (e = apply_lock(op, mlock))
			(void) apply_lock(op, munlock);
		else
			lock_state |= TXTLOCK;
		return (e);
		/*NOTREACHED*/

	/*
	 * DATLOCK: locks data segment(s), including the stack and all
	 * future growth in the address space.
	 */
	case DATLOCK:

		/*
		 * If a data or process lock is already set, then fail.
		 */
		if ((lock_state & DATLOCK) || (lock_state & PROCLOCK)) {
			errno = EINVAL;
			return (-1);
		}

		/*
		 * Try to lock the data segments.  On failure, back out
		 * the locks and return.
		 */
		if (e = apply_lock(op, mlock)) {
			(void) apply_lock(op, munlock);
			return (-1);
		}

		/*
		 * Try to lock the stack segment.  Find out the extent
		 * and start of the stack (there should be a function for
		 * this!) and then iterate over the pages of the stack
		 * locking them.  The stack *could* be sparely populated.
		 * Ignore lock failures resulting from the absence of a
		 * mapping.
		 */
		(void) getrlimit(RLIMIT_STACK, &rl);
		for (a1 = (caddr_t)USRSTACK - page_size;
		    a1 != (caddr_t)USRSTACK - rl.rlim_cur; a1 -= page_size)
			if (e = mlock(a1, page_size)) {
				if (errno == ENOMEM)
					e = 0;
				break;
			}

		/*
		 * If we were successful in locking the stack, then
		 * try to set a lock for all future mappings.
		 */
		if (!e)
			e = mlockall(MCL_FUTURE);

		/*
		 * If failures have occurred, back out the locks
		 * and return failure.
		 */
		if (e) {
			e = errno;
			(void) apply_lock(op, munlock);
			for (a2 = (caddr_t)USRSTACK - page_size; a2 != a1;
			    a2 -= page_size)
				(void) munlock(a2, page_size);
			errno = e;
			return (-1);
		}

		/*
		 * Data, stack, and growth have been locked.  Set state
		 * and return success.
		 */
		lock_state |= DATLOCK;
		return (0);
		/*NOTREACHED*/

	/*
	 * PROCLOCK: lock everything, and all future things as well.
	 * There should be nothing locked when this is called.
	 */
	case PROCLOCK:
		if (lock_state) {
			errno = EINVAL;
			return (-1);
		}
		if (mlockall(MCL_CURRENT | MCL_FUTURE) == 0) {
			lock_state |= PROCLOCK;
			return (0);
		} else
			return (-1);
		/*NOTREACHED*/

	/*
	 * Invalid operation.
	 */
	default:
		errno = EINVAL;
		return (-1);
		/*NOTREACHED*/
	}
}