libndmp/common/libndmp.c

	libndmp.c revision 2654012f83cec5dc15b61dfe3e4a4915f186e7a6
/*
 * 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);
    }
    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);
}