ndmpd/ndmp/ndmpd_zfs.c

/*
 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2011, 2015 by Delphix. All rights reserved.
 */

/*
 * 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.
 */
/* Copyright (c) 2007, The Storage Networking Industry Association. */
/* Copyright (c) 1996, 1997 PDC, Network Appliance. All Rights Reserved */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/lwp.h>
#include <sys/fs/zfs.h>
#include <sys/mtio.h>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <libzfs.h>
#include <stdio.h>
#include "ndmpd_common.h"
#include "ndmpd.h"

typedef struct {
    char nzs_findprop[ZFS_MAXPROPLEN]; /* prop substring to find */
    char nzs_snapname[ZFS_MAX_DATASET_NAME_LEN]; /* snap's name */
    char nzs_snapprop[ZFS_MAXPROPLEN]; /* snap's prop value */
    char nzs_snapskip[ZFS_MAXPROPLEN]; /* snap to skip */
    uint32_t nzs_prop_major;       /* property major version */
    uint32_t nzs_prop_minor;       /* property minor version */
} ndmpd_zfs_snapfind_t;

mutex_t ndmpd_zfs_fd_lock;

static int ndmpd_zfs_open_fds(ndmpd_zfs_args_t *);
static void ndmpd_zfs_close_fds(ndmpd_zfs_args_t *);

static void ndmpd_zfs_close_one_fd(ndmpd_zfs_args_t *, int);

static int ndmpd_zfs_header_write(ndmpd_session_t *);
static int ndmpd_zfs_header_read(ndmpd_zfs_args_t *);

static int ndmpd_zfs_backup_send_read(ndmpd_zfs_args_t *);
static int ndmpd_zfs_backup_tape_write(ndmpd_zfs_args_t *);

static int ndmpd_zfs_restore(ndmpd_zfs_args_t *);
static int ndmpd_zfs_restore_tape_read(ndmpd_zfs_args_t *);
static int ndmpd_zfs_restore_recv_write(ndmpd_zfs_args_t *);

static int ndmpd_zfs_reader_writer(ndmpd_zfs_args_t *, int **, int **);

static int ndmpd_zfs_addenv_backup_size(ndmpd_zfs_args_t *, u_longlong_t);

static boolean_t ndmpd_zfs_backup_pathvalid(ndmpd_zfs_args_t *);
static int ndmpd_zfs_backup_getpath(ndmpd_zfs_args_t *, char *, int);
static int ndmpd_zfs_backup_getenv(ndmpd_zfs_args_t *);

static boolean_t ndmpd_zfs_restore_pathvalid(ndmpd_zfs_args_t *);
static int ndmpd_zfs_restore_getpath(ndmpd_zfs_args_t *);
static int ndmpd_zfs_restore_getenv(ndmpd_zfs_args_t *);

static int ndmpd_zfs_getenv(ndmpd_zfs_args_t *);
static int ndmpd_zfs_getenv_zfs_mode(ndmpd_zfs_args_t *);
static int ndmpd_zfs_getenv_zfs_force(ndmpd_zfs_args_t *);
static int ndmpd_zfs_getenv_level(ndmpd_zfs_args_t *);
static int ndmpd_zfs_getenv_update(ndmpd_zfs_args_t *);
static int ndmpd_zfs_getenv_dmp_name(ndmpd_zfs_args_t *);
static int ndmpd_zfs_getenv_zfs_backup_size(ndmpd_zfs_args_t *);

static boolean_t ndmpd_zfs_dmp_name_valid(ndmpd_zfs_args_t *, char *);
static boolean_t ndmpd_zfs_is_incremental(ndmpd_zfs_args_t *);
static int ndmpd_zfs_send_fhist(ndmpd_zfs_args_t *);

static int ndmpd_zfs_snapshot_prepare(ndmpd_zfs_args_t *);
static int ndmpd_zfs_snapshot_cleanup(ndmpd_zfs_args_t *, int);
static int ndmpd_zfs_snapshot_create(ndmpd_zfs_args_t *);
static int ndmpd_zfs_snapshot_unuse(ndmpd_zfs_args_t *,
    boolean_t, ndmpd_zfs_snapfind_t *);
static boolean_t ndmpd_zfs_snapshot_ndmpd_generated(char *);
static int ndmpd_zfs_snapshot_find(ndmpd_zfs_args_t *, ndmpd_zfs_snapfind_t *);

static int ndmpd_zfs_snapshot_prop_find(zfs_handle_t *, void *);
static int ndmpd_zfs_snapshot_prop_get(zfs_handle_t *, char *);
static int ndmpd_zfs_snapshot_prop_add(ndmpd_zfs_args_t *);
static int ndmpd_zfs_snapshot_prop_create(ndmpd_zfs_args_t *, char *,
    boolean_t *);
static int ndmpd_zfs_prop_create_subprop(ndmpd_zfs_args_t *, char *, int,
    boolean_t);
static int ndmpd_zfs_snapshot_prop_remove(ndmpd_zfs_args_t *,
    ndmpd_zfs_snapfind_t *);
static boolean_t ndmpd_zfs_prop_version_check(char *, uint32_t *, uint32_t *);

static int ndmpd_zfs_snapname_create(ndmpd_zfs_args_t *, char *, int);

static void ndmpd_zfs_zerr_dma_log(ndmpd_zfs_args_t *);

static int ndmpd_zfs_backup(ndmpd_zfs_args_t *);

/*
 * Syntax for com.sun.ndmp:incr property value:
 *  #.#.n|u/$LEVEL.$DMP_NAME.$ZFS_MODE(/ ...)
 *
 * where
 *  #.# is the version number
 *  'n' means ndmp-generated; 'u' means user-supplied
 *  $LEVEL: backup (incremental) level [0-9]
 *  $DMP_NAME: set name [default: "level"]
 *  $ZFS_MODE: d | r | p [for dataset, recursive, or package]
 *
 * Examples:
 *
 *  0.0.n/0.bob.p
 *  0.0.u/1.bob.p/0.jane.d
 *
 * Note: NDMPD_ZFS_SUBPROP_MAX is calculated based on ZFS_MAXPROPLEN
 */

#define NDMPD_ZFS_PROP_INCR "com.sun.ndmp:incr"
#define NDMPD_ZFS_SUBPROP_MAX   28

/*
 * NDMPD_ZFS_LOG_ZERR
 *
 * As coded, there should be no races in the retrieval of the ZFS errno
 * from the ndmpd_zfs_args->nz_zlibh.  I.e., for a given ndmpd_zfs backup
 * or restore, there should only ever be one ZFS library call taking place
 * at any one moment in time.
 */

#define NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, ...) {           \
    NDMP_LOG(LOG_ERR, __VA_ARGS__);                 \
    NDMP_LOG(LOG_ERR, "%s--%s",                 \
        libzfs_error_action((ndmpd_zfs_args)->nz_zlibh),            \
        libzfs_error_description((ndmpd_zfs_args)->nz_zlibh));      \
    ndmpd_zfs_zerr_dma_log((ndmpd_zfs_args));           \
}

int
ndmpd_zfs_init(ndmpd_session_t *session)
{
    ndmpd_zfs_args_t *ndmpd_zfs_args = &session->ns_ndmpd_zfs_args;
    int version = session->ns_protocol_version;

    bzero(ndmpd_zfs_args, sizeof (*ndmpd_zfs_args));

    if ((version < NDMPV3) || (version > NDMPV4)) {
        NDMP_LOG(LOG_ERR, "Unknown or unsupported version %d", version);
        return (-1);
    }

    if ((ndmpd_zfs_args->nz_zlibh = libzfs_init()) == NULL) {
        NDMP_LOG(LOG_ERR, "libzfs init error [%d]", errno);
        return (-1);
    }

    if (ndmpd_zfs_open_fds(ndmpd_zfs_args) < 0) {
        NDMP_LOG(LOG_ERR, "open_fds() failure(): %d\n", errno);
        return (-1);
    }

    ndmpd_zfs_args->nz_bufsize = ndmp_buffer_get_size(session);
    ndmpd_zfs_args->nz_window_len = session->ns_mover.md_window_length;

    ndmpd_zfs_args->nz_nlp = ndmp_get_nlp(session);

    assert(ndmpd_zfs_args->nz_nlp != NULL);

    ndmpd_zfs_args->nz_nlp->nlp_bytes_total = 0;

    session->ns_data.dd_module.dm_module_cookie = ndmpd_zfs_args;
    session->ns_data.dd_data_size = 0;
    session->ns_data.dd_module.dm_stats.ms_est_bytes_remaining = 0;
    session->ns_data.dd_module.dm_stats.ms_est_time_remaining  = 0;

    session->ns_data.dd_bytes_left_to_read = 0;
    session->ns_data.dd_position = 0;
    session->ns_data.dd_discard_length = 0;
    session->ns_data.dd_read_offset = 0;
    session->ns_data.dd_read_length = 0;

    ndmpd_zfs_params->mp_get_env_func = ndmpd_api_get_env;
    ndmpd_zfs_params->mp_add_env_func = ndmpd_api_add_env;
    ndmpd_zfs_params->mp_set_env_func = ndmpd_api_set_env;
    ndmpd_zfs_params->mp_dispatch_func = ndmpd_api_dispatch;
    ndmpd_zfs_params->mp_daemon_cookie = (void *)session;
    ndmpd_zfs_params->mp_protocol_version = session->ns_protocol_version;
    ndmpd_zfs_params->mp_stats = &session->ns_data.dd_module.dm_stats;
    ndmpd_zfs_params->mp_add_file_handler_func =
        ndmpd_api_add_file_handler;
    ndmpd_zfs_params->mp_remove_file_handler_func =
        ndmpd_api_remove_file_handler;
    ndmpd_zfs_params->mp_seek_func = 0;

    switch (version) {
    case NDMPV3:
        ndmpd_zfs_params->mp_write_func = ndmpd_api_write_v3;
        ndmpd_zfs_params->mp_read_func = ndmpd_api_read_v3;
        ndmpd_zfs_params->mp_get_name_func = ndmpd_api_get_name_v3;
        ndmpd_zfs_params->mp_done_func = ndmpd_api_done_v3;
        ndmpd_zfs_params->mp_log_func_v3 = ndmpd_api_log_v3;
        ndmpd_zfs_params->mp_file_recovered_func =
            ndmpd_api_file_recovered_v3;
        break;
    case NDMPV4:
        ndmpd_zfs_params->mp_write_func = ndmpd_api_write_v3;
        ndmpd_zfs_params->mp_read_func = ndmpd_api_read_v3;
        ndmpd_zfs_params->mp_get_name_func = ndmpd_api_get_name_v3;
        ndmpd_zfs_params->mp_done_func = ndmpd_api_done_v3;
        ndmpd_zfs_params->mp_log_func_v3 = ndmpd_api_log_v4;
        ndmpd_zfs_params->mp_file_recovered_func =
            ndmpd_api_file_recovered_v4;
        break;
    default:
        /* error already returned above for this case */
        break;
    }

    return (0);
}

void
ndmpd_zfs_fini(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    libzfs_fini(ndmpd_zfs_args->nz_zlibh);

    ndmpd_zfs_close_fds(ndmpd_zfs_args);
}

static int
ndmpd_zfs_open_fds(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    int err;

    err = pipe(ndmpd_zfs_args->nz_pipe_fd);
    if (err)
        NDMP_LOG(LOG_ERR, "pipe(2) failed: %s:\n", strerror(errno));

    return (err);
}

/*
 * ndmpd_zfs_close_fds()
 *
 * In the abort case, use dup2() to redirect the end of the pipe that is
 * being written to (to a new pipe).  Close the ends of the new pipe to cause
 * EPIPE to be returned to the writing thread.  This will cause the writer
 * and reader to terminate without having any of the writer's data erroneously
 * go to any reopened descriptor.
 */

static void
ndmpd_zfs_close_fds(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    int pipe_end;
    int fds[2];

    if (session->ns_data.dd_state != NDMP_DATA_STATE_ACTIVE) {
        ndmpd_zfs_close_one_fd(ndmpd_zfs_args, PIPE_ZFS);
        ndmpd_zfs_close_one_fd(ndmpd_zfs_args, PIPE_TAPE);
        return;
    }

    (void) mutex_lock(&ndmpd_zfs_fd_lock);

    if (ndmpd_zfs_params->mp_operation == NDMP_DATA_OP_BACKUP) {
        pipe_end = PIPE_ZFS;
    } else {
        pipe_end = PIPE_TAPE;
    }

    if (ndmpd_zfs_args->nz_pipe_fd[pipe_end] != -1) {
        if (pipe(fds) != 0) {
            (void) mutex_unlock(&ndmpd_zfs_fd_lock);
            NDMP_LOG(LOG_ERR, "pipe(2) failed: %s:\n",
                strerror(errno));
            return;
        }

        (void) dup2(fds[0], ndmpd_zfs_args->nz_pipe_fd[pipe_end]);
        (void) close(fds[0]);
        (void) close(fds[1]);

        ndmpd_zfs_args->nz_pipe_fd[pipe_end] = -1;
    }

    (void) mutex_unlock(&ndmpd_zfs_fd_lock);
}

static void
ndmpd_zfs_close_one_fd(ndmpd_zfs_args_t *ndmpd_zfs_args, int pipe_end)
{
    (void) mutex_lock(&ndmpd_zfs_fd_lock);
    (void) close(ndmpd_zfs_args->nz_pipe_fd[pipe_end]);
    ndmpd_zfs_args->nz_pipe_fd[pipe_end] = -1;
    (void) mutex_unlock(&ndmpd_zfs_fd_lock);
}

static int
ndmpd_zfs_header_write(ndmpd_session_t *session)
{
    ndmpd_zfs_args_t *ndmpd_zfs_args = &session->ns_ndmpd_zfs_args;
    int32_t bufsize = ndmpd_zfs_args->nz_bufsize;
    ndmpd_zfs_header_t *tape_header = &ndmpd_zfs_args->nz_tape_header;
    char *buf;

    buf = ndmp_malloc(bufsize);
    if (buf == NULL) {
        NDMP_LOG(LOG_DEBUG, "buf NULL");
        return (-1);
    }

    (void) strlcpy(tape_header->nzh_magic, NDMPUTF8MAGIC,
        sizeof (NDMPUTF8MAGIC));
    tape_header->nzh_major = LE_32(NDMPD_ZFS_MAJOR_VERSION);
    tape_header->nzh_minor = LE_32(NDMPD_ZFS_MINOR_VERSION);
    tape_header->nzh_hdrlen = LE_32(bufsize);

    bzero(buf, bufsize);
    (void) memcpy(buf, tape_header, sizeof (ndmpd_zfs_header_t));

    NDMP_LOG(LOG_DEBUG, "header (major, minor, length): %u %u %u",
        NDMPD_ZFS_MAJOR_VERSION,
        NDMPD_ZFS_MINOR_VERSION,
        bufsize);

    if (MOD_WRITE(ndmpd_zfs_params, buf, bufsize) != 0) {
        free(buf);
        NDMP_LOG(LOG_ERR, "MOD_WRITE error");
        return (-1);
    }

    free(buf);

    session->ns_data.dd_module.dm_stats.ms_bytes_processed = bufsize;

    return (0);
}

static int
ndmpd_zfs_header_read(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    int32_t bufsize = ndmpd_zfs_args->nz_bufsize;
    ndmpd_zfs_header_t *tape_header = &ndmpd_zfs_args->nz_tape_header;
    uint32_t hdrlen;
    int32_t header_left;
    int err;
    char *buf;

    buf = ndmp_malloc(bufsize);
    if (buf == NULL) {
        NDMP_LOG(LOG_DEBUG, "buf NULL");
        return (-1);
    }

    bzero(buf, bufsize);

    /*
     * Read nz_bufsize worth of bytes first (the size of a mover record).
     */

    err = MOD_READ(ndmpd_zfs_params, buf, bufsize);

    if (err != 0) {
        NDMP_LOG(LOG_ERR, "MOD_READ error: %d", err);
        free(buf);
        return (-1);
    }

    (void) memcpy(tape_header, buf, sizeof (ndmpd_zfs_header_t));

    if (strcmp(tape_header->nzh_magic, NDMPUTF8MAGIC) != 0) {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "bad magic string\n");
        goto _err;
    }

    if (tape_header->nzh_major > LE_32(NDMPD_ZFS_MAJOR_VERSION)) {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "major number larger than supported: (%d %d)\n",
            LE_32(tape_header->nzh_major), NDMPD_ZFS_MAJOR_VERSION);
        goto _err;
    }

    /*
     * Major version 0 (regardless of minor version):
     * Header must be a multiple of the mover record size.
     */

    hdrlen = LE_32(tape_header->nzh_hdrlen);
    if (hdrlen > bufsize) {
        header_left = hdrlen - bufsize;
        while (header_left > 0) {
            err = MOD_READ(ndmpd_zfs_params, buf, bufsize);
            if (err == -1) {
                ndmpd_zfs_dma_log(ndmpd_zfs_args,
                    NDMP_LOG_ERROR, "bad header\n");
                goto _err;
            }
            header_left -= bufsize;
        }
    }

    NDMP_LOG(LOG_DEBUG, "tape header: %s; %u %u; %u ",
        tape_header->nzh_magic,
        LE_32(tape_header->nzh_major),
        LE_32(tape_header->nzh_minor),
        LE_32(tape_header->nzh_hdrlen));

    ndmpd_zfs_args->nz_nlp->nlp_bytes_total = hdrlen;

    free(buf);
    return (0);

_err:

    NDMP_LOG(LOG_ERR, "tape header: %s; %u %u; %u ",
        tape_header->nzh_magic,
        LE_32(tape_header->nzh_major),
        LE_32(tape_header->nzh_minor),
        LE_32(tape_header->nzh_hdrlen));

    free(buf);
    return (-1);
}

int
ndmpd_zfs_backup_starter(void *arg)
{
    ndmpd_zfs_args_t *ndmpd_zfs_args = arg;
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    int cleanup_err = 0;
    int err = 0;

    ndmp_session_ref(session);

    if (ndmpd_zfs_snapshot_prepare(ndmpd_zfs_args) != 0) {
        err = -1;
        goto _done;
    }

    err = ndmpd_zfs_backup(ndmpd_zfs_args);

    cleanup_err = ndmpd_zfs_snapshot_cleanup(ndmpd_zfs_args, err);

    NDMP_LOG(LOG_DEBUG,
        "data bytes_total(including header):%llu",
        session->ns_data.dd_module.dm_stats.ms_bytes_processed);

    if (err == 0)
        err = ndmpd_zfs_send_fhist(ndmpd_zfs_args);

_done:
    NS_DEC(nbk);
    MOD_DONE(ndmpd_zfs_params, err ? err : cleanup_err);
    ndmp_session_unref(session);
    ndmpd_zfs_fini(ndmpd_zfs_args);

    return (err);
}

static int
ndmpd_zfs_send_fhist(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    struct stat64 st;
    char *envp;

    envp = MOD_GETENV(ndmpd_zfs_params, "HIST");
    if (!envp)
        return (0);

    if (!(strchr("YT", toupper(*envp)))) {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_WARNING,
            "HIST is not set.  No file history will be "
            "generated.\n");
        return (0);
    }

    /* Build up a sample root dir stat */
    (void) memset(&st, 0, sizeof (struct stat64));
    st.st_mode = S_IFDIR | 0777;
    st.st_mtime = st.st_atime = st.st_ctime = time(NULL);
    st.st_uid = st.st_gid = 0;
    st.st_size = 1;
    st.st_nlink = 1;

    if (ndmpd_api_file_history_dir_v3(session, ".", ROOT_INODE,
        ROOT_INODE) != 0)
        return (-1);
    if (ndmpd_api_file_history_dir_v3(session, "..", ROOT_INODE,
        ROOT_INODE) != 0)
        return (-1);
    if (ndmpd_api_file_history_node_v3(session, ROOT_INODE, &st, 0) != 0)
        return (-1);

    ndmpd_file_history_cleanup(session, TRUE);
    return (0);
}

static int
ndmpd_zfs_backup(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    int *read_err = NULL;
    int *write_err = NULL;
    int result = 0;
    int err;

    if (session->ns_eof)
        return (-1);

    if (!session->ns_data.dd_abort) {
        if (ndmpd_zfs_header_write(session)) {
            ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
                "ndmpd_zfs header write error\n");
            return (-1);
        }

        err = ndmpd_zfs_reader_writer(ndmpd_zfs_args,
            &read_err, &write_err);

        if (err || read_err || write_err || session->ns_eof)
            result = EPIPE;
    }

    if (session->ns_data.dd_abort) {
        ndmpd_audit_backup(session->ns_connection,
            ndmpd_zfs_args->nz_dataset,
            session->ns_data.dd_data_addr.addr_type,
            ndmpd_zfs_args->nz_dataset, EINTR);
        NDMP_LOG(LOG_DEBUG, "Backing up \"%s\" aborted.",
            ndmpd_zfs_args->nz_dataset);

        (void) ndmpd_zfs_post_backup(ndmpd_zfs_args);
        err = -1;
    } else {
        ndmpd_audit_backup(session->ns_connection,
            ndmpd_zfs_args->nz_dataset,
            session->ns_data.dd_data_addr.addr_type,
            ndmpd_zfs_args->nz_dataset, result);

        err = ndmpd_zfs_post_backup(ndmpd_zfs_args);
        if (err || result)
            err = -1;

        if (err == 0)  {
            NDMP_LOG(LOG_DEBUG, "Backing up \"%s\" finished.",
                ndmpd_zfs_args->nz_dataset);
        } else {
            NDMP_LOG(LOG_DEBUG, "An error occurred while backing up"
                " \"%s\"", ndmpd_zfs_args->nz_dataset);
        }
    }

    return (err);
}

/*
 * ndmpd_zfs_backup_send_read()
 *
 * This routine executes zfs_send() to create the backup data stream.
 * The value of ZFS_MODE determines the type of zfs_send():
 *  dataset ('d'): Only the dataset specified (i.e., top level) is backed up
 *  recursive ('r'): The dataset and its child file systems are backed up
 *  package ('p'): Same as 'r', except all intermediate snapshots are also
 *          backed up
 *
 * Volumes do not have descednants, so 'd' and 'r' produce equivalent results.
 */

static int
ndmpd_zfs_backup_send_read(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    sendflags_t flags = { 0 };
    char *fromsnap = NULL;
    zfs_handle_t *zhp;
    int err;

    zhp = zfs_open(ndmpd_zfs_args->nz_zlibh,
        ndmpd_zfs_args->nz_dataset, ndmpd_zfs_args->nz_type);

    if (!zhp) {
        if (!session->ns_data.dd_abort)
            NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_open");
        return (-1);
    }

    switch (ndmpd_zfs_args->nz_zfs_mode) {
    case ('d'):
        flags.props = B_TRUE;
        break;
    case ('r'):
        flags.replicate = B_TRUE;
        break;
    case ('p'):
        flags.doall = B_TRUE;
        flags.replicate = B_TRUE;
        break;
    default:
        NDMP_LOG(LOG_ERR, "unknown zfs_mode: %c",
            ndmpd_zfs_args->nz_zfs_mode);
        zfs_close(zhp);
        return (-1);
    }

    if (ndmpd_zfs_is_incremental(ndmpd_zfs_args)) {
        if (ndmpd_zfs_args->nz_fromsnap[0] == '\0') {
            NDMP_LOG(LOG_ERR, "no fromsnap");
            zfs_close(zhp);
            return (-1);
        }
        fromsnap = ndmpd_zfs_args->nz_fromsnap;
    }

    err = zfs_send(zhp, fromsnap, ndmpd_zfs_args->nz_snapname, &flags,
        ndmpd_zfs_args->nz_pipe_fd[PIPE_ZFS], NULL, NULL, NULL);

    if (err && !session->ns_data.dd_abort)
        NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_send: %d", err);

    zfs_close(zhp);

    return (err);
}

/*
 * ndmpd_zfs_backup_tape_write()
 *
 * The data begins on a mover record boundary (because
 * the header is the size of a mover record--i.e.
 * ndmpd_zfs_args->nz_bufsize).
 */

static int
ndmpd_zfs_backup_tape_write(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    int bufsize = ndmpd_zfs_args->nz_bufsize;
    u_longlong_t *bytes_totalp;
    int count;
    char *buf;

    buf = ndmp_malloc(bufsize);
    if (buf == NULL) {
        NDMP_LOG(LOG_DEBUG, "buf NULL");
        return (-1);
    }

    bytes_totalp =
        &(session->ns_data.dd_module.dm_stats.ms_bytes_processed);

    for (;;) {
        bzero(buf, bufsize);

        count = read(ndmpd_zfs_args->nz_pipe_fd[PIPE_TAPE], buf,
            bufsize);

        if (count == 0) /* EOF */ {
            NDMP_LOG(LOG_DEBUG,
                "zfs_send stream size: %llu bytes; "
                "full backup size (including header): %llu",
                *bytes_totalp - bufsize, *bytes_totalp);
            free(buf);

            return (ndmpd_zfs_addenv_backup_size(ndmpd_zfs_args,
                *bytes_totalp));
        }

        if (count == -1) {
            NDMP_LOG(LOG_DEBUG, "pipe read error (errno %d)",
                errno);
            free(buf);
            return (-1);
        }
        NS_ADD(rdisk, count);

        if (MOD_WRITE(ndmpd_zfs_params, buf, count) != 0) {
            (void) ndmpd_zfs_abort((void *) ndmpd_zfs_args);
            NDMP_LOG(LOG_ERR, "MOD_WRITE error");
            free(buf);
            return (-1);
        }

        *bytes_totalp += count;
    }
    /* NOTREACHED */
}

static int
ndmpd_zfs_addenv_backup_size(ndmpd_zfs_args_t *ndmpd_zfs_args,
    u_longlong_t bytes_total)
{
    char zfs_backup_size[32];
    int err;

    (void) snprintf(zfs_backup_size, sizeof (zfs_backup_size), "%llu",
        bytes_total);

    err = MOD_ADDENV(ndmpd_zfs_params, "ZFS_BACKUP_SIZE", zfs_backup_size);

    if (err) {
        NDMP_LOG(LOG_ERR, "Failed to add ZFS_BACKUP_SIZE env");
        return (-1);
    }

    NDMP_LOG(LOG_DEBUG, "Added ZFS_BACKUP_SIZE env: %s", zfs_backup_size);

    return (0);
}

int
ndmpd_zfs_restore_starter(void *arg)
{
    ndmpd_zfs_args_t *ndmpd_zfs_args = arg;
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    int err;

    ndmp_session_ref(session);

    err = ndmpd_zfs_restore(ndmpd_zfs_args);

    MOD_DONE(ndmpd_zfs_params, err);

    NS_DEC(nrs);

    ndmp_session_unref(session);

    ndmpd_zfs_fini(ndmpd_zfs_args);

    return (err);
}

static int
ndmpd_zfs_restore(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    int *read_err = NULL;
    int *write_err = NULL;
    int result = 0;
    int err;

    if (!session->ns_data.dd_abort) {
        if (ndmpd_zfs_header_read(ndmpd_zfs_args)) {
            ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
                "ndmpd_zfs header read error\n");
            return (-1);
        }

        err = ndmpd_zfs_reader_writer(ndmpd_zfs_args,
            &write_err, &read_err);

        if (err || read_err || write_err || session->ns_eof)
            result = EIO;
    }

    if (session->ns_data.dd_abort) {
        NDMP_LOG(LOG_DEBUG, "Restoring to \"%s\" aborted.",
            ndmpd_zfs_args->nz_dataset);
        ndmpd_audit_restore(session->ns_connection,
            ndmpd_zfs_args->nz_dataset,
            session->ns_data.dd_data_addr.addr_type,
            ndmpd_zfs_args->nz_dataset, EINTR);
        (void) ndmpd_zfs_post_restore(ndmpd_zfs_args);
        err = -1;
    } else {
        ndmpd_audit_restore(session->ns_connection,
            ndmpd_zfs_args->nz_dataset,
            session->ns_data.dd_data_addr.addr_type,
            ndmpd_zfs_args->nz_dataset, result);
        err = ndmpd_zfs_post_restore(ndmpd_zfs_args);
        if (err || result)
            err = -1;

        if (err == 0) {
            NDMP_LOG(LOG_DEBUG, "Restoring to \"%s\" finished",
                ndmpd_zfs_args->nz_dataset);
        } else {
            NDMP_LOG(LOG_DEBUG, "An error occurred while restoring"
                " to \"%s\"", ndmpd_zfs_args->nz_dataset);
        }
    }

    return (err);
}

static int
ndmpd_zfs_restore_tape_read(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    int bufsize = ndmpd_zfs_args->nz_bufsize;
    u_longlong_t backup_size = ndmpd_zfs_args->nz_zfs_backup_size;
    u_longlong_t *bytes_totalp;
    u_longlong_t bytes;
    char *buf;
    int count;
    int err;

    buf = ndmp_malloc(bufsize);
    if (buf == NULL) {
        NDMP_LOG(LOG_DEBUG, "buf NULL");
        return (-1);
    }

    bytes_totalp = &ndmpd_zfs_args->nz_nlp->nlp_bytes_total;

    while (*bytes_totalp < backup_size) {

        bytes = backup_size - *bytes_totalp;

        if (bytes >= bufsize)
            bytes = bufsize;

        err = MOD_READ(ndmpd_zfs_params, buf, bytes);

        if (err != 0) {
            NDMP_LOG(LOG_ERR, "MOD_READ error: %d; returning -1",
                err);
            free(buf);
            return (-1);
        }

        count = write(ndmpd_zfs_args->nz_pipe_fd[PIPE_TAPE], buf,
            bytes);

        if (count != bytes) {
            NDMP_LOG(LOG_ERR, "count (%d) != bytes (%d)",
                count, bytes);

            if (count == -1) {
                NDMP_LOG(LOG_ERR, "pipe write error: errno: %d",
                    errno);

                if (session->ns_data.dd_abort)
                    NDMP_LOG(LOG_DEBUG, "abort set");
            }

            free(buf);
            return (-1);
        }

        NS_ADD(wdisk, count);

        *bytes_totalp += count;
    }

    free(buf);
    return (0);
}

/*
 * ndmpd_zfs_restore_recv_write()
 *
 * This routine executes zfs_receive() to restore the backup.
 */

static int
ndmpd_zfs_restore_recv_write(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    recvflags_t flags;
    int err;

    bzero(&flags, sizeof (recvflags_t));

    flags.nomount = B_TRUE;

    NDMP_LOG(LOG_DEBUG, "nz_zfs_force: %d\n", ndmpd_zfs_args->nz_zfs_force);

    if (ndmpd_zfs_args->nz_zfs_force)
        flags.force = B_TRUE;

    err = zfs_receive(ndmpd_zfs_args->nz_zlibh, ndmpd_zfs_args->nz_dataset,
        NULL, &flags, ndmpd_zfs_args->nz_pipe_fd[PIPE_ZFS], NULL);

    if (err && !session->ns_data.dd_abort)
        NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_receive: %d", err);

    return (err);
}

/*
 * ndmpd_zfs_reader_writer()
 *
 * Two separate threads are used for actual backup or restore.
 */

static int
ndmpd_zfs_reader_writer(ndmpd_zfs_args_t *ndmpd_zfs_args,
    int **sendrecv_errp, int **tape_errp)
{
    funct_t sendrecv_func;
    funct_t tape_func;
    int sendrecv_err;
    int tape_err;

    switch (ndmpd_zfs_params->mp_operation) {
    case NDMP_DATA_OP_BACKUP:
        sendrecv_func = (funct_t)ndmpd_zfs_backup_send_read;
        tape_func = (funct_t)ndmpd_zfs_backup_tape_write;
        break;
    case NDMP_DATA_OP_RECOVER:
        sendrecv_func = (funct_t)ndmpd_zfs_restore_recv_write;
        tape_func = (funct_t)ndmpd_zfs_restore_tape_read;
        break;
    }

    sendrecv_err = pthread_create(&ndmpd_zfs_args->nz_sendrecv_thread,
        NULL, sendrecv_func, ndmpd_zfs_args);

    if (sendrecv_err == 0) {
        tape_err = pthread_create(&ndmpd_zfs_args->nz_tape_thread,
            NULL, tape_func, ndmpd_zfs_args);

        if (tape_err) {
            /*
             * The close of the tape side of the pipe will cause
             * nz_sendrecv_thread to error in the zfs_send/recv()
             * call and to return.  Hence we do not need
             * to explicitly cancel the sendrecv_thread here
             * (the pthread_join() below is sufficient).
             */

            (void) close(ndmpd_zfs_args->nz_pipe_fd[PIPE_TAPE]);
            NDMP_LOG(LOG_ERR, "Could not start tape thread; "
                "aborting z-op");
        }

        (void) pthread_join(ndmpd_zfs_args->nz_sendrecv_thread,
            (void **) sendrecv_errp);
    }

    if ((tape_err == 0) &&
        (ndmpd_zfs_params->mp_operation == NDMP_DATA_OP_RECOVER))
        ndmpd_zfs_close_one_fd(ndmpd_zfs_args, PIPE_TAPE);

    ndmpd_zfs_close_one_fd(ndmpd_zfs_args, PIPE_ZFS);

    if ((sendrecv_err == 0) && (tape_err == 0)) {
        (void) pthread_join(ndmpd_zfs_args->nz_tape_thread,
            (void **) tape_errp);
    }

    if ((tape_err == 0) &&
        (ndmpd_zfs_params->mp_operation == NDMP_DATA_OP_BACKUP))
        ndmpd_zfs_close_one_fd(ndmpd_zfs_args, PIPE_TAPE);

    return (sendrecv_err ? sendrecv_err : tape_err);
}

int
ndmpd_zfs_abort(void *arg)
{
    ndmpd_zfs_args_t *ndmpd_zfs_args = arg;
    char str[8];

    if (ndmpd_zfs_params->mp_operation == NDMP_DATA_OP_BACKUP)
        (void) strlcpy(str, "backup", 8);
    else
        (void) strlcpy(str, "recover", 8);

    NDMP_LOG(LOG_ERR, "ndmpd_zfs_abort() called...aborting %s operation",
        str);

    ndmpd_zfs_close_fds(ndmpd_zfs_args);

    return (0);
}

/*
 * ndmpd_zfs_pre_backup()
 *
 * Note: The memset to 0 of nctxp ensures that nctx->nc_cmds == NULL.
 * This ensures that ndmp_include_zfs() will fail, which is
 * a requirement for "zfs"-type backup.
 */

int
ndmpd_zfs_pre_backup(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    ndmp_context_t *nctxp = &ndmpd_zfs_args->nz_nctx;
    int err;

    if (ndmp_pl == NULL || ndmp_pl->np_pre_backup == NULL)
        return (0);

    (void) memset(nctxp, 0, sizeof (ndmp_context_t));
    nctxp->nc_plversion = ndmp_pl->np_plversion;
    nctxp->nc_plname = ndmpd_get_prop(NDMP_PLUGIN_PATH);
    nctxp->nc_ddata = (void *) session;
    nctxp->nc_params = ndmpd_zfs_params;

    err = ndmp_pl->np_pre_backup(ndmp_pl, nctxp,
        ndmpd_zfs_args->nz_dataset);

    if (err != 0) {
        NDMP_LOG(LOG_DEBUG, "Pre-backup plug-in: %m");
        (void) ndmpd_zfs_post_backup(ndmpd_zfs_args);
    }

    return (err);
}

int
ndmpd_zfs_post_backup(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmp_context_t *nctxp = &ndmpd_zfs_args->nz_nctx;
    int err = 0;

    if (ndmp_pl == NULL || ndmp_pl->np_post_backup == NULL)
        return (0);

    err = ndmp_pl->np_post_backup(ndmp_pl, nctxp, err);

    if (err == -1)
        NDMP_LOG(LOG_DEBUG, "Post-backup plug-in: %m");

    return (err);
}

int
ndmpd_zfs_pre_restore(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    ndmp_context_t *nctxp = &ndmpd_zfs_args->nz_nctx;
    char bkpath[ZFS_MAX_DATASET_NAME_LEN];
    int err;

    if (ndmp_pl == NULL || ndmp_pl->np_pre_restore == NULL)
        return (0);

    err = ndmpd_zfs_backup_getpath(ndmpd_zfs_args, bkpath,
        ZFS_MAX_DATASET_NAME_LEN);

    if (err != 0) {
        NDMP_LOG(LOG_DEBUG, "error getting bkup path: %d", err);
        return (-1);
    }

    err = ndmpd_zfs_restore_getpath(ndmpd_zfs_args);

    if (err != 0) {
        NDMP_LOG(LOG_DEBUG, "error getting restore path: %d", err);
        return (-1);
    }

    (void) memset(nctxp, 0, sizeof (ndmp_context_t));
    nctxp->nc_ddata = (void *) session;
    nctxp->nc_params = ndmpd_zfs_params;

    err = ndmp_pl->np_pre_restore(ndmp_pl, nctxp, bkpath,
        ndmpd_zfs_args->nz_dataset);

    if (err != 0) {
        NDMP_LOG(LOG_DEBUG, "Pre-restore plug-in: %m");
        return (-1);
    }

    return (0);
}

int
ndmpd_zfs_post_restore(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmp_context_t *nctxp = &ndmpd_zfs_args->nz_nctx;
    int err = 0;

    if (ndmp_pl == NULL || ndmp_pl->np_post_restore == NULL)
        return (0);

    err = ndmp_pl->np_post_restore(ndmp_pl, nctxp, err);

    if (err == -1)
        NDMP_LOG(LOG_DEBUG, "Post-restore plug-in: %m");

    return (err);
}

boolean_t
ndmpd_zfs_backup_parms_valid(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_zfs_snapfind_t snapdata;

    if (ndmpd_zfs_backup_getenv(ndmpd_zfs_args) != 0)
        return (B_FALSE);

    if (!ndmpd_zfs_backup_pathvalid(ndmpd_zfs_args))
        return (B_FALSE);

    if (ndmpd_zfs_is_incremental(ndmpd_zfs_args)) {
        (void) ndmpd_zfs_prop_create_subprop(ndmpd_zfs_args,
            snapdata.nzs_findprop, ZFS_MAXPROPLEN, B_TRUE);

        snapdata.nzs_snapname[0] = '\0';
        snapdata.nzs_snapprop[0] = '\0';

        if (ndmpd_zfs_snapshot_find(ndmpd_zfs_args, &snapdata))
            return (B_FALSE);

        if (snapdata.nzs_snapname[0] == '\0') { /* not found */
            ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
                "Snapshot for level %d does not exist\n",
                ndmpd_zfs_args->nz_level-1);
            return (B_FALSE);
        }

        (void) strlcpy(ndmpd_zfs_args->nz_fromsnap,
            snapdata.nzs_snapname, ZFS_MAX_DATASET_NAME_LEN);
    }

    return (B_TRUE);
}

/*
 * ndmpd_zfs_backup_pathvalid()
 *
 * Make sure the path is of an existing dataset
 */

static boolean_t
ndmpd_zfs_backup_pathvalid(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    char zpath[ZFS_MAX_DATASET_NAME_LEN];
    char propstr[ZFS_MAXPROPLEN];
    zfs_handle_t *zhp;
    zfs_type_t ztype = 0;
    int err;

    if (ndmpd_zfs_backup_getpath(ndmpd_zfs_args, zpath,
        ZFS_MAX_DATASET_NAME_LEN) != 0)
        return (B_FALSE);

    if (ndmpd_zfs_args->nz_snapname[0] != '\0') {
        zhp = zfs_open(ndmpd_zfs_args->nz_zlibh, zpath,
            ZFS_TYPE_SNAPSHOT);

        if (!zhp) {
            NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args,
                "zfs_open (snap)");
            ndmpd_zfs_args->nz_snapname[0] = '\0';
            ndmpd_zfs_args->nz_dataset[0] = '\0';
            return (B_FALSE);
        }

        err = ndmpd_zfs_snapshot_prop_get(zhp, propstr);

        zfs_close(zhp);

        if (err) {
            NDMP_LOG(LOG_DEBUG,
                "ndmpd_zfs_snapshot_prop_get failed");
            return (-1);
        }

        if (propstr && ndmpd_zfs_snapshot_ndmpd_generated(propstr)) {
            ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
                "cannot use an ndmpd-generated snapshot\n");
            return (B_FALSE);
        }
    }

    zhp = zfs_open(ndmpd_zfs_args->nz_zlibh,
        ndmpd_zfs_args->nz_dataset, ZFS_TYPE_DATASET);

    if (zhp) {
        ztype = zfs_get_type(zhp);
        zfs_close(zhp);
    }

    if ((ztype == ZFS_TYPE_VOLUME) ||
        (ztype == ZFS_TYPE_FILESYSTEM)) {
        ndmpd_zfs_args->nz_type = ztype;
        return (B_TRUE);
    }

    ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
        "Invalid file system or volume.\n");

    return (B_FALSE);
}

/*
 * ndmpd_zfs_backup_getpath()
 *
 * Retrieve the backup path from the environment, which should
 * be of the form "/dataset[@snap]".  The leading slash is required
 * by certain DMA's but can otherwise be ignored.
 *
 * (Note: "dataset" can consist of more than one component,
 * e.g. "pool", "pool/volume", "pool/fs/fs2".)
 *
 * The dataset name and the snapshot name (if any) will be
 * stored in ndmpd_zfs_args.
 */

static int
ndmpd_zfs_backup_getpath(ndmpd_zfs_args_t *ndmpd_zfs_args, char *zpath,
    int zlen)
{
    char *env_path;
    char *at;

    env_path = get_backup_path_v3(ndmpd_zfs_params);
    if (env_path == NULL)
        return (-1);

    if (env_path[0] != '/') {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "Invalid path: %s (leading slash required)\n", env_path);
        return (-1);
    }

    (void) strlcpy(zpath, &env_path[1], zlen);
    (void) strlcpy(ndmpd_zfs_args->nz_dataset, &env_path[1],
        ZFS_MAX_DATASET_NAME_LEN);

    at = strchr(ndmpd_zfs_args->nz_dataset, '@');
    if (at) {
        *at = '\0';
        (void) strlcpy(ndmpd_zfs_args->nz_snapname, ++at,
            ZFS_MAX_DATASET_NAME_LEN);
    } else {
        ndmpd_zfs_args->nz_snapname[0] = '\0';
    }

    (void) trim_whitespace(ndmpd_zfs_args->nz_dataset);

    return (0);
}

static int
ndmpd_zfs_backup_getenv(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    return (ndmpd_zfs_getenv(ndmpd_zfs_args));
}

boolean_t
ndmpd_zfs_restore_parms_valid(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    if (ndmpd_zfs_restore_getenv(ndmpd_zfs_args) != 0)
        return (B_FALSE);

    if (!ndmpd_zfs_restore_pathvalid(ndmpd_zfs_args))
        return (B_FALSE);

    return (B_TRUE);
}

static boolean_t
ndmpd_zfs_restore_pathvalid(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    zfs_handle_t *zhp;
    char *at;

    if (ndmpd_zfs_restore_getpath(ndmpd_zfs_args) != 0)
        return (B_FALSE);

    at = strchr(ndmpd_zfs_args->nz_dataset, '@');

    if (at) {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_WARNING,
            "%s ignored in restore path\n", at);
        *at = '\0';
    }

    ndmpd_zfs_args->nz_type = ZFS_TYPE_VOLUME | ZFS_TYPE_FILESYSTEM;

    zhp = zfs_open(ndmpd_zfs_args->nz_zlibh,
        ndmpd_zfs_args->nz_dataset, ndmpd_zfs_args->nz_type);

    if (zhp) {
        zfs_close(zhp);

        if (!ndmpd_zfs_is_incremental(ndmpd_zfs_args)) {
            ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
                "Restore dataset exists.\n"
                "A nonexistent dataset must be specified "
                "for 'zfs' non-incremental restore.\n");
            return (B_FALSE);
        }
    }

    NDMP_LOG(LOG_DEBUG, "restore path: %s\n", ndmpd_zfs_args->nz_dataset);

    return (B_TRUE);
}

/*
 * ndmpd_zfs_restore_getpath()
 *
 * Be sure to not include the leading slash, which is required for
 * compatibility with backup applications (NBU) but which is not part
 * of the ZFS syntax.  (Note that this done explicitly in all paths
 * below except those calling ndmpd_zfs_backup_getpath(), because it is
 * already stripped in that function.)
 *
 * In addition, the DMA might add a trailing slash to the path.
 * Strip all such slashes.
 */

static int
ndmpd_zfs_restore_getpath(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    int version = ndmpd_zfs_params->mp_protocol_version;
    char zpath[ZFS_MAX_DATASET_NAME_LEN];
    mem_ndmp_name_v3_t *namep_v3;
    char *dataset = ndmpd_zfs_args->nz_dataset;
    char *nm;
    char *p;
    int len;
    int err;

    namep_v3 = (mem_ndmp_name_v3_t *)MOD_GETNAME(ndmpd_zfs_params, 0);

    if (namep_v3 == NULL) {
        NDMP_LOG(LOG_DEBUG, "Can't get Nlist[0]");
        return (-1);
    }

    if (namep_v3->nm3_dpath) {
        if (namep_v3->nm3_dpath[0] != '/') {
            ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
                "Invalid path: %s (leading slash required)\n",
                namep_v3->nm3_dpath);
            return (-1);
        }

        (void) strlcpy(dataset, &(namep_v3->nm3_dpath[1]),
            ZFS_MAX_DATASET_NAME_LEN);

        if (namep_v3->nm3_newnm) {
            (void) strlcat(dataset, "/", ZFS_MAX_DATASET_NAME_LEN);
            (void) strlcat(dataset, namep_v3->nm3_newnm,
                ZFS_MAX_DATASET_NAME_LEN);

        } else {
            if (version == NDMPV3) {
                /*
                 * The following does not apply for V4.
                 *
                 * Find the last component of nm3_opath.
                 * nm3_opath has no trailing '/'.
                 */
                p = strrchr(namep_v3->nm3_opath, '/');
                nm = p? p : namep_v3->nm3_opath;
                (void) strlcat(dataset, "/",
                    ZFS_MAX_DATASET_NAME_LEN);
                (void) strlcat(dataset, nm,
                    ZFS_MAX_DATASET_NAME_LEN);
            }
        }
    } else {
        err = ndmpd_zfs_backup_getpath(ndmpd_zfs_args, zpath,
            ZFS_MAX_DATASET_NAME_LEN);
        if (err)
            return (err);
    }

    len = strlen(dataset);
    while (dataset[len-1] == '/') {
        dataset[len-1] = '\0';
        len--;
    }

    return (0);
}

static int
ndmpd_zfs_restore_getenv(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    if (ndmpd_zfs_getenv_zfs_backup_size(ndmpd_zfs_args) != 0)
        return (-1);

    return (ndmpd_zfs_getenv(ndmpd_zfs_args));
}

static int
ndmpd_zfs_getenv(ndmpd_zfs_args_t *ndmpd_zfs_args)
{

    if (ndmpd_zfs_getenv_level(ndmpd_zfs_args) != 0)
        return (-1);

    if (ndmpd_zfs_getenv_zfs_mode(ndmpd_zfs_args) != 0)
        return (-1);

    if (ndmpd_zfs_getenv_zfs_force(ndmpd_zfs_args) != 0)
        return (-1);

    if (ndmpd_zfs_getenv_update(ndmpd_zfs_args) != 0)
        return (-1);

    if (ndmpd_zfs_getenv_dmp_name(ndmpd_zfs_args) != 0)
        return (-1);

    return (0);
}

static int
ndmpd_zfs_getenv_zfs_mode(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    char *envp;

    envp = MOD_GETENV(ndmpd_zfs_params, "ZFS_MODE");

    if (envp == NULL) {
        NDMP_LOG(LOG_DEBUG, "env(ZFS_MODE) not specified, "
            "defaulting to recursive");
        ndmpd_zfs_args->nz_zfs_mode = 'r';
        return (0);
    }

    if ((strcmp(envp, "dataset") == 0) || (strcmp(envp, "d") == 0)) {
        ndmpd_zfs_args->nz_zfs_mode = 'd';
    } else if ((strcmp(envp, "recursive") == 0) ||
        (strcmp(envp, "r") == 0)) {
        ndmpd_zfs_args->nz_zfs_mode = 'r';
    } else if ((strcmp(envp, "package") == 0) || (strcmp(envp, "p") == 0)) {
        ndmpd_zfs_args->nz_zfs_mode = 'p';
    } else {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "Invalid ZFS_MODE value \"%s\".\n", envp);
        return (-1);
    }

    NDMP_LOG(LOG_DEBUG, "env(ZFS_MODE): \"%c\"",
        ndmpd_zfs_args->nz_zfs_mode);

    return (0);
}

/*
 * ndmpd_zfs_getenv_zfs_force()
 *
 * If SMF property zfs-force-override is set to "yes" or "no", this
 * value will override any value of NDMP environment variable ZFS_FORCE
 * as set by the DMA admin (or override the default of 'n', if ZFS_FORCE
 * is not set).  By default, zfs-force-override is "off", which means it
 * will not override ZFS_FORCE.
 */

static int
ndmpd_zfs_getenv_zfs_force(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    char *envp_force;
    char *override;

    override = ndmpd_get_prop(NDMP_ZFS_FORCE_OVERRIDE);

    if (strcasecmp(override, "yes") == 0) {
        ndmpd_zfs_args->nz_zfs_force = B_TRUE;
        NDMP_LOG(LOG_NOTICE,
            "SMF property zfs-force-override set to 'yes', "
            "overriding ZFS_FORCE");
        return (0);
    }

    if (strcasecmp(override, "no") == 0) {
        ndmpd_zfs_args->nz_zfs_force = B_FALSE;
        NDMP_LOG(LOG_NOTICE,
            "SMF property zfs-force-override set to 'no', "
            "overriding ZFS_FORCE");
        return (0);
    }

    if (strcasecmp(override, "off") != 0) {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "SMF property zfs-force-override set to invalid value of "
            "'%s'; treating it as 'off'.", override);
    }

    envp_force = MOD_GETENV(ndmpd_zfs_params, "ZFS_FORCE");

    if (envp_force == NULL) {
        NDMP_LOG(LOG_DEBUG,
            "env(ZFS_FORCE) not specified, defaulting to FALSE");
        ndmpd_zfs_args->nz_zfs_force = B_FALSE;
        return (0);
    }

    /*
     * The value can be either 't' ("true" for v3) or 'y' ("yes" for v4).
     */

    if (strchr("tTyY", *envp_force))
        ndmpd_zfs_args->nz_zfs_force = B_TRUE;

    NDMP_LOG(LOG_DEBUG, "env(ZFS_FORCE): \"%s\"", envp_force);

    return (0);
}

static int
ndmpd_zfs_getenv_level(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    char *envp;

    envp = MOD_GETENV(ndmpd_zfs_params, "LEVEL");

    if (envp == NULL) {
        NDMP_LOG(LOG_DEBUG, "env(LEVEL) not specified, "
            "defaulting to 0");
        ndmpd_zfs_args->nz_level = 0;
        return (0);
    }

    if (envp[1] != '\0') {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "Invalid backup level \"%s\".\n", envp);
        return (-1);
    }

    if (!isdigit(*envp)) {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "Invalid backup level \"%s\".\n", envp);
        return (-1);
    }

    ndmpd_zfs_args->nz_level = atoi(envp);

    NDMP_LOG(LOG_DEBUG, "env(LEVEL): \"%d\"",
        ndmpd_zfs_args->nz_level);

    return (0);
}

static int
ndmpd_zfs_getenv_update(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    char *envp_update;

    envp_update = MOD_GETENV(ndmpd_zfs_params, "UPDATE");

    if (envp_update == NULL) {
        NDMP_LOG(LOG_DEBUG,
            "env(UPDATE) not specified, defaulting to TRUE");
        ndmpd_zfs_args->nz_update = B_TRUE;
        return (0);
    }

    /*
     * The value can be either 't' ("true" for v3) or 'y' ("yes" for v4).
     */

    if (strchr("tTyY", *envp_update))
        ndmpd_zfs_args->nz_update = B_TRUE;

    NDMP_LOG(LOG_DEBUG, "env(UPDATE): \"%s\"", envp_update);

    return (0);
}

static int
ndmpd_zfs_getenv_dmp_name(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    char *envp;

    envp = MOD_GETENV(ndmpd_zfs_params, "DMP_NAME");

    if (envp == NULL) {
        NDMP_LOG(LOG_DEBUG,
            "env(DMP_NAME) not specified, defaulting to 'level'");
        (void) strlcpy(ndmpd_zfs_args->nz_dmp_name, "level",
            NDMPD_ZFS_DMP_NAME_MAX);
        return (0);
    }

    if (!ndmpd_zfs_dmp_name_valid(ndmpd_zfs_args, envp))
        return (-1);

    (void) strlcpy(ndmpd_zfs_args->nz_dmp_name, envp,
        NDMPD_ZFS_DMP_NAME_MAX);

    NDMP_LOG(LOG_DEBUG, "env(DMP_NAME): \"%s\"", envp);

    return (0);
}

static int
ndmpd_zfs_getenv_zfs_backup_size(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    char *zfs_backup_size;

    zfs_backup_size = MOD_GETENV(ndmpd_zfs_params, "ZFS_BACKUP_SIZE");

    if (zfs_backup_size == NULL) {
        NDMP_LOG(LOG_ERR, "ZFS_BACKUP_SIZE env is NULL");
        return (-1);
    }

    NDMP_LOG(LOG_DEBUG, "ZFS_BACKUP_SIZE: %s\n", zfs_backup_size);

    (void) sscanf(zfs_backup_size, "%llu",
        &ndmpd_zfs_args->nz_zfs_backup_size);

    return (0);
}

/*
 * ndmpd_zfs_dmp_name_valid()
 *
 * This function verifies that the dmp_name is valid.
 *
 * The dmp_name is restricted to alphanumeric characters plus
 * the underscore and hyphen, and must be 31 characters or less.
 * This is due to its use in the NDMPD_ZFS_PROP_INCR property
 * and in the ZFS snapshot name (if an ndmpd-generated snapshot
 * is required).
 */

static boolean_t
ndmpd_zfs_dmp_name_valid(ndmpd_zfs_args_t *ndmpd_zfs_args, char *dmp_name)
{
    char *c;

    if (strlen(dmp_name) >= NDMPD_ZFS_DMP_NAME_MAX) {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "DMP_NAME %s is longer than %d\n",
            dmp_name, NDMPD_ZFS_DMP_NAME_MAX-1);
        return (B_FALSE);
    }

    for (c = dmp_name; *c != '\0'; c++) {
        if (!isalpha(*c) && !isdigit(*c) &&
            (*c != '_') && (*c != '-')) {
            ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
                "DMP_NAME %s contains illegal character %c\n",
                dmp_name, *c);
            return (B_FALSE);
        }
    }

    NDMP_LOG(LOG_DEBUG, "DMP_NAME is valid: %s\n", dmp_name);
    return (B_TRUE);
}

/*
 * ndmpd_zfs_is_incremental()
 *
 * This can only be called after ndmpd_zfs_getenv_level()
 * has been called.
 */

static boolean_t
ndmpd_zfs_is_incremental(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    return (ndmpd_zfs_args->nz_level != 0);
}

/*
 * ndmpd_zfs_snapshot_prepare()
 *
 * If no snapshot was supplied by the user, create a snapshot
 * for use by ndmpd.
 */

static int
ndmpd_zfs_snapshot_prepare(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    boolean_t recursive = B_FALSE;
    int zfs_err = 0;

    if (session->ns_data.dd_abort) {
        NDMP_LOG(LOG_DEBUG, "Backing up \"%s\" aborted.",
            ndmpd_zfs_args->nz_dataset);
        return (-1);
    }

    if (ndmpd_zfs_args->nz_snapname[0] == '\0') {
        ndmpd_zfs_args->nz_ndmpd_snap = B_TRUE;

        if (ndmpd_zfs_snapshot_create(ndmpd_zfs_args) != 0) {
            ndmpd_zfs_args->nz_snapname[0] = '\0';

            ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
                "Error creating snapshot for %s\n",
                ndmpd_zfs_args->nz_dataset);

            return (-1);
        }
    }

    if (ndmpd_zfs_snapshot_prop_add(ndmpd_zfs_args)) {
        NDMP_LOG(LOG_DEBUG,
            "ndmpd_zfs_snapshot_prop_add error\n");

        if (ndmpd_zfs_args->nz_ndmpd_snap) {

            if (ndmpd_zfs_args->nz_zfs_mode != 'd')
                recursive = B_TRUE;

            (void) snapshot_destroy(ndmpd_zfs_args->nz_dataset,
                ndmpd_zfs_args->nz_snapname, recursive, B_FALSE,
                &zfs_err);
        }

        return (-1);
    }

    return (0);
}

/*
 * ndmpd_zfs_snapshot_cleanup()
 *
 * If UPDATE = y, find the old snapshot (if any) corresponding to
 * {LEVEL, DMP_NAME, ZFS_MODE}. If it was ndmpd-generated,
 * remove the snapshot.  Otherwise, update its NDMPD_ZFS_PROP_INCR
 * property to remove {L, D, Z}.
 *
 * If UPDATE = n, if an ndmpd-generated snapshot was used for backup,
 * remove the snapshot.  Otherwise, update its NDMPD_ZFS_PROP_INCR
 * property to remove {L, D, Z}.
 */

static int
ndmpd_zfs_snapshot_cleanup(ndmpd_zfs_args_t *ndmpd_zfs_args, int err)
{
    ndmpd_session_t *session = (ndmpd_session_t *)
        (ndmpd_zfs_params->mp_daemon_cookie);
    ndmpd_zfs_snapfind_t snapdata;
    boolean_t ndmpd_generated = B_FALSE;

    bzero(&snapdata, sizeof (ndmpd_zfs_snapfind_t));

    (void) ndmpd_zfs_prop_create_subprop(ndmpd_zfs_args,
        snapdata.nzs_findprop, ZFS_MAXPROPLEN, B_FALSE);

    if (ndmpd_zfs_args->nz_update && !session->ns_data.dd_abort && !err) {
        /*
         * Find the existing snapshot, if any, to "unuse."
         * Indicate that the current snapshot used for backup
         * should be skipped in the search.  (The search is
         * sorted by creation time but this cannot be relied
         * upon for user-supplied snapshots.)
         */

        (void) snprintf(snapdata.nzs_snapskip, ZFS_MAX_DATASET_NAME_LEN,
            "%s", ndmpd_zfs_args->nz_snapname);

        if (ndmpd_zfs_snapshot_find(ndmpd_zfs_args, &snapdata)) {
            NDMP_LOG(LOG_DEBUG, "ndmpd_zfs_snapshot_find error\n");
            goto _remove_tmp_snap;
        }

        if (snapdata.nzs_snapname[0] != '\0') { /* snapshot found */
            ndmpd_generated = ndmpd_zfs_snapshot_ndmpd_generated
                (snapdata.nzs_snapprop);

            if (ndmpd_zfs_snapshot_unuse(ndmpd_zfs_args,
                ndmpd_generated, &snapdata) != 0) {
                NDMP_LOG(LOG_DEBUG,
                    "ndmpd_zfs_snapshot_unuse error\n");
                goto _remove_tmp_snap;
            }
        }

        if (session->ns_data.dd_abort)
            goto _remove_tmp_snap;

        return (0);
    }

_remove_tmp_snap:

    (void) snprintf(snapdata.nzs_snapname, ZFS_MAX_DATASET_NAME_LEN, "%s",
        ndmpd_zfs_args->nz_snapname);

    (void) strlcpy(snapdata.nzs_snapprop, ndmpd_zfs_args->nz_snapprop,
        ZFS_MAXPROPLEN);

    snapdata.nzs_snapskip[0] = '\0';

    if (ndmpd_zfs_snapshot_unuse(ndmpd_zfs_args,
        ndmpd_zfs_args->nz_ndmpd_snap, &snapdata) != 0) {
        NDMP_LOG(LOG_DEBUG, "ndmpd_zfs_snapshot_unuse error\n");
        return (-1);
    }

    if (!ndmpd_zfs_args->nz_update)
        return (0);

    return (-1);
}

static int
ndmpd_zfs_snapshot_create(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    boolean_t recursive = B_FALSE;

    if (ndmpd_zfs_snapname_create(ndmpd_zfs_args,
        ndmpd_zfs_args->nz_snapname, ZFS_MAX_DATASET_NAME_LEN - 1) < 0) {
        NDMP_LOG(LOG_ERR, "Error (%d) creating snapshot name for %s",
            errno, ndmpd_zfs_args->nz_dataset);
        return (-1);
    }

    if (ndmpd_zfs_args->nz_zfs_mode != 'd')
        recursive = B_TRUE;

    if (snapshot_create(ndmpd_zfs_args->nz_dataset,
        ndmpd_zfs_args->nz_snapname, recursive, B_FALSE) != 0) {
        NDMP_LOG(LOG_ERR, "could not create snapshot %s@%s",
            ndmpd_zfs_args->nz_dataset, ndmpd_zfs_args->nz_snapname);
        return (-1);
    }

    NDMP_LOG(LOG_DEBUG, "created snapshot %s@%s",
        ndmpd_zfs_args->nz_dataset, ndmpd_zfs_args->nz_snapname);

    return (0);
}

/*
 * ndmpd_zfs_snapshot_unuse()
 *
 * Given a pre-existing snapshot of the given {L, D, Z}:
 * If snapshot is ndmpd-generated, remove snapshot.
 * If not ndmpd-generated, or if the ndmpd-generated snapshot
 * cannot be destroyed, remove the {L, D, Z} substring from the
 * snapshot's NDMPD_ZFS_PROP_INCR property.
 *
 * In the event of a failure, it may be that two snapshots will
 * have the {L, D, Z} property set on them.  This is not desirable,
 * so return an error and log the failure.
 */

static int
ndmpd_zfs_snapshot_unuse(ndmpd_zfs_args_t *ndmpd_zfs_args,
    boolean_t ndmpd_generated, ndmpd_zfs_snapfind_t *snapdata_p)
{
    boolean_t recursive = B_FALSE;
    int zfs_err = 0;
    int err = 0;

    if (ndmpd_generated) {
        if (ndmpd_zfs_args->nz_zfs_mode != 'd')
            recursive = B_TRUE;

        err = snapshot_destroy(ndmpd_zfs_args->nz_dataset,
            snapdata_p->nzs_snapname, recursive, B_FALSE, &zfs_err);

        if (err) {
            NDMP_LOG(LOG_ERR, "snapshot_destroy: %s@%s;"
                " err: %d; zfs_err: %d",
                ndmpd_zfs_args->nz_dataset,
                snapdata_p->nzs_snapname, err, zfs_err);
            return (-1);
        }
    }

    if (!ndmpd_generated || zfs_err) {
        if (ndmpd_zfs_snapshot_prop_remove(ndmpd_zfs_args, snapdata_p))
            return (-1);
    }

    return (0);
}

static boolean_t
ndmpd_zfs_snapshot_ndmpd_generated(char *snapprop)
{
    char origin;

    (void) sscanf(snapprop, "%*u.%*u.%c%*s", &origin);

    return (origin == 'n');
}

/*
 * ndmpd_zfs_snapshot_find()
 *
 * Find a snapshot with a particular value for
 * the NDMPD_ZFS_PROP_INCR property.
 */

static int
ndmpd_zfs_snapshot_find(ndmpd_zfs_args_t *ndmpd_zfs_args,
    ndmpd_zfs_snapfind_t *snapdata)
{
    zfs_handle_t *zhp;
    int err;

    zhp = zfs_open(ndmpd_zfs_args->nz_zlibh, ndmpd_zfs_args->nz_dataset,
        ndmpd_zfs_args->nz_type);

    if (!zhp) {
        NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_open");
        return (-1);
    }

    err = zfs_iter_snapshots_sorted(zhp, ndmpd_zfs_snapshot_prop_find,
        snapdata);

    zfs_close(zhp);

    if (err) {
        NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_iter_snapshots: %d",
            err);
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "Error iterating snapshots\n");
        return (-1);
    }

    return (0);
}

/*
 * ndmpd_zfs_snapshot_prop_find()
 *
 * Find a snapshot with a particular value for
 * NDMPD_ZFS_PROP_INCR.  Fill in data for the first one
 * found (sorted by creation time).  However, skip the
 * the snapshot indicated in nzs_snapskip, if any.
 */

static int
ndmpd_zfs_snapshot_prop_find(zfs_handle_t *zhp, void *arg)
{
    ndmpd_zfs_snapfind_t *snapdata_p = (ndmpd_zfs_snapfind_t *)arg;
    char propstr[ZFS_MAXPROPLEN];
    char findprop_plus_slash[ZFS_MAXPROPLEN];
    char *justsnap;
    int err = 0;

    if (snapdata_p->nzs_snapname[0] != '\0') {
        NDMP_LOG(LOG_DEBUG, "no need to get prop for snapshot %s",
            (char *)zfs_get_name(zhp));
        goto _done;
    }

    err = ndmpd_zfs_snapshot_prop_get(zhp, propstr);

    if (err) {
        NDMP_LOG(LOG_DEBUG, "ndmpd_zfs_snapshot_prop_get failed");
        goto _done;
    }

    if (propstr[0] == '\0') {
        NDMP_LOG(LOG_DEBUG, "snapshot %s: propr not set",
            (char *)zfs_get_name(zhp));
        goto _done;
    }

    (void) snprintf(findprop_plus_slash, ZFS_MAXPROPLEN, "/%s",
        snapdata_p->nzs_findprop);

    if (!strstr((const char *)propstr,
        (const char *)findprop_plus_slash)) {
        NDMP_LOG(LOG_DEBUG, "snapshot %s: property %s (%s not found)",
            (char *)zfs_get_name(zhp), propstr,
            snapdata_p->nzs_findprop);
        goto _done;
    }

    if (!ndmpd_zfs_prop_version_check(propstr,
        &snapdata_p->nzs_prop_major, &snapdata_p->nzs_prop_minor)) {
        NDMP_LOG(LOG_DEBUG, "snapshot %s: property %s (%s found)",
            (char *)zfs_get_name(zhp),  propstr,
            snapdata_p->nzs_findprop);
        NDMP_LOG(LOG_DEBUG, "did not pass version check");
        goto _done;
    }

    justsnap = strchr(zfs_get_name(zhp), '@') + 1;

    if (strcmp(justsnap, snapdata_p->nzs_snapskip) != 0) {
        (void) strlcpy(snapdata_p->nzs_snapname, justsnap,
            ZFS_MAX_DATASET_NAME_LEN);

        (void) strlcpy(snapdata_p->nzs_snapprop, propstr,
            ZFS_MAXPROPLEN);

        NDMP_LOG(LOG_DEBUG, "found match: %s [%s]\n",
            snapdata_p->nzs_snapname, snapdata_p->nzs_snapprop);
    }

_done:
    zfs_close(zhp);
    return (err);
}

/*
 * ndmpd_zfs_snapshot_prop_get()
 *
 * Retrieve NDMPD_ZFS_PROP_INCR property from snapshot
 */

static int
ndmpd_zfs_snapshot_prop_get(zfs_handle_t *zhp, char *propstr)
{
    nvlist_t *userprop;
    nvlist_t *propval;
    char *strval;
    int err;

    propstr[0] = '\0';

    userprop = zfs_get_user_props(zhp);

    if (userprop == NULL)
        return (0);

    err = nvlist_lookup_nvlist(userprop, NDMPD_ZFS_PROP_INCR, &propval);

    if (err != 0) {
        if (err == ENOENT)
            return (0);

        NDMP_LOG(LOG_DEBUG, "nvlist_lookup_nvlist error: %d\n", err);

        return (-1);
    }

    err = nvlist_lookup_string(propval, ZPROP_VALUE, &strval);

    if (err != 0) {
        if (err == ENOENT)
            return (0);

        NDMP_LOG(LOG_DEBUG, "nvlist_lookup_string error: %d\n", err);

        return (-1);
    }

    (void) strlcpy(propstr, strval, ZFS_MAXPROPLEN);

    return (0);
}

/*
 * ndmpd_zfs_snapshot_prop_add()
 *
 * Update snapshot's NDMPD_ZFS_PROP_INCR property with
 * the current LEVEL, DMP_NAME, and ZFS_MODE values
 * (add property if it doesn't exist)
 */

static int
ndmpd_zfs_snapshot_prop_add(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    char fullname[ZFS_MAX_DATASET_NAME_LEN];
    char propstr[ZFS_MAXPROPLEN];
    zfs_handle_t *zhp;
    boolean_t set;
    int err;

    (void) snprintf(fullname, ZFS_MAX_DATASET_NAME_LEN, "%s@%s",
        ndmpd_zfs_args->nz_dataset,
        ndmpd_zfs_args->nz_snapname);

    zhp = zfs_open(ndmpd_zfs_args->nz_zlibh, fullname, ZFS_TYPE_SNAPSHOT);

    if (!zhp) {
        NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_open (snap)");
        return (-1);
    }

    bzero(propstr, ZFS_MAXPROPLEN);

    if (ndmpd_zfs_snapshot_prop_get(zhp, propstr)) {
        NDMP_LOG(LOG_DEBUG, "error getting property");
        zfs_close(zhp);
        return (-1);
    }

    if (ndmpd_zfs_snapshot_prop_create(ndmpd_zfs_args, propstr, &set)) {
        zfs_close(zhp);
        return (-1);
    }

    if (set) {
        err = zfs_prop_set(zhp, NDMPD_ZFS_PROP_INCR, propstr);
        if (err) {
            NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_prop_set: %d",
                err);
            NDMP_LOG(LOG_ERR, "error setting property %s",
                propstr);
            zfs_close(zhp);
            return (-1);
        }
    }

    zfs_close(zhp);

    (void) strlcpy(ndmpd_zfs_args->nz_snapprop, propstr, ZFS_MAXPROPLEN);

    return (0);
}

static int
ndmpd_zfs_snapshot_prop_create(ndmpd_zfs_args_t *ndmpd_zfs_args,
    char *propstr, boolean_t *set)
{
    char subprop[ZFS_MAXPROPLEN];
    char *p = propstr;
    int slash_count = 0;

    *set = B_TRUE;

    (void) ndmpd_zfs_prop_create_subprop(ndmpd_zfs_args,
        subprop, ZFS_MAXPROPLEN, B_FALSE);

    if (propstr[0] == '\0') {
        (void) snprintf(propstr, ZFS_MAXPROPLEN, "%u.%u.%c/%s",
            NDMPD_ZFS_PROP_MAJOR_VERSION,
            NDMPD_ZFS_PROP_MINOR_VERSION,
            (ndmpd_zfs_args->nz_ndmpd_snap) ? 'n' : 'u',
            subprop);
        return (0);
    }

    if (strstr((const char *)propstr, (const char *)subprop)) {
        NDMP_LOG(LOG_DEBUG, "Did not add entry %s as it already exists",
            subprop);
        *set = B_FALSE;
        return (0);
    }

    while (*p) {
        if (*(p++) == '/')
            slash_count++;
    }

    if (slash_count >= NDMPD_ZFS_SUBPROP_MAX) {
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "snapshot %s: user property %s limit of %d subprops "
            "reached; cannot complete operation",
            ndmpd_zfs_args->nz_snapname,
            NDMPD_ZFS_PROP_INCR,
            NDMPD_ZFS_SUBPROP_MAX);
        return (-1);
    }

    assert((strlen(propstr) + strlen(subprop) + 2) < ZFS_MAXPROPLEN);

    (void) strlcat(propstr, "/", ZFS_MAXPROPLEN);
    (void) strlcat(propstr, subprop, ZFS_MAXPROPLEN);

    return (0);
}

static int
ndmpd_zfs_prop_create_subprop(ndmpd_zfs_args_t *ndmpd_zfs_args,
    char *subprop, int len, boolean_t prev_level)
{
    return (snprintf(subprop, len, "%d.%s.%c",
        prev_level ? ndmpd_zfs_args->nz_level-1 : ndmpd_zfs_args->nz_level,
        ndmpd_zfs_args->nz_dmp_name,
        ndmpd_zfs_args->nz_zfs_mode));
}

/*
 * ndmpd_zfs_snapshot_prop_remove()
 *
 * Remove specified substring from the snapshot's
 * NDMPD_ZFS_PROP_INCR property
 */

static int
ndmpd_zfs_snapshot_prop_remove(ndmpd_zfs_args_t *ndmpd_zfs_args,
    ndmpd_zfs_snapfind_t *snapdata_p)
{
    char findprop_plus_slash[ZFS_MAXPROPLEN];
    char fullname[ZFS_MAX_DATASET_NAME_LEN];
    char newprop[ZFS_MAXPROPLEN];
    char tmpstr[ZFS_MAXPROPLEN];
    zfs_handle_t *zhp;
    char *ptr;
    int err;

    (void) snprintf(fullname, ZFS_MAX_DATASET_NAME_LEN, "%s@%s",
        ndmpd_zfs_args->nz_dataset,
        snapdata_p->nzs_snapname);

    zhp = zfs_open(ndmpd_zfs_args->nz_zlibh, fullname, ZFS_TYPE_SNAPSHOT);

    if (!zhp) {
        NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_open");
        return (-1);
    }

    bzero(newprop, ZFS_MAXPROPLEN);

    /*
     * If the substring to be removed is the only {L, D, Z}
     * in the property, remove the entire property
     */

    tmpstr[0] = '\0';

    (void) sscanf(snapdata_p->nzs_snapprop, "%*u.%*u.%*c/%1023s", tmpstr);

    if (strcmp(tmpstr, snapdata_p->nzs_findprop) == 0) {

        err = zfs_prop_set(zhp, NDMPD_ZFS_PROP_INCR, newprop);

        zfs_close(zhp);

        if (err) {
            NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_prop_set: %d",
                err);
            NDMP_LOG(LOG_ERR, "error setting property %s", newprop);
            return (-1);
        }

        return (0);
    }

    (void) snprintf(findprop_plus_slash, ZFS_MAXPROPLEN, "/%s",
        snapdata_p->nzs_findprop);

    ptr = strstr((const char *)snapdata_p->nzs_snapprop,
        (const char *)findprop_plus_slash);

    if (ptr == NULL) {
        /*
         * This shouldn't happen.  Just return success.
         */
        zfs_close(zhp);

        return (0);
    }

    /*
     * Remove "nzs_findprop" substring from property
     *
     * Example property:
     *  0.0.u/1.bob.p/0.jane.d
     *
     * Note that there will always be a prefix to the
     * strstr() result.  Hence the below code works for
     * all cases.
     */

    ptr--;
    (void) strncpy(newprop, snapdata_p->nzs_snapprop,
        (char *)ptr - snapdata_p->nzs_snapprop);
    ptr += strlen(snapdata_p->nzs_findprop) + 1;
    (void) strlcat(newprop, ptr, ZFS_MAXPROPLEN);

    err = zfs_prop_set(zhp, NDMPD_ZFS_PROP_INCR, newprop);

    zfs_close(zhp);

    if (err) {
        NDMPD_ZFS_LOG_ZERR(ndmpd_zfs_args, "zfs_prop_set: %d", err);
        NDMP_LOG(LOG_ERR, "error modifying property %s", newprop);
        return (-1);
    }

    return (0);
}

static boolean_t
ndmpd_zfs_prop_version_check(char *propstr, uint32_t *major, uint32_t *minor)
{
    (void) sscanf(propstr, "%u.%u.%*c%*s", major, minor);

    if (*major > NDMPD_ZFS_PROP_MAJOR_VERSION) {
        NDMP_LOG(LOG_ERR, "unsupported prop major (%u > %u)",
            *major, NDMPD_ZFS_PROP_MAJOR_VERSION);
        return (B_FALSE);
    }

    if (*minor > NDMPD_ZFS_PROP_MINOR_VERSION) {
        NDMP_LOG(LOG_ERR, "later prop minor (%u > %u)",
            *minor, NDMPD_ZFS_PROP_MINOR_VERSION);
    }

    NDMP_LOG(LOG_DEBUG, "passed version check: "
        "supported prop major (%u <= %u); (snapprop minor: %u [%u])",
        *major, NDMPD_ZFS_PROP_MAJOR_VERSION,
        *minor, NDMPD_ZFS_PROP_MINOR_VERSION);

    return (B_TRUE);
}

static int
ndmpd_zfs_snapname_create(ndmpd_zfs_args_t *ndmpd_zfs_args,
    char *snapname, int namelen)
{
    char subprop[ZFS_MAXPROPLEN];
    struct timeval tp;
    int err = 0;

    (void) ndmpd_zfs_prop_create_subprop(ndmpd_zfs_args,
        subprop, ZFS_MAXPROPLEN, B_FALSE);

    (void) gettimeofday(&tp, NULL);

    err = snprintf(snapname, namelen,
        "ndmp.%s.%ld.%ld",
        subprop,
        tp.tv_sec,
        tp.tv_usec);

    if (err > namelen) {
        NDMP_LOG(LOG_ERR, "name of snapshot [%s...] would exceed %d",
            snapname, namelen);
        return (-1);
    }

    return (0);
}

static void
ndmpd_zfs_zerr_dma_log(ndmpd_zfs_args_t *ndmpd_zfs_args)
{
    switch (libzfs_errno(ndmpd_zfs_args->nz_zlibh)) {
    case EZFS_EXISTS:
    case EZFS_BUSY:
    case EZFS_NOENT:
    case EZFS_INVALIDNAME:
    case EZFS_MOUNTFAILED:
    case EZFS_UMOUNTFAILED:
    case EZFS_NAMETOOLONG:
    case EZFS_BADRESTORE:

        /* use existing error text */

        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "%s: %s: %s\n",
            ndmpd_zfs_args->nz_dataset,
            libzfs_error_action(ndmpd_zfs_args->nz_zlibh),
            libzfs_error_description(ndmpd_zfs_args->nz_zlibh));

        break;

    case EZFS_NOMEM:
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "Unable to obtain memory for operation\n");
        break;

    case EZFS_PROPSPACE:
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "A bad ZFS quota or reservation was encountered.\n");
        break;

    case EZFS_BADSTREAM:
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "The backup stream is invalid.\n");
        break;

    case EZFS_ZONED:
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "An error related to the local zone occurred.\n");
        break;

    case EZFS_NOSPC:
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "No more space is available\n");
        break;

    case EZFS_IO:
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "An I/O error occurred.\n");
        break;

    default:
        ndmpd_zfs_dma_log(ndmpd_zfs_args, NDMP_LOG_ERROR,
            "An internal ndmpd error occurred.  "
            "Please contact support\n");
        break;
    }
}

void
ndmpd_zfs_dma_log(ndmpd_zfs_args_t *ndmpd_zfs_args, ndmp_log_type log_type,
    char *format, ...)
{
    static char buf[1024];
    va_list ap;

    va_start(ap, format);

    /*LINTED variable format specifier */
    (void) vsnprintf(buf, sizeof (buf), format, ap);
    va_end(ap);

    MOD_LOGV3(ndmpd_zfs_params, log_type, buf);

    if ((log_type) == NDMP_LOG_ERROR) {
        NDMP_LOG(LOG_ERR, buf);
    } else {
        NDMP_LOG(LOG_NOTICE, buf);
    }
}