]>
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.
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
)
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"), 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
) {
185 (void) fprintf(fp
, "%c", symbol
);
189 print_cmn(FILE *fp
, differ_info_t
*di
, const char *file
)
191 stream_bytes(fp
, di
->dsmnt
);
192 stream_bytes(fp
, file
);
196 print_rename(FILE *fp
, differ_info_t
*di
, const char *old
, const char *new,
200 (void) fprintf(fp
, "%10lld.%09lld\t",
201 (longlong_t
)isb
->zs_ctime
[0],
202 (longlong_t
)isb
->zs_ctime
[1]);
203 (void) fprintf(fp
, "%c\t", ZDIFF_RENAMED
);
205 print_what(fp
, isb
->zs_mode
);
206 (void) fprintf(fp
, "\t");
208 print_cmn(fp
, di
, old
);
210 (void) fprintf(fp
, "\t");
212 (void) fprintf(fp
, " -> ");
213 print_cmn(fp
, di
, new);
214 (void) fprintf(fp
, "\n");
218 print_link_change(FILE *fp
, differ_info_t
*di
, int delta
, const char *file
,
222 (void) fprintf(fp
, "%10lld.%09lld\t",
223 (longlong_t
)isb
->zs_ctime
[0],
224 (longlong_t
)isb
->zs_ctime
[1]);
225 (void) fprintf(fp
, "%c\t", ZDIFF_MODIFIED
);
227 print_what(fp
, isb
->zs_mode
);
228 (void) fprintf(fp
, "\t");
230 print_cmn(fp
, di
, file
);
231 (void) fprintf(fp
, "\t(%+d)", delta
);
232 (void) fprintf(fp
, "\n");
236 print_file(FILE *fp
, differ_info_t
*di
, char type
, const char *file
,
240 (void) fprintf(fp
, "%10lld.%09lld\t",
241 (longlong_t
)isb
->zs_ctime
[0],
242 (longlong_t
)isb
->zs_ctime
[1]);
243 (void) fprintf(fp
, "%c\t", type
);
245 print_what(fp
, isb
->zs_mode
);
246 (void) fprintf(fp
, "\t");
248 print_cmn(fp
, di
, file
);
249 (void) fprintf(fp
, "\n");
253 write_inuse_diffs_one(FILE *fp
, differ_info_t
*di
, uint64_t dobj
)
255 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 */
317 same_name
= do_name_cmp(fobjname
, tobjname
);
319 /* Simple modification or no change */
320 if (fsb
.zs_gen
== tsb
.zs_gen
) {
321 /* No apparent changes. Could we assert !this? */
322 if (fsb
.zs_ctime
[0] == tsb
.zs_ctime
[0] &&
323 fsb
.zs_ctime
[1] == tsb
.zs_ctime
[1])
326 print_link_change(fp
, di
, change
,
327 change
> 0 ? fobjname
: tobjname
, &tsb
);
328 } else if (same_name
) {
329 print_file(fp
, di
, ZDIFF_MODIFIED
, fobjname
, &tsb
);
331 print_rename(fp
, di
, fobjname
, tobjname
, &tsb
);
335 /* file re-created or object re-used */
336 print_file(fp
, di
, ZDIFF_REMOVED
, fobjname
, &fsb
);
337 print_file(fp
, di
, ZDIFF_ADDED
, tobjname
, &tsb
);
343 write_inuse_diffs(FILE *fp
, differ_info_t
*di
, dmu_diff_record_t
*dr
)
348 for (o
= dr
->ddr_first
; o
<= dr
->ddr_last
; o
++) {
349 if (err
= write_inuse_diffs_one(fp
, di
, o
))
356 describe_free(FILE *fp
, differ_info_t
*di
, uint64_t object
, char *namebuf
,
361 if (get_stats_for_obj(di
, di
->fromsnap
, object
, namebuf
,
363 /* Let it slide, if in the delete queue on from side */
364 if (di
->zerr
== ENOENT
&& sb
.zs_links
== 0) {
371 print_file(fp
, di
, ZDIFF_REMOVED
, namebuf
, &sb
);
376 write_free_diffs(FILE *fp
, differ_info_t
*di
, dmu_diff_record_t
*dr
)
378 zfs_cmd_t zc
= { 0 };
379 libzfs_handle_t
*lhdl
= di
->zhp
->zfs_hdl
;
380 char fobjname
[MAXPATHLEN
];
382 (void) strlcpy(zc
.zc_name
, di
->fromsnap
, sizeof (zc
.zc_name
));
383 zc
.zc_obj
= dr
->ddr_first
- 1;
385 ASSERT(di
->zerr
== 0);
387 while (zc
.zc_obj
< dr
->ddr_last
) {
390 err
= ioctl(lhdl
->libzfs_fd
, ZFS_IOC_NEXT_OBJ
, &zc
);
392 if (zc
.zc_obj
== di
->shares
) {
396 if (zc
.zc_obj
> dr
->ddr_last
) {
399 err
= describe_free(fp
, di
, zc
.zc_obj
, fobjname
,
403 } else if (errno
== ESRCH
) {
406 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
407 dgettext(TEXT_DOMAIN
,
408 "next allocated object (> %lld) find failure"),
422 differ_info_t
*di
= arg
;
423 dmu_diff_record_t dr
;
427 if ((ofp
= fdopen(di
->outputfd
, "w")) == NULL
) {
429 (void) strerror_r(errno
, di
->errbuf
, sizeof (di
->errbuf
));
430 (void) close(di
->datafd
);
435 char *cp
= (char *)&dr
;
436 int len
= sizeof (dr
);
440 rv
= read(di
->datafd
, cp
, len
);
443 } while (len
> 0 && rv
> 0);
445 if (rv
< 0 || (rv
== 0 && len
!= sizeof (dr
))) {
448 } else if (rv
== 0) {
449 /* end of file at a natural breaking point */
453 switch (dr
.ddr_type
) {
455 err
= write_free_diffs(ofp
, di
, &dr
);
458 err
= write_inuse_diffs(ofp
, di
, &dr
);
470 (void) close(di
->datafd
);
474 ASSERT(di
->zerr
== EINVAL
);
475 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
476 dgettext(TEXT_DOMAIN
,
477 "Internal error: bad data from diff IOCTL"));
484 find_shares_object(differ_info_t
*di
)
486 char fullpath
[MAXPATHLEN
];
487 struct stat64 sb
= { 0 };
489 (void) strlcpy(fullpath
, di
->dsmnt
, MAXPATHLEN
);
490 (void) strlcat(fullpath
, ZDIFF_SHARESDIR
, MAXPATHLEN
);
492 if (stat64(fullpath
, &sb
) != 0) {
493 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
494 dgettext(TEXT_DOMAIN
, "Cannot stat %s"), fullpath
);
495 return (zfs_error(di
->zhp
->zfs_hdl
, EZFS_DIFF
, di
->errbuf
));
498 di
->shares
= (uint64_t)sb
.st_ino
;
503 make_temp_snapshot(differ_info_t
*di
)
505 libzfs_handle_t
*hdl
= di
->zhp
->zfs_hdl
;
506 zfs_cmd_t zc
= { 0 };
508 (void) snprintf(zc
.zc_value
, sizeof (zc
.zc_value
),
509 ZDIFF_PREFIX
, getpid());
510 (void) strlcpy(zc
.zc_name
, di
->ds
, sizeof (zc
.zc_name
));
511 zc
.zc_cleanup_fd
= di
->cleanupfd
;
513 if (ioctl(hdl
->libzfs_fd
, ZFS_IOC_TMP_SNAPSHOT
, &zc
) != 0) {
516 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
517 dgettext(TEXT_DOMAIN
, "The diff delegated "
518 "permission is needed in order\nto create a "
519 "just-in-time snapshot for diffing\n"));
520 return (zfs_error(hdl
, EZFS_DIFF
, di
->errbuf
));
522 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
523 dgettext(TEXT_DOMAIN
, "Cannot create just-in-time "
524 "snapshot of '%s'"), zc
.zc_name
);
525 return (zfs_standard_error(hdl
, err
, di
->errbuf
));
529 di
->tmpsnap
= zfs_strdup(hdl
, zc
.zc_value
);
530 di
->tosnap
= zfs_asprintf(hdl
, "%s@%s", di
->ds
, di
->tmpsnap
);
535 teardown_differ_info(differ_info_t
*di
)
544 (void) close(di
->cleanupfd
);
548 get_snapshot_names(differ_info_t
*di
, const char *fromsnap
,
551 libzfs_handle_t
*hdl
= di
->zhp
->zfs_hdl
;
560 * dataset@snap1 dataset@snap2
561 * dataset@snap1 @snap2
562 * dataset@snap1 dataset
563 * @snap1 dataset@snap2
565 if (tosnap
== NULL
) {
566 /* only a from snapshot given, must be valid */
567 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
568 dgettext(TEXT_DOMAIN
,
569 "Badly formed snapshot name %s"), fromsnap
);
571 if (!zfs_validate_name(hdl
, fromsnap
, ZFS_TYPE_SNAPSHOT
,
573 return (zfs_error(hdl
, EZFS_INVALIDNAME
,
577 atptrf
= strchr(fromsnap
, '@');
578 ASSERT(atptrf
!= NULL
);
579 fdslen
= atptrf
- fromsnap
;
581 di
->fromsnap
= zfs_strdup(hdl
, fromsnap
);
582 di
->ds
= zfs_strdup(hdl
, fromsnap
);
583 di
->ds
[fdslen
] = '\0';
585 /* the to snap will be a just-in-time snap of the head */
586 return (make_temp_snapshot(di
));
589 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
590 dgettext(TEXT_DOMAIN
,
591 "Unable to determine which snapshots to compare"));
593 atptrf
= strchr(fromsnap
, '@');
594 atptrt
= strchr(tosnap
, '@');
595 fdslen
= atptrf
? atptrf
- fromsnap
: strlen(fromsnap
);
596 tdslen
= atptrt
? atptrt
- tosnap
: strlen(tosnap
);
597 fsnlen
= strlen(fromsnap
) - fdslen
; /* includes @ sign */
598 tsnlen
= strlen(tosnap
) - tdslen
; /* includes @ sign */
600 if (fsnlen
<= 1 || tsnlen
== 1 || (fdslen
== 0 && tdslen
== 0) ||
601 (fsnlen
== 0 && tsnlen
== 0)) {
602 return (zfs_error(hdl
, EZFS_INVALIDNAME
, di
->errbuf
));
603 } else if ((fdslen
> 0 && tdslen
> 0) &&
604 ((tdslen
!= fdslen
|| strncmp(fromsnap
, tosnap
, fdslen
) != 0))) {
606 * not the same dataset name, might be okay if
607 * tosnap is a clone of a fromsnap descendant.
609 char origin
[ZFS_MAXNAMELEN
];
613 di
->ds
= zfs_alloc(di
->zhp
->zfs_hdl
, tdslen
+ 1);
614 (void) strncpy(di
->ds
, tosnap
, tdslen
);
615 di
->ds
[tdslen
] = '\0';
617 zhp
= zfs_open(hdl
, di
->ds
, ZFS_TYPE_FILESYSTEM
);
618 while (zhp
!= NULL
) {
619 (void) zfs_prop_get(zhp
, ZFS_PROP_ORIGIN
,
620 origin
, sizeof (origin
), &src
, NULL
, 0, B_FALSE
);
622 if (strncmp(origin
, fromsnap
, fsnlen
) == 0)
625 (void) zfs_close(zhp
);
626 zhp
= zfs_open(hdl
, origin
, ZFS_TYPE_FILESYSTEM
);
630 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
631 dgettext(TEXT_DOMAIN
,
632 "Not an earlier snapshot from the same fs"));
633 return (zfs_error(hdl
, EZFS_INVALIDNAME
, di
->errbuf
));
635 (void) zfs_close(zhp
);
638 di
->isclone
= B_TRUE
;
639 di
->fromsnap
= zfs_strdup(hdl
, fromsnap
);
641 di
->tosnap
= zfs_strdup(hdl
, tosnap
);
643 return (make_temp_snapshot(di
));
646 int dslen
= fdslen
? fdslen
: tdslen
;
648 di
->ds
= zfs_alloc(hdl
, dslen
+ 1);
649 (void) strncpy(di
->ds
, fdslen
? fromsnap
: tosnap
, dslen
);
650 di
->ds
[dslen
] = '\0';
652 di
->fromsnap
= zfs_asprintf(hdl
, "%s%s", di
->ds
, atptrf
);
654 di
->tosnap
= zfs_asprintf(hdl
, "%s%s", di
->ds
, atptrt
);
656 return (make_temp_snapshot(di
));
663 get_mountpoint(differ_info_t
*di
, char *dsnm
, char **mntpt
)
667 mounted
= is_mounted(di
->zhp
->zfs_hdl
, dsnm
, mntpt
);
668 if (mounted
== B_FALSE
) {
669 (void) snprintf(di
->errbuf
, sizeof (di
->errbuf
),
670 dgettext(TEXT_DOMAIN
,
671 "Cannot diff an unmounted snapshot"));
672 return (zfs_error(di
->zhp
->zfs_hdl
, EZFS_BADTYPE
, di
->errbuf
));
675 /* Avoid a double slash at the beginning of root-mounted datasets */
676 if (**mntpt
== '/' && *(*mntpt
+ 1) == '\0')
682 get_mountpoints(differ_info_t
*di
)
688 * first get the mountpoint for the parent dataset
690 if (get_mountpoint(di
, di
->ds
, &di
->dsmnt
) != 0)
693 strptr
= strchr(di
->tosnap
, '@');
694 ASSERT3P(strptr
, !=, NULL
);
695 di
->tomnt
= zfs_asprintf(di
->zhp
->zfs_hdl
, "%s%s%s", di
->dsmnt
,
696 ZDIFF_SNAPDIR
, ++strptr
);
698 strptr
= strchr(di
->fromsnap
, '@');
699 ASSERT3P(strptr
, !=, NULL
);
701 frommntpt
= di
->dsmnt
;
707 err
= get_mountpoint(di
, di
->fromsnap
, &mntpt
);
714 di
->frommnt
= zfs_asprintf(di
->zhp
->zfs_hdl
, "%s%s%s", frommntpt
,
715 ZDIFF_SNAPDIR
, ++strptr
);
724 setup_differ_info(zfs_handle_t
*zhp
, const char *fromsnap
,
725 const char *tosnap
, differ_info_t
*di
)
729 di
->cleanupfd
= open(ZFS_DEV
, O_RDWR
|O_EXCL
);
730 VERIFY(di
->cleanupfd
>= 0);
732 if (get_snapshot_names(di
, fromsnap
, tosnap
) != 0)
735 if (get_mountpoints(di
) != 0)
738 if (find_shares_object(di
) != 0)
745 zfs_show_diffs(zfs_handle_t
*zhp
, int outfd
, const char *fromsnap
,
746 const char *tosnap
, int flags
)
748 zfs_cmd_t zc
= { 0 };
750 differ_info_t di
= { 0 };
755 (void) snprintf(errbuf
, sizeof (errbuf
),
756 dgettext(TEXT_DOMAIN
, "zfs diff failed"));
758 if (setup_differ_info(zhp
, fromsnap
, tosnap
, &di
)) {
759 teardown_differ_info(&di
);
764 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
765 teardown_differ_info(&di
);
766 return (zfs_error(zhp
->zfs_hdl
, EZFS_PIPEFAILED
, errbuf
));
769 di
.scripted
= (flags
& ZFS_DIFF_PARSEABLE
);
770 di
.classify
= (flags
& ZFS_DIFF_CLASSIFY
);
771 di
.timestamped
= (flags
& ZFS_DIFF_TIMESTAMP
);
774 di
.datafd
= pipefd
[0];
776 if (pthread_create(&tid
, NULL
, differ
, &di
)) {
777 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
778 (void) close(pipefd
[0]);
779 (void) close(pipefd
[1]);
780 teardown_differ_info(&di
);
781 return (zfs_error(zhp
->zfs_hdl
,
782 EZFS_THREADCREATEFAILED
, errbuf
));
786 (void) strlcpy(zc
.zc_value
, di
.fromsnap
, strlen(di
.fromsnap
) + 1);
787 (void) strlcpy(zc
.zc_name
, di
.tosnap
, strlen(di
.tosnap
) + 1);
788 zc
.zc_cookie
= pipefd
[1];
790 iocerr
= ioctl(zhp
->zfs_hdl
->libzfs_fd
, ZFS_IOC_DIFF
, &zc
);
792 (void) snprintf(errbuf
, sizeof (errbuf
),
793 dgettext(TEXT_DOMAIN
, "Unable to obtain diffs"));
794 if (errno
== EPERM
) {
795 zfs_error_aux(zhp
->zfs_hdl
, dgettext(TEXT_DOMAIN
,
796 "\n The sys_mount privilege or diff delegated "
797 "permission is needed\n to execute the "
799 } else if (errno
== EXDEV
) {
800 zfs_error_aux(zhp
->zfs_hdl
, dgettext(TEXT_DOMAIN
,
801 "\n Not an earlier snapshot from the same fs"));
802 } else if (errno
!= EPIPE
|| di
.zerr
== 0) {
803 zfs_error_aux(zhp
->zfs_hdl
, strerror(errno
));
805 (void) close(pipefd
[1]);
806 (void) pthread_cancel(tid
);
807 (void) pthread_join(tid
, NULL
);
808 teardown_differ_info(&di
);
809 if (di
.zerr
!= 0 && di
.zerr
!= EPIPE
) {
810 zfs_error_aux(zhp
->zfs_hdl
, strerror(di
.zerr
));
811 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFF
, di
.errbuf
));
813 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFFDATA
, errbuf
));
817 (void) close(pipefd
[1]);
818 (void) pthread_join(tid
, NULL
);
821 zfs_error_aux(zhp
->zfs_hdl
, strerror(di
.zerr
));
822 return (zfs_error(zhp
->zfs_hdl
, EZFS_DIFF
, di
.errbuf
));
824 teardown_differ_info(&di
);