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