path: root/usr/src/lib/libidmap/common/utils.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 (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * Utility routines
 */

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <libintl.h>
#include <assert.h>
#include <ucontext.h>
#include <pthread.h>
#include "idmap_impl.h"

#define	_UDT_SIZE_INCR	1

#define	_GET_IDS_SIZE_INCR	1

static struct timeval TIMEOUT = { 25, 0 };

struct idmap_handle {
	CLIENT		*client;
	boolean_t	failed;
	rwlock_t	lock;
};

static struct idmap_handle idmap_handle = {
	NULL,		/* client */
	B_TRUE,		/* failed */
	DEFAULTRWLOCK,	/* lock */
};

static idmap_stat _idmap_clnt_connect(void);
static void _idmap_clnt_disconnect(void);

idmap_retcode
_udt_extend_batch(idmap_udt_handle_t *udthandle)
{
	idmap_update_op	*tmplist;
	size_t		nsize;

	if (udthandle->next >= udthandle->batch.idmap_update_batch_len) {
		nsize = (udthandle->batch.idmap_update_batch_len +
		    _UDT_SIZE_INCR) * sizeof (*tmplist);
		tmplist = realloc(
		    udthandle->batch.idmap_update_batch_val, nsize);
		if (tmplist == NULL)
			return (IDMAP_ERR_MEMORY);
		(void) memset((uchar_t *)tmplist +
		    (udthandle->batch.idmap_update_batch_len *
		    sizeof (*tmplist)), 0,
		    _UDT_SIZE_INCR * sizeof (*tmplist));
		udthandle->batch.idmap_update_batch_val = tmplist;
		udthandle->batch.idmap_update_batch_len += _UDT_SIZE_INCR;
	}
	udthandle->batch.idmap_update_batch_val[udthandle->next].opnum =
	    OP_NONE;
	return (IDMAP_SUCCESS);
}

idmap_retcode
_get_ids_extend_batch(idmap_get_handle_t *gh)
{
	idmap_mapping	*t1;
	idmap_get_res_t	*t2;
	size_t		nsize, len;

	len = gh->batch.idmap_mapping_batch_len;
	if (gh->next >= len) {
		/* extend the request array */
		nsize = (len + _GET_IDS_SIZE_INCR) * sizeof (*t1);
		t1 = realloc(gh->batch.idmap_mapping_batch_val, nsize);
		if (t1 == NULL)
			return (IDMAP_ERR_MEMORY);
		(void) memset((uchar_t *)t1 + (len * sizeof (*t1)), 0,
		    _GET_IDS_SIZE_INCR * sizeof (*t1));
		gh->batch.idmap_mapping_batch_val = t1;

		/* extend the return list */
		nsize = (len + _GET_IDS_SIZE_INCR) * sizeof (*t2);
		t2 = realloc(gh->retlist, nsize);
		if (t2 == NULL)
			return (IDMAP_ERR_MEMORY);
		(void) memset((uchar_t *)t2 + (len * sizeof (*t2)), 0,
		    _GET_IDS_SIZE_INCR * sizeof (*t2));
		gh->retlist = t2;

		gh->batch.idmap_mapping_batch_len += _GET_IDS_SIZE_INCR;
	}
	return (IDMAP_SUCCESS);
}

idmap_stat
_iter_get_next_list(int type, idmap_iter_t *iter,
		void *arg, uchar_t **list, size_t valsize,
		xdrproc_t xdr_arg_proc, xdrproc_t xdr_res_proc)
{
	idmap_stat rc;

	iter->next = 0;
	iter->retlist = NULL;

	/* init the result */
	if (*list) {
		xdr_free(xdr_res_proc, (caddr_t)*list);
	} else {
		if ((*list = malloc(valsize)) == NULL) {
			errno = ENOMEM;
			return (IDMAP_ERR_MEMORY);
		}
	}
	(void) memset(*list, 0, valsize);

	rc = _idmap_clnt_call(type,
	    xdr_arg_proc, (caddr_t)arg,
	    xdr_res_proc, (caddr_t)*list,
	    TIMEOUT);
	if (rc != IDMAP_SUCCESS) {
		free(*list);
		return (rc);
	}
	iter->retlist = *list;
	return (IDMAP_SUCCESS);
}

/*
 * Convert the return values from an RPC request into an idmap return code.
 * Set errno on error.
 */
static
idmap_stat
_idmap_rpc2stat(enum clnt_stat clntstat, CLIENT *clnt)
{
	/*
	 * We only deal with door_call(3C) errors here. We look at
	 * r_err.re_errno instead of r_err.re_status because we need
	 * to differentiate between RPC failures caused by bad door fd
	 * and others.
	 */
	struct rpc_err r_err;

	if (clntstat == RPC_SUCCESS)
		return (IDMAP_SUCCESS);

	clnt_geterr(clnt, &r_err);
	errno = r_err.re_errno;
	switch (r_err.re_errno) {
	case ENOMEM:
		return (IDMAP_ERR_MEMORY);
	case EBADF:
		return (IDMAP_ERR_RPC_HANDLE);
	default:
		return (IDMAP_ERR_RPC);
	}
}

/*
 * Management of the connection to idmapd.
 *
 * The intent is that connections to idmapd are automatically maintained,
 * reconnecting if necessary.  No attempt is made to retry connnection
 * attempts; a failure to connect yields an immediate error return.
 *
 * State of the connection is maintained through the "client" and "failed"
 * elements of the handle structure:
 *
 * client   failed
 * NULL     true     Failed on a previous request and was not recovered.
 * NULL     false    Should never happen.
 * nonNULL  true     Structure exists, but an error has occurred.  Waiting
 *                   for a chance to attempt to reconnect.
 * nonNULL  false    Connection is good.
 *
 * Note that the initial state is NULL/true, so that the first request
 * will establish the initial connection.
 *
 * Concurrency is managed through the rw lock "lock".  Only the writer is
 * allowed to connect or disconnect, and thus only the writer can set
 * "failed" to "false".  Readers are allowed to use the "client" pointer,
 * and to set "failed" to "true", indicating that they have encountered a
 * failure.  The "client" pointer is only valid while one holds a reader
 * lock.  Once "failed" has been set to "true", all requests (including
 * the retry of the failing request) will attempt to gain the writer lock.
 * When they succeed, indicating that there are no requests in flight and
 * thus no outstanding references to the CLIENT structure, they check
 * again to see if the connection is still failed (since another thread
 * might have fixed it), and then if it is still failed they disconnect
 * and reconnect.
 */

/*
 * Make an RPC call.  Automatically reconnect if the connection to idmapd
 * fails.  Convert RPC results to idmap return codes.
 */
idmap_stat
_idmap_clnt_call(
    const rpcproc_t procnum,
    const xdrproc_t inproc,
    const caddr_t in,
    const xdrproc_t outproc,
    caddr_t out,
    const struct timeval tout)
{
	enum clnt_stat	clntstat;
	idmap_stat rc;

	(void) rw_rdlock(&idmap_handle.lock);
	for (;;) {
		if (idmap_handle.failed) {
			/* No connection.  Bid to see if we should fix it. */
			(void) rw_unlock(&idmap_handle.lock);
			/* Somebody else might fix it here. */
			(void) rw_wrlock(&idmap_handle.lock);
			/*
			 * At this point, everybody else is asleep waiting
			 * for us.  Check to see if somebody else has already
			 * fixed the problem.
			 */
			if (idmap_handle.failed) {
				/* It's our job to fix. */
				_idmap_clnt_disconnect();
				rc = _idmap_clnt_connect();
				if (rc != IDMAP_SUCCESS) {
					/* We couldn't fix it. */
					assert(idmap_handle.failed);
					assert(idmap_handle.client == NULL);
					break;
				}
				/* We fixed it. */
				idmap_handle.failed = B_FALSE;
			}

			/* It's fixed now. */
			(void) rw_unlock(&idmap_handle.lock);
			/*
			 * Starting here, somebody might declare it failed
			 * again.
			 */
			(void) rw_rdlock(&idmap_handle.lock);
			continue;
		}

		clntstat = clnt_call(idmap_handle.client, procnum, inproc, in,
		    outproc, out, tout);
		rc = _idmap_rpc2stat(clntstat, idmap_handle.client);
		if (rc == IDMAP_ERR_RPC_HANDLE) {
			/* Failed.  Needs to be reconnected. */
			idmap_handle.failed = B_TRUE;
			continue;
		}

		/* Success or unrecoverable failure. */
		break;
	}
	(void) rw_unlock(&idmap_handle.lock);
	return (rc);
}

#define	MIN_STACK_NEEDS	65536

/*
 * Connect to idmapd.
 * Must be single-threaded through rw_wrlock(&idmap_handle.lock).
 */
static
idmap_stat
_idmap_clnt_connect(void)
{
	uint_t			sendsz = 0;
	stack_t			st;

	/*
	 * clnt_door_call() alloca()s sendsz bytes (twice too, once for
	 * the call args buffer and once for the call result buffer), so
	 * we want to pick a sendsz that will be large enough, but not
	 * too large.
	 */
	if (stack_getbounds(&st) == 0) {
		/*
		 * Estimate how much stack space is left;
		 * st.ss_sp is the top of stack.
		 */
		if ((char *)&sendsz < (char *)st.ss_sp)
			/* stack grows up */
			sendsz = ((char *)st.ss_sp - (char *)&sendsz);
		else
			/* stack grows down */
			sendsz = ((char *)&sendsz - (char *)st.ss_sp);

		if (sendsz <= MIN_STACK_NEEDS) {
			sendsz = 0;	/* RPC call may fail */
		} else {
			/* Leave 64Kb (just a guess) for our needs */
			sendsz -= MIN_STACK_NEEDS;

			/* Divide the stack space left by two */
			sendsz = RNDUP(sendsz / 2);

			/* Limit sendsz to 256KB */
			if (sendsz > IDMAP_MAX_DOOR_RPC)
				sendsz = IDMAP_MAX_DOOR_RPC;
		}
	}

	idmap_handle.client = clnt_door_create(IDMAP_PROG, IDMAP_V1, sendsz);
	if (idmap_handle.client == NULL)
		return (IDMAP_ERR_RPC);

	return (IDMAP_SUCCESS);
}

/*
 * Disconnect from idmapd, if we're connected.
 */
static
void
_idmap_clnt_disconnect(void)
{
	CLIENT *clnt;

	clnt = idmap_handle.client;
	if (clnt != NULL) {
		if (clnt->cl_auth)
			auth_destroy(clnt->cl_auth);
		clnt_destroy(clnt);
		idmap_handle.client = NULL;
	}
}