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/*
23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26/*
27 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
28 */
29
30/*
31 * System includes
32 */
33#include <assert.h>
34#include <libintl.h>
35#include <libnvpair.h>
36#include <libzfs.h>
37#include <stdio.h>
38#include <stdlib.h>
39#include <string.h>
40#include <sys/types.h>
41#include <sys/stat.h>
42#include <unistd.h>
43
44#include <libbe.h>
45#include <libbe_priv.h>
46
47/* Private function prototypes */
48static int be_rollback_check_callback(zfs_handle_t *, void *);
49static int be_rollback_callback(zfs_handle_t *, void *);
50
51
52/* ******************************************************************** */
53/*			Public Functions				*/
54/* ******************************************************************** */
55
56/*
57 * Function:	be_create_snapshot
58 * Description:	Creates a recursive snapshot of all the datasets within a BE.
59 *		If the name of the BE to snapshot is not provided, it assumes
60 *		we're snapshotting the currently running BE.  If the snapshot
61 *		name is not provided it creates an auto named snapshot, which
62 *		will be returned to the caller upon success.
63 * Parameters:
64 *		be_attrs - pointer to nvlist_t of attributes being passed in.
65 *			The following attributes are used by this function:
66 *
67 *			BE_ATTR_ORIG_BE_NAME		*optional
68 *			BE_ATTR_SNAP_NAME		*optional
69 *			BE_ATTR_POLICY			*optional
70 *
71 *			If the BE_ATTR_SNAP_NAME was not passed in, upon
72 *			successful BE snapshot creation, the following
73 *			attribute value will be returned to the caller by
74 *			setting it in the be_attrs parameter passed in:
75 *
76 *			BE_ATTR_SNAP_NAME
77 *
78 * Return:
79 *		BE_SUCCESS - Success
80 *		be_errno_t - Failure
81 * Scope:
82 *		Public
83 */
84int
85be_create_snapshot(nvlist_t *be_attrs)
86{
87	char		*be_name = NULL;
88	char		*snap_name = NULL;
89	char		*policy = NULL;
90	boolean_t	autoname = B_FALSE;
91	int 		ret = BE_SUCCESS;
92
93	/* Initialize libzfs handle */
94	if (!be_zfs_init())
95		return (BE_ERR_INIT);
96
97	/* Get original BE name if one was provided */
98	if (nvlist_lookup_pairs(be_attrs, NV_FLAG_NOENTOK,
99	    BE_ATTR_ORIG_BE_NAME, DATA_TYPE_STRING, &be_name, NULL) != 0) {
100		be_print_err(gettext("be_create_snapshot: failed to "
101		    "lookup BE_ATTR_ORIG_BE_NAME attribute\n"));
102		be_zfs_fini();
103		return (BE_ERR_INVAL);
104	}
105
106	/* Validate original BE name if one was provided */
107	if (be_name != NULL && !be_valid_be_name(be_name)) {
108		be_print_err(gettext("be_create_snapshot: "
109		    "invalid BE name %s\n"), be_name);
110		be_zfs_fini();
111		return (BE_ERR_INVAL);
112	}
113
114	/* Get snapshot name to create if one was provided */
115	if (nvlist_lookup_pairs(be_attrs, NV_FLAG_NOENTOK,
116	    BE_ATTR_SNAP_NAME, DATA_TYPE_STRING, &snap_name, NULL) != 0) {
117		be_print_err(gettext("be_create_snapshot: "
118		    "failed to lookup BE_ATTR_SNAP_NAME attribute\n"));
119		be_zfs_fini();
120		return (BE_ERR_INVAL);
121	}
122
123	/* Get BE policy to create this snapshot under */
124	if (nvlist_lookup_pairs(be_attrs, NV_FLAG_NOENTOK,
125	    BE_ATTR_POLICY, DATA_TYPE_STRING, &policy, NULL) != 0) {
126		be_print_err(gettext("be_create_snapshot: "
127		    "failed to lookup BE_ATTR_POLICY attribute\n"));
128		be_zfs_fini();
129		return (BE_ERR_INVAL);
130	}
131
132	/*
133	 * If no snap_name ws provided, we're going to create an
134	 * auto named snapshot.  Set flag so that we know to pass
135	 * the auto named snapshot to the caller later.
136	 */
137	if (snap_name == NULL)
138		autoname = B_TRUE;
139
140	if ((ret = _be_create_snapshot(be_name, &snap_name, policy))
141	    == BE_SUCCESS) {
142		if (autoname == B_TRUE) {
143			/*
144			 * Set auto named snapshot name in the
145			 * nvlist passed in by the caller.
146			 */
147			if (nvlist_add_string(be_attrs, BE_ATTR_SNAP_NAME,
148			    snap_name) != 0) {
149				be_print_err(gettext("be_create_snapshot: "
150				    "failed to add auto snap name (%s) to "
151				    "be_attrs\n"), snap_name);
152				ret = BE_ERR_NOMEM;
153			}
154		}
155	}
156
157	be_zfs_fini();
158
159	return (ret);
160}
161
162/*
163 * Function:	be_destroy_snapshot
164 * Description:	Iterates through all the datasets of the BE and deletes
165 *		the snapshots of each one with the specified name.  If the
166 *		BE name is not provided, it assumes we're operating on the
167 *		currently running BE.  The name of the snapshot name to
168 *		destroy must be provided.
169 * Parameters:
170 *		be_attrs - pointer to nvlist_t of attributes being passed in.
171 *			   The following attribute values are used by this
172 *			   function:
173 *
174 *			   BE_ATTR_ORIG_BE_NAME		*optional
175 *			   BE_ATTR_SNAP_NAME		*required
176 * Return:
177 *		BE_SUCCESS - Success
178 *		be_errno_t - Failure
179 * Scope:
180 *		Public
181 */
182int
183be_destroy_snapshot(nvlist_t *be_attrs)
184{
185	char	*be_name = NULL;
186	char	*snap_name = NULL;
187	int 	ret = BE_SUCCESS;
188
189	/* Initialize libzfs handle */
190	if (!be_zfs_init())
191		return (BE_ERR_INIT);
192
193	/* Get original BE name if one was provided */
194	if (nvlist_lookup_pairs(be_attrs, NV_FLAG_NOENTOK,
195	    BE_ATTR_ORIG_BE_NAME, DATA_TYPE_STRING, &be_name, NULL) != 0) {
196		be_print_err(gettext("be_destroy_snapshot: "
197		    "failed to lookup BE_ATTR_ORIG_BE_NAME attribute\n"));
198		return (BE_ERR_INVAL);
199	}
200
201	/* Validate original BE name if one was provided */
202	if (be_name != NULL && !be_valid_be_name(be_name)) {
203		be_print_err(gettext("be_destroy_snapshot: "
204		    "invalid BE name %s\n"), be_name);
205		return (BE_ERR_INVAL);
206	}
207
208	/* Get snapshot name to destroy */
209	if (nvlist_lookup_string(be_attrs, BE_ATTR_SNAP_NAME, &snap_name)
210	    != 0) {
211		be_print_err(gettext("be_destroy_snapshot: "
212		    "failed to lookup BE_ATTR_SNAP_NAME attribute.\n"));
213		return (BE_ERR_INVAL);
214	}
215
216	ret = _be_destroy_snapshot(be_name, snap_name);
217
218	be_zfs_fini();
219
220	return (ret);
221}
222
223/*
224 * Function:	be_rollback
225 * Description:	Rolls back a BE and all of its children datasets to the
226 *		named snapshot.  All of the BE's datasets must have the
227 *		named snapshot for this function to succeed.  If the name
228 *		of the BE is not passed in, this function assumes we're
229 *		operating on the currently booted live BE.
230 *
231 *		Note - This function does not check if the BE has any
232 *		younger snapshots than the one we're trying to rollback to.
233 *		If it does, then those younger snapshots and their dependent
234 *		clone file systems will get destroyed in the process of
235 *		rolling back.
236 *
237 * Parameters:
238 *		be_attrs - pointer to nvlist_t of attributes being passed in.
239 *			   The following attributes are used by this function:
240 *
241 *			   BE_ATTR_ORIG_BE_NAME		*optional
242 *			   BE_ATTR_SNAP_NAME		*required
243 *
244 * Returns:
245 *		BE_SUCCESS - Success
246 *		be_errno_t - Failure
247 * Scope:
248 *		Public
249 */
250int
251be_rollback(nvlist_t *be_attrs)
252{
253	be_transaction_data_t	bt = { 0 };
254	zfs_handle_t		*zhp = NULL;
255	zpool_handle_t		*zphp;
256	char			obe_root_ds[MAXPATHLEN];
257	char			*obe_name = NULL;
258	int			zret = 0, ret = BE_SUCCESS;
259	struct be_defaults be_defaults;
260
261	/* Initialize libzfs handle */
262	if (!be_zfs_init())
263		return (BE_ERR_INIT);
264
265	if ((ret = be_find_current_be(&bt)) != BE_SUCCESS) {
266		return (ret);
267	}
268
269	/* Get original BE name if one was provided */
270	if (nvlist_lookup_pairs(be_attrs, NV_FLAG_NOENTOK,
271	    BE_ATTR_ORIG_BE_NAME, DATA_TYPE_STRING, &obe_name, NULL) != 0) {
272		be_print_err(gettext("be_rollback: "
273		    "failed to lookup BE_ATTR_ORIG_BE_NAME attribute\n"));
274		return (BE_ERR_INVAL);
275	}
276
277	be_get_defaults(&be_defaults);
278
279	/* If original BE name not provided, use current BE */
280	if (obe_name != NULL) {
281		bt.obe_name = obe_name;
282		/* Validate original BE name  */
283		if (!be_valid_be_name(bt.obe_name)) {
284			be_print_err(gettext("be_rollback: "
285			    "invalid BE name %s\n"), bt.obe_name);
286			return (BE_ERR_INVAL);
287		}
288	}
289
290	/* Get snapshot name to rollback to */
291	if (nvlist_lookup_string(be_attrs, BE_ATTR_SNAP_NAME, &bt.obe_snap_name)
292	    != 0) {
293		be_print_err(gettext("be_rollback: "
294		    "failed to lookup BE_ATTR_SNAP_NAME attribute.\n"));
295		return (BE_ERR_INVAL);
296	}
297
298	if (be_defaults.be_deflt_rpool_container) {
299		if ((zphp = zpool_open(g_zfs, bt.obe_zpool)) == NULL) {
300			be_print_err(gettext("be_rollback: failed to "
301			    "open rpool (%s): %s\n"), bt.obe_zpool,
302			    libzfs_error_description(g_zfs));
303			return (zfs_err_to_be_err(g_zfs));
304		}
305		zret = be_find_zpool_callback(zphp, &bt);
306	} else {
307		/* Find which zpool obe_name lives in */
308		if ((zret = zpool_iter(g_zfs, be_find_zpool_callback, &bt)) ==
309		    0) {
310			be_print_err(gettext("be_rollback: "
311			    "failed to find zpool for BE (%s)\n"), bt.obe_name);
312			return (BE_ERR_BE_NOENT);
313		} else if (zret < 0) {
314			be_print_err(gettext("be_rollback: "
315			    "zpool_iter failed: %s\n"),
316			    libzfs_error_description(g_zfs));
317			return (zfs_err_to_be_err(g_zfs));
318		}
319	}
320
321	/* Generate string for BE's root dataset */
322	be_make_root_ds(bt.obe_zpool, bt.obe_name, obe_root_ds,
323	    sizeof (obe_root_ds));
324	bt.obe_root_ds = obe_root_ds;
325
326	if (getzoneid() != GLOBAL_ZONEID) {
327		if (!be_zone_compare_uuids(bt.obe_root_ds)) {
328			be_print_err(gettext("be_rollback: rolling back zone "
329			    "root dataset from non-active global BE is not "
330			    "supported\n"));
331			return (BE_ERR_NOTSUP);
332		}
333	}
334
335	/* Get handle to BE's root dataset */
336	if ((zhp = zfs_open(g_zfs, bt.obe_root_ds, ZFS_TYPE_DATASET)) == NULL) {
337		be_print_err(gettext("be_rollback: "
338		    "failed to open BE root dataset (%s): %s\n"),
339		    bt.obe_root_ds, libzfs_error_description(g_zfs));
340		return (zfs_err_to_be_err(g_zfs));
341	}
342
343	/*
344	 * Check that snapshot name exists for this BE and all of its
345	 * children file systems.  This call will end up closing the
346	 * zfs handle passed in whether it succeeds or fails.
347	 */
348	if ((ret = be_rollback_check_callback(zhp, bt.obe_snap_name)) != 0) {
349		zhp = NULL;
350		return (ret);
351	}
352
353	/* Get handle to BE's root dataset */
354	if ((zhp = zfs_open(g_zfs, bt.obe_root_ds, ZFS_TYPE_DATASET)) == NULL) {
355		be_print_err(gettext("be_rollback: "
356		    "failed to open BE root dataset (%s): %s\n"),
357		    bt.obe_root_ds, libzfs_error_description(g_zfs));
358		return (zfs_err_to_be_err(g_zfs));
359	}
360
361	/*
362	 * Iterate through a BE's datasets and roll them all back to
363	 * the specified snapshot.  This call will end up closing the
364	 * zfs handle passed in whether it succeeds or fails.
365	 */
366	if ((ret = be_rollback_callback(zhp, bt.obe_snap_name)) != 0) {
367		zhp = NULL;
368		be_print_err(gettext("be_rollback: "
369		    "failed to rollback BE %s to %s\n"), bt.obe_name,
370		    bt.obe_snap_name);
371		return (ret);
372	}
373	zhp = NULL;
374	be_zfs_fini();
375	return (BE_SUCCESS);
376}
377
378
379/* ******************************************************************** */
380/*			Semi-Private Functions				*/
381/* ******************************************************************** */
382
383/*
384 * Function:	_be_create_snapshot
385 * Description:	see be_create_snapshot
386 * Parameters:
387 *		be_name - The name of the BE that we're taking a snapshot of.
388 *		snap_name - The name of the snapshot we're creating. If
389 *			snap_name is NULL an auto generated name will be used,
390 *			and upon success, will return that name via this
391 *			reference pointer.  The caller is responsible for
392 *			freeing the returned name.
393 *		policy - The clean-up policy type. (library wide use only)
394 * Return:
395 *		BE_SUCCESS - Success
396 *		be_errno_t - Failure
397 * Scope:
398 *		Semi-private (library wide use only)
399 */
400int
401_be_create_snapshot(char *be_name, char **snap_name, char *policy)
402{
403	be_transaction_data_t	bt = { 0 };
404	zfs_handle_t		*zhp = NULL;
405	nvlist_t		*ss_props = NULL;
406	char			ss[MAXPATHLEN];
407	char			root_ds[MAXPATHLEN];
408	int			pool_version = 0;
409	int			i = 0;
410	int			zret = 0, ret = BE_SUCCESS;
411	boolean_t		autoname = B_FALSE;
412
413	/* Set parameters in bt structure */
414	bt.obe_name = be_name;
415	bt.obe_snap_name = *snap_name;
416	bt.policy = policy;
417
418	/* If original BE name not supplied, use current BE */
419	if (bt.obe_name == NULL) {
420		if ((ret = be_find_current_be(&bt)) != BE_SUCCESS) {
421			return (ret);
422		}
423	}
424
425	/* Find which zpool obe_name lives in */
426	if ((zret = zpool_iter(g_zfs, be_find_zpool_callback, &bt)) == 0) {
427		be_print_err(gettext("be_create_snapshot: failed to "
428		    "find zpool for BE (%s)\n"), bt.obe_name);
429		return (BE_ERR_BE_NOENT);
430	} else if (zret < 0) {
431		be_print_err(gettext("be_create_snapshot: "
432		    "zpool_iter failed: %s\n"),
433		    libzfs_error_description(g_zfs));
434		return (zfs_err_to_be_err(g_zfs));
435	}
436
437	be_make_root_ds(bt.obe_zpool, bt.obe_name, root_ds,
438	    sizeof (root_ds));
439	bt.obe_root_ds = root_ds;
440
441	if (getzoneid() != GLOBAL_ZONEID) {
442		if (!be_zone_compare_uuids(bt.obe_root_ds)) {
443			be_print_err(gettext("be_create_snapshot: creating "
444			    "snapshot for the zone root dataset from "
445			    "non-active global BE is not "
446			    "supported\n"));
447			return (BE_ERR_NOTSUP);
448		}
449	}
450
451	/* If BE policy not specified, use the default policy */
452	if (bt.policy == NULL) {
453		bt.policy = be_default_policy();
454	} else {
455		/* Validate policy type */
456		if (!valid_be_policy(bt.policy)) {
457			be_print_err(gettext("be_create_snapshot: "
458			    "invalid BE policy type (%s)\n"), bt.policy);
459			return (BE_ERR_INVAL);
460		}
461	}
462
463	/*
464	 * If snapshot name not specified, set auto name flag and
465	 * generate auto snapshot name.
466	 */
467	if (bt.obe_snap_name == NULL) {
468		autoname = B_TRUE;
469		if ((bt.obe_snap_name = be_auto_snap_name())
470		    == NULL) {
471			be_print_err(gettext("be_create_snapshot: "
472			    "failed to create auto snapshot name\n"));
473			ret =  BE_ERR_AUTONAME;
474			goto done;
475		}
476	}
477
478	/* Generate the name of the snapshot to take. */
479	(void) snprintf(ss, sizeof (ss), "%s@%s", bt.obe_root_ds,
480	    bt.obe_snap_name);
481
482	/* Get handle to BE's root dataset */
483	if ((zhp = zfs_open(g_zfs, bt.obe_root_ds, ZFS_TYPE_DATASET))
484	    == NULL) {
485		be_print_err(gettext("be_create_snapshot: "
486		    "failed to open BE root dataset (%s): %s\n"),
487		    bt.obe_root_ds, libzfs_error_description(g_zfs));
488		ret = zfs_err_to_be_err(g_zfs);
489		goto done;
490	}
491
492	/* Get the ZFS pool version of the pool where this dataset resides */
493	if (zfs_spa_version(zhp, &pool_version) != 0) {
494		be_print_err(gettext("be_create_snapshot: failed to "
495		    "get ZFS pool version for %s: %s\n"), zfs_get_name(zhp),
496		    libzfs_error_description(g_zfs));
497	}
498
499	/*
500	 * If ZFS pool version supports snapshot user properties, store
501	 * cleanup policy there.  Otherwise don't set one - this snapshot
502	 * will always inherit the cleanup policy from its parent.
503	 */
504	if (getzoneid() == GLOBAL_ZONEID) {
505		if (pool_version >= SPA_VERSION_SNAP_PROPS) {
506			if (nvlist_alloc(&ss_props, NV_UNIQUE_NAME, 0) != 0) {
507				be_print_err(gettext("be_create_snapshot: "
508				    "internal error: out of memory\n"));
509				return (BE_ERR_NOMEM);
510			}
511			if (nvlist_add_string(ss_props, BE_POLICY_PROPERTY,
512			    bt.policy) != 0) {
513				be_print_err(gettext("be_create_snapshot: "
514				    "internal error: out of memory\n"));
515				nvlist_free(ss_props);
516				return (BE_ERR_NOMEM);
517			}
518		} else if (policy != NULL) {
519			/*
520			 * If an explicit cleanup policy was requested
521			 * by the caller and we don't support it, error out.
522			 */
523			be_print_err(gettext("be_create_snapshot: cannot set "
524			    "cleanup policy: ZFS pool version is %d\n"),
525			    pool_version);
526			return (BE_ERR_NOTSUP);
527		}
528	}
529
530	/* Create the snapshots recursively */
531	if (zfs_snapshot(g_zfs, ss, B_TRUE, ss_props) != 0) {
532		if (!autoname || libzfs_errno(g_zfs) != EZFS_EXISTS) {
533			be_print_err(gettext("be_create_snapshot: "
534			    "recursive snapshot of %s failed: %s\n"),
535			    ss, libzfs_error_description(g_zfs));
536
537			if (libzfs_errno(g_zfs) == EZFS_EXISTS)
538				ret = BE_ERR_SS_EXISTS;
539			else
540				ret = zfs_err_to_be_err(g_zfs);
541
542			goto done;
543		} else {
544			for (i = 1; i < BE_AUTO_NAME_MAX_TRY; i++) {
545
546				/* Sleep 1 before retrying */
547				(void) sleep(1);
548
549				/* Generate new auto snapshot name. */
550				free(bt.obe_snap_name);
551				if ((bt.obe_snap_name =
552				    be_auto_snap_name()) == NULL) {
553					be_print_err(gettext(
554					    "be_create_snapshot: failed to "
555					    "create auto snapshot name\n"));
556					ret = BE_ERR_AUTONAME;
557					goto done;
558				}
559
560				/* Generate string of the snapshot to take. */
561				(void) snprintf(ss, sizeof (ss), "%s@%s",
562				    bt.obe_root_ds, bt.obe_snap_name);
563
564				/* Create the snapshots recursively */
565				if (zfs_snapshot(g_zfs, ss, B_TRUE, ss_props)
566				    != 0) {
567					if (libzfs_errno(g_zfs) !=
568					    EZFS_EXISTS) {
569						be_print_err(gettext(
570						    "be_create_snapshot: "
571						    "recursive snapshot of %s "
572						    "failed: %s\n"), ss,
573						    libzfs_error_description(
574						    g_zfs));
575						ret = zfs_err_to_be_err(g_zfs);
576						goto done;
577					}
578				} else {
579					break;
580				}
581			}
582
583			/*
584			 * If we exhausted the maximum number of tries,
585			 * free the auto snap name and set error.
586			 */
587			if (i == BE_AUTO_NAME_MAX_TRY) {
588				be_print_err(gettext("be_create_snapshot: "
589				    "failed to create unique auto snapshot "
590				    "name\n"));
591				free(bt.obe_snap_name);
592				bt.obe_snap_name = NULL;
593				ret = BE_ERR_AUTONAME;
594			}
595		}
596	}
597
598	/*
599	 * If we succeeded in creating an auto named snapshot, store
600	 * the name in the nvlist passed in by the caller.
601	 */
602	if (autoname && bt.obe_snap_name) {
603		*snap_name = bt.obe_snap_name;
604	}
605
606done:
607	ZFS_CLOSE(zhp);
608
609	nvlist_free(ss_props);
610
611	return (ret);
612}
613
614/*
615 * Function:	_be_destroy_snapshot
616 * Description:	see be_destroy_snapshot
617 * Parameters:
618 *		be_name - The name of the BE that the snapshot belongs to.
619 *		snap_name - The name of the snapshot we're destroying.
620 * Return:
621 *		BE_SUCCESS - Success
622 *		be_errno_t - Failure
623 * Scope:
624 *		Semi-private (library wide use only)
625 */
626int
627_be_destroy_snapshot(char *be_name, char *snap_name)
628{
629	be_transaction_data_t	bt = { 0 };
630	zfs_handle_t		*zhp;
631	char			ss[MAXPATHLEN];
632	char			root_ds[MAXPATHLEN];
633	int			err = BE_SUCCESS, ret = BE_SUCCESS;
634
635	/* Make sure we actaully have a snapshot name */
636	if (snap_name == NULL) {
637		be_print_err(gettext("be_destroy_snapshot: "
638		    "invalid snapshot name\n"));
639		return (BE_ERR_INVAL);
640	}
641
642	/* Set parameters in bt structure */
643	bt.obe_name = be_name;
644	bt.obe_snap_name = snap_name;
645
646	/* If original BE name not supplied, use current BE */
647	if (bt.obe_name == NULL) {
648		if ((err = be_find_current_be(&bt)) != BE_SUCCESS) {
649			return (err);
650		}
651	}
652
653	/* Find which zpool be_name lives in */
654	if ((ret = zpool_iter(g_zfs, be_find_zpool_callback, &bt)) == 0) {
655		be_print_err(gettext("be_destroy_snapshot: "
656		    "failed to find zpool for BE (%s)\n"), bt.obe_name);
657		return (BE_ERR_BE_NOENT);
658	} else if (ret < 0) {
659		be_print_err(gettext("be_destroy_snapshot: "
660		    "zpool_iter failed: %s\n"),
661		    libzfs_error_description(g_zfs));
662		return (zfs_err_to_be_err(g_zfs));
663	}
664
665	be_make_root_ds(bt.obe_zpool, bt.obe_name, root_ds,
666	    sizeof (root_ds));
667	bt.obe_root_ds = root_ds;
668
669	zhp = zfs_open(g_zfs, bt.obe_root_ds, ZFS_TYPE_DATASET);
670	if (zhp == NULL) {
671		/*
672		 * The zfs_open failed, return an error.
673		 */
674		be_print_err(gettext("be_destroy_snapshot: "
675		    "failed to open BE root dataset (%s): %s\n"),
676		    bt.obe_root_ds, libzfs_error_description(g_zfs));
677		err = zfs_err_to_be_err(g_zfs);
678	} else {
679		/*
680		 * Generate the name of the snapshot to take.
681		 */
682		(void) snprintf(ss, sizeof (ss), "%s@%s", bt.obe_name,
683		    bt.obe_snap_name);
684
685		/*
686		 * destroy the snapshot.
687		 */
688		/*
689		 * The boolean set to B_FALSE and passed to zfs_destroy_snaps()
690		 * tells zfs to process and destroy the snapshots now.
691		 * Otherwise the call will potentially return where the
692		 * snapshot isn't actually destroyed yet, and ZFS is waiting
693		 * until all the references to the snapshot have been
694		 * released before actually destroying the snapshot.
695		 */
696		if (zfs_destroy_snaps(zhp, bt.obe_snap_name, B_FALSE) != 0) {
697			err = zfs_err_to_be_err(g_zfs);
698			be_print_err(gettext("be_destroy_snapshot: "
699			    "failed to destroy snapshot %s: %s\n"), ss,
700			    libzfs_error_description(g_zfs));
701		}
702	}
703
704	ZFS_CLOSE(zhp);
705
706	return (err);
707}
708
709/* ********************************************************************	*/
710/*			Private Functions				*/
711/* ********************************************************************	*/
712
713/*
714 * Function:	be_rollback_check_callback
715 * Description:	Callback function used to iterate through a BE's filesystems
716 *		to check if a given snapshot name exists.
717 * Parameters:
718 *		zhp - zfs_handle_t pointer to filesystem being processed.
719 *		data - name of the snapshot to check for.
720 * Returns:
721 *		0 - Success, snapshot name exists for all filesystems.
722 *		be_errno_t - Failure, snapshot name does not exist for all
723 *		filesystems.
724 * Scope:
725 *		Private
726 */
727static int
728be_rollback_check_callback(zfs_handle_t *zhp, void *data)
729{
730	char		*snap_name = data;
731	char		ss[MAXPATHLEN];
732	int		ret = BE_SUCCESS;
733
734	/* Generate string for this filesystem's snapshot name */
735	(void) snprintf(ss, sizeof (ss), "%s@%s", zfs_get_name(zhp), snap_name);
736
737	/* Check if snapshot exists */
738	if (!zfs_dataset_exists(g_zfs, ss, ZFS_TYPE_SNAPSHOT)) {
739		be_print_err(gettext("be_rollback_check_callback: "
740		    "snapshot does not exist %s\n"), ss);
741		ZFS_CLOSE(zhp);
742		return (BE_ERR_SS_NOENT);
743	}
744
745	/* Iterate this dataset's children and check them */
746	if ((ret = zfs_iter_filesystems(zhp, be_rollback_check_callback,
747	    snap_name)) != 0) {
748		ZFS_CLOSE(zhp);
749		return (ret);
750	}
751
752	ZFS_CLOSE(zhp);
753	return (0);
754}
755
756/*
757 * Function:	be_rollback_callback
758 * Description:	Callback function used to iterate through a BE's filesystems
759 *		and roll them all back to the specified snapshot name.
760 * Parameters:
761 *		zhp - zfs_handle_t pointer to filesystem being processed.
762 *		data - name of snapshot to rollback to.
763 * Returns:
764 *		0 - Success
765 *		be_errno_t - Failure
766 * Scope:
767 *		Private
768 */
769static int
770be_rollback_callback(zfs_handle_t *zhp, void *data)
771{
772	zfs_handle_t	*zhp_snap = NULL;
773	char		*snap_name = data;
774	char		ss[MAXPATHLEN];
775	int		ret = 0;
776
777	/* Generate string for this filesystem's snapshot name */
778	(void) snprintf(ss, sizeof (ss), "%s@%s", zfs_get_name(zhp), snap_name);
779
780	/* Get handle to this filesystem's snapshot */
781	if ((zhp_snap = zfs_open(g_zfs, ss, ZFS_TYPE_SNAPSHOT)) == NULL) {
782		be_print_err(gettext("be_rollback_callback: "
783		    "failed to open snapshot %s: %s\n"), zfs_get_name(zhp),
784		    libzfs_error_description(g_zfs));
785		ret = zfs_err_to_be_err(g_zfs);
786		ZFS_CLOSE(zhp);
787		return (ret);
788	}
789
790	/* Rollback dataset */
791	if (zfs_rollback(zhp, zhp_snap, B_FALSE) != 0) {
792		be_print_err(gettext("be_rollback_callback: "
793		    "failed to rollback BE dataset %s to snapshot %s: %s\n"),
794		    zfs_get_name(zhp), ss, libzfs_error_description(g_zfs));
795		ret = zfs_err_to_be_err(g_zfs);
796		ZFS_CLOSE(zhp_snap);
797		ZFS_CLOSE(zhp);
798		return (ret);
799	}
800
801	ZFS_CLOSE(zhp_snap);
802	/* Iterate this dataset's children and roll them back */
803	if ((ret = zfs_iter_filesystems(zhp, be_rollback_callback,
804	    snap_name)) != 0) {
805		ZFS_CLOSE(zhp);
806		return (ret);
807	}
808
809	ZFS_CLOSE(zhp);
810	return (0);
811}
812