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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
23 #
24
25 #
26 # get script name (bname)
27 #
28 bname=`basename $0`
29
30 #
31 # common shell script functions
32 #
33 . /usr/lib/brand/shared/common.ksh
34
35 #
36 # error messages
37 #
38 m_usage=$(gettext "Usage: %s: [-hFn]")
39
40 m_1_zfs_promote=$(gettext "promoting '%s'.")
41 m_1_zfs_destroy=$(gettext "destroying '%s'.")
42 m_2_zfs_rename=$(gettext "renaming '%s' to '%s'.")
43 m_3_zfs_set=$(gettext "setting property %s='%s' for '%s'.")
44 m_rm_r=$(gettext "recursively deleting '%s'.")
45 m_rm=$(gettext "deleting '%s'.")
46
47 w_no_ds=$(gettext "Warning: no zonepath dataset found.")
48
49 f_usage_err=$(gettext "Error: invalid usage")
50 f_abort=$(gettext "Error: internal error detected, aborting.")
51 f_1_zfs_promote=$(gettext "Error: promoting ZFS dataset '%s'.")
52 f_2_zfs_rename=$(gettext "Error: renaming ZFS dataset '%s' to '%s'.")
53 f_3_zfs_set=$(gettext "Error: setting ZFS propery %s='%s' for '%s'.")
54 f_1_zfs_destroy=$(gettext "Error: destroying ZFS dataset.")
55 f_2_zfs_get=$(gettext "Error: reading ZFS dataset property '%s' from '%s'.")
56 f_user_snap=$(gettext "Error: user snapshot(s) detected.")
57 f_stray_snap=$(gettext "Error: uncloned snapshot(s) detected.")
58 f_stray_clone=$(gettext "Error: cloned zone datasets found outsize of zone.")
59 f_rm_snap=$(gettext "Error: please delete snapshot(s) and retry uninstall.")
60 f_rm_clone=$(gettext "Error: please delete clone(s) and retry uninstall.")
61 f_iu_clone=$(gettext "Error: cloned zone dataset(s) in use.")
62 f_dis_clone=$(gettext "Error: please stop using clone(s) and retry uninstall.")
63
64 #
65 # functions
66 #
67 print_array()
68 {
69 typeset -n pa_array=$1
70
71 (( pa_i = 0 ))
72 while (( $pa_i < ${#pa_array[@]} )); do
73 printf "\t${pa_array[$pa_i]}\n"
74 (( pa_i = $pa_i + 1 ))
75 done
76 }
77
78 usage()
79 {
80 printf "$m_usage\n" "$bname"
81 exit $ZONE_SUBPROC_USAGE
82 }
83
84 usage_err()
85 {
86 printf "$f_usage_err\n" >&2
87 usage >&2
88 }
89
90 rm_zonepath()
91 {
92 # cleanup stuff we know about and leave any user data alone
93
94 [[ -z "$opt_n" ]] && [[ -n "$opt_v" ]] &&
95 printf "$m_rm\n" "$zonepath/SUNWattached.xml"
96 $nop /bin/rm -f "$zonepath/SUNWattached.xml"
97
98 [[ -z "$opt_n" ]] && [[ -n "$opt_v" ]] &&
99 printf "$m_rm_r\n" "$zonepath/lu"
100 $nop /bin/rm -rf "$zonepath/lu"
101
102 [[ -z "$opt_n" ]] && [[ -n "$opt_v" ]] &&
103 printf "$m_rm_r\n" "$zonepath/dev"
104 $nop /bin/rm -rf "$zonepath/dev"
105
106 [[ -z "$opt_n" ]] && [[ -n "$opt_v" ]] &&
107 printf "$m_rm_r\n" "$zonepath/root"
108 $nop /bin/rm -rf "$zonepath/root"
109
110 [[ -z "$opt_n" ]] && [[ -n "$opt_v" ]] &&
111 printf "$m_rm\n" "$zonepath"
112 $nop /bin/rmdir "$zonepath" 2>/dev/null
113 }
114
115 zfs_destroy()
116 {
117 zd_fs1="$1"
118
119 # first figure out if the target fs has an origin snapshot
120 zd_origin=`/sbin/zfs get -H -o value origin "$zd_fs1"`
121 if [[ $? != 0 ]]; then
122 printf "$f_2_zfs_get\n" origin "$zd_fs1" >&2
123 exit $ZONE_SUBPROC_FATAL
124 fi
125
126 [[ -z "$opt_n" ]] && [[ -n "$opt_v" ]] &&
127 printf "$m_1_zfs_destroy\n" "$zd_fs1"
128
129 #
130 # note that we specify the '-r' flag so that we destroy any
131 # descendants (filesystems and snapshot) of the specified
132 # filesystem.
133 #
134 $nop /sbin/zfs destroy -r "$zd_fs1"
135 if [[ $? != 0 ]]; then
136 printf "$f_1_zfs_destroy\n" "$zd_fs1" >&2
137 exit $ZONE_SUBPROC_FATAL
138 fi
139
140 [[ "$zd_origin" == "-" ]] && return
141
142 [[ -z "$opt_n" ]] && [[ -n "$opt_v" ]] &&
143 printf "$m_1_zfs_destroy\n" "$zd_origin"
144
145 $nop /sbin/zfs destroy "$zd_origin" 2>/dev/null
146 #
147 # we ignore errors while trying to destroy the origin since
148 # the origin could have been used as the source for other
149 # clones
150 #
151 }
152
153 zfs_promote()
154 {
155 zp_fs1="$1"
156
157 [[ -z "$opt_n" ]] &&
158 printf "$m_1_zfs_promote\n" "$zp_fs1"
159
160 $nop /sbin/zfs promote "$zp_fs1"
161 if [[ $? != 0 ]]; then
162 printf "$f_1_zfs_promote\n" "$zp_fs1" >&2
163 exit $ZONE_SUBPROC_FATAL
164 fi
165 }
166
167 zfs_rename()
168 {
169 zr_fs1="$1"
170 zr_fs2="$2"
171
172 [[ -z "$opt_n" ]] &&
173 printf "$m_2_zfs_rename\n" "$zr_fs1" "$zr_fs2"
174
175 $nop /sbin/zfs rename "$zr_fs1" "$zr_fs2"
176 if [[ $? != 0 ]]; then
177 printf "$f_2_zfs_rename\n" "$zr_fs1" "$zr_fs2" >&2
178 return 1
179 fi
180 return 0
181 }
182
183 zfs_set()
184 {
185 zs_prop=$1
186 zs_value=$2
187 zs_fs1=$3
188
189 [[ -z "$opt_n" ]] && [[ -n "$opt_v" ]] &&
190 printf "$m_3_zfs_set\n" "$zs_prop" "$zs_value" "$zs_fs1"
191
192 $nop /sbin/zfs set "$zs_prop"="$zs_value" "$zs_fs1"
193 if [[ $? != 0 ]]; then
194 printf "$f_3_zfs_set\n" "$zs_prop" "$zs_value" "$zs_fs1"
195 return 1
196 fi
197 return 0
198 }
199
200 zfs_set_array()
201 {
202 zsa_prop=$1
203 zsa_value=$2
204 typeset -n zsa_array=$3
205 zsa_ignore_errors=$4
206
207 (( zsa_i = 0 ))
208 while (( $zsa_i < ${#zsa_array[@]} )); do
209 zfs_set "$zsa_prop" "$zsa_value" "${zsa_array[$zsa_i]}"
210 [[ $? != 0 ]] && [[ -z "$zsa_ignore_errors" ]] &&
211 return 1
212 (( zsa_i = $zsa_i + 1 ))
213 done
214 return 0
215 }
216
217
218 (( snap_rename_zbe_i = 1 ))
219 (( snap_rename_snap_i = 1 ))
220 snap_rename_init()
221 {
222 (( snap_rename_zbe_i = 1 ))
223 (( snap_rename_snap_i = 1 ))
224 }
225
226 snap_rename()
227 {
228 eval sr_fs=\${$1}
229 eval sr_snap=\${$2}
230
231 if [[ "$sr_snap" == ~(Elr)(zbe-[0-9][0-9]*) ]]; then
232 sr_snap="zbe-$snap_rename_zbe_i"
233 (( snap_rename_zbe_i = $snap_rename_zbe_i + 1 ))
234 elif [[ "$sr_snap" == ~(Er)(_snap[0-9]*) ]]; then
235 sr_snap=${sr_snap##~(Er)([0-9]*)}
236 sr_snap="${sr_snap}${snap_rename_snap_i}"
237 (( snap_rename_snap_i = $snap_rename_snap_i + 1 ))
238 else
239 printf "$f_user_snap\n" >&2
240 printf "\t$sr_fs@$sr_snap\n" >&2
241 printf "$f_rm_snap\n" >&2
242 exit $ZONE_SUBPROC_FATAL
243 fi
244
245 eval $2="$sr_snap"
246 }
247
248 # find the dataset associated with $zonepath
249 uninstall_get_zonepath_ds()
250 {
251 ZONEPATH_DS=`/sbin/zfs list -t filesystem -o name,mountpoint | \
252 /bin/nawk -v zonepath=$zonepath '{
253 if ($2 == zonepath)
254 print $1
255 }'`
256
257 if [ -z "$ZONEPATH_DS" ]; then
258 # there is no $zonepath dataset
259 rm_zonepath
260 exit $ZONE_SUBPROC_OK
261 fi
262 }
263
264 # find the dataset associated with $ZONEPATH_DS/ROOT
265 uninstall_get_zonepath_root_ds()
266 {
267 ZONEPATH_RDS=`/sbin/zfs list -H -t filesystem -o name \
268 $ZONEPATH_DS/ROOT 2>/dev/null`
269
270 if [ -z "$ZONEPATH_RDS" ]; then
271 # there is no $ZONEPATH_DS/ROOT dataset
272 c=`/sbin/zfs list -H -t filesystem -r $ZONEPATH_DS | wc -l`
273 if [ $c = 1 ]; then
274 # $zonepath dataset has no descendents
275 zfs_destroy "$ZONEPATH_DS"
276 fi
277 rm_zonepath
278 exit $ZONE_SUBPROC_OK
279 fi
280 }
281
282 destroy_zone_dataset()
283 {
284 fs=$1
285
286 pool=${fs%%/*}
287
288 # Fastpath. if there are no snapshots of $fs then just delete it.
289 c=`/sbin/zfs list -H -t snapshot -o name -r $fs | grep "^$fs@" |
290 LC_ALL=C LANG=C wc -l`
291 if (( $c == 0 )) ; then
292 zfs_destroy "$fs"
293 return
294 fi
295
296 #
297 # This zone BE has snapshots. This can happen if a zone has
298 # multiple BEs (in which case we have snapshots named "zbe-XXX"),
299 # if this zone has been used as the source for a clone of
300 # another zone (in which case we have snapshots named
301 # "XXX_snap"), or if an administrator has been doing manual
302 # snapshotting.
303 #
304 # To be able to destroy this dataset (which we'll call the
305 # origin) we need to get rid of all it's snapshots. The "easiest"
306 # way to do this is to:
307 #
308 # - delete any uncloned origin snapshots
309 # - find the oldest clone of the youngest origin snapshot (which
310 # we'll call the oldest clone)
311 # - check if there are any snapshots naming conflicts between
312 # the origin and the oldest clone.
313 # - if so, find any clones of those conflicting origin snapshots
314 # - make sure that those clones are not zoned an in-use.
315 # - if any of those clones are zoned, unzone them.
316 # - rename origin snapshots to eliminate naming conflicts
317 # - for any clones that we unzoned, rezone them.
318 # - promote the oldest clone
319 # - destroy the origin and all it's descendants
320 #
321
322 #
323 # Get a list of all the cloned datasets within the zpool
324 # containing the origin filesystem. Filter out any filesystems
325 # that are descendants of origin because we are planning to
326 # destroy them anyway.
327 #
328 unset clones clones_origin
329 (( clones_c = 0 ))
330 pool=${fs%%/*}
331 LANG=C LC_ALL=C /sbin/zfs list -H -t filesystem -s creation \
332 -o name,origin -r "$pool" |
333 while IFS=" " read name origin; do
334
335 # skip non-clone filesystems
336 [[ "$origin" == "-" ]] &&
337 continue
338
339 # skip desendents of the origin we plan to destroy
340 [[ "$name" == ~()(${fs}/*) ]] &&
341 continue
342
343 # record this clone and it's origin
344 clones[$clones_c]="$name"
345 clones_origin[$clones_c]="$origin"
346 (( clones_c = $clones_c + 1 ))
347 done
348
349 #
350 # Now do a sanity check. Search for clones of a child datasets
351 # of the dataset we want to destroy, that are not themselves
352 # children of the dataset we're going to destroy). This should
353 # really never happen unless the global zone admin has cloned a
354 # snapshot of a zone filesystem to a location outside of that
355 # zone. bad admin...
356 #
357 unset stray_clones
358 (( stray_clones_c = 0 ))
359 (( j = 0 ))
360 while (( $j < $clones_c )); do
361 # is the clone origin a descendant of $fs?
362 if [[ "${clones_origin[$j]}" != ~()(${fs}/*) ]]; then
363 # we don't care.
364 (( j = $j + 1 ))
365 continue
366 fi
367 stray_clones[$stray_clones_c]=${clones[$j]}
368 (( stray_clones_c = $stray_clones_c + 1 ))
369 (( j = $j + 1 ))
370 done
371 if (( stray_clones_c > 0 )); then
372 #
373 # sigh. the admin has done something strange.
374 # tell them to clean it up and retry.
375 #
376 printf "$f_stray_clone\n" >&2
377 print_array stray_clones >&2
378 printf "$f_rm_clone\n" >&2
379 exit $ZONE_SUBPROC_FATAL
380 fi
381
382 # Find all the snapshots of the origin filesystem.
383 unset s_origin
384 (( s_origin_c = 0 ))
385 /sbin/zfs list -H -t snapshot -s creation -o name -r $fs |
386 grep "^$fs@" | while read name; do
387 s_origin[$s_origin_c]=$name
388 (( s_origin_c = $s_origin_c + 1 ))
389 done
390
391 #
392 # Now go through the origin snapshots and find those which don't
393 # have clones. We're going to explicity delete these snapshots
394 # before we do the promotion.
395 #
396 unset s_delete
397 (( s_delete_c = 0 ))
398 (( j = 0 ))
399 while (( $j < $s_origin_c )); do
400 (( k = 0 ))
401 while (( $k < $clones_c )); do
402 # if we have a match then break out of this loop
403 [[ "${s_origin[$j]}" == "${clones_origin[$k]}" ]] &&
404 break
405 (( k = $k + 1 ))
406 done
407 if (( $k != $clones_c )); then
408 # this snapshot has a clone, move on to the next one
409 (( j = $j + 1 ))
410 continue
411 fi
412
413 # snapshot has no clones so add it to our delete list
414 s_delete[$s_delete_c]=${s_origin[$j]}
415 (( s_delete_c = $s_delete_c + 1 ))
416 # remove it from the origin snapshot list
417 (( k = $j + 1 ))
418 while (( $k < $s_origin_c )); do
419 s_origin[(( $k - 1 ))]=${s_origin[$k]}
420 (( k = $k + 1 ))
421 done
422 (( s_origin_c = $s_origin_c - 1 ))
423 done
424
425 #
426 # Fastpath. If there are no remaining snapshots then just
427 # delete the origin filesystem (and all it's descendents) and
428 # move onto the next zone BE.
429 #
430 if (( $s_origin_c == 0 )); then
431 zfs_destroy "$fs"
432 return
433 fi
434
435 # find the youngest snapshot of $fs
436 s_youngest=${s_origin[(( $s_origin_c - 1 ))]}
437
438 # Find the oldest clone of the youngest snapshot of $fs
439 unset s_clone
440 (( j = $clones_c - 1 ))
441 while (( $j >= 0 )); do
442 if [[ "$s_youngest" == "${clones_origin[$j]}" ]]; then
443 s_clone=${clones[$j]}
444 break
445 fi
446 (( j = $j - 1 ))
447 done
448 if [[ -z "$s_clone" ]]; then
449 # uh oh. something has gone wrong. bail.
450 printf "$f_stray_snap\n" >&2
451 printf "\t$s_youngest\n" >&2
452 printf "$f_rm_snap\n" >&2
453 exit $ZONE_SUBPROC_FATAL
454 fi
455
456 # create an array of clone snapshot names
457 unset s_clone_s
458 (( s_clone_s_c = 0 ))
459 /sbin/zfs list -H -t snapshot -s creation -o name -r $s_clone |
460 grep "^$s_clone@" | while read name; do
461 s_clone_s[$s_clone_s_c]=${name##*@}
462 (( s_clone_s_c = $s_clone_s_c + 1 ))
463 done
464
465 # create an arrays of possible origin snapshot renames
466 unset s_origin_snap
467 unset s_rename
468 (( j = 0 ))
469 while (( $j < $s_origin_c )); do
470 s_origin_snap[$j]=${s_origin[$j]##*@}
471 s_rename[$j]=${s_origin[$j]##*@}
472 (( j = $j + 1 ))
473 done
474
475 #
476 # Search for snapshot name collisions between the origin and
477 # oldest clone. If we find one, generate a new name for the
478 # origin snapshot and re-do the collision check.
479 #
480 snap_rename_init
481 (( j = 0 ))
482 while (( $j < $s_origin_c )); do
483 (( k = 0 ))
484 while (( $k < $s_clone_s_c )); do
485
486 # if there's no naming conflict continue
487 if [[ "${s_rename[$j]}" != "${s_clone_s[$k]}" ]]; then
488 (( k = $k + 1 ))
489 continue
490 fi
491
492 #
493 # The origin snapshot conflicts with a clone
494 # snapshot. Choose a new name and then restart
495 # then check that against clone snapshot names.
496 #
497 snap_rename fs "s_rename[$j]"
498 (( k = 0 ))
499 continue;
500 done
501
502 # if we didn't rename this snapshot then continue
503 if [[ "${s_rename[$j]}" == "${s_origin_snap[$j]}" ]]; then
504 (( j = $j + 1 ))
505 continue
506 fi
507
508 #
509 # We need to rename this origin snapshot because it
510 # conflicts with a clone snapshot name. So above we
511 # chose a name that didn't conflict with any other clone
512 # snapshot names. But we also have to avoid naming
513 # conflicts with any other origin snapshot names. So
514 # check for that now.
515 #
516 (( k = 0 ))
517 while (( $k < $s_origin_c )); do
518
519 # don't compare against ourself
520 if (( $j == $k )); then
521 (( k = $k + 1 ))
522 continue
523 fi
524
525 # if there's no naming conflict continue
526 if [[ "${s_rename[$j]}" != "${s_rename[$k]}" ]]; then
527 (( k = $k + 1 ))
528 continue
529 fi
530
531 #
532 # The new origin snapshot name conflicts with
533 # another origin snapshot name. Choose a new
534 # name and then go back to check the new name
535 # for uniqueness against all the clone snapshot
536 # names.
537 #
538 snap_rename fs "s_rename[$j]"
539 continue 2;
540 done
541
542 #
543 # A new unique name has been chosen. Move on to the
544 # next origin snapshot.
545 #
546 (( j = $j + 1 ))
547 snap_rename_init
548 done
549
550 #
551 # So now we know what snapshots need to be renamed before the
552 # promotion. But there's an additional problem. If any of the
553 # filesystems cloned from these snapshots have the "zoned"
554 # attribute set (which is highly likely) or if they are in use
555 # (and can't be unmounted and re-mounted) then the snapshot
556 # rename will fail. So now we'll search for all the clones of
557 # snapshots we plan to rename and look for ones that are zoned.
558 #
559 # We'll ignore any snapshot clones that may be in use but are
560 # not zoned. If these clones are in-use, the rename will fail
561 # and we'll abort, there's not much else we can do about it.
562 # But if they are not in use the snapshot rename will unmount
563 # and remount the clone. This is ok because when the zoned
564 # attribute is off, we know that the clone was originally
565 # mounted from the global zone. (So unmounting and remounting
566 # it from the global zone is ok.)
567 #
568 # But we'll abort this whole operation if we find any clones
569 # that that are zoned and in use. (This can happen if another
570 # zone has been cloned from this one and is now booted.) The
571 # reason we do this is because those zoned filesystems could
572 # have originally mounted from within the zone. So if we
573 # cleared the zone attribute and did the rename, we'd be
574 # remounting the filesystem from the global zone. This would
575 # result in the zone losing the ability to unmount the
576 # filesystem, which would be bad.
577 #
578 unset zoned_clones zoned_iu_clones
579 (( zoned_clones_c = 0 ))
580 (( zoned_iu_clones_c = 0 ))
581 (( j = 0 ))
582 # walk through all the clones
583 while (( $j < $clones_c )); do
584 # walk through all the origin snapshots
585 (( k = 0 ))
586 while (( $k < $s_origin_c )); do
587 #
588 # check if this clone originated from a snapshot that
589 # we need to rename.
590 #
591 [[ "${clones_origin[$j]}" == "${s_origin[$k]}" ]] &&
592 [[ "${s_origin_snap[$k]}" != "${s_rename[$k]}" ]] &&
593 break
594 (( k = $k + 1 ))
595 continue
596 done
597 if (( $k == $s_origin_c )); then
598 # This isn't a clone of a snapshot we want to rename.
599 (( j = $j + 1 ))
600 continue;
601 fi
602
603 # get the zoned attr for this clone.
604 zoned=`LC_ALL=C LANG=C \
605 /sbin/zfs get -H -o value zoned ${clones[$j]}`
606 if [[ "$zoned" != on ]]; then
607 # This clone isn't zoned so ignore it.
608 (( j = $j + 1 ))
609 continue
610 fi
611
612 # remember this clone so we can muck with it's zoned attr.
613 zoned_clones[$zoned_clones_c]=${clones[$j]}
614 (( zoned_clones_c = $zoned_clones_c + 1 ))
615
616 # check if it's in use
617 mounted=`LC_ALL=C LANG=C \
618 /sbin/zfs get -H -o value mounted ${clones[$j]}`
619 if [[ "$mounted" != yes ]]; then
620 # Good news. This clone isn't in use.
621 (( j = $j + 1 ))
622 continue
623 fi
624
625 # Sigh. This clone is in use so we're destined to fail.
626 zoned_iu_clones[$zoned_iu_clones_c]=${clones[$j]}
627 (( zoned_iu_clones_c = $zoned_iu_clones_c + 1 ))
628
629 # keep looking for errors so we can report them all at once.
630 (( j = $j + 1 ))
631 done
632 if (( zoned_iu_clones_c > 0 )); then
633 #
634 # Tell the admin
635 #
636 printf "$f_iu_clone\n" >&2
637 print_array zoned_iu_clones >&2
638 printf "$f_dis_clone\n" >&2
639 exit $ZONE_SUBPROC_FATAL
640 fi
641
642 #
643 # Ok. So we're finally done with planning and we can do some
644 # damage. We're going to:
645 # - destroy unused snapshots
646 # - unzone clones which originate from snapshots we need to rename
647 # - rename conflicting snapshots
648 # - rezone any clones which we unzoned
649 # - promote the oldest clone of the youngest snapshot
650 # - finally destroy the origin filesystem.
651 #
652
653 # delete any unsed snapshot
654 (( j = 0 ))
655 while (( $j < $s_delete_c )); do
656 zfs_destroy "${s_delete[$j]}"
657 (( j = $j + 1 ))
658 done
659
660 # unzone clones
661 zfs_set_array zoned off zoned_clones ||
662 zfs_set_array zoned on zoned_clones 1
663
664 # rename conflicting snapshots
665 (( j = 0 ))
666 while (( $j < $s_origin_c )); do
667 if [[ "${s_origin_snap[$j]}" != "${s_rename[$j]}" ]]; then
668 zfs_rename "${s_origin[$j]}" "$fs@${s_rename[$j]}"
669 if [[ $? != 0 ]]; then
670 # re-zone the clones before aborting
671 zfs_set_array zoned on zoned_clones 1
672 exit $ZONE_SUBPROC_FATAL
673 fi
674 fi
675 (( j = $j + 1 ))
676 done
677
678 # re-zone the clones
679 zfs_set_array zoned on zoned_clones 1
680
681 # promote the youngest clone of the oldest snapshot
682 zfs_promote "$s_clone"
683
684 # destroy the origin filesystem and it's descendants
685 zfs_destroy "$fs"
686 }
687
688 #
689 # This function expects an array named fs_all to exist which is initialized
690 # with the zone's ZFS datasets that should be destroyed. fs_all_c is the
691 # count of the number of elements in the array. ZONEPATH_RDS is the
692 # zonepath/root dataset and ZONEPATH_DS is the zonepath dataset.
693 #
694 destroy_zone_datasets()
695 {
696 # Destroy the zone BEs datasets one by one.
697 (( i = 0 ))
698 while (( $i < $fs_all_c )); do
699 fs=${fs_all[$i]}
700
701 destroy_zone_dataset "$fs"
702 (( i = $i + 1 ))
703 done
704
705 #
706 # Check if there are any other datasets left. There may be datasets
707 # associated with other GZ BEs, so we need to leave things alone in
708 # that case.
709 #
710 c=`/sbin/zfs list -H -t filesystem -r $ZONEPATH_RDS | wc -l`
711 if [ $c = 1 ]; then
712 zfs_destroy "$ZONEPATH_RDS"
713 fi
714 c=`/sbin/zfs list -H -t filesystem -r $ZONEPATH_DS | wc -l`
715 if [ $c = 1 ]; then
716 zfs_destroy "$ZONEPATH_DS"
717 fi
718
719 rm_zonepath
720 }