Illumos #1644, #1645, #1646, #1647, #1708

[zfs.git] / module / zfs / dmu_send.c

diff --git a/module/zfs/dmu_send.c b/module/zfs/dmu_send.c
index fad770e..2f06132 100644 (file)
--- a/module/zfs/dmu_send.c
+++ b/module/zfs/dmu_send.c
@@ -20,9 +20,9 @@
  */
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
- */
-/*
+ * Copyright (c) 2011 by Delphix. All rights reserved.
  * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
+ * Copyright (c) 2011 by Delphix. All rights reserved.
  */
 
 #include <sys/dmu.h>
@@ -47,6 +47,9 @@
 #include <sys/ddt.h>
 #include <sys/zfs_onexit.h>
 
+/* Set this tunable to TRUE to replace corrupt data with 0x2f5baddb10c */
+int zfs_send_corrupt_data = B_FALSE;
+
 static char *dmu_recv_tag = "dmu_recv_tag";
 
 /*
@@ -368,8 +371,20 @@ backup_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, arc_buf_t *pbuf,
 
                if (dsl_read(NULL, spa, bp, pbuf,
                    arc_getbuf_func, &abuf, ZIO_PRIORITY_ASYNC_READ,
-                   ZIO_FLAG_CANFAIL, &aflags, zb) != 0)
-                       return (EIO);
+                   ZIO_FLAG_CANFAIL, &aflags, zb) != 0) {
+                       if (zfs_send_corrupt_data) {
+                               uint64_t *ptr;
+                               /* Send a block filled with 0x"zfs badd bloc" */
+                               abuf = arc_buf_alloc(spa, blksz, &abuf,
+                                   ARC_BUFC_DATA);
+                               for (ptr = abuf->b_data;
+                                   (char *)ptr < (char *)abuf->b_data + blksz;
+                                   ptr++)
+                                       *ptr = 0x2f5baddb10c;
+                       } else {
+                               return (EIO);
+                       }
+               }
 
                err = dump_data(ba, type, zb->zb_object, zb->zb_blkid * blksz,
                    blksz, bp, abuf->b_data);
@@ -498,6 +513,85 @@ dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin,
        return (0);
 }
 
+int
+dmu_send_estimate(objset_t *tosnap, objset_t *fromsnap, boolean_t fromorigin,
+    uint64_t *sizep)
+{
+       dsl_dataset_t *ds = tosnap->os_dsl_dataset;
+       dsl_dataset_t *fromds = fromsnap ? fromsnap->os_dsl_dataset : NULL;
+       dsl_pool_t *dp = ds->ds_dir->dd_pool;
+       int err;
+       uint64_t size, recordsize;
+
+       /* 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) {
+               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;
+               }
+       }
+
+       /* Get uncompressed size estimate of changed data. */
+       if (fromds == NULL) {
+               size = ds->ds_phys->ds_uncompressed_bytes;
+       } else {
+               uint64_t used, comp;
+               err = dsl_dataset_space_written(fromds, ds,
+                   &used, &comp, &size);
+               if (fromorigin)
+                       dsl_dataset_rele(fromds, FTAG);
+               if (err)
+                       return (err);
+       }
+
+       /*
+        * Assume that space (both on-disk and in-stream) is dominated by
+        * data.  We will adjust for indirect blocks and the copies property,
+        * but ignore per-object space used (eg, dnodes and DRR_OBJECT records).
+        */
+
+       /*
+        * Subtract out approximate space used by indirect blocks.
+        * Assume most space is used by data blocks (non-indirect, non-dnode).
+        * Assume all blocks are recordsize.  Assume ditto blocks and
+        * internal fragmentation counter out compression.
+        *
+        * Therefore, space used by indirect blocks is sizeof(blkptr_t) per
+        * block, which we observe in practice.
+        */
+       rw_enter(&dp->dp_config_rwlock, RW_READER);
+       err = dsl_prop_get_ds(ds, "recordsize",
+           sizeof (recordsize), 1, &recordsize, NULL);
+       rw_exit(&dp->dp_config_rwlock);
+       if (err)
+               return (err);
+       size -= size / recordsize * sizeof (blkptr_t);
+
+       /* Add in the space for the record associated with each block. */
+       size += size / recordsize * sizeof (dmu_replay_record_t);
+
+       *sizep = size;
+
+       return (0);
+}
+
 struct recvbeginsyncarg {
        const char *tofs;
        const char *tosnap;
@@ -1500,7 +1594,7 @@ dmu_recv_existing_end(dmu_recv_cookie_t *drc)
 {
        struct recvendsyncarg resa;
        dsl_dataset_t *ds = drc->drc_logical_ds;
-       int err;
+       int err, myerr;
 
        /*
         * XXX hack; seems the ds is still dirty and dsl_pool_zil_clean()
@@ -1538,7 +1632,8 @@ out:
        if (err == 0 && drc->drc_guid_to_ds_map != NULL)
                (void) add_ds_to_guidmap(drc->drc_guid_to_ds_map, ds);
        dsl_dataset_disown(ds, dmu_recv_tag);
-       (void) dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE);
+       myerr = dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE);
+       ASSERT3U(myerr, ==, 0);
        return (err);
 }