]>
git.proxmox.com Git - mirror_zfs.git/blob - lib/libzfs/libzfs_diff.c
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.
34 #include <sys/types.h>
44 #include <sys/zfs_ioctl.h>
46 #include "libzfs_impl.h"
48 #define ZDIFF_SNAPDIR "/.zfs/snapshot/"
49 #define ZDIFF_SHARESDIR "/.zfs/shares/"
50 #define ZDIFF_PREFIX "zfs-diff-%d"
52 #define ZDIFF_ADDED '+'
53 #define ZDIFF_MODIFIED 'M'
54 #define ZDIFF_REMOVED '-'
55 #define ZDIFF_RENAMED 'R'
58 do_name_cmp(const char *fpath
, const char *tpath
)
61 fname
= strrchr(fpath
, '/') + 1;
62 tname
= strrchr(tpath
, '/') + 1;
63 return (strcmp(fname
, tname
) == 0);
66 typedef struct differ_info
{
79 boolean_t timestamped
;
88 * Given a {dsname, object id}, get the object path
91 get_stats_for_obj(differ_info_t
*di
, const char *dsname
, uint64_t obj
,
92 char *pn
, int maxlen
, zfs_stat_t
*sb
)
94 zfs_cmd_t zc
= {"\0"};
97 (void) strlcpy(zc
.zc_name
, dsname
, sizeof (zc
.zc_name
));
101 error
= ioctl(di
->zhp
->zfs_hdl
->libzfs_fd
, ZFS_IOC_OBJ_TO_STATS
, &zc
);
104 /* we can get stats even if we failed to get a path */
105 (void) memcpy(sb
, &zc
.zc_stat
, sizeof (zfs_stat_t
));
107 ASSERT(di
->zerr
== 0);
108 (void) strlcpy(pn
, zc
.zc_value
, maxlen
);
112 if (di
->zerr
== EPERM
) {
113 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
114 dgettext(TEXT_DOMAIN
,
115 "The sys_config privilege or diff delegated permission "
116 "is needed\nto discover path names"));
119 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
120 dgettext(TEXT_DOMAIN
,
121 "Unable to determine path or stats for "
122 "object %lld in %s"), (longlong_t
)obj
, dsname
);
130 * Prints a file name out a character at a time. If the character is
131 * not in the range of what we consider "printable" ASCII, display it
132 * as an escaped 4-digit octal value. ASCII values less than a space
133 * are all control characters and we declare the upper end as the
134 * DELete character. This also is the last 7-bit ASCII character.
135 * We choose to treat all 8-bit ASCII as not printable for this
139 stream_bytes(FILE *fp
, const char *string
)
142 if (*string
> ' ' && *string
!= '\\' && *string
< '\177')
143 (void) fprintf(fp
, "%c", *string
++);
145 (void) fprintf(fp
, "\\%04o", (unsigned char)*string
++);
150 print_what(FILE *fp
, mode_t what
)
154 switch (what
& S_IFMT
) {
190 (void) fprintf(fp
, "%c", symbol
);
194 print_cmn(FILE *fp
, differ_info_t
*di
, const char *file
)
196 stream_bytes(fp
, di
->dsmnt
);
197 stream_bytes(fp
, file
);
201 print_rename(FILE *fp
, differ_info_t
*di
, const char *old
, const char *new,
205 (void) fprintf(fp
, "%10lld.%09lld\t",
206 (longlong_t
)isb
->zs_ctime
[0],
207 (longlong_t
)isb
->zs_ctime
[1]);
208 (void) fprintf(fp
, "%c\t", ZDIFF_RENAMED
);
210 print_what(fp
, isb
->zs_mode
);
211 (void) fprintf(fp
, "\t");
213 print_cmn(fp
, di
, old
);
215 (void) fprintf(fp
, "\t");
217 (void) fprintf(fp
, " -> ");
218 print_cmn(fp
, di
, new);
219 (void) fprintf(fp
, "\n");
223 print_link_change(FILE *fp
, differ_info_t
*di
, int delta
, const char *file
,
227 (void) fprintf(fp
, "%10lld.%09lld\t",
228 (longlong_t
)isb
->zs_ctime
[0],
229 (longlong_t
)isb
->zs_ctime
[1]);
230 (void) fprintf(fp
, "%c\t", ZDIFF_MODIFIED
);
232 print_what(fp
, isb
->zs_mode
);
233 (void) fprintf(fp
, "\t");
235 print_cmn(fp
, di
, file
);
236 (void) fprintf(fp
, "\t(%+d)", delta
);
237 (void) fprintf(fp
, "\n");
241 print_file(FILE *fp
, differ_info_t
*di
, char type
, const char *file
,
245 (void) fprintf(fp
, "%10lld.%09lld\t",
246 (longlong_t
)isb
->zs_ctime
[0],
247 (longlong_t
)isb
->zs_ctime
[1]);
248 (void) fprintf(fp
, "%c\t", type
);
250 print_what(fp
, isb
->zs_mode
);
251 (void) fprintf(fp
, "\t");
253 print_cmn(fp
, di
, file
);
254 (void) fprintf(fp
, "\n");
258 write_inuse_diffs_one(FILE *fp
, differ_info_t
*di
, uint64_t dobj
)
260 struct zfs_stat fsb
, tsb
;
263 char fobjname
[MAXPATHLEN
], tobjname
[MAXPATHLEN
];
264 int fobjerr
, tobjerr
;
267 if (dobj
== di
->shares
)
271 * Check the from and to snapshots for info on the object. If
272 * we get ENOENT, then the object just didn't exist in that
273 * snapshot. If we get ENOTSUP, then we tried to get
274 * info on a non-ZPL object, which we don't care about anyway.
276 fobjerr
= get_stats_for_obj(di
, di
->fromsnap
, dobj
, fobjname
,
278 if (fobjerr
&& di
->zerr
!= ENOENT
&& di
->zerr
!= ENOTSUP
)
281 tobjerr
= get_stats_for_obj(di
, di
->tosnap
, dobj
, tobjname
,
283 if (tobjerr
&& di
->zerr
!= ENOENT
&& di
->zerr
!= ENOTSUP
)
287 * Unallocated object sharing the same meta dnode block
289 if (fobjerr
&& tobjerr
) {
290 ASSERT(di
->zerr
== ENOENT
|| di
->zerr
== ENOTSUP
);
295 di
->zerr
= 0; /* negate get_stats_for_obj() from side that failed */
296 fmode
= fsb
.zs_mode
& S_IFMT
;
297 tmode
= tsb
.zs_mode
& S_IFMT
;
298 if (fmode
== S_IFDIR
|| tmode
== S_IFDIR
|| fsb
.zs_links
== 0 ||
302 change
= tsb
.zs_links
- fsb
.zs_links
;
306 print_link_change(fp
, di
, change
, tobjname
, &tsb
);
309 print_file(fp
, di
, ZDIFF_ADDED
, tobjname
, &tsb
);
311 } else if (tobjerr
) {
313 print_link_change(fp
, di
, change
, fobjname
, &fsb
);
316 print_file(fp
, di
, ZDIFF_REMOVED
, fobjname
, &fsb
);
320 if (fmode
!= tmode
&& fsb
.zs_gen
== tsb
.zs_gen
)
321 tsb
.zs_gen
++; /* Force a generational difference */
322 same_name
= do_name_cmp(fobjname
, tobjname
);
324 /* Simple modification or no change */
325 if (fsb
.zs_gen
== tsb
.zs_gen
) {
326 /* No apparent changes. Could we assert !this? */
327 if (fsb
.zs_ctime
[0] == tsb
.zs_ctime
[0] &&
328 fsb
.zs_ctime
[1] == tsb
.zs_ctime
[1])
331 print_link_change(fp
, di
, change
,
332 change
> 0 ? fobjname
: tobjname
, &tsb
);
333 } else if (same_name
) {
334 print_file(fp
, di
, ZDIFF_MODIFIED
, fobjname
, &tsb
);
336 print_rename(fp
, di
, fobjname
, tobjname
, &tsb
);
340 /* file re-created or object re-used */
341 print_file(fp
, di
, ZDIFF_REMOVED
, fobjname
, &fsb
);
342 print_file(fp
, di
, ZDIFF_ADDED
, tobjname
, &tsb
);
348 write_inuse_diffs(FILE *fp
, differ_info_t
*di
, dmu_diff_record_t
*dr
)
353 for (o
= dr
->ddr_first
; o
<= dr
->ddr_last
; o
++) {
354 if ((err
= write_inuse_diffs_one(fp
, di
, o
)))
361 describe_free(FILE *fp
, differ_info_t
*di
, uint64_t object
, char *namebuf
,
366 if (get_stats_for_obj(di
, di
->fromsnap
, object
, namebuf
,
368 /* Let it slide, if in the delete queue on from side */
369 if (di
->zerr
== ENOENT
&& sb
.zs_links
== 0) {
376 print_file(fp
, di
, ZDIFF_REMOVED
, namebuf
, &sb
);
381 write_free_diffs(FILE *fp
, differ_info_t
*di
, dmu_diff_record_t
*dr
)
383 zfs_cmd_t zc
= {"\0"};
384 libzfs_handle_t
*lhdl
= di
->zhp
->zfs_hdl
;
385 char fobjname
[MAXPATHLEN
];
387 (void) strlcpy(zc
.zc_name
, di
->fromsnap
, sizeof (zc
.zc_name
));
388 zc
.zc_obj
= dr
->ddr_first
- 1;
390 ASSERT(di
->zerr
== 0);
392 while (zc
.zc_obj
< dr
->ddr_last
) {
395 err
= ioctl(lhdl
->libzfs_fd
, ZFS_IOC_NEXT_OBJ
, &zc
);
397 if (zc
.zc_obj
== di
->shares
) {
401 if (zc
.zc_obj
> dr
->ddr_last
) {
404 err
= describe_free(fp
, di
, zc
.zc_obj
, fobjname
,
408 } else if (errno
== ESRCH
) {
411 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
412 dgettext(TEXT_DOMAIN
,
413 "next allocated object (> %lld) find failure"),
414 (longlong_t
)zc
.zc_obj
);
427 differ_info_t
*di
= arg
;
428 dmu_diff_record_t dr
;
432 if ((ofp
= fdopen(di
->outputfd
, "w")) == NULL
) {
434 strncpy(di
->errbuf
, strerror(errno
), sizeof (di
->errbuf
));
435 (void) close(di
->datafd
);
440 char *cp
= (char *)&dr
;
441 int len
= sizeof (dr
);
445 rv
= read(di
->datafd
, cp
, len
);
448 } while (len
> 0 && rv
> 0);
450 if (rv
< 0 || (rv
== 0 && len
!= sizeof (dr
))) {
453 } else if (rv
== 0) {
454 /* end of file at a natural breaking point */
458 switch (dr
.ddr_type
) {
460 err
= write_free_diffs(ofp
, di
, &dr
);
463 err
= write_inuse_diffs(ofp
, di
, &dr
);
475 (void) close(di
->datafd
);
479 ASSERT(di
->zerr
== EINVAL
);
480 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
481 dgettext(TEXT_DOMAIN
,
482 "Internal error: bad data from diff IOCTL"));
489 find_shares_object(differ_info_t
*di
)
491 char fullpath
[MAXPATHLEN
];
492 struct stat64 sb
= { 0 };
494 (void) strlcpy(fullpath
, di
->dsmnt
, MAXPATHLEN
);
495 (void) strlcat(fullpath
, ZDIFF_SHARESDIR
, MAXPATHLEN
);
497 if (stat64(fullpath
, &sb
) != 0) {
498 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
499 dgettext(TEXT_DOMAIN
, "Cannot stat %s"), fullpath
);
500 return (zfs_error(di
->zhp
->zfs_hdl
, EZFS_DIFF
, di
->errbuf
));
503 di
->shares
= (uint64_t)sb
.st_ino
;
508 make_temp_snapshot(differ_info_t
*di
)
510 libzfs_handle_t
*hdl
= di
->zhp
->zfs_hdl
;
511 zfs_cmd_t zc
= {"\0"};
513 (void) snprintf(zc
.zc_value
, sizeof (zc
.zc_value
),
514 ZDIFF_PREFIX
, getpid());
515 (void) strlcpy(zc
.zc_name
, di
->ds
, sizeof (zc
.zc_name
));
516 zc
.zc_cleanup_fd
= di
->cleanupfd
;
518 if (ioctl(hdl
->libzfs_fd
, ZFS_IOC_TMP_SNAPSHOT
, &zc
) != 0) {
521 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
522 dgettext(TEXT_DOMAIN
, "The diff delegated "
523 "permission is needed in order\nto create a "
524 "just-in-time snapshot for diffing\n"));
525 return (zfs_error(hdl
, EZFS_DIFF
, di
->errbuf
));
527 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
528 dgettext(TEXT_DOMAIN
, "Cannot create just-in-time "
529 "snapshot of '%s'"), zc
.zc_name
);
530 return (zfs_standard_error(hdl
, err
, di
->errbuf
));
534 di
->tmpsnap
= zfs_strdup(hdl
, zc
.zc_value
);
535 di
->tosnap
= zfs_asprintf(hdl
, "%s@%s", di
->ds
, di
->tmpsnap
);
540 teardown_differ_info(differ_info_t
*di
)
549 (void) close(di
->cleanupfd
);
553 get_snapshot_names(differ_info_t
*di
, const char *fromsnap
,
556 libzfs_handle_t
*hdl
= di
->zhp
->zfs_hdl
;
565 * dataset@snap1 dataset@snap2
566 * dataset@snap1 @snap2
567 * dataset@snap1 dataset
568 * @snap1 dataset@snap2
570 if (tosnap
== NULL
) {
571 /* only a from snapshot given, must be valid */
572 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
573 dgettext(TEXT_DOMAIN
,
574 "Badly formed snapshot name %s"), fromsnap
);
576 if (!zfs_validate_name(hdl
, fromsnap
, ZFS_TYPE_SNAPSHOT
,
578 return (zfs_error(hdl
, EZFS_INVALIDNAME
,
582 atptrf
= strchr(fromsnap
, '@');
583 ASSERT(atptrf
!= NULL
);
584 fdslen
= atptrf
- fromsnap
;
586 di
->fromsnap
= zfs_strdup(hdl
, fromsnap
);
587 di
->ds
= zfs_strdup(hdl
, fromsnap
);
588 di
->ds
[fdslen
] = '\0';
590 /* the to snap will be a just-in-time snap of the head */
591 return (make_temp_snapshot(di
));
594 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
595 dgettext(TEXT_DOMAIN
,
596 "Unable to determine which snapshots to compare"));
598 atptrf
= strchr(fromsnap
, '@');
599 atptrt
= strchr(tosnap
, '@');
600 fdslen
= atptrf
? atptrf
- fromsnap
: strlen(fromsnap
);
601 tdslen
= atptrt
? atptrt
- tosnap
: strlen(tosnap
);
602 fsnlen
= strlen(fromsnap
) - fdslen
; /* includes @ sign */
603 tsnlen
= strlen(tosnap
) - tdslen
; /* includes @ sign */
605 if (fsnlen
<= 1 || tsnlen
== 1 || (fdslen
== 0 && tdslen
== 0) ||
606 (fsnlen
== 0 && tsnlen
== 0)) {
607 return (zfs_error(hdl
, EZFS_INVALIDNAME
, di
->errbuf
));
608 } else if ((fdslen
> 0 && tdslen
> 0) &&
609 ((tdslen
!= fdslen
|| strncmp(fromsnap
, tosnap
, fdslen
) != 0))) {
611 * not the same dataset name, might be okay if
612 * tosnap is a clone of a fromsnap descendant.
614 char origin
[ZFS_MAXNAMELEN
];
618 di
->ds
= zfs_alloc(di
->zhp
->zfs_hdl
, tdslen
+ 1);
619 (void) strncpy(di
->ds
, tosnap
, tdslen
);
620 di
->ds
[tdslen
] = '\0';
622 zhp
= zfs_open(hdl
, di
->ds
, ZFS_TYPE_FILESYSTEM
);
623 while (zhp
!= NULL
) {
624 if (zfs_prop_get(zhp
, ZFS_PROP_ORIGIN
, origin
,
625 sizeof (origin
), &src
, NULL
, 0, B_FALSE
) != 0) {
626 (void) zfs_close(zhp
);
630 if (strncmp(origin
, fromsnap
, fsnlen
) == 0)
633 (void) zfs_close(zhp
);
634 zhp
= zfs_open(hdl
, origin
, ZFS_TYPE_FILESYSTEM
);
638 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
639 dgettext(TEXT_DOMAIN
,
640 "Not an earlier snapshot from the same fs"));
641 return (zfs_error(hdl
, EZFS_INVALIDNAME
, di
->errbuf
));
643 (void) zfs_close(zhp
);
646 di
->isclone
= B_TRUE
;
647 di
->fromsnap
= zfs_strdup(hdl
, fromsnap
);
649 di
->tosnap
= zfs_strdup(hdl
, tosnap
);
651 return (make_temp_snapshot(di
));
654 int dslen
= fdslen
? fdslen
: tdslen
;
656 di
->ds
= zfs_alloc(hdl
, dslen
+ 1);
657 (void) strncpy(di
->ds
, fdslen
? fromsnap
: tosnap
, dslen
);
658 di
->ds
[dslen
] = '\0';
660 di
->fromsnap
= zfs_asprintf(hdl
, "%s%s", di
->ds
, atptrf
);
662 di
->tosnap
= zfs_asprintf(hdl
, "%s%s", di
->ds
, atptrt
);
664 return (make_temp_snapshot(di
));
671 get_mountpoint(differ_info_t
*di
, char *dsnm
, char **mntpt
)
675 mounted
= is_mounted(di
->zhp
->zfs_hdl
, dsnm
, mntpt
);
676 if (mounted
== B_FALSE
) {
677 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
678 dgettext(TEXT_DOMAIN
,
679 "Cannot diff an unmounted snapshot"));
680 return (zfs_error(di
->zhp
->zfs_hdl
, EZFS_BADTYPE
, di
->errbuf
));
683 /* Avoid a double slash at the beginning of root-mounted datasets */
684 if (**mntpt
== '/' && *(*mntpt
+ 1) == '\0')
690 get_mountpoints(differ_info_t
*di
)
696 * first get the mountpoint for the parent dataset
698 if (get_mountpoint(di
, di
->ds
, &di
->dsmnt
) != 0)
701 strptr
= strchr(di
->tosnap
, '@');
702 ASSERT3P(strptr
, !=, NULL
);
703 di
->tomnt
= zfs_asprintf(di
->zhp
->zfs_hdl
, "%s%s%s", di
->dsmnt
,
704 ZDIFF_SNAPDIR
, ++strptr
);
706 strptr
= strchr(di
->fromsnap
, '@');
707 ASSERT3P(strptr
, !=, NULL
);
709 frommntpt
= di
->dsmnt
;
715 err
= get_mountpoint(di
, di
->fromsnap
, &mntpt
);
722 di
->frommnt
= zfs_asprintf(di
->zhp
->zfs_hdl
, "%s%s%s", frommntpt
,
723 ZDIFF_SNAPDIR
, ++strptr
);
732 setup_differ_info(zfs_handle_t
*zhp
, const char *fromsnap
,
733 const char *tosnap
, differ_info_t
*di
)
737 di
->cleanupfd
= open(ZFS_DEV
, O_RDWR
);
738 VERIFY(di
->cleanupfd
>= 0);
740 if (get_snapshot_names(di
, fromsnap
, tosnap
) != 0)
743 if (get_mountpoints(di
) != 0)
746 if (find_shares_object(di
) != 0)
753 zfs_show_diffs(zfs_handle_t
*zhp
, int outfd
, const char *fromsnap
,
754 const char *tosnap
, int flags
)
756 zfs_cmd_t zc
= {"\0"};
758 differ_info_t di
= { 0 };
763 (void) snprintf(errbuf
, sizeof (errbuf
),
764 dgettext(TEXT_DOMAIN
, "zfs diff failed"));
766 if (setup_differ_info(zhp
, fromsnap
, tosnap
, &di
)) {
767 teardown_differ_info(&di
);
772 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
773 teardown_differ_info(&di
);
774 return (zfs_error(zhp
->zfs_hdl
, EZFS_PIPEFAILED
, errbuf
));
777 di
.scripted
= (flags
& ZFS_DIFF_PARSEABLE
);
778 di
.classify
= (flags
& ZFS_DIFF_CLASSIFY
);
779 di
.timestamped
= (flags
& ZFS_DIFF_TIMESTAMP
);
782 di
.datafd
= pipefd
[0];
784 if (pthread_create(&tid
, NULL
, differ
, &di
)) {
785 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
786 (void) close(pipefd
[0]);
787 (void) close(pipefd
[1]);
788 teardown_differ_info(&di
);
789 return (zfs_error(zhp
->zfs_hdl
,
790 EZFS_THREADCREATEFAILED
, errbuf
));
794 (void) strlcpy(zc
.zc_value
, di
.fromsnap
, strlen(di
.fromsnap
) + 1);
795 (void) strlcpy(zc
.zc_name
, di
.tosnap
, strlen(di
.tosnap
) + 1);
796 zc
.zc_cookie
= pipefd
[1];
798 iocerr
= ioctl(zhp
->zfs_hdl
->libzfs_fd
, ZFS_IOC_DIFF
, &zc
);
800 (void) snprintf(errbuf
, sizeof (errbuf
),
801 dgettext(TEXT_DOMAIN
, "Unable to obtain diffs"));
802 if (errno
== EPERM
) {
803 zfs_error_aux(zhp
->zfs_hdl
, dgettext(TEXT_DOMAIN
,
804 "\n The sys_mount privilege or diff delegated "
805 "permission is needed\n to execute the "
807 } else if (errno
== EXDEV
) {
808 zfs_error_aux(zhp
->zfs_hdl
, dgettext(TEXT_DOMAIN
,
809 "\n Not an earlier snapshot from the same fs"));
810 } else if (errno
!= EPIPE
|| di
.zerr
== 0) {
811 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
813 (void) close(pipefd
[1]);
814 (void) pthread_cancel(tid
);
815 (void) pthread_join(tid
, NULL
);
816 teardown_differ_info(&di
);
817 if (di
.zerr
!= 0 && di
.zerr
!= EPIPE
) {
818 zfs_error_aux(zhp
->zfs_hdl
, strerror(di
.zerr
));
819 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFF
, di
.errbuf
));
821 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFFDATA
, errbuf
));
825 (void) close(pipefd
[1]);
826 (void) pthread_join(tid
, NULL
);
829 zfs_error_aux(zhp
->zfs_hdl
, strerror(di
.zerr
));
830 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFF
, di
.errbuf
));
832 teardown_differ_info(&di
);