OpenSolaris_b135/lib/lvm/libmeta/common/metarpcopen.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 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Just in case we're not in a build environment, make sure that
* TEXT_DOMAIN gets set to something.
*/
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
#include <meta.h>
#include <metad.h>
#include <sdssc.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define CC_TTL_MAX 20
typedef struct {
char *cc_node;
struct timeval cc_ttl;
CLIENT *cc_clp;
} client_cache_t;
typedef struct client_header {
client_cache_t **ch_cache; /* array of clients. */
mutex_t ch_mutex; /* lock access to ch_cache */
} client_header_t;
/*
* This structure is used to pass data from meta_client_create to
* client_create_helper via meta_client_create_retry.
*/
typedef struct clnt_data {
rpcprog_t cd_prognum; /* RPC program number */
rpcvers_t cd_version; /* Desired interface version */
char *cd_nettype; /* Type of network to use */
} clnt_data_t;
#define MALLOC_BLK_SIZE 10
static client_header_t client_header = {(client_cache_t **)NULL, DEFAULTMUTEX};
static void
cc_add(
client_header_t *header,
char *node,
CLIENT *clntp,
md_error_t *ep
)
{
client_cache_t ***cachep = &header->ch_cache;
struct timeval now;
int i;
int j = 0;
if (gettimeofday(&now, NULL) == -1) {
(void) mdsyserror(ep, errno, "gettimeofday()");
return;
}
(void) mutex_lock(&header->ch_mutex);
if (*cachep) {
for (i = 0; (*cachep)[i] != NULL; i++)
if (strcmp((*cachep)[i]->cc_node, node) == 0 &&
(*cachep)[i]->cc_clp == NULL) {
(*cachep)[i]->cc_clp = clntp;
(*cachep)[i]->cc_ttl = now;
(void) mutex_unlock(&header->ch_mutex);
return;
}
} else {
*cachep = Calloc(MALLOC_BLK_SIZE, sizeof (**cachep));
i = 0;
}
(*cachep)[i] = Zalloc(sizeof (***cachep));
(*cachep)[i]->cc_node = Strdup(node);
(*cachep)[i]->cc_clp = clntp;
(*cachep)[i]->cc_ttl = now;
if ((++i % MALLOC_BLK_SIZE) == 0) {
*cachep = Realloc(*cachep,
(i + MALLOC_BLK_SIZE) * sizeof (**cachep));
for (j = i; j < (i + MALLOC_BLK_SIZE); j++)
(*cachep)[j] = NULL;
}
(void) mutex_unlock(&header->ch_mutex);
}
static void
rel_clntp(client_cache_t *cachep)
{
CLIENT *clntp = cachep->cc_clp;
if (clntp != NULL) {
auth_destroy(clntp->cl_auth);
clnt_destroy(clntp);
}
cachep->cc_clp = NULL;
}
static void
cc_destroy(client_header_t *header)
{
client_cache_t ***cachep = &header->ch_cache;
int i;
(void) mutex_lock(&header->ch_mutex);
if (*cachep) {
for (i = 0; ((*cachep)[i] != NULL); i++) {
client_cache_t *p = (*cachep)[i];
Free(p->cc_node);
rel_clntp(p);
Free(p);
}
Free(*cachep);
*cachep = NULL;
}
(void) mutex_unlock(&header->ch_mutex);
}
/*
* Set the timeout value for this client handle.
*/
int
cl_sto(
CLIENT *clntp,
char *hostname,
long time_out,
md_error_t *ep
)
{
struct timeval nto;
(void) memset(&nto, '\0', sizeof (nto));
nto.tv_sec = time_out;
if (clnt_control(clntp, CLSET_TIMEOUT, (char *)&nto) != TRUE)
return (mdrpcerror(ep, clntp, hostname,
dgettext(TEXT_DOMAIN, "metad client set timeout")));
return (0);
}
/*
* client_create_vers_retry is the helper function to be passed to
* meta_client_create_retry to do the actual work of creating the client
* when version selection is necessary.
*/
/* ARGSUSED */
static CLIENT *
client_create_vers_retry(char *hostname,
void *ignore,
struct timeval *tout
)
{
rpcvers_t vers; /* Version # not needed. */
return (clnt_create_vers_timed(hostname, METAD, &vers,
METAD_VERSION, METAD_VERSION_DEVID, "tcp", tout));
}
/*
* client_create_helper is the helper function to be passed to
* meta_client_create_retry when plain vanilla client create is desired.
*/
static CLIENT *
client_create_helper(char *hostname, void *private, struct timeval *time_out)
{
clnt_data_t *cd = (clnt_data_t *)private;
return (clnt_create_timed(hostname, cd->cd_prognum, cd->cd_version,
cd->cd_nettype, time_out));
}
/*
* meta_client_create_retry is a general function to assist in creating RPC
* clients. This function handles retrying if the attempt to create a
* client fails. meta_client_create_retry itself does not actually create
* the client. Instead it calls the helper function, func, to do that job.
*
* With the help of func, meta_client_create_retry will create an RPC
* connection allowing up to tout seconds to complete the task. If the
* connection creation fails for RPC_RPCBFAILURE, RPC_CANTRECV or
* RPC_PROGNOTREGISTERED and tout seconds have not passed,
* meta_client_create_retry will try again. The reason retries are
* important is that when the inet daemon is being refreshed, it can take
* 15-20 seconds for it to start responding again.
*
* Arguments:
*
* hostname - Name of remote host
*
* func - Pointer to the helper function, that will
* actually try to create the client.
*
* data - Private data to be passed on to func.
* meta_client_create_retry treats this as an opaque
* pointer.
*
* tout - Number of seconds to allow for the connection
* attempt.
*
* ep - Standard SVM error pointer. May be NULL.
*/
CLIENT *
meta_client_create_retry(
char *hostname,
clnt_create_func_t func,
void *data,
time_t tout,
md_error_t *ep
)
{
static int debug; /* print debugging info */
static int debug_set = 0;
CLIENT *clnt = (CLIENT *) NULL;
struct timeval curtime;
char *d;
struct timeval start;
struct timeval timeout;
if (debug_set == 0) {
d = getenv("MD_DEBUG");
if (d == NULL) {
debug = 0;
} else {
debug = (strstr(d, "RPC") == NULL) ? 0 : 1;
}
debug_set = 1;
}
timeout.tv_usec = 0;
if (gettimeofday(&start, NULL) == -1) {
if (ep != (md_error_t *)NULL) {
(void) mdsyserror(ep, errno, "gettimeofday()");
}
return (clnt);
}
curtime = start;
while ((curtime.tv_sec - start.tv_sec) < tout) {
/* Use remaining time as the timeout value. */
timeout.tv_sec = tout - (curtime.tv_sec - start.tv_sec);
clnt = (*func)(hostname, data, &timeout);
if (clnt != (CLIENT *) NULL)
break;
if ((rpc_createerr.cf_stat == RPC_RPCBFAILURE) ||
(rpc_createerr.cf_stat == RPC_PROGNOTREGISTERED) ||
(rpc_createerr.cf_stat == RPC_CANTRECV)) {
if (debug) {
clnt_pcreateerror("meta_client_create_retry");
}
/* If error might be fixed in time, sleep & try again */
(void) sleep(2);
if (gettimeofday(&curtime, NULL) == -1) {
if (ep != (md_error_t *)NULL) {
(void) mdsyserror(ep, errno,
"gettimeofday()");
}
return (clnt);
}
} else {
/* Not a recoverable error. */
break;
}
}
if ((clnt == (CLIENT *) NULL) && (ep != (md_error_t *)NULL)) {
(void) mdrpccreateerror(ep, hostname,
"meta_client_create_retry");
}
return (clnt);
}
/*
* meta_client_create is intended to be used within SVM as a replacement
* for calls to clnt_create. meta_client_create invokes the retry
* mechanism of meta_client_create_retry.
*/
CLIENT *
meta_client_create(char *host, rpcprog_t prognum, rpcvers_t version,
char *nettype)
{
clnt_data_t cd;
cd.cd_prognum = prognum;
cd.cd_version = version;
cd.cd_nettype = nettype;
return (meta_client_create_retry(host, client_create_helper,
(void *)&cd, MD_CLNT_CREATE_TOUT, (md_error_t *)NULL));
}
/*
* create and return RPC connection
*/
CLIENT *
metarpcopen(
char *hostname,
long time_out,
md_error_t *ep
)
{
CLIENT *clntp = NULL;
client_cache_t ***cachep = &client_header.ch_cache;
int i;
long delta;
struct timeval now;
struct in_addr p_ip;
char *host_sc = NULL;
char host_priv[18];
/*
* If we are in cluster mode, lets use the private interconnect
* hostnames to establish the rpc connections.
*/
if (sdssc_bind_library() != SDSSC_NOT_BOUND)
if (sdssc_get_priv_ipaddr(hostname, &p_ip) == SDSSC_OKAY) {
/*
* inet_ntoa() returns pointer to a string in the
* base 256 notation d.d.d.d (IPv4) and so
* host_priv[18] should be sufficient enough to
* hold it.
*/
host_sc = inet_ntoa(p_ip);
if (host_sc != NULL) {
int size = sizeof (host_priv);
if (strlcpy(host_priv, host_sc, size) < size)
hostname = host_priv;
}
}
if (gettimeofday(&now, NULL) == -1) {
(void) mdsyserror(ep, errno, "gettimeofday()");
return (NULL);
}
/*
* Before trying to create the client, make sure that the core SVM
* services are enabled by the Service Management Facility. We
* don't want to suffer the 60 second timeout if the services are
* not even enabled. This call actually only verifies that they
* are enabled on this host no matter which host the caller wants
* to connect to. Nonetheless, if the services are not enabled on
* the local host, our RPC stuff is not going to work as expected.
*/
if (meta_smf_isonline(META_SMF_CORE, ep) == 0) {
return (NULL);
}
(void) mutex_lock(&client_header.ch_mutex);
if (client_header.ch_cache) {
for (i = 0; (*cachep)[i] != NULL; i++) {
if (strcmp((*cachep)[i]->cc_node, hostname) == 0) {
clntp = (*cachep)[i]->cc_clp;
if (clntp == NULL)
continue;
delta = now.tv_sec -
(*cachep)[i]->cc_ttl.tv_sec;
if (delta > CC_TTL_MAX) {
rel_clntp((*cachep)[i]);
continue;
}
if (cl_sto(clntp, hostname, time_out,
ep) != 0) {
(void) mutex_unlock(
&client_header.ch_mutex);
return (NULL);
}
(void) mutex_unlock(&client_header.ch_mutex);
return (clntp);
}
}
}
(void) mutex_unlock(&client_header.ch_mutex);
/*
* Try to create a version 2 client handle by default.
* If this fails (i.e. client is version 1), try to
* create a version 1 client handle.
*/
clntp = meta_client_create_retry(hostname, client_create_vers_retry,
(void *)NULL, MD_CLNT_CREATE_TOUT, ep);
/* open connection */
if (clntp == NULL) {
(void) mdrpccreateerror(ep, hostname,
dgettext(TEXT_DOMAIN, "metad client create"));
cc_add(&client_header, hostname, NULL, ep);
return (NULL);
} else {
auth_destroy(clntp->cl_auth);
clntp->cl_auth = authsys_create_default();
assert(clntp->cl_auth != NULL);
}
cc_add(&client_header, hostname, clntp, ep);
if (cl_sto(clntp, hostname, time_out, ep) != 0)
return (NULL);
return (clntp);
}
/*
* metarpcclose - is a place holder so that when using
* metarpcopen, it does not appear that
* we have dangling opens. We can at some
* later decrement open counts here too, if needed.
*/
/*ARGSUSED*/
void
metarpcclose(CLIENT *clntp)
{
}
void
metarpccloseall(void)
{
cc_destroy(&client_header);
}