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.
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.
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]
23 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
25 * Copyright (c) 2015, 2017 by Delphix. All rights reserved.
26 * Copyright 2016 Joyent, Inc.
27 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
37 #include <sys/types.h>
47 #include <sys/zfs_ioctl.h>
49 #include "libzfs_impl.h"
51 #define ZDIFF_SNAPDIR "/.zfs/snapshot/"
52 #define ZDIFF_SHARESDIR "/.zfs/shares/"
53 #define ZDIFF_PREFIX "zfs-diff-%d"
55 #define ZDIFF_ADDED '+'
56 #define ZDIFF_MODIFIED 'M'
57 #define ZDIFF_REMOVED '-'
58 #define ZDIFF_RENAMED 'R'
60 typedef struct differ_info
{
73 boolean_t timestamped
;
82 * Given a {dsname, object id}, get the object path
85 get_stats_for_obj(differ_info_t
*di
, const char *dsname
, uint64_t obj
,
86 char *pn
, int maxlen
, zfs_stat_t
*sb
)
91 (void) strlcpy(zc
.zc_name
, dsname
, sizeof (zc
.zc_name
));
95 error
= ioctl(di
->zhp
->zfs_hdl
->libzfs_fd
, ZFS_IOC_OBJ_TO_STATS
, &zc
);
98 /* we can get stats even if we failed to get a path */
99 (void) memcpy(sb
, &zc
.zc_stat
, sizeof (zfs_stat_t
));
101 ASSERT(di
->zerr
== 0);
102 (void) strlcpy(pn
, zc
.zc_value
, maxlen
);
106 if (di
->zerr
== ESTALE
) {
107 (void) snprintf(pn
, maxlen
, "(on_delete_queue)");
109 } else if (di
->zerr
== EPERM
) {
110 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
111 dgettext(TEXT_DOMAIN
,
112 "The sys_config privilege or diff delegated permission "
113 "is needed\nto discover path names"));
116 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
117 dgettext(TEXT_DOMAIN
,
118 "Unable to determine path or stats for "
119 "object %lld in %s"), obj
, dsname
);
127 * Prints a file name out a character at a time. If the character is
128 * not in the range of what we consider "printable" ASCII, display it
129 * as an escaped 3-digit octal value. ASCII values less than a space
130 * are all control characters and we declare the upper end as the
131 * DELete character. This also is the last 7-bit ASCII character.
132 * We choose to treat all 8-bit ASCII as not printable for this
136 stream_bytes(FILE *fp
, const char *string
)
140 while ((c
= *string
++) != '\0') {
141 if (c
> ' ' && c
!= '\\' && c
< '\177') {
142 (void) fprintf(fp
, "%c", c
);
144 (void) fprintf(fp
, "\\%03o", (uint8_t)c
);
150 print_what(FILE *fp
, mode_t what
)
154 switch (what
& S_IFMT
) {
186 (void) fprintf(fp
, "%c", symbol
);
190 print_cmn(FILE *fp
, differ_info_t
*di
, const char *file
)
192 stream_bytes(fp
, di
->dsmnt
);
193 stream_bytes(fp
, file
);
197 print_rename(FILE *fp
, differ_info_t
*di
, const char *old
, const char *new,
201 (void) fprintf(fp
, "%10lld.%09lld\t",
202 (longlong_t
)isb
->zs_ctime
[0],
203 (longlong_t
)isb
->zs_ctime
[1]);
204 (void) fprintf(fp
, "%c\t", ZDIFF_RENAMED
);
206 print_what(fp
, isb
->zs_mode
);
207 (void) fprintf(fp
, "\t");
209 print_cmn(fp
, di
, old
);
211 (void) fprintf(fp
, "\t");
213 (void) fprintf(fp
, " -> ");
214 print_cmn(fp
, di
, new);
215 (void) fprintf(fp
, "\n");
219 print_link_change(FILE *fp
, differ_info_t
*di
, int delta
, const char *file
,
223 (void) fprintf(fp
, "%10lld.%09lld\t",
224 (longlong_t
)isb
->zs_ctime
[0],
225 (longlong_t
)isb
->zs_ctime
[1]);
226 (void) fprintf(fp
, "%c\t", ZDIFF_MODIFIED
);
228 print_what(fp
, isb
->zs_mode
);
229 (void) fprintf(fp
, "\t");
231 print_cmn(fp
, di
, file
);
232 (void) fprintf(fp
, "\t(%+d)", delta
);
233 (void) fprintf(fp
, "\n");
237 print_file(FILE *fp
, differ_info_t
*di
, char type
, const char *file
,
241 (void) fprintf(fp
, "%10lld.%09lld\t",
242 (longlong_t
)isb
->zs_ctime
[0],
243 (longlong_t
)isb
->zs_ctime
[1]);
244 (void) fprintf(fp
, "%c\t", type
);
246 print_what(fp
, isb
->zs_mode
);
247 (void) fprintf(fp
, "\t");
249 print_cmn(fp
, di
, file
);
250 (void) fprintf(fp
, "\n");
254 write_inuse_diffs_one(FILE *fp
, differ_info_t
*di
, uint64_t dobj
)
256 struct zfs_stat fsb
, tsb
;
258 char fobjname
[MAXPATHLEN
], tobjname
[MAXPATHLEN
];
259 int fobjerr
, tobjerr
;
262 if (dobj
== di
->shares
)
266 * Check the from and to snapshots for info on the object. If
267 * we get ENOENT, then the object just didn't exist in that
268 * snapshot. If we get ENOTSUP, then we tried to get
269 * info on a non-ZPL object, which we don't care about anyway.
271 fobjerr
= get_stats_for_obj(di
, di
->fromsnap
, dobj
, fobjname
,
273 if (fobjerr
&& di
->zerr
!= ENOENT
&& di
->zerr
!= ENOTSUP
)
276 tobjerr
= get_stats_for_obj(di
, di
->tosnap
, dobj
, tobjname
,
278 if (tobjerr
&& di
->zerr
!= ENOENT
&& di
->zerr
!= ENOTSUP
)
282 * Unallocated object sharing the same meta dnode block
284 if (fobjerr
&& tobjerr
) {
285 ASSERT(di
->zerr
== ENOENT
|| di
->zerr
== ENOTSUP
);
290 di
->zerr
= 0; /* negate get_stats_for_obj() from side that failed */
291 fmode
= fsb
.zs_mode
& S_IFMT
;
292 tmode
= tsb
.zs_mode
& S_IFMT
;
293 if (fmode
== S_IFDIR
|| tmode
== S_IFDIR
|| fsb
.zs_links
== 0 ||
297 change
= tsb
.zs_links
- fsb
.zs_links
;
301 print_link_change(fp
, di
, change
, tobjname
, &tsb
);
304 print_file(fp
, di
, ZDIFF_ADDED
, tobjname
, &tsb
);
306 } else if (tobjerr
) {
308 print_link_change(fp
, di
, change
, fobjname
, &fsb
);
311 print_file(fp
, di
, ZDIFF_REMOVED
, fobjname
, &fsb
);
315 if (fmode
!= tmode
&& fsb
.zs_gen
== tsb
.zs_gen
)
316 tsb
.zs_gen
++; /* Force a generational difference */
318 /* Simple modification or no change */
319 if (fsb
.zs_gen
== tsb
.zs_gen
) {
320 /* No apparent changes. Could we assert !this? */
321 if (fsb
.zs_ctime
[0] == tsb
.zs_ctime
[0] &&
322 fsb
.zs_ctime
[1] == tsb
.zs_ctime
[1])
325 print_link_change(fp
, di
, change
,
326 change
> 0 ? fobjname
: tobjname
, &tsb
);
327 } else if (strcmp(fobjname
, tobjname
) == 0) {
328 print_file(fp
, di
, ZDIFF_MODIFIED
, fobjname
, &tsb
);
330 print_rename(fp
, di
, fobjname
, tobjname
, &tsb
);
334 /* file re-created or object re-used */
335 print_file(fp
, di
, ZDIFF_REMOVED
, fobjname
, &fsb
);
336 print_file(fp
, di
, ZDIFF_ADDED
, tobjname
, &tsb
);
342 write_inuse_diffs(FILE *fp
, differ_info_t
*di
, dmu_diff_record_t
*dr
)
347 for (o
= dr
->ddr_first
; o
<= dr
->ddr_last
; o
++) {
348 if ((err
= write_inuse_diffs_one(fp
, di
, o
)) != 0)
355 describe_free(FILE *fp
, differ_info_t
*di
, uint64_t object
, char *namebuf
,
360 if (get_stats_for_obj(di
, di
->fromsnap
, object
, namebuf
,
362 /* Let it slide, if in the delete queue on from side */
363 if (di
->zerr
== ENOENT
&& sb
.zs_links
== 0) {
370 print_file(fp
, di
, ZDIFF_REMOVED
, namebuf
, &sb
);
375 write_free_diffs(FILE *fp
, differ_info_t
*di
, dmu_diff_record_t
*dr
)
377 zfs_cmd_t zc
= { 0 };
378 libzfs_handle_t
*lhdl
= di
->zhp
->zfs_hdl
;
379 char fobjname
[MAXPATHLEN
];
381 (void) strlcpy(zc
.zc_name
, di
->fromsnap
, sizeof (zc
.zc_name
));
382 zc
.zc_obj
= dr
->ddr_first
- 1;
384 ASSERT(di
->zerr
== 0);
386 while (zc
.zc_obj
< dr
->ddr_last
) {
389 err
= ioctl(lhdl
->libzfs_fd
, ZFS_IOC_NEXT_OBJ
, &zc
);
391 if (zc
.zc_obj
== di
->shares
) {
395 if (zc
.zc_obj
> dr
->ddr_last
) {
398 err
= describe_free(fp
, di
, zc
.zc_obj
, fobjname
,
402 } else if (errno
== ESRCH
) {
405 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
406 dgettext(TEXT_DOMAIN
,
407 "next allocated object (> %lld) find failure"),
421 differ_info_t
*di
= arg
;
422 dmu_diff_record_t dr
;
426 if ((ofp
= fdopen(di
->outputfd
, "w")) == NULL
) {
428 (void) strerror_r(errno
, di
->errbuf
, sizeof (di
->errbuf
));
429 (void) close(di
->datafd
);
434 char *cp
= (char *)&dr
;
435 int len
= sizeof (dr
);
439 rv
= read(di
->datafd
, cp
, len
);
442 } while (len
> 0 && rv
> 0);
444 if (rv
< 0 || (rv
== 0 && len
!= sizeof (dr
))) {
447 } else if (rv
== 0) {
448 /* end of file at a natural breaking point */
452 switch (dr
.ddr_type
) {
454 err
= write_free_diffs(ofp
, di
, &dr
);
457 err
= write_inuse_diffs(ofp
, di
, &dr
);
469 (void) close(di
->datafd
);
473 ASSERT(di
->zerr
== EINVAL
);
474 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
475 dgettext(TEXT_DOMAIN
,
476 "Internal error: bad data from diff IOCTL"));
483 find_shares_object(differ_info_t
*di
)
485 char fullpath
[MAXPATHLEN
];
486 struct stat64 sb
= { 0 };
488 (void) strlcpy(fullpath
, di
->dsmnt
, MAXPATHLEN
);
489 (void) strlcat(fullpath
, ZDIFF_SHARESDIR
, MAXPATHLEN
);
491 if (stat64(fullpath
, &sb
) != 0) {
492 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
493 dgettext(TEXT_DOMAIN
, "Cannot stat %s"), fullpath
);
494 return (zfs_error(di
->zhp
->zfs_hdl
, EZFS_DIFF
, di
->errbuf
));
497 di
->shares
= (uint64_t)sb
.st_ino
;
502 make_temp_snapshot(differ_info_t
*di
)
504 libzfs_handle_t
*hdl
= di
->zhp
->zfs_hdl
;
505 zfs_cmd_t zc
= { 0 };
507 (void) snprintf(zc
.zc_value
, sizeof (zc
.zc_value
),
508 ZDIFF_PREFIX
, getpid());
509 (void) strlcpy(zc
.zc_name
, di
->ds
, sizeof (zc
.zc_name
));
510 zc
.zc_cleanup_fd
= di
->cleanupfd
;
512 if (ioctl(hdl
->libzfs_fd
, ZFS_IOC_TMP_SNAPSHOT
, &zc
) != 0) {
515 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
516 dgettext(TEXT_DOMAIN
, "The diff delegated "
517 "permission is needed in order\nto create a "
518 "just-in-time snapshot for diffing\n"));
519 return (zfs_error(hdl
, EZFS_DIFF
, di
->errbuf
));
521 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
522 dgettext(TEXT_DOMAIN
, "Cannot create just-in-time "
523 "snapshot of '%s'"), zc
.zc_name
);
524 return (zfs_standard_error(hdl
, err
, di
->errbuf
));
528 di
->tmpsnap
= zfs_strdup(hdl
, zc
.zc_value
);
529 di
->tosnap
= zfs_asprintf(hdl
, "%s@%s", di
->ds
, di
->tmpsnap
);
534 teardown_differ_info(differ_info_t
*di
)
543 (void) close(di
->cleanupfd
);
547 get_snapshot_names(differ_info_t
*di
, const char *fromsnap
,
550 libzfs_handle_t
*hdl
= di
->zhp
->zfs_hdl
;
559 * dataset@snap1 dataset@snap2
560 * dataset@snap1 @snap2
561 * dataset@snap1 dataset
562 * @snap1 dataset@snap2
564 if (tosnap
== NULL
) {
565 /* only a from snapshot given, must be valid */
566 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
567 dgettext(TEXT_DOMAIN
,
568 "Badly formed snapshot name %s"), fromsnap
);
570 if (!zfs_validate_name(hdl
, fromsnap
, ZFS_TYPE_SNAPSHOT
,
572 return (zfs_error(hdl
, EZFS_INVALIDNAME
,
576 atptrf
= strchr(fromsnap
, '@');
577 ASSERT(atptrf
!= NULL
);
578 fdslen
= atptrf
- fromsnap
;
580 di
->fromsnap
= zfs_strdup(hdl
, fromsnap
);
581 di
->ds
= zfs_strdup(hdl
, fromsnap
);
582 di
->ds
[fdslen
] = '\0';
584 /* the to snap will be a just-in-time snap of the head */
585 return (make_temp_snapshot(di
));
588 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
589 dgettext(TEXT_DOMAIN
,
590 "Unable to determine which snapshots to compare"));
592 atptrf
= strchr(fromsnap
, '@');
593 atptrt
= strchr(tosnap
, '@');
594 fdslen
= atptrf
? atptrf
- fromsnap
: strlen(fromsnap
);
595 tdslen
= atptrt
? atptrt
- tosnap
: strlen(tosnap
);
596 fsnlen
= strlen(fromsnap
) - fdslen
; /* includes @ sign */
597 tsnlen
= strlen(tosnap
) - tdslen
; /* includes @ sign */
599 if (fsnlen
<= 1 || tsnlen
== 1 || (fdslen
== 0 && tdslen
== 0) ||
600 (fsnlen
== 0 && tsnlen
== 0)) {
601 return (zfs_error(hdl
, EZFS_INVALIDNAME
, di
->errbuf
));
602 } else if ((fdslen
> 0 && tdslen
> 0) &&
603 ((tdslen
!= fdslen
|| strncmp(fromsnap
, tosnap
, fdslen
) != 0))) {
605 * not the same dataset name, might be okay if
606 * tosnap is a clone of a fromsnap descendant.
608 char origin
[ZFS_MAX_DATASET_NAME_LEN
];
612 di
->ds
= zfs_alloc(di
->zhp
->zfs_hdl
, tdslen
+ 1);
613 (void) strncpy(di
->ds
, tosnap
, tdslen
);
614 di
->ds
[tdslen
] = '\0';
616 zhp
= zfs_open(hdl
, di
->ds
, ZFS_TYPE_FILESYSTEM
);
617 while (zhp
!= NULL
) {
618 if (zfs_prop_get(zhp
, ZFS_PROP_ORIGIN
, origin
,
619 sizeof (origin
), &src
, NULL
, 0, B_FALSE
) != 0) {
620 (void) zfs_close(zhp
);
624 if (strncmp(origin
, fromsnap
, fsnlen
) == 0)
627 (void) zfs_close(zhp
);
628 zhp
= zfs_open(hdl
, origin
, ZFS_TYPE_FILESYSTEM
);
632 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
633 dgettext(TEXT_DOMAIN
,
634 "Not an earlier snapshot from the same fs"));
635 return (zfs_error(hdl
, EZFS_INVALIDNAME
, di
->errbuf
));
637 (void) zfs_close(zhp
);
640 di
->isclone
= B_TRUE
;
641 di
->fromsnap
= zfs_strdup(hdl
, fromsnap
);
643 di
->tosnap
= zfs_strdup(hdl
, tosnap
);
645 return (make_temp_snapshot(di
));
648 int dslen
= fdslen
? fdslen
: tdslen
;
650 di
->ds
= zfs_alloc(hdl
, dslen
+ 1);
651 (void) strncpy(di
->ds
, fdslen
? fromsnap
: tosnap
, dslen
);
652 di
->ds
[dslen
] = '\0';
654 di
->fromsnap
= zfs_asprintf(hdl
, "%s%s", di
->ds
, atptrf
);
656 di
->tosnap
= zfs_asprintf(hdl
, "%s%s", di
->ds
, atptrt
);
658 return (make_temp_snapshot(di
));
665 get_mountpoint(differ_info_t
*di
, char *dsnm
, char **mntpt
)
669 mounted
= is_mounted(di
->zhp
->zfs_hdl
, dsnm
, mntpt
);
670 if (mounted
== B_FALSE
) {
671 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
672 dgettext(TEXT_DOMAIN
,
673 "Cannot diff an unmounted snapshot"));
674 return (zfs_error(di
->zhp
->zfs_hdl
, EZFS_BADTYPE
, di
->errbuf
));
677 /* Avoid a double slash at the beginning of root-mounted datasets */
678 if (**mntpt
== '/' && *(*mntpt
+ 1) == '\0')
684 get_mountpoints(differ_info_t
*di
)
690 * first get the mountpoint for the parent dataset
692 if (get_mountpoint(di
, di
->ds
, &di
->dsmnt
) != 0)
695 strptr
= strchr(di
->tosnap
, '@');
696 ASSERT3P(strptr
, !=, NULL
);
697 di
->tomnt
= zfs_asprintf(di
->zhp
->zfs_hdl
, "%s%s%s", di
->dsmnt
,
698 ZDIFF_SNAPDIR
, ++strptr
);
700 strptr
= strchr(di
->fromsnap
, '@');
701 ASSERT3P(strptr
, !=, NULL
);
703 frommntpt
= di
->dsmnt
;
709 err
= get_mountpoint(di
, di
->fromsnap
, &mntpt
);
716 di
->frommnt
= zfs_asprintf(di
->zhp
->zfs_hdl
, "%s%s%s", frommntpt
,
717 ZDIFF_SNAPDIR
, ++strptr
);
726 setup_differ_info(zfs_handle_t
*zhp
, const char *fromsnap
,
727 const char *tosnap
, differ_info_t
*di
)
731 di
->cleanupfd
= open(ZFS_DEV
, O_RDWR
|O_EXCL
);
732 VERIFY(di
->cleanupfd
>= 0);
734 if (get_snapshot_names(di
, fromsnap
, tosnap
) != 0)
737 if (get_mountpoints(di
) != 0)
740 if (find_shares_object(di
) != 0)
747 zfs_show_diffs(zfs_handle_t
*zhp
, int outfd
, const char *fromsnap
,
748 const char *tosnap
, int flags
)
750 zfs_cmd_t zc
= { 0 };
752 differ_info_t di
= { 0 };
757 (void) snprintf(errbuf
, sizeof (errbuf
),
758 dgettext(TEXT_DOMAIN
, "zfs diff failed"));
760 if (setup_differ_info(zhp
, fromsnap
, tosnap
, &di
)) {
761 teardown_differ_info(&di
);
766 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
767 teardown_differ_info(&di
);
768 return (zfs_error(zhp
->zfs_hdl
, EZFS_PIPEFAILED
, errbuf
));
771 di
.scripted
= (flags
& ZFS_DIFF_PARSEABLE
);
772 di
.classify
= (flags
& ZFS_DIFF_CLASSIFY
);
773 di
.timestamped
= (flags
& ZFS_DIFF_TIMESTAMP
);
776 di
.datafd
= pipefd
[0];
778 if (pthread_create(&tid
, NULL
, differ
, &di
)) {
779 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
780 (void) close(pipefd
[0]);
781 (void) close(pipefd
[1]);
782 teardown_differ_info(&di
);
783 return (zfs_error(zhp
->zfs_hdl
,
784 EZFS_THREADCREATEFAILED
, errbuf
));
788 (void) strlcpy(zc
.zc_value
, di
.fromsnap
, strlen(di
.fromsnap
) + 1);
789 (void) strlcpy(zc
.zc_name
, di
.tosnap
, strlen(di
.tosnap
) + 1);
790 zc
.zc_cookie
= pipefd
[1];
792 iocerr
= ioctl(zhp
->zfs_hdl
->libzfs_fd
, ZFS_IOC_DIFF
, &zc
);
794 (void) snprintf(errbuf
, sizeof (errbuf
),
795 dgettext(TEXT_DOMAIN
, "Unable to obtain diffs"));
796 if (errno
== EPERM
) {
797 zfs_error_aux(zhp
->zfs_hdl
, dgettext(TEXT_DOMAIN
,
798 "\n The sys_mount privilege or diff delegated "
799 "permission is needed\n to execute the "
801 } else if (errno
== EXDEV
) {
802 zfs_error_aux(zhp
->zfs_hdl
, dgettext(TEXT_DOMAIN
,
803 "\n Not an earlier snapshot from the same fs"));
804 } else if (errno
!= EPIPE
|| di
.zerr
== 0) {
805 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
807 (void) close(pipefd
[1]);
808 (void) pthread_cancel(tid
);
809 (void) pthread_join(tid
, NULL
);
810 teardown_differ_info(&di
);
811 if (di
.zerr
!= 0 && di
.zerr
!= EPIPE
) {
812 zfs_error_aux(zhp
->zfs_hdl
, strerror(di
.zerr
));
813 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFF
, di
.errbuf
));
815 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFFDATA
, errbuf
));
819 (void) close(pipefd
[1]);
820 (void) pthread_join(tid
, NULL
);
823 zfs_error_aux(zhp
->zfs_hdl
, strerror(di
.zerr
));
824 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFF
, di
.errbuf
));
826 teardown_differ_info(&di
);