/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#include <sys/dmu.h>

#include <sys/dmu_impl.h>

#include <sys/dmu_tx.h>

#include <sys/dbuf.h>

#include <sys/dnode.h>

#include <sys/zfs_context.h>

#include <sys/dmu_objset.h>

#include <sys/dmu_traverse.h>

#include <sys/dsl_dataset.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_pool.h>

#include <sys/dsl_synctask.h>

#include <sys/zfs_ioctl.h>

#include <sys/zap.h>

#include <sys/zio_checksum.h>

static char *dmu_recv_tag = "dmu_recv_tag";

struct backuparg {

	dmu_replay_record_t *drr;

	vnode_t *vp;

	offset_t *off;

	objset_t *os;

	zio_cksum_t zc;

	int err;

};

static int

dump_bytes(struct backuparg *ba, void *buf, int len)

{

	ssize_t resid; /* have to get resid to get detailed errno */

	ASSERT3U(len % 8, ==, 0);

	fletcher_4_incremental_native(buf, len, &ba->zc);

	ba->err = vn_rdwr(UIO_WRITE, ba->vp,

	    (caddr_t)buf, len,

	    0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid);

	*ba->off += len;

	return (ba->err);

}

static int

dump_free(struct backuparg *ba, uint64_t object, uint64_t offset,

    uint64_t length)

{

	/* write a FREE record */

	bzero(ba->drr, sizeof (dmu_replay_record_t));

	ba->drr->drr_type = DRR_FREE;

	ba->drr->drr_u.drr_free.drr_object = object;

	ba->drr->drr_u.drr_free.drr_offset = offset;

	ba->drr->drr_u.drr_free.drr_length = length;

	if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))

		return (EINTR);

	return (0);

}

static int

dump_data(struct backuparg *ba, dmu_object_type_t type,

    uint64_t object, uint64_t offset, int blksz, void *data)

{

	/* write a DATA record */

	bzero(ba->drr, sizeof (dmu_replay_record_t));

	ba->drr->drr_type = DRR_WRITE;

	ba->drr->drr_u.drr_write.drr_object = object;

	ba->drr->drr_u.drr_write.drr_type = type;

	ba->drr->drr_u.drr_write.drr_offset = offset;

	ba->drr->drr_u.drr_write.drr_length = blksz;

	if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))

		return (EINTR);

	if (dump_bytes(ba, data, blksz))

		return (EINTR);

	return (0);

}

static int

dump_freeobjects(struct backuparg *ba, uint64_t firstobj, uint64_t numobjs)

{

	/* write a FREEOBJECTS record */

	bzero(ba->drr, sizeof (dmu_replay_record_t));

	ba->drr->drr_type = DRR_FREEOBJECTS;

	ba->drr->drr_u.drr_freeobjects.drr_firstobj = firstobj;

	ba->drr->drr_u.drr_freeobjects.drr_numobjs = numobjs;

	if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))

		return (EINTR);

	return (0);

}

static int

dump_dnode(struct backuparg *ba, uint64_t object, dnode_phys_t *dnp)

{

	if (dnp == NULL || dnp->dn_type == DMU_OT_NONE)

		return (dump_freeobjects(ba, object, 1));

	/* write an OBJECT record */

	bzero(ba->drr, sizeof (dmu_replay_record_t));

	ba->drr->drr_type = DRR_OBJECT;

	ba->drr->drr_u.drr_object.drr_object = object;

	ba->drr->drr_u.drr_object.drr_type = dnp->dn_type;

	ba->drr->drr_u.drr_object.drr_bonustype = dnp->dn_bonustype;

	ba->drr->drr_u.drr_object.drr_blksz =

	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT;

	ba->drr->drr_u.drr_object.drr_bonuslen = dnp->dn_bonuslen;

	ba->drr->drr_u.drr_object.drr_checksum = dnp->dn_checksum;

	ba->drr->drr_u.drr_object.drr_compress = dnp->dn_compress;

	if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))

		return (EINTR);

	if (dump_bytes(ba, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)))

		return (EINTR);

	/* free anything past the end of the file */

	if (dump_free(ba, object, (dnp->dn_maxblkid + 1) *

	    (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL))

		return (EINTR);

	if (ba->err)

		return (EINTR);

	return (0);

}

#define	BP_SPAN(dnp, level) \

	(((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \

	(level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT)))

static int

backup_cb(spa_t *spa, blkptr_t *bp, const zbookmark_t *zb,

    const dnode_phys_t *dnp, void *arg)

{

	struct backuparg *ba = arg;

	dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE;

	int err = 0;

	if (issig(JUSTLOOKING) && issig(FORREAL))

		return (EINTR);

	if (zb->zb_object != 0 && DMU_OBJECT_IS_SPECIAL(zb->zb_object)) {

		return (0);

	} else if (bp == NULL && zb->zb_object == 0) {

		uint64_t span = BP_SPAN(dnp, zb->zb_level);

		uint64_t dnobj = (zb->zb_blkid * span) >> DNODE_SHIFT;

		err = dump_freeobjects(ba, dnobj, span >> DNODE_SHIFT);

	} else if (bp == NULL) {

		uint64_t span = BP_SPAN(dnp, zb->zb_level);

		err = dump_free(ba, zb->zb_object, zb->zb_blkid * span, span);

	} else if (zb->zb_level > 0 || type == DMU_OT_OBJSET) {

		return (0);

	} else if (type == DMU_OT_DNODE) {

		dnode_phys_t *blk;

		int i;

		int blksz = BP_GET_LSIZE(bp);

		uint32_t aflags = ARC_WAIT;

		arc_buf_t *abuf;

		if (arc_read_nolock(NULL, spa, bp,

		    arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ,

		    ZIO_FLAG_CANFAIL, &aflags, zb) != 0)

			return (EIO);

		blk = abuf->b_data;

		for (i = 0; i < blksz >> DNODE_SHIFT; i++) {

			uint64_t dnobj = (zb->zb_blkid <<

			    (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i;

			err = dump_dnode(ba, dnobj, blk+i);

			if (err)

				break;

		}

		(void) arc_buf_remove_ref(abuf, &abuf);

	} else { /* it's a level-0 block of a regular object */

		uint32_t aflags = ARC_WAIT;

		arc_buf_t *abuf;

		int blksz = BP_GET_LSIZE(bp);

		if (arc_read_nolock(NULL, spa, bp,

		    arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ,

		    ZIO_FLAG_CANFAIL, &aflags, zb) != 0)

			return (EIO);

		err = dump_data(ba, type, zb->zb_object, zb->zb_blkid * blksz,

		    blksz, abuf->b_data);

		(void) arc_buf_remove_ref(abuf, &abuf);

	}

	ASSERT(err == 0 || err == EINTR);

	return (err);

}

int

dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin,

    vnode_t *vp, offset_t *off)

{

	dmu_replay_record_t *drr;

	struct backuparg ba;

	int err;

	uint64_t fromtxg = 0;

	/* tosnap must be a snapshot */

	if (ds->ds_phys->ds_next_snap_obj == 0)

		return (EINVAL);

	/* fromsnap must be an earlier snapshot from the same fs as tosnap */

	if (fromds && (ds->ds_dir != fromds->ds_dir ||

	    fromds->ds_phys->ds_creation_txg >= ds->ds_phys->ds_creation_txg))

		return (EXDEV);

	if (fromorigin) {

		dsl_pool_t *dp = ds->ds_dir->dd_pool;

		if (fromsnap)

			return (EINVAL);

		if (dsl_dir_is_clone(ds->ds_dir)) {

			rw_enter(&dp->dp_config_rwlock, RW_READER);

			err = dsl_dataset_hold_obj(dp,

			    ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &fromds);

			rw_exit(&dp->dp_config_rwlock);

			if (err)

				return (err);

		} else {

			fromorigin = B_FALSE;

		}

	}

	drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP);

	drr->drr_type = DRR_BEGIN;

	drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC;

	drr->drr_u.drr_begin.drr_version = DMU_BACKUP_STREAM_VERSION;

	drr->drr_u.drr_begin.drr_creation_time =

	    ds->ds_phys->ds_creation_time;

	if (fromorigin)

		drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CLONE;

	drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid;

	if (ds->ds_phys->ds_flags & DS_FLAG_CI_DATASET)

		drr->drr_u.drr_begin.drr_flags |= DRR_FLAG_CI_DATA;

	if (fromds)

		drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid;

	dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname);

	if (fromds)

		fromtxg = fromds->ds_phys->ds_creation_txg;

	if (fromorigin)

		dsl_dataset_rele(fromds, FTAG);

	ba.drr = drr;

	ba.vp = vp;

	ba.os = tosnap;

	ba.off = off;

	ZIO_SET_CHECKSUM(&ba.zc, 0, 0, 0, 0);

	if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t))) {

		kmem_free(drr, sizeof (dmu_replay_record_t));

		return (ba.err);

	}

	err = traverse_dataset(ds, fromtxg, TRAVERSE_PRE | TRAVERSE_PREFETCH,

	    backup_cb, &ba);

	if (err) {

		if (err == EINTR && ba.err)

			err = ba.err;

		kmem_free(drr, sizeof (dmu_replay_record_t));

		return (err);

	}

	bzero(drr, sizeof (dmu_replay_record_t));

	drr->drr_type = DRR_END;

	drr->drr_u.drr_end.drr_checksum = ba.zc;

	if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t))) {

		kmem_free(drr, sizeof (dmu_replay_record_t));

		return (ba.err);

	}

	kmem_free(drr, sizeof (dmu_replay_record_t));

	return (0);

}

struct recvbeginsyncarg {

	const char *tofs;

	const char *tosnap;

	dsl_dataset_t *origin;

	uint64_t fromguid;

	dmu_objset_type_t type;

	void *tag;

	boolean_t force;

	uint64_t dsflags;

	char clonelastname[MAXNAMELEN];

	dsl_dataset_t *ds; /* the ds to recv into; returned from the syncfunc */

};

/* ARGSUSED */

static int

recv_new_check(void *arg1, void *arg2, dmu_tx_t *tx)

{

	dsl_dir_t *dd = arg1;

	struct recvbeginsyncarg *rbsa = arg2;

	objset_t *mos = dd->dd_pool->dp_meta_objset;

	uint64_t val;

	int err;

	err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj,

	    strrchr(rbsa->tofs, '/') + 1, sizeof (uint64_t), 1, &val);

	if (err != ENOENT)

		return (err ? err : EEXIST);

	if (rbsa->origin) {

		/* make sure it's a snap in the same pool */

		if (rbsa->origin->ds_dir->dd_pool != dd->dd_pool)

			return (EXDEV);

		if (!dsl_dataset_is_snapshot(rbsa->origin))

			return (EINVAL);

		if (rbsa->origin->ds_phys->ds_guid != rbsa->fromguid)

			return (ENODEV);

	}

	return (0);

}

static void

recv_new_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)

{

	dsl_dir_t *dd = arg1;

	struct recvbeginsyncarg *rbsa = arg2;

	uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags;

	uint64_t dsobj;

	/* Create and open new dataset. */

	dsobj = dsl_dataset_create_sync(dd, strrchr(rbsa->tofs, '/') + 1,

	    rbsa->origin, flags, cr, tx);

	VERIFY(0 == dsl_dataset_own_obj(dd->dd_pool, dsobj,

	if (rbsa->origin == NULL) {

		(void) dmu_objset_create_impl(dd->dd_pool->dp_spa,

		    rbsa->ds, &rbsa->ds->ds_phys->ds_bp, rbsa->type, tx);

	}

	spa_history_internal_log(LOG_DS_REPLAY_FULL_SYNC,

	    dd->dd_pool->dp_spa, tx, cr, "dataset = %lld", dsobj);

}

/* ARGSUSED */

static int

recv_existing_check(void *arg1, void *arg2, dmu_tx_t *tx)

{

	dsl_dataset_t *ds = arg1;

	struct recvbeginsyncarg *rbsa = arg2;

	int err;

	uint64_t val;

	/* must not have any changes since most recent snapshot */

	if (!rbsa->force && dsl_dataset_modified_since_lastsnap(ds))

		return (ETXTBSY);

	if (rbsa->fromguid) {

		/* if incremental, most recent snapshot must match fromguid */

		if (ds->ds_prev == NULL)

			return (ENODEV);

		if (ds->ds_prev->ds_phys->ds_guid != rbsa->fromguid)

			return (ENODEV);

	} else {

		/* if full, most recent snapshot must be $ORIGIN */

		if (ds->ds_phys->ds_prev_snap_txg >= TXG_INITIAL)

			return (ENODEV);

	}

	/* temporary clone name must not exist */

	err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset,

	    ds->ds_dir->dd_phys->dd_child_dir_zapobj,

	    rbsa->clonelastname, 8, 1, &val);

	if (err == 0)

		return (EEXIST);

	if (err != ENOENT)

		return (err);

	/* new snapshot name must not exist */

	err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset,

	    ds->ds_phys->ds_snapnames_zapobj, rbsa->tosnap, 8, 1, &val);

	if (err == 0)

		return (EEXIST);

	if (err != ENOENT)

		return (err);

	return (0);

}

/* ARGSUSED */

static void

recv_existing_sync(void *arg1, void *arg2, cred_t *cr, dmu_tx_t *tx)

{

	dsl_dataset_t *ohds = arg1;

	struct recvbeginsyncarg *rbsa = arg2;

	dsl_pool_t *dp = ohds->ds_dir->dd_pool;

	dsl_dataset_t *cds;

	uint64_t flags = DS_FLAG_INCONSISTENT | rbsa->dsflags;

	uint64_t dsobj;

	/* create and open the temporary clone */

	dsobj = dsl_dataset_create_sync(ohds->ds_dir, rbsa->clonelastname,

	    ohds->ds_prev, flags, cr, tx);

	/*

	 * If we actually created a non-clone, we need to create the

	 * objset in our new dataset.

	 */

	if (BP_IS_HOLE(dsl_dataset_get_blkptr(cds))) {

		(void) dmu_objset_create_impl(dp->dp_spa,

		    cds, dsl_dataset_get_blkptr(cds), rbsa->type, tx);

	}

	/* copy the refquota from the target fs to the clone */

	if (ohds->ds_quota > 0)

		dsl_dataset_set_quota_sync(cds, &ohds->ds_quota, cr, tx);

	rbsa->ds = cds;

	spa_history_internal_log(LOG_DS_REPLAY_INC_SYNC,

	    dp->dp_spa, tx, cr, "dataset = %lld", dsobj);

}

/*

 * NB: callers *MUST* call dmu_recv_stream() if dmu_recv_begin()

 * succeeds; otherwise we will leak the holds on the datasets.

 */

int

dmu_recv_begin(char *tofs, char *tosnap, struct drr_begin *drrb,

    boolean_t force, objset_t *origin, dmu_recv_cookie_t *drc)

{

	int err = 0;

	boolean_t byteswap;

	struct recvbeginsyncarg rbsa = { 0 };

	uint64_t version;

	int flags;

	dsl_dataset_t *ds;

	if (drrb->drr_magic == DMU_BACKUP_MAGIC)

		byteswap = FALSE;

	else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC))

		byteswap = TRUE;

	else

		return (EINVAL);

	rbsa.tofs = tofs;

	rbsa.tosnap = tosnap;

	rbsa.fromguid = drrb->drr_fromguid;

	rbsa.type = drrb->drr_type;

	rbsa.tag = FTAG;

	rbsa.dsflags = 0;

	version = drrb->drr_version;

	flags = drrb->drr_flags;

	if (byteswap) {

		rbsa.type = BSWAP_32(rbsa.type);

		rbsa.fromguid = BSWAP_64(rbsa.fromguid);

		version = BSWAP_64(version);

		flags = BSWAP_32(flags);

	}

	if (version != DMU_BACKUP_STREAM_VERSION ||

	    rbsa.type >= DMU_OST_NUMTYPES ||

	    ((flags & DRR_FLAG_CLONE) && origin == NULL))

		return (EINVAL);

	if (flags & DRR_FLAG_CI_DATA)

		rbsa.dsflags = DS_FLAG_CI_DATASET;

	bzero(drc, sizeof (dmu_recv_cookie_t));