xref: /onnv-gate/usr/src/lib/libndmp/common/libndmp.c (revision 8193:9b3c96bc17e3)

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * BSD 3 Clause License
 *
 * Copyright (c) 2007, The Storage Networking Industry Association.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 	- Redistributions of source code must retain the above copyright
 *	  notice, this list of conditions and the following disclaimer.
 *
 * 	- Redistributions in binary form must reproduce the above copyright
 *	  notice, this list of conditions and the following disclaimer in
 *	  the documentation and/or other materials provided with the
 *	  distribution.
 *
 *	- Neither the name of The Storage Networking Industry Association (SNIA)
 *	  nor the names of its contributors may be used to endorse or promote
 *	  products derived from this software without specific prior written
 *	  permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include <locale.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <fcntl.h>
#include <door.h>
#include <thread.h>
#include <ndmpd_door.h>
#include <libndmp.h>

static int ndmp_door_fildes = -1;
static char *buf;
static ndmp_door_ctx_t *dec_ctx;
static ndmp_door_ctx_t *enc_ctx;
static door_arg_t arg;
static mutex_t ndmp_lock = DEFAULTMUTEX;

static int ndmp_door_setup(int opcode);
static int ndmp_door_call(void);
static int ndmp_door_fini(void);

/* ndmp library APIs */
int
ndmp_get_devinfo(ndmp_devinfo_t **dip, size_t *size)
{
	ndmp_devinfo_t *dipptr;
	int i;
	int opcode = NDMP_DEVICES_GET_INFO;

	(void) mutex_lock(&ndmp_lock);
	if (ndmp_door_setup(opcode))
		goto err;

	if (ndmp_door_call())
		goto err;

	/* get the number of devices available */
	*size = ndmp_door_get_uint32(dec_ctx);

	*dip = malloc(sizeof (ndmp_devinfo_t) * *size);
	if (!*dip) {
		free(buf);
		ndmp_errno = ENDMP_MEM_ALLOC;
		goto err;
	}
	dipptr = *dip;
	for (i = 0; i < *size; i++, dipptr++) {
		dipptr->nd_dev_type = ndmp_door_get_int32(dec_ctx);
		dipptr->nd_name = ndmp_door_get_string(dec_ctx);
		dipptr->nd_lun = ndmp_door_get_int32(dec_ctx);
		dipptr->nd_sid = ndmp_door_get_int32(dec_ctx);
		dipptr->nd_vendor = ndmp_door_get_string(dec_ctx);
		dipptr->nd_product = ndmp_door_get_string(dec_ctx);
		dipptr->nd_revision = ndmp_door_get_string(dec_ctx);
		dipptr->nd_serial = ndmp_door_get_string(dec_ctx);
		dipptr->nd_wwn = ndmp_door_get_string(dec_ctx);
	}
	if (ndmp_door_fini()) {
		free(*dip);
		goto err;
	}
	(void) mutex_unlock(&ndmp_lock);
	return (0);
err:
	(void) mutex_unlock(&ndmp_lock);
	return (-1);
}

void
ndmp_get_devinfo_free(ndmp_devinfo_t *dip, size_t size)
{
	ndmp_devinfo_t *dipptr;
	int i;

	dipptr = dip;
	for (i = 0; i < size; i++, dipptr++) {
		free(dipptr->nd_name);
		free(dipptr->nd_vendor);
		free(dipptr->nd_product);
		free(dipptr->nd_revision);
	}
	free(dip);
}

int
ndmp_terminate_session(int session)
{
	int ret;
	int opcode = NDMP_TERMINATE_SESSION_ID;

	(void) mutex_lock(&ndmp_lock);
	if (ndmp_door_setup(opcode))
		goto err;

	ndmp_door_put_uint32(enc_ctx, session);
	if (ndmp_door_call())
		goto err;

	ret = ndmp_door_get_uint32(dec_ctx);
	if (ndmp_door_fini())
		goto err;

	(void) mutex_unlock(&ndmp_lock);
	return (ret);
err:
	(void) mutex_unlock(&ndmp_lock);
	return (-1);
}

int
ndmp_get_session_info(ndmp_session_info_t **sinfo, size_t *size)
{
	int status;
	int i, j;
	ndmp_session_info_t *sp;
	ndmp_dt_pval_t *ep;
	ndmp_dt_name_t *np;
	ndmp_dt_name_v3_t *npv3;
	int opcode = NDMP_SHOW;

	(void) mutex_lock(&ndmp_lock);
	if (ndmp_door_setup(opcode))
		goto err;

	if (ndmp_door_call())
		goto err;

	/* number of sessions */
	*size = ndmp_door_get_int32(dec_ctx);

	*sinfo = malloc((sizeof (ndmp_session_info_t)) * *size);
	if (!*sinfo) {
		free(buf);
		ndmp_errno = ENDMP_MEM_ALLOC;
		goto err;
	}
	sp = *sinfo;
	for (i = 0; i < *size; i++, sp++) {
		status = ndmp_door_get_int32(dec_ctx);
		if (status == NDMP_SESSION_NODATA)
			continue;

		/* connection common info */
		sp->nsi_sid = ndmp_door_get_int32(dec_ctx);
		sp->nsi_pver = ndmp_door_get_int32(dec_ctx);
		sp->nsi_auth = ndmp_door_get_int32(dec_ctx);
		sp->nsi_eof = ndmp_door_get_int32(dec_ctx);
		sp->nsi_cl_addr = ndmp_door_get_string(dec_ctx);
		/*
		 * scsi and tape data are same for all version,
		 * so keep reading
		 */
		/* connection common scsi info.   */
		sp->nsi_scsi.ns_scsi_open = ndmp_door_get_int32(dec_ctx);
		sp->nsi_scsi.ns_adapter_name = ndmp_door_get_string(dec_ctx);
		sp->nsi_scsi.ns_valid_target_set = ndmp_door_get_int32(dec_ctx);
		if (sp->nsi_scsi.ns_valid_target_set) {
			sp->nsi_scsi.ns_scsi_id = ndmp_door_get_int32(dec_ctx);
			sp->nsi_scsi.ns_lun = ndmp_door_get_int32(dec_ctx);
		}

		/* connection common tape info.   */
		sp->nsi_tape.nt_fd = ndmp_door_get_int32(dec_ctx);
		if (sp->nsi_tape.nt_fd != -1) {
			sp->nsi_tape.nt_rec_count =
			    ndmp_door_get_uint64(dec_ctx);
			sp->nsi_tape.nt_mode = ndmp_door_get_int32(dec_ctx);
			sp->nsi_tape.nt_dev_name =
			    ndmp_door_get_string(dec_ctx);
			sp->nsi_tape.nt_adapter_name =
			    ndmp_door_get_string(dec_ctx);
			sp->nsi_tape.nt_sid = ndmp_door_get_int32(dec_ctx);
			sp->nsi_tape.nt_lun = ndmp_door_get_int32(dec_ctx);
		}
		/* all the V2 mover data are same as V3/V4 */
		sp->nsi_mover.nm_state = ndmp_door_get_int32(dec_ctx);
		sp->nsi_mover.nm_mode = ndmp_door_get_int32(dec_ctx);
		sp->nsi_mover.nm_pause_reason = ndmp_door_get_int32(dec_ctx);
		sp->nsi_mover.nm_halt_reason = ndmp_door_get_int32(dec_ctx);
		sp->nsi_mover.nm_rec_size = ndmp_door_get_uint64(dec_ctx);
		sp->nsi_mover.nm_rec_num = ndmp_door_get_uint64(dec_ctx);
		sp->nsi_mover.nm_mov_pos = ndmp_door_get_uint64(dec_ctx);
		sp->nsi_mover.nm_window_offset = ndmp_door_get_uint64(dec_ctx);
		sp->nsi_mover.nm_window_length = ndmp_door_get_uint64(dec_ctx);
		sp->nsi_mover.nm_sock = ndmp_door_get_int32(dec_ctx);

		/* Read V3/V4 mover info */
		if ((sp->nsi_pver == NDMP_V3) || (sp->nsi_pver == NDMP_V4)) {
			sp->nsi_mover.nm_listen_sock =
			    ndmp_door_get_int32(dec_ctx);
			sp->nsi_mover.nm_addr_type =
			    ndmp_door_get_int32(dec_ctx);
			sp->nsi_mover.nm_tcp_addr =
			    ndmp_door_get_string(dec_ctx);
		}

		/* connection common data info */
		sp->nsi_data.nd_oper = ndmp_door_get_int32(dec_ctx);
		sp->nsi_data.nd_state = ndmp_door_get_int32(dec_ctx);
		sp->nsi_data.nd_halt_reason = ndmp_door_get_int32(dec_ctx);
		sp->nsi_data.nd_sock = ndmp_door_get_int32(dec_ctx);
		sp->nsi_data.nd_addr_type = ndmp_door_get_int32(dec_ctx);
		sp->nsi_data.nd_abort = ndmp_door_get_int32(dec_ctx);
		sp->nsi_data.nd_read_offset = ndmp_door_get_uint64(dec_ctx);
		sp->nsi_data.nd_read_length = ndmp_door_get_uint64(dec_ctx);
		sp->nsi_data.nd_total_size = ndmp_door_get_uint64(dec_ctx);
		sp->nsi_data.nd_env_len = ndmp_door_get_uint64(dec_ctx);
		sp->nsi_data.nd_env =
		    malloc(sizeof (ndmp_dt_pval_t) * sp->nsi_data.nd_env_len);
		if (!sp->nsi_data.nd_env) {
			free(buf);
			ndmp_errno = ENDMP_MEM_ALLOC;
			goto err;
		}
		ep = sp->nsi_data.nd_env;
		for (j = 0; j < sp->nsi_data.nd_env_len; j++, ep++) {
			ep->np_name = ndmp_door_get_string(dec_ctx);
			ep->np_value = ndmp_door_get_string(dec_ctx);
		}
		sp->nsi_data.nd_tcp_addr = ndmp_door_get_string(dec_ctx);

		/* Read V2 data info */
		if (sp->nsi_pver == NDMP_V2) {
			sp->nsi_data.nld_nlist_len =
			    ndmp_door_get_int64(dec_ctx);
			sp->nsi_data.nd_nlist.nld_nlist =
			    malloc(sizeof (ndmp_dt_name_t) *
			    sp->nsi_data.nld_nlist_len);
			if (!sp->nsi_data.nd_nlist.nld_nlist) {
				free(buf);
				ndmp_errno = ENDMP_MEM_ALLOC;
				goto err;
			}
			np = sp->nsi_data.nd_nlist.nld_nlist;

			for (j = 0; j < sp->nsi_data.nld_nlist_len; j++, np++) {
				np->nn_name = ndmp_door_get_string(dec_ctx);
				np->nn_dest = ndmp_door_get_string(dec_ctx);
			}
		} else if ((sp->nsi_pver == NDMP_V3) ||
		    (sp->nsi_pver == NDMP_V4)) {
			/* Read V3/V4 data info */
			sp->nsi_data.nd_nlist.nld_dt_v3.dv3_listen_sock =
			    ndmp_door_get_int32(dec_ctx);
			sp->nsi_data.nd_nlist.nld_dt_v3.dv3_bytes_processed =
			    ndmp_door_get_uint64(dec_ctx);
			sp->nsi_data.nld_nlist_len =
			    ndmp_door_get_uint64(dec_ctx);
			sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist =
			    malloc(sizeof (ndmp_dt_name_v3_t) *
			    sp->nsi_data.nld_nlist_len);
			if (!sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist) {
				free(buf);
				ndmp_errno = ENDMP_MEM_ALLOC;
				goto err;
			}
			npv3 = sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist;
			for (j = 0; j < sp->nsi_data.nld_nlist_len;
			    j++, npv3++) {
				npv3->nn3_opath = ndmp_door_get_string(dec_ctx);
				npv3->nn3_dpath = ndmp_door_get_string(dec_ctx);
				npv3->nn3_node = ndmp_door_get_uint64(dec_ctx);
				npv3->nn3_fh_info =
				    ndmp_door_get_uint64(dec_ctx);
			}
		}
	}

	if (ndmp_door_fini())
		goto err;

	(void) mutex_unlock(&ndmp_lock);
	return (0);
err:
	(void) mutex_unlock(&ndmp_lock);
	return (-1);
}

void
ndmp_get_session_info_free(ndmp_session_info_t *sinfo, size_t size)
{
	ndmp_session_info_t *sp;
	ndmp_dt_pval_t *ep;
	ndmp_dt_name_t *np;
	ndmp_dt_name_v3_t *npv3;
	int i, j;

	sp = sinfo;
	for (i = 0; i < size; i++, sp++) {
		free(sp->nsi_cl_addr);
		free(sp->nsi_scsi.ns_adapter_name);
		if (sp->nsi_tape.nt_fd != -1) {
			free(sp->nsi_tape.nt_dev_name);
			free(sp->nsi_tape.nt_adapter_name);
		}
		if ((sp->nsi_pver == NDMP_V3) || (sp->nsi_pver == NDMP_V4))
			free(sp->nsi_mover.nm_tcp_addr);

		ep = sp->nsi_data.nd_env;
		for (j = 0; j < sp->nsi_data.nd_env_len; j++, ep++) {
			free(ep->np_name);
			free(ep->np_value);
		}
		free(sp->nsi_data.nd_env);
		free(sp->nsi_data.nd_tcp_addr);

		if (sp->nsi_pver == NDMP_V2) {
			np = sp->nsi_data.nd_nlist.nld_nlist;
			for (j = 0; j < sp->nsi_data.nld_nlist_len; j++, np++) {
				free(np->nn_name);
				free(np->nn_dest);
			}
			free(sp->nsi_data.nd_nlist.nld_nlist);
		} else if ((sp->nsi_pver == NDMP_V3) ||
		    (sp->nsi_pver == NDMP_V4)) {
			npv3 = sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist;
			for (j = 0; j < sp->nsi_data.nld_nlist_len;
			    j++, npv3++) {
				free(npv3->nn3_opath);
				free(npv3->nn3_dpath);
			}
			free(sp->nsi_data.nd_nlist.nld_dt_v3.dv3_nlist);
		}
	}
	free(sinfo);
}

/* ARGSUSED */
int
ndmp_get_stats(ndmp_stat_t *statp)
{
	int opcode = NDMP_GET_STAT;

	(void) mutex_lock(&ndmp_lock);
	if (!statp) {
		ndmp_errno = ENDMP_INVALID_ARG;
		goto err;
	}

	if (ndmp_door_setup(opcode))
		goto err;

	if (ndmp_door_call())
		goto err;

	statp->ns_trun = ndmp_door_get_uint32(dec_ctx);
	statp->ns_twait = ndmp_door_get_uint32(dec_ctx);
	statp->ns_nbk = ndmp_door_get_uint32(dec_ctx);
	statp->ns_nrs = ndmp_door_get_uint32(dec_ctx);
	statp->ns_rfile = ndmp_door_get_uint32(dec_ctx);
	statp->ns_wfile = ndmp_door_get_uint32(dec_ctx);
	statp->ns_rdisk = ndmp_door_get_uint64(dec_ctx);
	statp->ns_wdisk = ndmp_door_get_uint64(dec_ctx);
	statp->ns_rtape = ndmp_door_get_uint64(dec_ctx);
	statp->ns_wtape = ndmp_door_get_uint64(dec_ctx);

	if (ndmp_door_fini())
		goto err;

	(void) mutex_unlock(&ndmp_lock);
	return (0);
err:
	(void) mutex_unlock(&ndmp_lock);
	return (-1);
}

int
ndmp_door_status(void)
{
	int opcode = NDMP_GET_DOOR_STATUS;

	(void) mutex_lock(&ndmp_lock);
	if (ndmp_door_setup(opcode))
		goto err;

	if (ndmp_door_call())
		goto err;

	if (ndmp_door_fini())
		goto err;

	(void) mutex_unlock(&ndmp_lock);
	return (0);
err:
	(void) mutex_unlock(&ndmp_lock);
	return (-1);
}

static int
ndmp_door_setup(int opcode)
{
	/* Open channel to NDMP service */
	if ((ndmp_door_fildes == -1) &&
	    (ndmp_door_fildes = open(NDMP_DOOR_SVC, O_RDONLY)) < 0) {
		ndmp_errno = ENDMP_DOOR_OPEN;
		return (-1);
	}

	buf = malloc(NDMP_DOOR_SIZE);
	if (!buf) {
		ndmp_errno = ENDMP_MEM_ALLOC;
		return (-1);
	}

	enc_ctx = ndmp_door_encode_start(buf, NDMP_DOOR_SIZE);
	if (enc_ctx == 0) {
		free(buf);
		ndmp_errno = ENDMP_DOOR_ENCODE_START;
		return (-1);
	}
	ndmp_door_put_uint32(enc_ctx, opcode);
	return (0);
}

static int
ndmp_door_call(void)
{
	uint32_t used;
	int rc;

	if ((ndmp_door_encode_finish(enc_ctx, &used)) != 0) {
		free(buf);
		ndmp_errno = ENDMP_DOOR_ENCODE_FINISH;
		return (-1);
	}

	arg.data_ptr = buf;
	arg.data_size = used;
	arg.desc_ptr = NULL;
	arg.desc_num = 0;
	arg.rbuf = buf;
	arg.rsize = NDMP_DOOR_SIZE;

	if (door_call(ndmp_door_fildes, &arg) < 0) {
		free(buf);
		ndmp_errno = ENDMP_DOOR_SRV_TIMEOUT;
		(void) close(ndmp_door_fildes);
		ndmp_door_fildes = -1;
		return (-1);
	}

	dec_ctx = ndmp_door_decode_start(arg.data_ptr, arg.data_size);
	rc = ndmp_door_get_uint32(dec_ctx);
	if (rc != NDMP_DOOR_SRV_SUCCESS) {
		free(buf);
		ndmp_errno = ENDMP_DOOR_SRV_OPERATION;
		return (-1);
	}
	return (0);
}

static int
ndmp_door_fini(void)
{
	if ((ndmp_door_decode_finish(dec_ctx)) != 0) {
		free(buf);
		ndmp_errno = ENDMP_DOOR_DECODE_FINISH;
		return (-1);
	}
	free(buf);
	return (0);
}