/*

 * 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 2004 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).

 */

#pragma weak plock = _plock

#include "synonyms.h"

#include <mtlib.h>

#include <sys/types.h>

#include <sys/mman.h>

#include <sys/lock.h>

#include <errno.h>

#include <stddef.h>

#include <unistd.h>

#include <thread.h>

#include <synch.h>

/*

 * Module-scope variables.

 */

static	int lock_state = 0;		/* lock state */

static	pid_t state_pid = -1;		/* pid to which state belongs */

static mutex_t plock_lock = DEFAULTMUTEX;

/*

 * plock

 */

int

plock(int op)				/* desired operation */

{

	int 	e;			/* return value */

	pid_t	pid;			/* current pid */

	lmutex_lock(&plock_lock);

	/*

	 * 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;

			lmutex_unlock(&plock_lock);

			return (-1);

		}

		e = munlockall();

		if (e) {

			lmutex_unlock(&plock_lock);

			return (-1);

		} else {

			lock_state = 0;

			lmutex_unlock(&plock_lock);

			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;

			lmutex_unlock(&plock_lock);

			return (-1);

		}

		/*

		 * Try to apply the lock(s).  If a failure occurs,

		 * memcntl backs them out automatically.

		 */

		e = memcntl(NULL, 0, MC_LOCKAS, (caddr_t)MCL_CURRENT,

		    PROC_TEXT|PRIVATE, (int)NULL);

		if (!e)

			lock_state |= TXTLOCK;

		lmutex_unlock(&plock_lock);

		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;

			lmutex_unlock(&plock_lock);

			return (-1);

		}

		/*

		 * Try to lock the data and stack segments.  On failure

		 * memcntl undoes the locks internally.

		 */

		e = memcntl(NULL, 0, MC_LOCKAS, (caddr_t)MCL_CURRENT,

		    PROC_DATA|PRIVATE, (int)NULL);

		if (e) {

			lmutex_unlock(&plock_lock);

			return (-1);

		}

		/* try to set a lock for all future mappings. */

		e = mlockall(MCL_FUTURE);

		/*

		 * If failures have occurred, back out the locks

		 * and return failure.

		 */

		if (e) {

			e = errno;

			(void) memcntl(NULL, 0, MC_UNLOCKAS,

			    (caddr_t)MCL_CURRENT, PROC_DATA|PRIVATE, (int)NULL);

			errno = e;

			lmutex_unlock(&plock_lock);

			return (-1);

		}

		/*

		 * Data, stack, and growth have been locked.  Set state

		 * and return success.

		 */

		lock_state |= DATLOCK;

		lmutex_unlock(&plock_lock);

		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;

			lmutex_unlock(&plock_lock);

			return (-1);

		}

		if (mlockall(MCL_CURRENT | MCL_FUTURE) == 0) {

			lock_state |= PROCLOCK;

			lmutex_unlock(&plock_lock);

			return (0);

		} else {

			lmutex_unlock(&plock_lock);

			return (-1);

		}

		/*NOTREACHED*/

	/*

	 * Invalid operation.

	 */

	default:

		errno = EINVAL;

		lmutex_unlock(&plock_lock);

		return (-1);

		/*NOTREACHED*/

	}

}