]>
git.proxmox.com Git - mirror_zfs-debian.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.
33 #include <sys/types.h>
43 #include <sys/zfs_ioctl.h>
45 #include "libzfs_impl.h"
47 #define ZDIFF_SNAPDIR "/.zfs/snapshot/"
48 #define ZDIFF_SHARESDIR "/.zfs/shares/"
49 #define ZDIFF_PREFIX "zfs-diff-%d"
51 #define ZDIFF_ADDED '+'
52 #define ZDIFF_MODIFIED 'M'
53 #define ZDIFF_REMOVED '-'
54 #define ZDIFF_RENAMED 'R'
57 do_name_cmp(const char *fpath
, const char *tpath
)
60 fname
= strrchr(fpath
, '/') + 1;
61 tname
= strrchr(tpath
, '/') + 1;
62 return (strcmp(fname
, tname
) == 0);
65 typedef struct differ_info
{
78 boolean_t timestamped
;
87 * Given a {dsname, object id}, get the object path
90 get_stats_for_obj(differ_info_t
*di
, const char *dsname
, uint64_t obj
,
91 char *pn
, int maxlen
, zfs_stat_t
*sb
)
93 zfs_cmd_t zc
= { "\0", "\0", "\0", "\0", 0 };
96 (void) strlcpy(zc
.zc_name
, dsname
, sizeof (zc
.zc_name
));
100 error
= ioctl(di
->zhp
->zfs_hdl
->libzfs_fd
, ZFS_IOC_OBJ_TO_STATS
, &zc
);
103 /* we can get stats even if we failed to get a path */
104 (void) memcpy(sb
, &zc
.zc_stat
, sizeof (zfs_stat_t
));
106 ASSERT(di
->zerr
== 0);
107 (void) strlcpy(pn
, zc
.zc_value
, maxlen
);
111 if (di
->zerr
== EPERM
) {
112 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
113 dgettext(TEXT_DOMAIN
,
114 "The sys_config privilege or diff delegated permission "
115 "is needed\nto discover path names"));
118 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
119 dgettext(TEXT_DOMAIN
,
120 "Unable to determine path or stats for "
121 "object %lld in %s"), (longlong_t
)obj
, dsname
);
129 * Prints a file name out a character at a time. If the character is
130 * not in the range of what we consider "printable" ASCII, display it
131 * as an escaped 3-digit octal value. ASCII values less than a space
132 * are all control characters and we declare the upper end as the
133 * DELete character. This also is the last 7-bit ASCII character.
134 * We choose to treat all 8-bit ASCII as not printable for this
138 stream_bytes(FILE *fp
, const char *string
)
141 if (*string
> ' ' && *string
!= '\\' && *string
< '\177')
142 (void) fprintf(fp
, "%c", *string
++);
144 (void) fprintf(fp
, "\\%03o", *string
++);
149 print_what(FILE *fp
, mode_t what
)
153 switch (what
& S_IFMT
) {
189 (void) fprintf(fp
, "%c", symbol
);
193 print_cmn(FILE *fp
, differ_info_t
*di
, const char *file
)
195 stream_bytes(fp
, di
->dsmnt
);
196 stream_bytes(fp
, file
);
200 print_rename(FILE *fp
, differ_info_t
*di
, const char *old
, const char *new,
204 (void) fprintf(fp
, "%10lld.%09lld\t",
205 (longlong_t
)isb
->zs_ctime
[0],
206 (longlong_t
)isb
->zs_ctime
[1]);
207 (void) fprintf(fp
, "%c\t", ZDIFF_RENAMED
);
209 print_what(fp
, isb
->zs_mode
);
210 (void) fprintf(fp
, "\t");
212 print_cmn(fp
, di
, old
);
214 (void) fprintf(fp
, "\t");
216 (void) fprintf(fp
, " -> ");
217 print_cmn(fp
, di
, new);
218 (void) fprintf(fp
, "\n");
222 print_link_change(FILE *fp
, differ_info_t
*di
, int delta
, const char *file
,
226 (void) fprintf(fp
, "%10lld.%09lld\t",
227 (longlong_t
)isb
->zs_ctime
[0],
228 (longlong_t
)isb
->zs_ctime
[1]);
229 (void) fprintf(fp
, "%c\t", ZDIFF_MODIFIED
);
231 print_what(fp
, isb
->zs_mode
);
232 (void) fprintf(fp
, "\t");
234 print_cmn(fp
, di
, file
);
235 (void) fprintf(fp
, "\t(%+d)", delta
);
236 (void) fprintf(fp
, "\n");
240 print_file(FILE *fp
, differ_info_t
*di
, char type
, const char *file
,
244 (void) fprintf(fp
, "%10lld.%09lld\t",
245 (longlong_t
)isb
->zs_ctime
[0],
246 (longlong_t
)isb
->zs_ctime
[1]);
247 (void) fprintf(fp
, "%c\t", type
);
249 print_what(fp
, isb
->zs_mode
);
250 (void) fprintf(fp
, "\t");
252 print_cmn(fp
, di
, file
);
253 (void) fprintf(fp
, "\n");
257 write_inuse_diffs_one(FILE *fp
, differ_info_t
*di
, uint64_t dobj
)
259 struct zfs_stat fsb
, tsb
;
262 char fobjname
[MAXPATHLEN
], tobjname
[MAXPATHLEN
];
263 int fobjerr
, tobjerr
;
266 if (dobj
== di
->shares
)
270 * Check the from and to snapshots for info on the object. If
271 * we get ENOENT, then the object just didn't exist in that
272 * snapshot. If we get ENOTSUP, then we tried to get
273 * info on a non-ZPL object, which we don't care about anyway.
275 fobjerr
= get_stats_for_obj(di
, di
->fromsnap
, dobj
, fobjname
,
277 if (fobjerr
&& di
->zerr
!= ENOENT
&& di
->zerr
!= ENOTSUP
)
280 tobjerr
= get_stats_for_obj(di
, di
->tosnap
, dobj
, tobjname
,
282 if (tobjerr
&& di
->zerr
!= ENOENT
&& di
->zerr
!= ENOTSUP
)
286 * Unallocated object sharing the same meta dnode block
288 if (fobjerr
&& tobjerr
) {
289 ASSERT(di
->zerr
== ENOENT
|| di
->zerr
== ENOTSUP
);
294 di
->zerr
= 0; /* negate get_stats_for_obj() from side that failed */
295 fmode
= fsb
.zs_mode
& S_IFMT
;
296 tmode
= tsb
.zs_mode
& S_IFMT
;
297 if (fmode
== S_IFDIR
|| tmode
== S_IFDIR
|| fsb
.zs_links
== 0 ||
301 change
= tsb
.zs_links
- fsb
.zs_links
;
305 print_link_change(fp
, di
, change
, tobjname
, &tsb
);
308 print_file(fp
, di
, ZDIFF_ADDED
, tobjname
, &tsb
);
310 } else if (tobjerr
) {
312 print_link_change(fp
, di
, change
, fobjname
, &fsb
);
315 print_file(fp
, di
, ZDIFF_REMOVED
, fobjname
, &fsb
);
319 if (fmode
!= tmode
&& fsb
.zs_gen
== tsb
.zs_gen
)
320 tsb
.zs_gen
++; /* Force a generational difference */
321 same_name
= do_name_cmp(fobjname
, tobjname
);
323 /* Simple modification or no change */
324 if (fsb
.zs_gen
== tsb
.zs_gen
) {
325 /* No apparent changes. Could we assert !this? */
326 if (fsb
.zs_ctime
[0] == tsb
.zs_ctime
[0] &&
327 fsb
.zs_ctime
[1] == tsb
.zs_ctime
[1])
330 print_link_change(fp
, di
, change
,
331 change
> 0 ? fobjname
: tobjname
, &tsb
);
332 } else if (same_name
) {
333 print_file(fp
, di
, ZDIFF_MODIFIED
, fobjname
, &tsb
);
335 print_rename(fp
, di
, fobjname
, tobjname
, &tsb
);
339 /* file re-created or object re-used */
340 print_file(fp
, di
, ZDIFF_REMOVED
, fobjname
, &fsb
);
341 print_file(fp
, di
, ZDIFF_ADDED
, tobjname
, &tsb
);
347 write_inuse_diffs(FILE *fp
, differ_info_t
*di
, dmu_diff_record_t
*dr
)
352 for (o
= dr
->ddr_first
; o
<= dr
->ddr_last
; o
++) {
353 if ((err
= write_inuse_diffs_one(fp
, di
, o
)))
360 describe_free(FILE *fp
, differ_info_t
*di
, uint64_t object
, char *namebuf
,
365 if (get_stats_for_obj(di
, di
->fromsnap
, object
, namebuf
,
367 /* Let it slide, if in the delete queue on from side */
368 if (di
->zerr
== ENOENT
&& sb
.zs_links
== 0) {
375 print_file(fp
, di
, ZDIFF_REMOVED
, namebuf
, &sb
);
380 write_free_diffs(FILE *fp
, differ_info_t
*di
, dmu_diff_record_t
*dr
)
382 zfs_cmd_t zc
= { "\0", "\0", "\0", "\0", 0 };
383 libzfs_handle_t
*lhdl
= di
->zhp
->zfs_hdl
;
384 char fobjname
[MAXPATHLEN
];
386 (void) strlcpy(zc
.zc_name
, di
->fromsnap
, sizeof (zc
.zc_name
));
387 zc
.zc_obj
= dr
->ddr_first
- 1;
389 ASSERT(di
->zerr
== 0);
391 while (zc
.zc_obj
< dr
->ddr_last
) {
394 err
= ioctl(lhdl
->libzfs_fd
, ZFS_IOC_NEXT_OBJ
, &zc
);
396 if (zc
.zc_obj
== di
->shares
) {
400 if (zc
.zc_obj
> dr
->ddr_last
) {
403 err
= describe_free(fp
, di
, zc
.zc_obj
, fobjname
,
407 } else if (errno
== ESRCH
) {
410 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
411 dgettext(TEXT_DOMAIN
,
412 "next allocated object (> %lld) find failure"),
413 (longlong_t
)zc
.zc_obj
);
426 differ_info_t
*di
= arg
;
427 dmu_diff_record_t dr
;
431 if ((ofp
= fdopen(di
->outputfd
, "w")) == NULL
) {
433 (void) strerror_r(errno
, di
->errbuf
, sizeof (di
->errbuf
));
434 (void) close(di
->datafd
);
439 char *cp
= (char *)&dr
;
440 int len
= sizeof (dr
);
444 rv
= read(di
->datafd
, cp
, len
);
447 } while (len
> 0 && rv
> 0);
449 if (rv
< 0 || (rv
== 0 && len
!= sizeof (dr
))) {
452 } else if (rv
== 0) {
453 /* end of file at a natural breaking point */
457 switch (dr
.ddr_type
) {
459 err
= write_free_diffs(ofp
, di
, &dr
);
462 err
= write_inuse_diffs(ofp
, di
, &dr
);
474 (void) close(di
->datafd
);
478 ASSERT(di
->zerr
== EINVAL
);
479 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
480 dgettext(TEXT_DOMAIN
,
481 "Internal error: bad data from diff IOCTL"));
488 find_shares_object(differ_info_t
*di
)
490 char fullpath
[MAXPATHLEN
];
491 struct stat64 sb
= { 0 };
493 (void) strlcpy(fullpath
, di
->dsmnt
, MAXPATHLEN
);
494 (void) strlcat(fullpath
, ZDIFF_SHARESDIR
, MAXPATHLEN
);
496 if (stat64(fullpath
, &sb
) != 0) {
497 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
498 dgettext(TEXT_DOMAIN
, "Cannot stat %s"), fullpath
);
499 return (zfs_error(di
->zhp
->zfs_hdl
, EZFS_DIFF
, di
->errbuf
));
502 di
->shares
= (uint64_t)sb
.st_ino
;
507 make_temp_snapshot(differ_info_t
*di
)
509 libzfs_handle_t
*hdl
= di
->zhp
->zfs_hdl
;
510 zfs_cmd_t zc
= { "\0", "\0", "\0", "\0", 0 };
512 (void) snprintf(zc
.zc_value
, sizeof (zc
.zc_value
),
513 ZDIFF_PREFIX
, getpid());
514 (void) strlcpy(zc
.zc_name
, di
->ds
, sizeof (zc
.zc_name
));
515 zc
.zc_cleanup_fd
= di
->cleanupfd
;
517 if (ioctl(hdl
->libzfs_fd
, ZFS_IOC_TMP_SNAPSHOT
, &zc
) != 0) {
520 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
521 dgettext(TEXT_DOMAIN
, "The diff delegated "
522 "permission is needed in order\nto create a "
523 "just-in-time snapshot for diffing\n"));
524 return (zfs_error(hdl
, EZFS_DIFF
, di
->errbuf
));
526 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
527 dgettext(TEXT_DOMAIN
, "Cannot create just-in-time "
528 "snapshot of '%s'"), zc
.zc_name
);
529 return (zfs_standard_error(hdl
, err
, di
->errbuf
));
533 di
->tmpsnap
= zfs_strdup(hdl
, zc
.zc_value
);
534 di
->tosnap
= zfs_asprintf(hdl
, "%s@%s", di
->ds
, di
->tmpsnap
);
539 teardown_differ_info(differ_info_t
*di
)
548 (void) close(di
->cleanupfd
);
552 get_snapshot_names(differ_info_t
*di
, const char *fromsnap
,
555 libzfs_handle_t
*hdl
= di
->zhp
->zfs_hdl
;
564 * dataset@snap1 dataset@snap2
565 * dataset@snap1 @snap2
566 * dataset@snap1 dataset
567 * @snap1 dataset@snap2
569 if (tosnap
== NULL
) {
570 /* only a from snapshot given, must be valid */
571 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
572 dgettext(TEXT_DOMAIN
,
573 "Badly formed snapshot name %s"), fromsnap
);
575 if (!zfs_validate_name(hdl
, fromsnap
, ZFS_TYPE_SNAPSHOT
,
577 return (zfs_error(hdl
, EZFS_INVALIDNAME
,
581 atptrf
= strchr(fromsnap
, '@');
582 ASSERT(atptrf
!= NULL
);
583 fdslen
= atptrf
- fromsnap
;
585 di
->fromsnap
= zfs_strdup(hdl
, fromsnap
);
586 di
->ds
= zfs_strdup(hdl
, fromsnap
);
587 di
->ds
[fdslen
] = '\0';
589 /* the to snap will be a just-in-time snap of the head */
590 return (make_temp_snapshot(di
));
593 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
594 dgettext(TEXT_DOMAIN
,
595 "Unable to determine which snapshots to compare"));
597 atptrf
= strchr(fromsnap
, '@');
598 atptrt
= strchr(tosnap
, '@');
599 fdslen
= atptrf
? atptrf
- fromsnap
: strlen(fromsnap
);
600 tdslen
= atptrt
? atptrt
- tosnap
: strlen(tosnap
);
601 fsnlen
= strlen(fromsnap
) - fdslen
; /* includes @ sign */
602 tsnlen
= strlen(tosnap
) - tdslen
; /* includes @ sign */
604 if (fsnlen
<= 1 || tsnlen
== 1 || (fdslen
== 0 && tdslen
== 0) ||
605 (fsnlen
== 0 && tsnlen
== 0)) {
606 return (zfs_error(hdl
, EZFS_INVALIDNAME
, di
->errbuf
));
607 } else if ((fdslen
> 0 && tdslen
> 0) &&
608 ((tdslen
!= fdslen
|| strncmp(fromsnap
, tosnap
, fdslen
) != 0))) {
610 * not the same dataset name, might be okay if
611 * tosnap is a clone of a fromsnap descendant.
613 char origin
[ZFS_MAXNAMELEN
];
617 di
->ds
= zfs_alloc(di
->zhp
->zfs_hdl
, tdslen
+ 1);
618 (void) strncpy(di
->ds
, tosnap
, tdslen
);
619 di
->ds
[tdslen
] = '\0';
621 zhp
= zfs_open(hdl
, di
->ds
, ZFS_TYPE_FILESYSTEM
);
622 while (zhp
!= NULL
) {
623 (void) zfs_prop_get(zhp
, ZFS_PROP_ORIGIN
,
624 origin
, sizeof (origin
), &src
, NULL
, 0, B_FALSE
);
626 if (strncmp(origin
, fromsnap
, fsnlen
) == 0)
629 (void) zfs_close(zhp
);
630 zhp
= zfs_open(hdl
, origin
, ZFS_TYPE_FILESYSTEM
);
634 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
635 dgettext(TEXT_DOMAIN
,
636 "Not an earlier snapshot from the same fs"));
637 return (zfs_error(hdl
, EZFS_INVALIDNAME
, di
->errbuf
));
639 (void) zfs_close(zhp
);
642 di
->isclone
= B_TRUE
;
643 di
->fromsnap
= zfs_strdup(hdl
, fromsnap
);
645 di
->tosnap
= zfs_strdup(hdl
, tosnap
);
647 return (make_temp_snapshot(di
));
650 int dslen
= fdslen
? fdslen
: tdslen
;
652 di
->ds
= zfs_alloc(hdl
, dslen
+ 1);
653 (void) strncpy(di
->ds
, fdslen
? fromsnap
: tosnap
, dslen
);
654 di
->ds
[dslen
] = '\0';
656 di
->fromsnap
= zfs_asprintf(hdl
, "%s%s", di
->ds
, atptrf
);
658 di
->tosnap
= zfs_asprintf(hdl
, "%s%s", di
->ds
, atptrt
);
660 return (make_temp_snapshot(di
));
667 get_mountpoint(differ_info_t
*di
, char *dsnm
, char **mntpt
)
671 mounted
= is_mounted(di
->zhp
->zfs_hdl
, dsnm
, mntpt
);
672 if (mounted
== B_FALSE
) {
673 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
674 dgettext(TEXT_DOMAIN
,
675 "Cannot diff an unmounted snapshot"));
676 return (zfs_error(di
->zhp
->zfs_hdl
, EZFS_BADTYPE
, di
->errbuf
));
679 /* Avoid a double slash at the beginning of root-mounted datasets */
680 if (**mntpt
== '/' && *(*mntpt
+ 1) == '\0')
686 get_mountpoints(differ_info_t
*di
)
692 * first get the mountpoint for the parent dataset
694 if (get_mountpoint(di
, di
->ds
, &di
->dsmnt
) != 0)
697 strptr
= strchr(di
->tosnap
, '@');
698 ASSERT3P(strptr
, !=, NULL
);
699 di
->tomnt
= zfs_asprintf(di
->zhp
->zfs_hdl
, "%s%s%s", di
->dsmnt
,
700 ZDIFF_SNAPDIR
, ++strptr
);
702 strptr
= strchr(di
->fromsnap
, '@');
703 ASSERT3P(strptr
, !=, NULL
);
705 frommntpt
= di
->dsmnt
;
711 err
= get_mountpoint(di
, di
->fromsnap
, &mntpt
);
718 di
->frommnt
= zfs_asprintf(di
->zhp
->zfs_hdl
, "%s%s%s", frommntpt
,
719 ZDIFF_SNAPDIR
, ++strptr
);
728 setup_differ_info(zfs_handle_t
*zhp
, const char *fromsnap
,
729 const char *tosnap
, differ_info_t
*di
)
733 di
->cleanupfd
= open(ZFS_DEV
, O_RDWR
);
734 VERIFY(di
->cleanupfd
>= 0);
736 if (get_snapshot_names(di
, fromsnap
, tosnap
) != 0)
739 if (get_mountpoints(di
) != 0)
742 if (find_shares_object(di
) != 0)
749 zfs_show_diffs(zfs_handle_t
*zhp
, int outfd
, const char *fromsnap
,
750 const char *tosnap
, int flags
)
752 zfs_cmd_t zc
= { "\0", "\0", "\0", "\0", 0 };
754 differ_info_t di
= { 0 };
759 (void) snprintf(errbuf
, sizeof (errbuf
),
760 dgettext(TEXT_DOMAIN
, "zfs diff failed"));
762 if (setup_differ_info(zhp
, fromsnap
, tosnap
, &di
)) {
763 teardown_differ_info(&di
);
768 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
769 teardown_differ_info(&di
);
770 return (zfs_error(zhp
->zfs_hdl
, EZFS_PIPEFAILED
, errbuf
));
773 di
.scripted
= (flags
& ZFS_DIFF_PARSEABLE
);
774 di
.classify
= (flags
& ZFS_DIFF_CLASSIFY
);
775 di
.timestamped
= (flags
& ZFS_DIFF_TIMESTAMP
);
778 di
.datafd
= pipefd
[0];
780 if (pthread_create(&tid
, NULL
, differ
, &di
)) {
781 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
782 (void) close(pipefd
[0]);
783 (void) close(pipefd
[1]);
784 teardown_differ_info(&di
);
785 return (zfs_error(zhp
->zfs_hdl
,
786 EZFS_THREADCREATEFAILED
, errbuf
));
790 (void) strlcpy(zc
.zc_value
, di
.fromsnap
, strlen(di
.fromsnap
) + 1);
791 (void) strlcpy(zc
.zc_name
, di
.tosnap
, strlen(di
.tosnap
) + 1);
792 zc
.zc_cookie
= pipefd
[1];
794 iocerr
= ioctl(zhp
->zfs_hdl
->libzfs_fd
, ZFS_IOC_DIFF
, &zc
);
796 (void) snprintf(errbuf
, sizeof (errbuf
),
797 dgettext(TEXT_DOMAIN
, "Unable to obtain diffs"));
798 if (errno
== EPERM
) {
799 zfs_error_aux(zhp
->zfs_hdl
, dgettext(TEXT_DOMAIN
,
800 "\n The sys_mount privilege or diff delegated "
801 "permission is needed\n to execute the "
803 } else if (errno
== EXDEV
) {
804 zfs_error_aux(zhp
->zfs_hdl
, dgettext(TEXT_DOMAIN
,
805 "\n Not an earlier snapshot from the same fs"));
806 } else if (errno
!= EPIPE
|| di
.zerr
== 0) {
807 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
809 (void) close(pipefd
[1]);
810 (void) pthread_cancel(tid
);
811 (void) pthread_join(tid
, NULL
);
812 teardown_differ_info(&di
);
813 if (di
.zerr
!= 0 && di
.zerr
!= EPIPE
) {
814 zfs_error_aux(zhp
->zfs_hdl
, strerror(di
.zerr
));
815 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFF
, di
.errbuf
));
817 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFFDATA
, errbuf
));
821 (void) close(pipefd
[1]);
822 (void) pthread_join(tid
, NULL
);
825 zfs_error_aux(zhp
->zfs_hdl
, strerror(di
.zerr
));
826 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFF
, di
.errbuf
));
828 teardown_differ_info(&di
);