dmu.c revision c5c6ffa0498b9c8555798756141b4a3061a138c1
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23 * Use is subject to license terms.
24 */
25
26#pragma ident	"%Z%%M%	%I%	%E% SMI"
27
28#include <sys/dmu.h>
29#include <sys/dmu_impl.h>
30#include <sys/dmu_tx.h>
31#include <sys/dbuf.h>
32#include <sys/dnode.h>
33#include <sys/zfs_context.h>
34#include <sys/dmu_objset.h>
35#include <sys/dmu_traverse.h>
36#include <sys/dsl_dataset.h>
37#include <sys/dsl_dir.h>
38#include <sys/dsl_pool.h>
39#include <sys/dsl_synctask.h>
40#include <sys/dmu_zfetch.h>
41#include <sys/zfs_ioctl.h>
42#include <sys/zap.h>
43#include <sys/zio_checksum.h>
44
45const dmu_object_type_info_t dmu_ot[DMU_OT_NUMTYPES] = {
46	{	byteswap_uint8_array,	TRUE,	"unallocated"		},
47	{	zap_byteswap,		TRUE,	"object directory"	},
48	{	byteswap_uint64_array,	TRUE,	"object array"		},
49	{	byteswap_uint8_array,	TRUE,	"packed nvlist"		},
50	{	byteswap_uint64_array,	TRUE,	"packed nvlist size"	},
51	{	byteswap_uint64_array,	TRUE,	"bplist"		},
52	{	byteswap_uint64_array,	TRUE,	"bplist header"		},
53	{	byteswap_uint64_array,	TRUE,	"SPA space map header"	},
54	{	byteswap_uint64_array,	TRUE,	"SPA space map"		},
55	{	byteswap_uint64_array,	TRUE,	"ZIL intent log"	},
56	{	dnode_buf_byteswap,	TRUE,	"DMU dnode"		},
57	{	dmu_objset_byteswap,	TRUE,	"DMU objset"		},
58	{	byteswap_uint64_array,	TRUE,	"DSL directory"		},
59	{	zap_byteswap,		TRUE,	"DSL directory child map"},
60	{	zap_byteswap,		TRUE,	"DSL dataset snap map"	},
61	{	zap_byteswap,		TRUE,	"DSL props"		},
62	{	byteswap_uint64_array,	TRUE,	"DSL dataset"		},
63	{	zfs_znode_byteswap,	TRUE,	"ZFS znode"		},
64	{	zfs_acl_byteswap,	TRUE,	"ZFS ACL"		},
65	{	byteswap_uint8_array,	FALSE,	"ZFS plain file"	},
66	{	zap_byteswap,		TRUE,	"ZFS directory"		},
67	{	zap_byteswap,		TRUE,	"ZFS master node"	},
68	{	zap_byteswap,		TRUE,	"ZFS delete queue"	},
69	{	byteswap_uint8_array,	FALSE,	"zvol object"		},
70	{	zap_byteswap,		TRUE,	"zvol prop"		},
71	{	byteswap_uint8_array,	FALSE,	"other uint8[]"		},
72	{	byteswap_uint64_array,	FALSE,	"other uint64[]"	},
73	{	zap_byteswap,		TRUE,	"other ZAP"		},
74	{	zap_byteswap,		TRUE,	"persistent error log"	},
75};
76
77int
78dmu_buf_hold(objset_t *os, uint64_t object, uint64_t offset,
79    void *tag, dmu_buf_t **dbp)
80{
81	dnode_t *dn;
82	uint64_t blkid;
83	dmu_buf_impl_t *db;
84	int err;
85
86	err = dnode_hold(os->os, object, FTAG, &dn);
87	if (err)
88		return (err);
89	blkid = dbuf_whichblock(dn, offset);
90	rw_enter(&dn->dn_struct_rwlock, RW_READER);
91	db = dbuf_hold(dn, blkid, tag);
92	rw_exit(&dn->dn_struct_rwlock);
93	if (db == NULL) {
94		err = EIO;
95	} else {
96		err = dbuf_read(db, NULL, DB_RF_CANFAIL);
97		if (err) {
98			dbuf_rele(db, tag);
99			db = NULL;
100		}
101	}
102
103	dnode_rele(dn, FTAG);
104	*dbp = &db->db;
105	return (err);
106}
107
108int
109dmu_bonus_max(void)
110{
111	return (DN_MAX_BONUSLEN);
112}
113
114/*
115 * returns ENOENT, EIO, or 0.
116 */
117int
118dmu_bonus_hold(objset_t *os, uint64_t object, void *tag, dmu_buf_t **dbp)
119{
120	dnode_t *dn;
121	int err, count;
122	dmu_buf_impl_t *db;
123
124	err = dnode_hold(os->os, object, FTAG, &dn);
125	if (err)
126		return (err);
127
128	rw_enter(&dn->dn_struct_rwlock, RW_READER);
129	if (dn->dn_bonus == NULL) {
130		rw_exit(&dn->dn_struct_rwlock);
131		rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
132		if (dn->dn_bonus == NULL)
133			dn->dn_bonus = dbuf_create_bonus(dn);
134	}
135	db = dn->dn_bonus;
136	rw_exit(&dn->dn_struct_rwlock);
137	mutex_enter(&db->db_mtx);
138	count = refcount_add(&db->db_holds, tag);
139	mutex_exit(&db->db_mtx);
140	if (count == 1)
141		dnode_add_ref(dn, db);
142	dnode_rele(dn, FTAG);
143
144	VERIFY(0 == dbuf_read(db, NULL, DB_RF_MUST_SUCCEED));
145
146	*dbp = &db->db;
147	return (0);
148}
149
150int
151dmu_buf_hold_array(objset_t *os, uint64_t object, uint64_t offset,
152    uint64_t length, int read, void *tag, int *numbufsp, dmu_buf_t ***dbpp)
153{
154	dnode_t *dn;
155	dmu_buf_t **dbp;
156	uint64_t blkid, nblks, i;
157	uint32_t flags;
158	int err;
159	zio_t *zio;
160
161	ASSERT(length <= DMU_MAX_ACCESS);
162
163	if (length == 0) {
164		if (numbufsp)
165			*numbufsp = 0;
166		*dbpp = NULL;
167		return (0);
168	}
169
170	flags = DB_RF_CANFAIL | DB_RF_NEVERWAIT;
171	if (length > zfetch_array_rd_sz)
172		flags |= DB_RF_NOPREFETCH;
173
174	err = dnode_hold(os->os, object, FTAG, &dn);
175	if (err)
176		return (err);
177
178	rw_enter(&dn->dn_struct_rwlock, RW_READER);
179	if (dn->dn_datablkshift) {
180		int blkshift = dn->dn_datablkshift;
181		nblks = (P2ROUNDUP(offset+length, 1ULL<<blkshift) -
182			P2ALIGN(offset, 1ULL<<blkshift)) >> blkshift;
183	} else {
184		ASSERT3U(offset + length, <=, dn->dn_datablksz);
185		nblks = 1;
186	}
187	dbp = kmem_zalloc(sizeof (dmu_buf_t *) * nblks, KM_SLEEP);
188
189	zio = zio_root(dn->dn_objset->os_spa, NULL, NULL, TRUE);
190	blkid = dbuf_whichblock(dn, offset);
191	for (i = 0; i < nblks; i++) {
192		dmu_buf_impl_t *db = dbuf_hold(dn, blkid+i, tag);
193		if (db == NULL) {
194			rw_exit(&dn->dn_struct_rwlock);
195			dmu_buf_rele_array(dbp, nblks, tag);
196			dnode_rele(dn, FTAG);
197			zio_nowait(zio);
198			return (EIO);
199		}
200		/* initiate async i/o */
201		if (read && db->db_state == DB_UNCACHED) {
202			rw_exit(&dn->dn_struct_rwlock);
203			(void) dbuf_read(db, zio, flags);
204			rw_enter(&dn->dn_struct_rwlock, RW_READER);
205		}
206		dbp[i] = &db->db;
207	}
208	rw_exit(&dn->dn_struct_rwlock);
209	dnode_rele(dn, FTAG);
210
211	/* wait for async i/o */
212	err = zio_wait(zio);
213	if (err) {
214		dmu_buf_rele_array(dbp, nblks, tag);
215		return (err);
216	}
217
218	/* wait for other io to complete */
219	if (read) {
220		for (i = 0; i < nblks; i++) {
221			dmu_buf_impl_t *db = (dmu_buf_impl_t *)dbp[i];
222			mutex_enter(&db->db_mtx);
223			while (db->db_state == DB_READ ||
224			    db->db_state == DB_FILL)
225				cv_wait(&db->db_changed, &db->db_mtx);
226			if (db->db_state == DB_UNCACHED)
227				err = EIO;
228			mutex_exit(&db->db_mtx);
229			if (err) {
230				dmu_buf_rele_array(dbp, nblks, tag);
231				return (err);
232			}
233		}
234	}
235
236	*numbufsp = nblks;
237	*dbpp = dbp;
238	return (0);
239}
240
241void
242dmu_buf_rele_array(dmu_buf_t **dbp_fake, int numbufs, void *tag)
243{
244	int i;
245	dmu_buf_impl_t **dbp = (dmu_buf_impl_t **)dbp_fake;
246
247	if (numbufs == 0)
248		return;
249
250	for (i = 0; i < numbufs; i++) {
251		if (dbp[i])
252			dbuf_rele(dbp[i], tag);
253	}
254
255	kmem_free(dbp, sizeof (dmu_buf_t *) * numbufs);
256}
257
258void
259dmu_prefetch(objset_t *os, uint64_t object, uint64_t offset, uint64_t len)
260{
261	dnode_t *dn;
262	uint64_t blkid;
263	int nblks, i, err;
264
265	if (len == 0) {  /* they're interested in the bonus buffer */
266		dn = os->os->os_meta_dnode;
267
268		if (object == 0 || object >= DN_MAX_OBJECT)
269			return;
270
271		rw_enter(&dn->dn_struct_rwlock, RW_READER);
272		blkid = dbuf_whichblock(dn, object * sizeof (dnode_phys_t));
273		dbuf_prefetch(dn, blkid);
274		rw_exit(&dn->dn_struct_rwlock);
275		return;
276	}
277
278	/*
279	 * XXX - Note, if the dnode for the requested object is not
280	 * already cached, we will do a *synchronous* read in the
281	 * dnode_hold() call.  The same is true for any indirects.
282	 */
283	err = dnode_hold(os->os, object, FTAG, &dn);
284	if (err != 0)
285		return;
286
287	rw_enter(&dn->dn_struct_rwlock, RW_READER);
288	if (dn->dn_datablkshift) {
289		int blkshift = dn->dn_datablkshift;
290		nblks = (P2ROUNDUP(offset+len, 1<<blkshift) -
291			P2ALIGN(offset, 1<<blkshift)) >> blkshift;
292	} else {
293		nblks = (offset < dn->dn_datablksz);
294	}
295
296	if (nblks != 0) {
297		blkid = dbuf_whichblock(dn, offset);
298		for (i = 0; i < nblks; i++)
299			dbuf_prefetch(dn, blkid+i);
300	}
301
302	rw_exit(&dn->dn_struct_rwlock);
303
304	dnode_rele(dn, FTAG);
305}
306
307int
308dmu_free_range(objset_t *os, uint64_t object, uint64_t offset,
309    uint64_t size, dmu_tx_t *tx)
310{
311	dnode_t *dn;
312	int err = dnode_hold(os->os, object, FTAG, &dn);
313	if (err)
314		return (err);
315	ASSERT(offset < UINT64_MAX);
316	ASSERT(size == -1ULL || size <= UINT64_MAX - offset);
317	dnode_free_range(dn, offset, size, tx);
318	dnode_rele(dn, FTAG);
319	return (0);
320}
321
322int
323dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
324    void *buf)
325{
326	dnode_t *dn;
327	dmu_buf_t **dbp;
328	int numbufs, i, err;
329
330	/*
331	 * Deal with odd block sizes, where there can't be data past the
332	 * first block.
333	 */
334	err = dnode_hold(os->os, object, FTAG, &dn);
335	if (err)
336		return (err);
337	if (dn->dn_datablkshift == 0) {
338		int newsz = offset > dn->dn_datablksz ? 0 :
339		    MIN(size, dn->dn_datablksz - offset);
340		bzero((char *)buf + newsz, size - newsz);
341		size = newsz;
342	}
343	dnode_rele(dn, FTAG);
344
345	while (size > 0) {
346		uint64_t mylen = MIN(size, DMU_MAX_ACCESS / 2);
347		int err;
348
349		/*
350		 * NB: we could do this block-at-a-time, but it's nice
351		 * to be reading in parallel.
352		 */
353		err = dmu_buf_hold_array(os, object, offset, mylen,
354		    TRUE, FTAG, &numbufs, &dbp);
355		if (err)
356			return (err);
357
358		for (i = 0; i < numbufs; i++) {
359			int tocpy;
360			int bufoff;
361			dmu_buf_t *db = dbp[i];
362
363			ASSERT(size > 0);
364
365			bufoff = offset - db->db_offset;
366			tocpy = (int)MIN(db->db_size - bufoff, size);
367
368			bcopy((char *)db->db_data + bufoff, buf, tocpy);
369
370			offset += tocpy;
371			size -= tocpy;
372			buf = (char *)buf + tocpy;
373		}
374		dmu_buf_rele_array(dbp, numbufs, FTAG);
375	}
376	return (0);
377}
378
379void
380dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
381    const void *buf, dmu_tx_t *tx)
382{
383	dmu_buf_t **dbp;
384	int numbufs, i;
385
386	VERIFY(0 == dmu_buf_hold_array(os, object, offset, size,
387	    FALSE, FTAG, &numbufs, &dbp));
388
389	for (i = 0; i < numbufs; i++) {
390		int tocpy;
391		int bufoff;
392		dmu_buf_t *db = dbp[i];
393
394		ASSERT(size > 0);
395
396		bufoff = offset - db->db_offset;
397		tocpy = (int)MIN(db->db_size - bufoff, size);
398
399		ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size);
400
401		if (tocpy == db->db_size)
402			dmu_buf_will_fill(db, tx);
403		else
404			dmu_buf_will_dirty(db, tx);
405
406		bcopy(buf, (char *)db->db_data + bufoff, tocpy);
407
408		if (tocpy == db->db_size)
409			dmu_buf_fill_done(db, tx);
410
411		offset += tocpy;
412		size -= tocpy;
413		buf = (char *)buf + tocpy;
414	}
415	dmu_buf_rele_array(dbp, numbufs, FTAG);
416}
417
418#ifdef _KERNEL
419int
420dmu_write_uio(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
421    uio_t *uio, dmu_tx_t *tx)
422{
423	dmu_buf_t **dbp;
424	int numbufs, i;
425	int err = 0;
426
427	err = dmu_buf_hold_array(os, object, offset, size,
428	    FALSE, FTAG, &numbufs, &dbp);
429	if (err)
430		return (err);
431
432	for (i = 0; i < numbufs; i++) {
433		int tocpy;
434		int bufoff;
435		dmu_buf_t *db = dbp[i];
436
437		ASSERT(size > 0);
438
439		bufoff = offset - db->db_offset;
440		tocpy = (int)MIN(db->db_size - bufoff, size);
441
442		ASSERT(i == 0 || i == numbufs-1 || tocpy == db->db_size);
443
444		if (tocpy == db->db_size)
445			dmu_buf_will_fill(db, tx);
446		else
447			dmu_buf_will_dirty(db, tx);
448
449		/*
450		 * XXX uiomove could block forever (eg. nfs-backed
451		 * pages).  There needs to be a uiolockdown() function
452		 * to lock the pages in memory, so that uiomove won't
453		 * block.
454		 */
455		err = uiomove((char *)db->db_data + bufoff, tocpy,
456		    UIO_WRITE, uio);
457
458		if (tocpy == db->db_size)
459			dmu_buf_fill_done(db, tx);
460
461		if (err)
462			break;
463
464		offset += tocpy;
465		size -= tocpy;
466	}
467	dmu_buf_rele_array(dbp, numbufs, FTAG);
468	return (err);
469}
470#endif
471
472/*
473 * XXX move send/recv stuff to its own new file!
474 */
475
476struct backuparg {
477	dmu_replay_record_t *drr;
478	vnode_t *vp;
479	objset_t *os;
480	zio_cksum_t zc;
481	int err;
482};
483
484static int
485dump_bytes(struct backuparg *ba, void *buf, int len)
486{
487	ssize_t resid; /* have to get resid to get detailed errno */
488	ASSERT3U(len % 8, ==, 0);
489
490	fletcher_4_incremental_native(buf, len, &ba->zc);
491	ba->err = vn_rdwr(UIO_WRITE, ba->vp,
492	    (caddr_t)buf, len,
493	    0, UIO_SYSSPACE, FAPPEND, RLIM64_INFINITY, CRED(), &resid);
494	return (ba->err);
495}
496
497static int
498dump_free(struct backuparg *ba, uint64_t object, uint64_t offset,
499    uint64_t length)
500{
501	/* write a FREE record */
502	bzero(ba->drr, sizeof (dmu_replay_record_t));
503	ba->drr->drr_type = DRR_FREE;
504	ba->drr->drr_u.drr_free.drr_object = object;
505	ba->drr->drr_u.drr_free.drr_offset = offset;
506	ba->drr->drr_u.drr_free.drr_length = length;
507
508	if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))
509		return (EINTR);
510	return (0);
511}
512
513static int
514dump_data(struct backuparg *ba, dmu_object_type_t type,
515    uint64_t object, uint64_t offset, int blksz, void *data)
516{
517	/* write a DATA record */
518	bzero(ba->drr, sizeof (dmu_replay_record_t));
519	ba->drr->drr_type = DRR_WRITE;
520	ba->drr->drr_u.drr_write.drr_object = object;
521	ba->drr->drr_u.drr_write.drr_type = type;
522	ba->drr->drr_u.drr_write.drr_offset = offset;
523	ba->drr->drr_u.drr_write.drr_length = blksz;
524
525	if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))
526		return (EINTR);
527	if (dump_bytes(ba, data, blksz))
528		return (EINTR);
529	return (0);
530}
531
532static int
533dump_freeobjects(struct backuparg *ba, uint64_t firstobj, uint64_t numobjs)
534{
535	/* write a FREEOBJECTS record */
536	bzero(ba->drr, sizeof (dmu_replay_record_t));
537	ba->drr->drr_type = DRR_FREEOBJECTS;
538	ba->drr->drr_u.drr_freeobjects.drr_firstobj = firstobj;
539	ba->drr->drr_u.drr_freeobjects.drr_numobjs = numobjs;
540
541	if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))
542		return (EINTR);
543	return (0);
544}
545
546static int
547dump_dnode(struct backuparg *ba, uint64_t object, dnode_phys_t *dnp)
548{
549	if (dnp == NULL || dnp->dn_type == DMU_OT_NONE)
550		return (dump_freeobjects(ba, object, 1));
551
552	/* write an OBJECT record */
553	bzero(ba->drr, sizeof (dmu_replay_record_t));
554	ba->drr->drr_type = DRR_OBJECT;
555	ba->drr->drr_u.drr_object.drr_object = object;
556	ba->drr->drr_u.drr_object.drr_type = dnp->dn_type;
557	ba->drr->drr_u.drr_object.drr_bonustype = dnp->dn_bonustype;
558	ba->drr->drr_u.drr_object.drr_blksz =
559	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT;
560	ba->drr->drr_u.drr_object.drr_bonuslen = dnp->dn_bonuslen;
561	ba->drr->drr_u.drr_object.drr_checksum = dnp->dn_checksum;
562	ba->drr->drr_u.drr_object.drr_compress = dnp->dn_compress;
563
564	if (dump_bytes(ba, ba->drr, sizeof (dmu_replay_record_t)))
565		return (EINTR);
566
567	if (dump_bytes(ba, DN_BONUS(dnp), P2ROUNDUP(dnp->dn_bonuslen, 8)))
568		return (EINTR);
569
570	/* free anything past the end of the file */
571	if (dump_free(ba, object, (dnp->dn_maxblkid + 1) *
572	    (dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT), -1ULL))
573		return (EINTR);
574	if (ba->err)
575		return (EINTR);
576	return (0);
577}
578
579#define	BP_SPAN(dnp, level) \
580	(((uint64_t)dnp->dn_datablkszsec) << (SPA_MINBLOCKSHIFT + \
581	(level) * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT)))
582
583static int
584backup_cb(traverse_blk_cache_t *bc, spa_t *spa, void *arg)
585{
586	struct backuparg *ba = arg;
587	uint64_t object = bc->bc_bookmark.zb_object;
588	int level = bc->bc_bookmark.zb_level;
589	uint64_t blkid = bc->bc_bookmark.zb_blkid;
590	blkptr_t *bp = bc->bc_blkptr.blk_birth ? &bc->bc_blkptr : NULL;
591	dmu_object_type_t type = bp ? BP_GET_TYPE(bp) : DMU_OT_NONE;
592	void *data = bc->bc_data;
593	int err = 0;
594
595	if (issig(JUSTLOOKING) && issig(FORREAL))
596		return (EINTR);
597
598	ASSERT(data || bp == NULL);
599
600	if (bp == NULL && object == 0) {
601		uint64_t span = BP_SPAN(bc->bc_dnode, level);
602		uint64_t dnobj = (blkid * span) >> DNODE_SHIFT;
603		err = dump_freeobjects(ba, dnobj, span >> DNODE_SHIFT);
604	} else if (bp == NULL) {
605		uint64_t span = BP_SPAN(bc->bc_dnode, level);
606		err = dump_free(ba, object, blkid * span, span);
607	} else if (data && level == 0 && type == DMU_OT_DNODE) {
608		dnode_phys_t *blk = data;
609		int i;
610		int blksz = BP_GET_LSIZE(bp);
611
612		for (i = 0; i < blksz >> DNODE_SHIFT; i++) {
613			uint64_t dnobj =
614			    (blkid << (DNODE_BLOCK_SHIFT - DNODE_SHIFT)) + i;
615			err = dump_dnode(ba, dnobj, blk+i);
616			if (err)
617				break;
618		}
619	} else if (level == 0 &&
620	    type != DMU_OT_DNODE && type != DMU_OT_OBJSET) {
621		int blksz = BP_GET_LSIZE(bp);
622		if (data == NULL) {
623			arc_buf_t *abuf;
624			zbookmark_t zb;
625
626			zb.zb_objset = ba->os->os->os_dsl_dataset->ds_object;
627			zb.zb_object = object;
628			zb.zb_level = level;
629			zb.zb_blkid = blkid;
630			(void) arc_read(NULL, spa, bp,
631			    dmu_ot[type].ot_byteswap, arc_getbuf_func, &abuf,
632			    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_MUSTSUCCEED,
633			    ARC_WAIT, &zb);
634
635			if (abuf) {
636				err = dump_data(ba, type, object, blkid * blksz,
637				    blksz, abuf->b_data);
638				(void) arc_buf_remove_ref(abuf, &abuf);
639			}
640		} else {
641			err = dump_data(ba, type, object, blkid * blksz,
642			    blksz, data);
643		}
644	}
645
646	ASSERT(err == 0 || err == EINTR);
647	return (err);
648}
649
650int
651dmu_sendbackup(objset_t *tosnap, objset_t *fromsnap, vnode_t *vp)
652{
653	dsl_dataset_t *ds = tosnap->os->os_dsl_dataset;
654	dsl_dataset_t *fromds = fromsnap ? fromsnap->os->os_dsl_dataset : NULL;
655	dmu_replay_record_t *drr;
656	struct backuparg ba;
657	int err;
658
659	/* tosnap must be a snapshot */
660	if (ds->ds_phys->ds_next_snap_obj == 0)
661		return (EINVAL);
662
663	/* fromsnap must be an earlier snapshot from the same fs as tosnap */
664	if (fromds && (ds->ds_dir != fromds->ds_dir ||
665	    fromds->ds_phys->ds_creation_txg >=
666	    ds->ds_phys->ds_creation_txg))
667		return (EXDEV);
668
669	drr = kmem_zalloc(sizeof (dmu_replay_record_t), KM_SLEEP);
670	drr->drr_type = DRR_BEGIN;
671	drr->drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC;
672	drr->drr_u.drr_begin.drr_version = DMU_BACKUP_VERSION;
673	drr->drr_u.drr_begin.drr_creation_time =
674	    ds->ds_phys->ds_creation_time;
675	drr->drr_u.drr_begin.drr_type = tosnap->os->os_phys->os_type;
676	drr->drr_u.drr_begin.drr_toguid = ds->ds_phys->ds_guid;
677	if (fromds)
678		drr->drr_u.drr_begin.drr_fromguid = fromds->ds_phys->ds_guid;
679	dsl_dataset_name(ds, drr->drr_u.drr_begin.drr_toname);
680
681	ba.drr = drr;
682	ba.vp = vp;
683	ba.os = tosnap;
684	ZIO_SET_CHECKSUM(&ba.zc, 0, 0, 0, 0);
685
686	if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t))) {
687		kmem_free(drr, sizeof (dmu_replay_record_t));
688		return (ba.err);
689	}
690
691	err = traverse_dsl_dataset(ds,
692	    fromds ? fromds->ds_phys->ds_creation_txg : 0,
693	    ADVANCE_PRE | ADVANCE_HOLES | ADVANCE_DATA | ADVANCE_NOLOCK,
694	    backup_cb, &ba);
695
696	if (err) {
697		if (err == EINTR && ba.err)
698			err = ba.err;
699		return (err);
700	}
701
702	bzero(drr, sizeof (dmu_replay_record_t));
703	drr->drr_type = DRR_END;
704	drr->drr_u.drr_end.drr_checksum = ba.zc;
705
706	if (dump_bytes(&ba, drr, sizeof (dmu_replay_record_t)))
707		return (ba.err);
708
709	kmem_free(drr, sizeof (dmu_replay_record_t));
710
711	return (0);
712}
713
714struct restorearg {
715	int err;
716	int byteswap;
717	vnode_t *vp;
718	char *buf;
719	uint64_t voff;
720	int buflen; /* number of valid bytes in buf */
721	int bufoff; /* next offset to read */
722	int bufsize; /* amount of memory allocated for buf */
723	zio_cksum_t zc;
724};
725
726/* ARGSUSED */
727static int
728replay_incremental_check(void *arg1, void *arg2, dmu_tx_t *tx)
729{
730	dsl_dataset_t *ds = arg1;
731	struct drr_begin *drrb = arg2;
732	const char *snapname;
733	int err;
734	uint64_t val;
735
736	/* must already be a snapshot of this fs */
737	if (ds->ds_phys->ds_prev_snap_obj == 0)
738		return (ENODEV);
739
740	/* most recent snapshot must match fromguid */
741	if (ds->ds_prev->ds_phys->ds_guid != drrb->drr_fromguid)
742		return (ENODEV);
743	/* must not have any changes since most recent snapshot */
744	if (ds->ds_phys->ds_bp.blk_birth >
745	    ds->ds_prev->ds_phys->ds_creation_txg)
746		return (ETXTBSY);
747
748	/* new snapshot name must not exist */
749	snapname = strrchr(drrb->drr_toname, '@');
750	if (snapname == NULL)
751		return (EEXIST);
752
753	snapname++;
754	err = zap_lookup(ds->ds_dir->dd_pool->dp_meta_objset,
755	    ds->ds_phys->ds_snapnames_zapobj, snapname, 8, 1, &val);
756	if (err == 0)
757		return (EEXIST);
758	if (err != ENOENT)
759		return (err);
760
761	return (0);
762}
763
764/* ARGSUSED */
765static void
766replay_incremental_sync(void *arg1, void *arg2, dmu_tx_t *tx)
767{
768	dsl_dataset_t *ds = arg1;
769	dmu_buf_will_dirty(ds->ds_dbuf, tx);
770	ds->ds_phys->ds_flags |= DS_FLAG_INCONSISTENT;
771}
772
773/* ARGSUSED */
774static int
775replay_full_check(void *arg1, void *arg2, dmu_tx_t *tx)
776{
777	dsl_dir_t *dd = arg1;
778	struct drr_begin *drrb = arg2;
779	objset_t *mos = dd->dd_pool->dp_meta_objset;
780	char *cp;
781	uint64_t val;
782	int err;
783
784	cp = strchr(drrb->drr_toname, '@');
785	*cp = '\0';
786	err = zap_lookup(mos, dd->dd_phys->dd_child_dir_zapobj,
787	    strrchr(drrb->drr_toname, '/') + 1,
788	    sizeof (uint64_t), 1, &val);
789	*cp = '@';
790
791	if (err != ENOENT)
792		return (err ? err : EEXIST);
793
794	return (0);
795}
796
797static void
798replay_full_sync(void *arg1, void *arg2, dmu_tx_t *tx)
799{
800	dsl_dir_t *dd = arg1;
801	struct drr_begin *drrb = arg2;
802	char *cp;
803	dsl_dataset_t *ds;
804	uint64_t dsobj;
805
806	cp = strchr(drrb->drr_toname, '@');
807	*cp = '\0';
808	dsobj = dsl_dataset_create_sync(dd, strrchr(drrb->drr_toname, '/') + 1,
809	    NULL, tx);
810	*cp = '@';
811
812	VERIFY(0 == dsl_dataset_open_obj(dd->dd_pool, dsobj, NULL,
813	    DS_MODE_EXCLUSIVE, FTAG, &ds));
814
815	(void) dmu_objset_create_impl(dsl_dataset_get_spa(ds),
816	    ds, drrb->drr_type, tx);
817
818	dmu_buf_will_dirty(ds->ds_dbuf, tx);
819	ds->ds_phys->ds_flags |= DS_FLAG_INCONSISTENT;
820
821	dsl_dataset_close(ds, DS_MODE_EXCLUSIVE, FTAG);
822}
823
824static int
825replay_end_check(void *arg1, void *arg2, dmu_tx_t *tx)
826{
827	objset_t *os = arg1;
828	struct drr_begin *drrb = arg2;
829	char *snapname;
830
831	/* XXX verify that drr_toname is in dd */
832
833	snapname = strchr(drrb->drr_toname, '@');
834	if (snapname == NULL)
835		return (EINVAL);
836	snapname++;
837
838	return (dsl_dataset_snapshot_check(os, snapname, tx));
839}
840
841static void
842replay_end_sync(void *arg1, void *arg2, dmu_tx_t *tx)
843{
844	objset_t *os = arg1;
845	struct drr_begin *drrb = arg2;
846	char *snapname;
847	dsl_dataset_t *ds, *hds;
848
849	snapname = strchr(drrb->drr_toname, '@') + 1;
850
851	dsl_dataset_snapshot_sync(os, snapname, tx);
852
853	/* set snapshot's creation time and guid */
854	hds = os->os->os_dsl_dataset;
855	VERIFY(0 == dsl_dataset_open_obj(hds->ds_dir->dd_pool,
856	    hds->ds_phys->ds_prev_snap_obj, NULL,
857	    DS_MODE_PRIMARY | DS_MODE_READONLY | DS_MODE_INCONSISTENT,
858	    FTAG, &ds));
859
860	dmu_buf_will_dirty(ds->ds_dbuf, tx);
861	ds->ds_phys->ds_creation_time = drrb->drr_creation_time;
862	ds->ds_phys->ds_guid = drrb->drr_toguid;
863	ds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT;
864
865	dsl_dataset_close(ds, DS_MODE_PRIMARY, FTAG);
866
867	dmu_buf_will_dirty(hds->ds_dbuf, tx);
868	hds->ds_phys->ds_flags &= ~DS_FLAG_INCONSISTENT;
869}
870
871void *
872restore_read(struct restorearg *ra, int len)
873{
874	void *rv;
875
876	/* some things will require 8-byte alignment, so everything must */
877	ASSERT3U(len % 8, ==, 0);
878
879	while (ra->buflen - ra->bufoff < len) {
880		ssize_t resid;
881		int leftover = ra->buflen - ra->bufoff;
882
883		(void) memmove(ra->buf, ra->buf + ra->bufoff, leftover);
884		ra->err = vn_rdwr(UIO_READ, ra->vp,
885		    (caddr_t)ra->buf + leftover, ra->bufsize - leftover,
886		    ra->voff, UIO_SYSSPACE, FAPPEND,
887		    RLIM64_INFINITY, CRED(), &resid);
888
889		ra->voff += ra->bufsize - leftover - resid;
890		ra->buflen = ra->bufsize - resid;
891		ra->bufoff = 0;
892		if (resid == ra->bufsize - leftover)
893			ra->err = EINVAL;
894		if (ra->err)
895			return (NULL);
896		/* Could compute checksum here? */
897	}
898
899	ASSERT3U(ra->bufoff % 8, ==, 0);
900	ASSERT3U(ra->buflen - ra->bufoff, >=, len);
901	rv = ra->buf + ra->bufoff;
902	ra->bufoff += len;
903	if (ra->byteswap)
904		fletcher_4_incremental_byteswap(rv, len, &ra->zc);
905	else
906		fletcher_4_incremental_native(rv, len, &ra->zc);
907	return (rv);
908}
909
910static void
911backup_byteswap(dmu_replay_record_t *drr)
912{
913#define	DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X))
914#define	DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X))
915	drr->drr_type = BSWAP_32(drr->drr_type);
916	switch (drr->drr_type) {
917	case DRR_BEGIN:
918		DO64(drr_begin.drr_magic);
919		DO64(drr_begin.drr_version);
920		DO64(drr_begin.drr_creation_time);
921		DO32(drr_begin.drr_type);
922		DO64(drr_begin.drr_toguid);
923		DO64(drr_begin.drr_fromguid);
924		break;
925	case DRR_OBJECT:
926		DO64(drr_object.drr_object);
927		/* DO64(drr_object.drr_allocation_txg); */
928		DO32(drr_object.drr_type);
929		DO32(drr_object.drr_bonustype);
930		DO32(drr_object.drr_blksz);
931		DO32(drr_object.drr_bonuslen);
932		break;
933	case DRR_FREEOBJECTS:
934		DO64(drr_freeobjects.drr_firstobj);
935		DO64(drr_freeobjects.drr_numobjs);
936		break;
937	case DRR_WRITE:
938		DO64(drr_write.drr_object);
939		DO32(drr_write.drr_type);
940		DO64(drr_write.drr_offset);
941		DO64(drr_write.drr_length);
942		break;
943	case DRR_FREE:
944		DO64(drr_free.drr_object);
945		DO64(drr_free.drr_offset);
946		DO64(drr_free.drr_length);
947		break;
948	case DRR_END:
949		DO64(drr_end.drr_checksum.zc_word[0]);
950		DO64(drr_end.drr_checksum.zc_word[1]);
951		DO64(drr_end.drr_checksum.zc_word[2]);
952		DO64(drr_end.drr_checksum.zc_word[3]);
953		break;
954	}
955#undef DO64
956#undef DO32
957}
958
959static int
960restore_object(struct restorearg *ra, objset_t *os, struct drr_object *drro)
961{
962	int err;
963	dmu_tx_t *tx;
964
965	err = dmu_object_info(os, drro->drr_object, NULL);
966
967	if (err != 0 && err != ENOENT)
968		return (EINVAL);
969
970	if (drro->drr_type == DMU_OT_NONE ||
971	    drro->drr_type >= DMU_OT_NUMTYPES ||
972	    drro->drr_bonustype >= DMU_OT_NUMTYPES ||
973	    drro->drr_checksum >= ZIO_CHECKSUM_FUNCTIONS ||
974	    drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS ||
975	    P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) ||
976	    drro->drr_blksz < SPA_MINBLOCKSIZE ||
977	    drro->drr_blksz > SPA_MAXBLOCKSIZE ||
978	    drro->drr_bonuslen > DN_MAX_BONUSLEN) {
979		return (EINVAL);
980	}
981
982	tx = dmu_tx_create(os);
983
984	if (err == ENOENT) {
985		/* currently free, want to be allocated */
986		dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
987		dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, 1);
988		err = dmu_tx_assign(tx, TXG_WAIT);
989		if (err) {
990			dmu_tx_abort(tx);
991			return (err);
992		}
993		err = dmu_object_claim(os, drro->drr_object,
994		    drro->drr_type, drro->drr_blksz,
995		    drro->drr_bonustype, drro->drr_bonuslen, tx);
996	} else {
997		/* currently allocated, want to be allocated */
998		dmu_tx_hold_bonus(tx, drro->drr_object);
999		/*
1000		 * We may change blocksize, so need to
1001		 * hold_write
1002		 */
1003		dmu_tx_hold_write(tx, drro->drr_object, 0, 1);
1004		err = dmu_tx_assign(tx, TXG_WAIT);
1005		if (err) {
1006			dmu_tx_abort(tx);
1007			return (err);
1008		}
1009
1010		err = dmu_object_reclaim(os, drro->drr_object,
1011		    drro->drr_type, drro->drr_blksz,
1012		    drro->drr_bonustype, drro->drr_bonuslen, tx);
1013	}
1014	if (err) {
1015		dmu_tx_commit(tx);
1016		return (EINVAL);
1017	}
1018
1019	dmu_object_set_checksum(os, drro->drr_object, drro->drr_checksum, tx);
1020	dmu_object_set_compress(os, drro->drr_object, drro->drr_compress, tx);
1021
1022	if (drro->drr_bonuslen) {
1023		dmu_buf_t *db;
1024		void *data;
1025		VERIFY(0 == dmu_bonus_hold(os, drro->drr_object, FTAG, &db));
1026		dmu_buf_will_dirty(db, tx);
1027
1028		ASSERT3U(db->db_size, ==, drro->drr_bonuslen);
1029		data = restore_read(ra, P2ROUNDUP(db->db_size, 8));
1030		if (data == NULL) {
1031			dmu_tx_commit(tx);
1032			return (ra->err);
1033		}
1034		bcopy(data, db->db_data, db->db_size);
1035		if (ra->byteswap) {
1036			dmu_ot[drro->drr_bonustype].ot_byteswap(db->db_data,
1037			    drro->drr_bonuslen);
1038		}
1039		dmu_buf_rele(db, FTAG);
1040	}
1041	dmu_tx_commit(tx);
1042	return (0);
1043}
1044
1045/* ARGSUSED */
1046static int
1047restore_freeobjects(struct restorearg *ra, objset_t *os,
1048    struct drr_freeobjects *drrfo)
1049{
1050	uint64_t obj;
1051
1052	if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj)
1053		return (EINVAL);
1054
1055	for (obj = drrfo->drr_firstobj;
1056	    obj < drrfo->drr_firstobj + drrfo->drr_numobjs; obj++) {
1057		dmu_tx_t *tx;
1058		int err;
1059
1060		if (dmu_object_info(os, obj, NULL) != 0)
1061			continue;
1062
1063		tx = dmu_tx_create(os);
1064		dmu_tx_hold_bonus(tx, obj);
1065		err = dmu_tx_assign(tx, TXG_WAIT);
1066		if (err) {
1067			dmu_tx_abort(tx);
1068			return (err);
1069		}
1070		err = dmu_object_free(os, obj, tx);
1071		dmu_tx_commit(tx);
1072		if (err && err != ENOENT)
1073			return (EINVAL);
1074	}
1075	return (0);
1076}
1077
1078static int
1079restore_write(struct restorearg *ra, objset_t *os,
1080    struct drr_write *drrw)
1081{
1082	dmu_tx_t *tx;
1083	void *data;
1084	int err;
1085
1086	if (drrw->drr_offset + drrw->drr_length < drrw->drr_offset ||
1087	    drrw->drr_type >= DMU_OT_NUMTYPES)
1088		return (EINVAL);
1089
1090	data = restore_read(ra, drrw->drr_length);
1091	if (data == NULL)
1092		return (ra->err);
1093
1094	if (dmu_object_info(os, drrw->drr_object, NULL) != 0)
1095		return (EINVAL);
1096
1097	tx = dmu_tx_create(os);
1098
1099	dmu_tx_hold_write(tx, drrw->drr_object,
1100	    drrw->drr_offset, drrw->drr_length);
1101	err = dmu_tx_assign(tx, TXG_WAIT);
1102	if (err) {
1103		dmu_tx_abort(tx);
1104		return (err);
1105	}
1106	if (ra->byteswap)
1107		dmu_ot[drrw->drr_type].ot_byteswap(data, drrw->drr_length);
1108	dmu_write(os, drrw->drr_object,
1109	    drrw->drr_offset, drrw->drr_length, data, tx);
1110	dmu_tx_commit(tx);
1111	return (0);
1112}
1113
1114/* ARGSUSED */
1115static int
1116restore_free(struct restorearg *ra, objset_t *os,
1117    struct drr_free *drrf)
1118{
1119	dmu_tx_t *tx;
1120	int err;
1121
1122	if (drrf->drr_length != -1ULL &&
1123	    drrf->drr_offset + drrf->drr_length < drrf->drr_offset)
1124		return (EINVAL);
1125
1126	if (dmu_object_info(os, drrf->drr_object, NULL) != 0)
1127		return (EINVAL);
1128
1129	tx = dmu_tx_create(os);
1130
1131	dmu_tx_hold_free(tx, drrf->drr_object,
1132	    drrf->drr_offset, drrf->drr_length);
1133	err = dmu_tx_assign(tx, TXG_WAIT);
1134	if (err) {
1135		dmu_tx_abort(tx);
1136		return (err);
1137	}
1138	err = dmu_free_range(os, drrf->drr_object,
1139	    drrf->drr_offset, drrf->drr_length, tx);
1140	dmu_tx_commit(tx);
1141	return (err);
1142}
1143
1144int
1145dmu_recvbackup(char *tosnap, struct drr_begin *drrb, uint64_t *sizep,
1146    vnode_t *vp, uint64_t voffset)
1147{
1148	struct restorearg ra;
1149	dmu_replay_record_t *drr;
1150	char *cp;
1151	objset_t *os = NULL;
1152	zio_cksum_t pzc;
1153
1154	bzero(&ra, sizeof (ra));
1155	ra.vp = vp;
1156	ra.voff = voffset;
1157	ra.bufsize = 1<<20;
1158	ra.buf = kmem_alloc(ra.bufsize, KM_SLEEP);
1159
1160	if (drrb->drr_magic == DMU_BACKUP_MAGIC) {
1161		ra.byteswap = FALSE;
1162	} else if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) {
1163		ra.byteswap = TRUE;
1164	} else {
1165		ra.err = EINVAL;
1166		goto out;
1167	}
1168
1169	/*
1170	 * NB: this assumes that struct drr_begin will be the largest in
1171	 * dmu_replay_record_t's drr_u, and thus we don't need to pad it
1172	 * with zeros to make it the same length as we wrote out.
1173	 */
1174	((dmu_replay_record_t *)ra.buf)->drr_type = DRR_BEGIN;
1175	((dmu_replay_record_t *)ra.buf)->drr_pad = 0;
1176	((dmu_replay_record_t *)ra.buf)->drr_u.drr_begin = *drrb;
1177	if (ra.byteswap) {
1178		fletcher_4_incremental_byteswap(ra.buf,
1179		    sizeof (dmu_replay_record_t), &ra.zc);
1180	} else {
1181		fletcher_4_incremental_native(ra.buf,
1182		    sizeof (dmu_replay_record_t), &ra.zc);
1183	}
1184	(void) strcpy(drrb->drr_toname, tosnap); /* for the sync funcs */
1185
1186	if (ra.byteswap) {
1187		drrb->drr_magic = BSWAP_64(drrb->drr_magic);
1188		drrb->drr_version = BSWAP_64(drrb->drr_version);
1189		drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time);
1190		drrb->drr_type = BSWAP_32(drrb->drr_type);
1191		drrb->drr_toguid = BSWAP_64(drrb->drr_toguid);
1192		drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid);
1193	}
1194
1195	ASSERT3U(drrb->drr_magic, ==, DMU_BACKUP_MAGIC);
1196
1197	if (drrb->drr_version != DMU_BACKUP_VERSION ||
1198	    drrb->drr_type >= DMU_OST_NUMTYPES ||
1199	    strchr(drrb->drr_toname, '@') == NULL) {
1200		ra.err = EINVAL;
1201		goto out;
1202	}
1203
1204	/*
1205	 * Process the begin in syncing context.
1206	 */
1207	if (drrb->drr_fromguid) {
1208		/* incremental backup */
1209		dsl_dataset_t *ds = NULL;
1210
1211		cp = strchr(tosnap, '@');
1212		*cp = '\0';
1213		ra.err = dsl_dataset_open(tosnap, DS_MODE_EXCLUSIVE, FTAG, &ds);
1214		*cp = '@';
1215		if (ra.err)
1216			goto out;
1217
1218		ra.err = dsl_sync_task_do(ds->ds_dir->dd_pool,
1219		    replay_incremental_check, replay_incremental_sync,
1220		    ds, drrb, 1);
1221		dsl_dataset_close(ds, DS_MODE_EXCLUSIVE, FTAG);
1222	} else {
1223		/* full backup */
1224		dsl_dir_t *dd = NULL;
1225		const char *tail;
1226
1227		/* can't restore full backup into topmost fs, for now */
1228		if (strrchr(drrb->drr_toname, '/') == NULL) {
1229			ra.err = EINVAL;
1230			goto out;
1231		}
1232
1233		cp = strchr(tosnap, '@');
1234		*cp = '\0';
1235		ra.err = dsl_dir_open(tosnap, FTAG, &dd, &tail);
1236		*cp = '@';
1237		if (ra.err)
1238			goto out;
1239		if (tail == NULL) {
1240			ra.err = EEXIST;
1241			goto out;
1242		}
1243
1244		ra.err = dsl_sync_task_do(dd->dd_pool, replay_full_check,
1245		    replay_full_sync, dd, drrb, 5);
1246		dsl_dir_close(dd, FTAG);
1247	}
1248	if (ra.err)
1249		goto out;
1250
1251	/*
1252	 * Open the objset we are modifying.
1253	 */
1254
1255	cp = strchr(tosnap, '@');
1256	*cp = '\0';
1257	ra.err = dmu_objset_open(tosnap, DMU_OST_ANY,
1258	    DS_MODE_PRIMARY | DS_MODE_INCONSISTENT, &os);
1259	*cp = '@';
1260	ASSERT3U(ra.err, ==, 0);
1261
1262	/*
1263	 * Read records and process them.
1264	 */
1265	pzc = ra.zc;
1266	while (ra.err == 0 &&
1267	    NULL != (drr = restore_read(&ra, sizeof (*drr)))) {
1268		if (issig(JUSTLOOKING) && issig(FORREAL)) {
1269			ra.err = EINTR;
1270			goto out;
1271		}
1272
1273		if (ra.byteswap)
1274			backup_byteswap(drr);
1275
1276		switch (drr->drr_type) {
1277		case DRR_OBJECT:
1278		{
1279			/*
1280			 * We need to make a copy of the record header,
1281			 * because restore_{object,write} may need to
1282			 * restore_read(), which will invalidate drr.
1283			 */
1284			struct drr_object drro = drr->drr_u.drr_object;
1285			ra.err = restore_object(&ra, os, &drro);
1286			break;
1287		}
1288		case DRR_FREEOBJECTS:
1289		{
1290			struct drr_freeobjects drrfo =
1291			    drr->drr_u.drr_freeobjects;
1292			ra.err = restore_freeobjects(&ra, os, &drrfo);
1293			break;
1294		}
1295		case DRR_WRITE:
1296		{
1297			struct drr_write drrw = drr->drr_u.drr_write;
1298			ra.err = restore_write(&ra, os, &drrw);
1299			break;
1300		}
1301		case DRR_FREE:
1302		{
1303			struct drr_free drrf = drr->drr_u.drr_free;
1304			ra.err = restore_free(&ra, os, &drrf);
1305			break;
1306		}
1307		case DRR_END:
1308		{
1309			struct drr_end drre = drr->drr_u.drr_end;
1310			/*
1311			 * We compare against the *previous* checksum
1312			 * value, because the stored checksum is of
1313			 * everything before the DRR_END record.
1314			 */
1315			if (drre.drr_checksum.zc_word[0] != 0 &&
1316			    ((drre.drr_checksum.zc_word[0] - pzc.zc_word[0]) |
1317			    (drre.drr_checksum.zc_word[1] - pzc.zc_word[1]) |
1318			    (drre.drr_checksum.zc_word[2] - pzc.zc_word[2]) |
1319			    (drre.drr_checksum.zc_word[3] - pzc.zc_word[3]))) {
1320				ra.err = ECKSUM;
1321				goto out;
1322			}
1323
1324			ra.err = dsl_sync_task_do(dmu_objset_ds(os)->
1325			    ds_dir->dd_pool, replay_end_check, replay_end_sync,
1326			    os, drrb, 3);
1327			goto out;
1328		}
1329		default:
1330			ra.err = EINVAL;
1331			goto out;
1332		}
1333		pzc = ra.zc;
1334	}
1335
1336out:
1337	if (os)
1338		dmu_objset_close(os);
1339
1340	/*
1341	 * Make sure we don't rollback/destroy unless we actually
1342	 * processed the begin properly.  'os' will only be set if this
1343	 * is the case.
1344	 */
1345	if (ra.err && os && tosnap && strchr(tosnap, '@')) {
1346		/*
1347		 * rollback or destroy what we created, so we don't
1348		 * leave it in the restoring state.
1349		 */
1350		dsl_dataset_t *ds;
1351		int err;
1352
1353		cp = strchr(tosnap, '@');
1354		*cp = '\0';
1355		err = dsl_dataset_open(tosnap,
1356		    DS_MODE_EXCLUSIVE | DS_MODE_INCONSISTENT,
1357		    FTAG, &ds);
1358		if (err == 0) {
1359			txg_wait_synced(ds->ds_dir->dd_pool, 0);
1360			if (drrb->drr_fromguid) {
1361				/* incremental: rollback to most recent snap */
1362				(void) dsl_dataset_rollback(ds);
1363				dsl_dataset_close(ds, DS_MODE_EXCLUSIVE, FTAG);
1364			} else {
1365				/* full: destroy whole fs */
1366				dsl_dataset_close(ds, DS_MODE_EXCLUSIVE, FTAG);
1367				(void) dsl_dataset_destroy(tosnap);
1368			}
1369		}
1370		*cp = '@';
1371	}
1372
1373	kmem_free(ra.buf, ra.bufsize);
1374	if (sizep)
1375		*sizep = ra.voff;
1376	return (ra.err);
1377}
1378
1379typedef struct {
1380	uint64_t	txg;
1381	dmu_buf_impl_t	*db;
1382	dmu_sync_cb_t	*done;
1383	void		*arg;
1384} dmu_sync_cbin_t;
1385
1386typedef union {
1387	dmu_sync_cbin_t	data;
1388	blkptr_t	blk;
1389} dmu_sync_cbarg_t;
1390
1391/* ARGSUSED */
1392static void
1393dmu_sync_done(zio_t *zio, arc_buf_t *buf, void *varg)
1394{
1395	dmu_sync_cbin_t *in = (dmu_sync_cbin_t *)varg;
1396	dmu_buf_impl_t *db = in->db;
1397	uint64_t txg = in->txg;
1398	dmu_sync_cb_t *done = in->done;
1399	void *arg = in->arg;
1400	blkptr_t *blk = (blkptr_t *)varg;
1401
1402	if (!BP_IS_HOLE(zio->io_bp)) {
1403		zio->io_bp->blk_fill = 1;
1404		BP_SET_TYPE(zio->io_bp, db->db_dnode->dn_type);
1405		BP_SET_LEVEL(zio->io_bp, 0);
1406	}
1407
1408	*blk = *zio->io_bp; /* structure assignment */
1409
1410	mutex_enter(&db->db_mtx);
1411	ASSERT(db->db_d.db_overridden_by[txg&TXG_MASK] == IN_DMU_SYNC);
1412	db->db_d.db_overridden_by[txg&TXG_MASK] = blk;
1413	cv_broadcast(&db->db_changed);
1414	mutex_exit(&db->db_mtx);
1415
1416	if (done)
1417		done(&(db->db), arg);
1418}
1419
1420/*
1421 * Intent log support: sync the block associated with db to disk.
1422 * N.B. and XXX: the caller is responsible for making sure that the
1423 * data isn't changing while dmu_sync() is writing it.
1424 *
1425 * Return values:
1426 *
1427 *	EEXIST: this txg has already been synced, so there's nothing to to.
1428 *		The caller should not log the write.
1429 *
1430 *	ENOENT: the block was dbuf_free_range()'d, so there's nothing to do.
1431 *		The caller should not log the write.
1432 *
1433 *	EALREADY: this block is already in the process of being synced.
1434 *		The caller should track its progress (somehow).
1435 *
1436 *	EINPROGRESS: the IO has been initiated.
1437 *		The caller should log this blkptr in the callback.
1438 *
1439 *	0: completed.  Sets *bp to the blkptr just written.
1440 *		The caller should log this blkptr immediately.
1441 */
1442int
1443dmu_sync(zio_t *pio, dmu_buf_t *db_fake,
1444    blkptr_t *bp, uint64_t txg, dmu_sync_cb_t *done, void *arg)
1445{
1446	dmu_buf_impl_t *db = (dmu_buf_impl_t *)db_fake;
1447	objset_impl_t *os = db->db_objset;
1448	dsl_pool_t *dp = os->os_dsl_dataset->ds_dir->dd_pool;
1449	tx_state_t *tx = &dp->dp_tx;
1450	dmu_sync_cbin_t *in;
1451	blkptr_t *blk;
1452	zbookmark_t zb;
1453	uint32_t arc_flag;
1454	int err;
1455
1456	ASSERT(BP_IS_HOLE(bp));
1457	ASSERT(txg != 0);
1458
1459
1460	dprintf("dmu_sync txg=%llu, s,o,q %llu %llu %llu\n",
1461	    txg, tx->tx_synced_txg, tx->tx_open_txg, tx->tx_quiesced_txg);
1462
1463	/*
1464	 * XXX - would be nice if we could do this without suspending...
1465	 */
1466	txg_suspend(dp);
1467
1468	/*
1469	 * If this txg already synced, there's nothing to do.
1470	 */
1471	if (txg <= tx->tx_synced_txg) {
1472		txg_resume(dp);
1473		/*
1474		 * If we're running ziltest, we need the blkptr regardless.
1475		 */
1476		if (txg > spa_freeze_txg(dp->dp_spa)) {
1477			/* if db_blkptr == NULL, this was an empty write */
1478			if (db->db_blkptr)
1479				*bp = *db->db_blkptr; /* structure assignment */
1480			return (0);
1481		}
1482		return (EEXIST);
1483	}
1484
1485	mutex_enter(&db->db_mtx);
1486
1487	blk = db->db_d.db_overridden_by[txg&TXG_MASK];
1488	if (blk == IN_DMU_SYNC) {
1489		/*
1490		 * We have already issued a sync write for this buffer.
1491		 */
1492		mutex_exit(&db->db_mtx);
1493		txg_resume(dp);
1494		return (EALREADY);
1495	} else if (blk != NULL) {
1496		/*
1497		 * This buffer had already been synced.  It could not
1498		 * have been dirtied since, or we would have cleared blk.
1499		 */
1500		*bp = *blk; /* structure assignment */
1501		mutex_exit(&db->db_mtx);
1502		txg_resume(dp);
1503		return (0);
1504	}
1505
1506	if (txg == tx->tx_syncing_txg) {
1507		while (db->db_data_pending) {
1508			/*
1509			 * IO is in-progress.  Wait for it to finish.
1510			 * XXX - would be nice to be able to somehow "attach"
1511			 * this zio to the parent zio passed in.
1512			 */
1513			cv_wait(&db->db_changed, &db->db_mtx);
1514			ASSERT(db->db_data_pending ||
1515			    (db->db_blkptr && db->db_blkptr->blk_birth == txg));
1516		}
1517
1518		if (db->db_blkptr && db->db_blkptr->blk_birth == txg) {
1519			/*
1520			 * IO is already completed.
1521			 */
1522			*bp = *db->db_blkptr; /* structure assignment */
1523			mutex_exit(&db->db_mtx);
1524			txg_resume(dp);
1525			return (0);
1526		}
1527	}
1528
1529	if (db->db_d.db_data_old[txg&TXG_MASK] == NULL) {
1530		/*
1531		 * This dbuf isn't dirty, must have been free_range'd.
1532		 * There's no need to log writes to freed blocks, so we're done.
1533		 */
1534		mutex_exit(&db->db_mtx);
1535		txg_resume(dp);
1536		return (ENOENT);
1537	}
1538
1539	ASSERT(db->db_d.db_overridden_by[txg&TXG_MASK] == NULL);
1540	db->db_d.db_overridden_by[txg&TXG_MASK] = IN_DMU_SYNC;
1541	/*
1542	 * XXX - a little ugly to stash the blkptr in the callback
1543	 * buffer.  We always need to make sure the following is true:
1544	 * ASSERT(sizeof(blkptr_t) >= sizeof(dmu_sync_cbin_t));
1545	 */
1546	in = kmem_alloc(sizeof (blkptr_t), KM_SLEEP);
1547	in->db = db;
1548	in->txg = txg;
1549	in->done = done;
1550	in->arg = arg;
1551	mutex_exit(&db->db_mtx);
1552	txg_resume(dp);
1553
1554	arc_flag = pio == NULL ? ARC_WAIT : ARC_NOWAIT;
1555	zb.zb_objset = os->os_dsl_dataset->ds_object;
1556	zb.zb_object = db->db.db_object;
1557	zb.zb_level = db->db_level;
1558	zb.zb_blkid = db->db_blkid;
1559	err = arc_write(pio, os->os_spa,
1560	    zio_checksum_select(db->db_dnode->dn_checksum, os->os_checksum),
1561	    zio_compress_select(db->db_dnode->dn_compress, os->os_compress),
1562	    dmu_get_replication_level(os->os_spa, &zb, db->db_dnode->dn_type),
1563	    txg, bp, db->db_d.db_data_old[txg&TXG_MASK], dmu_sync_done, in,
1564	    ZIO_PRIORITY_SYNC_WRITE, ZIO_FLAG_MUSTSUCCEED, arc_flag, &zb);
1565	ASSERT(err == 0);
1566
1567	return (arc_flag == ARC_NOWAIT ? EINPROGRESS : 0);
1568}
1569
1570uint64_t
1571dmu_object_max_nonzero_offset(objset_t *os, uint64_t object)
1572{
1573	dnode_t *dn;
1574
1575	/* XXX assumes dnode_hold will not get an i/o error */
1576	(void) dnode_hold(os->os, object, FTAG, &dn);
1577	uint64_t rv = dnode_max_nonzero_offset(dn);
1578	dnode_rele(dn, FTAG);
1579	return (rv);
1580}
1581
1582int
1583dmu_object_set_blocksize(objset_t *os, uint64_t object, uint64_t size, int ibs,
1584	dmu_tx_t *tx)
1585{
1586	dnode_t *dn;
1587	int err;
1588
1589	err = dnode_hold(os->os, object, FTAG, &dn);
1590	if (err)
1591		return (err);
1592	err = dnode_set_blksz(dn, size, ibs, tx);
1593	dnode_rele(dn, FTAG);
1594	return (err);
1595}
1596
1597void
1598dmu_object_set_checksum(objset_t *os, uint64_t object, uint8_t checksum,
1599	dmu_tx_t *tx)
1600{
1601	dnode_t *dn;
1602
1603	/* XXX assumes dnode_hold will not get an i/o error */
1604	(void) dnode_hold(os->os, object, FTAG, &dn);
1605	ASSERT(checksum < ZIO_CHECKSUM_FUNCTIONS);
1606	dn->dn_checksum = checksum;
1607	dnode_setdirty(dn, tx);
1608	dnode_rele(dn, FTAG);
1609}
1610
1611void
1612dmu_object_set_compress(objset_t *os, uint64_t object, uint8_t compress,
1613	dmu_tx_t *tx)
1614{
1615	dnode_t *dn;
1616
1617	/* XXX assumes dnode_hold will not get an i/o error */
1618	(void) dnode_hold(os->os, object, FTAG, &dn);
1619	ASSERT(compress < ZIO_COMPRESS_FUNCTIONS);
1620	dn->dn_compress = compress;
1621	dnode_setdirty(dn, tx);
1622	dnode_rele(dn, FTAG);
1623}
1624
1625/*
1626 * XXX - eventually, this should take into account per-dataset (or
1627 *       even per-object?) user requests for higher levels of replication.
1628 */
1629int
1630dmu_get_replication_level(spa_t *spa, zbookmark_t *zb, dmu_object_type_t ot)
1631{
1632	int ncopies = 1;
1633
1634	if (dmu_ot[ot].ot_metadata)
1635		ncopies++;
1636	if (zb->zb_level != 0)
1637		ncopies++;
1638	if (zb->zb_objset == 0 && zb->zb_object == 0)
1639		ncopies++;
1640	return (MIN(ncopies, spa_max_replication(spa)));
1641}
1642
1643int
1644dmu_offset_next(objset_t *os, uint64_t object, boolean_t hole, uint64_t *off)
1645{
1646	dnode_t *dn;
1647	int i, err;
1648
1649	err = dnode_hold(os->os, object, FTAG, &dn);
1650	if (err)
1651		return (err);
1652	/*
1653	 * Sync any current changes before
1654	 * we go trundling through the block pointers.
1655	 */
1656	for (i = 0; i < TXG_SIZE; i++) {
1657		if (list_link_active(&dn->dn_dirty_link[i]))
1658			break;
1659	}
1660	if (i != TXG_SIZE) {
1661		dnode_rele(dn, FTAG);
1662		txg_wait_synced(dmu_objset_pool(os), 0);
1663		err = dnode_hold(os->os, object, FTAG, &dn);
1664		if (err)
1665			return (err);
1666	}
1667
1668	err = dnode_next_offset(dn, hole, off, 1, 1);
1669	dnode_rele(dn, FTAG);
1670
1671	return (err);
1672}
1673
1674void
1675dmu_object_info_from_dnode(dnode_t *dn, dmu_object_info_t *doi)
1676{
1677	rw_enter(&dn->dn_struct_rwlock, RW_READER);
1678	mutex_enter(&dn->dn_mtx);
1679
1680	doi->doi_data_block_size = dn->dn_datablksz;
1681	doi->doi_metadata_block_size = dn->dn_indblkshift ?
1682	    1ULL << dn->dn_indblkshift : 0;
1683	doi->doi_indirection = dn->dn_nlevels;
1684	doi->doi_checksum = dn->dn_checksum;
1685	doi->doi_compress = dn->dn_compress;
1686	doi->doi_physical_blks = (DN_USED_BYTES(dn->dn_phys) +
1687	    SPA_MINBLOCKSIZE/2) >> SPA_MINBLOCKSHIFT;
1688	doi->doi_max_block_offset = dn->dn_phys->dn_maxblkid;
1689	doi->doi_type = dn->dn_type;
1690	doi->doi_bonus_size = dn->dn_bonuslen;
1691	doi->doi_bonus_type = dn->dn_bonustype;
1692
1693	mutex_exit(&dn->dn_mtx);
1694	rw_exit(&dn->dn_struct_rwlock);
1695}
1696
1697/*
1698 * Get information on a DMU object.
1699 * If doi is NULL, just indicates whether the object exists.
1700 */
1701int
1702dmu_object_info(objset_t *os, uint64_t object, dmu_object_info_t *doi)
1703{
1704	dnode_t *dn;
1705	int err = dnode_hold(os->os, object, FTAG, &dn);
1706
1707	if (err)
1708		return (err);
1709
1710	if (doi != NULL)
1711		dmu_object_info_from_dnode(dn, doi);
1712
1713	dnode_rele(dn, FTAG);
1714	return (0);
1715}
1716
1717/*
1718 * As above, but faster; can be used when you have a held dbuf in hand.
1719 */
1720void
1721dmu_object_info_from_db(dmu_buf_t *db, dmu_object_info_t *doi)
1722{
1723	dmu_object_info_from_dnode(((dmu_buf_impl_t *)db)->db_dnode, doi);
1724}
1725
1726/*
1727 * Faster still when you only care about the size.
1728 * This is specifically optimized for zfs_getattr().
1729 */
1730void
1731dmu_object_size_from_db(dmu_buf_t *db, uint32_t *blksize, u_longlong_t *nblk512)
1732{
1733	dnode_t *dn = ((dmu_buf_impl_t *)db)->db_dnode;
1734
1735	*blksize = dn->dn_datablksz;
1736	/* add 1 for dnode space */
1737	*nblk512 = ((DN_USED_BYTES(dn->dn_phys) + SPA_MINBLOCKSIZE/2) >>
1738	    SPA_MINBLOCKSHIFT) + 1;
1739}
1740
1741/*
1742 * Given a bookmark, return the name of the dataset, object, and range in
1743 * human-readable format.
1744 */
1745int
1746spa_bookmark_name(spa_t *spa, zbookmark_t *zb, char *dsname, size_t dslen,
1747    char *objname, size_t objlen, char *range, size_t rangelen)
1748{
1749	dsl_pool_t *dp;
1750	dsl_dataset_t *ds = NULL;
1751	objset_t *os = NULL;
1752	dnode_t *dn = NULL;
1753	int err, shift;
1754
1755	if (dslen < MAXNAMELEN || objlen < 32 || rangelen < 64)
1756		return (ENOSPC);
1757
1758	dp = spa_get_dsl(spa);
1759	if (zb->zb_objset != 0) {
1760		rw_enter(&dp->dp_config_rwlock, RW_READER);
1761		err = dsl_dataset_open_obj(dp, zb->zb_objset,
1762		    NULL, DS_MODE_NONE, FTAG, &ds);
1763		if (err) {
1764			rw_exit(&dp->dp_config_rwlock);
1765			return (err);
1766		}
1767		dsl_dataset_name(ds, dsname);
1768		dsl_dataset_close(ds, DS_MODE_NONE, FTAG);
1769		rw_exit(&dp->dp_config_rwlock);
1770
1771		err = dmu_objset_open(dsname, DMU_OST_ANY, DS_MODE_NONE, &os);
1772		if (err)
1773			goto out;
1774
1775	} else {
1776		dsl_dataset_name(NULL, dsname);
1777		os = dp->dp_meta_objset;
1778	}
1779
1780
1781	if (zb->zb_object == DMU_META_DNODE_OBJECT) {
1782		(void) strncpy(objname, "mdn", objlen);
1783	} else {
1784		(void) snprintf(objname, objlen, "%lld",
1785		    (longlong_t)zb->zb_object);
1786	}
1787
1788	err = dnode_hold(os->os, zb->zb_object, FTAG, &dn);
1789	if (err)
1790		goto out;
1791
1792	shift = (dn->dn_datablkshift?dn->dn_datablkshift:SPA_MAXBLOCKSHIFT) +
1793	    zb->zb_level * (dn->dn_indblkshift - SPA_BLKPTRSHIFT);
1794	(void) snprintf(range, rangelen, "%llu-%llu",
1795	    (u_longlong_t)(zb->zb_blkid << shift),
1796	    (u_longlong_t)((zb->zb_blkid+1) << shift));
1797
1798out:
1799	if (dn)
1800		dnode_rele(dn, FTAG);
1801	if (os && os != dp->dp_meta_objset)
1802		dmu_objset_close(os);
1803	return (err);
1804}
1805
1806void
1807byteswap_uint64_array(void *vbuf, size_t size)
1808{
1809	uint64_t *buf = vbuf;
1810	size_t count = size >> 3;
1811	int i;
1812
1813	ASSERT((size & 7) == 0);
1814
1815	for (i = 0; i < count; i++)
1816		buf[i] = BSWAP_64(buf[i]);
1817}
1818
1819void
1820byteswap_uint32_array(void *vbuf, size_t size)
1821{
1822	uint32_t *buf = vbuf;
1823	size_t count = size >> 2;
1824	int i;
1825
1826	ASSERT((size & 3) == 0);
1827
1828	for (i = 0; i < count; i++)
1829		buf[i] = BSWAP_32(buf[i]);
1830}
1831
1832void
1833byteswap_uint16_array(void *vbuf, size_t size)
1834{
1835	uint16_t *buf = vbuf;
1836	size_t count = size >> 1;
1837	int i;
1838
1839	ASSERT((size & 1) == 0);
1840
1841	for (i = 0; i < count; i++)
1842		buf[i] = BSWAP_16(buf[i]);
1843}
1844
1845/* ARGSUSED */
1846void
1847byteswap_uint8_array(void *vbuf, size_t size)
1848{
1849}
1850
1851void
1852dmu_init(void)
1853{
1854	dbuf_init();
1855	dnode_init();
1856	arc_init();
1857}
1858
1859void
1860dmu_fini(void)
1861{
1862	arc_fini();
1863	dnode_fini();
1864	dbuf_fini();
1865}
1866