1 /*
2 * Copyright (c) 2008 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * $DragonFly: src/sbin/hammer/cmd_snapshot.c,v 1.7 2008/07/10 18:47:22 mneumann Exp $
35 */
36
37 #include "hammer.h"
38
39 #define DEFAULT_SNAPSHOT_NAME "snap-%Y%m%d-%H%M"
40
41 static void snapshot_usage(int exit_code);
42 static void snapshot_add(int fd, const char *fsym, const char *tsym,
43 const char *label, hammer_tid_t tid);
44 static void snapshot_ls(const char *path);
45 static void snapshot_del(int fsfd, hammer_tid_t tid);
46 static char *dirpart(const char *path);
47
48 /*
49 * hammer snap <path> [<note>]
50 *
51 * Path may be a directory, softlink, or non-existent (a softlink will be
52 * created).
53 */
54 void
hammer_cmd_snap(char ** av,int ac,int tostdout,int fsbase)55 hammer_cmd_snap(char **av, int ac, int tostdout, int fsbase)
56 {
57 struct hammer_ioc_synctid synctid;
58 struct hammer_ioc_version version;
59 char *dirpath;
60 char *fsym = NULL;
61 char *tsym = NULL;
62 struct stat st;
63 char note[64];
64 int fsfd;
65
66 if (ac == 0 || ac > 2) {
67 snapshot_usage(1);
68 /* not reached */
69 }
70
71 if (ac == 2)
72 snprintf(note, sizeof(note), "%s", av[1]);
73 else
74 note[0] = 0;
75
76 /*
77 * Figure out the softlink path and directory path
78 */
79 if (stat(av[0], &st) < 0) {
80 dirpath = dirpart(av[0]);
81 tsym = strdup(av[0]);
82 } else if (S_ISDIR(st.st_mode)) {
83 time_t t = time(NULL);
84 struct tm *tp;
85 char extbuf[64];
86
87 tp = localtime(&t);
88 strftime(extbuf, sizeof(extbuf), DEFAULT_SNAPSHOT_NAME, tp);
89
90 dirpath = strdup(av[0]);
91 asprintf(&tsym, "%s/%s", dirpath, extbuf);
92 } else {
93 err(2, "hammer snap: File %s exists and is not a directory",
94 av[0]);
95 /* not reached */
96 }
97
98 /*
99 * Get a handle on some directory in the filesystem for the
100 * ioctl (so it is stored in the correct PFS).
101 */
102 fsfd = open(dirpath, O_RDONLY);
103 if (fsfd < 0) {
104 err(2, "hammer snap: Cannot open directory %s", dirpath);
105 /* not reached */
106 }
107
108 /*
109 * Must be at least version 3 to use this command.
110 */
111 bzero(&version, sizeof(version));
112
113 if (ioctl(fsfd, HAMMERIOC_GET_VERSION, &version) < 0) {
114 err(2, "Unable to create snapshot");
115 /* not reached */
116 } else if (version.cur_version < 3) {
117 errx(2, "Unable to create snapshot: This directive requires "
118 "you to upgrade\n"
119 "the filesystem to version 3. "
120 "Use 'hammer snapshot' for legacy operation.");
121 /* not reached */
122 }
123 HammerVersion = version.cur_version;
124
125 /*
126 * Synctid to get a transaction id for the snapshot.
127 */
128 bzero(&synctid, sizeof(synctid));
129 synctid.op = HAMMER_SYNCTID_SYNC2;
130 if (ioctl(fsfd, HAMMERIOC_SYNCTID, &synctid) < 0) {
131 err(2, "hammer snap: Synctid %s failed",
132 dirpath);
133 /* not reached */
134 }
135 if (tostdout) {
136 if (strcmp(dirpath, ".") == 0 || strcmp(dirpath, "..") == 0) {
137 printf("%s/@@0x%016jx\n",
138 dirpath, (uintmax_t)synctid.tid);
139 } else {
140 printf("%s@@0x%016jx\n",
141 dirpath, (uintmax_t)synctid.tid);
142 }
143 fsym = NULL;
144 tsym = NULL;
145 }
146
147 /*
148 * Contents of the symlink being created.
149 */
150 if (fsbase) {
151 struct statfs buf;
152
153 if (statfs(dirpath, &buf) < 0) {
154 err(2, "hammer snap: Cannot determine mount for %s",
155 dirpath);
156 /* not reached */
157 }
158 asprintf(&fsym, "%s/@@0x%016jx",
159 buf.f_mntonname, (uintmax_t)synctid.tid);
160 } else if (strcmp(dirpath, ".") == 0 || strcmp(dirpath, "..") == 0) {
161 asprintf(&fsym, "%s/@@0x%016jx",
162 dirpath, (uintmax_t)synctid.tid);
163 } else {
164 asprintf(&fsym, "%s@@0x%016jx",
165 dirpath, (uintmax_t)synctid.tid);
166 }
167
168 /*
169 * Create the snapshot.
170 */
171 snapshot_add(fsfd, fsym, tsym, note, synctid.tid);
172 free(dirpath);
173 free(fsym);
174 free(tsym);
175 }
176
177 /*
178 * hammer snapls [<path> ...]
179 *
180 * If no arguments are specified snapshots for the PFS containing the
181 * current directory are listed.
182 */
183 void
hammer_cmd_snapls(char ** av,int ac)184 hammer_cmd_snapls(char **av, int ac)
185 {
186 int i;
187
188 for (i = 0; i < ac; ++i)
189 snapshot_ls(av[i]);
190 if (ac == 0)
191 snapshot_ls(".");
192 }
193
194 /*
195 * hammer snaprm <path> ...
196 * hammer snaprm <transid> ...
197 * hammer snaprm <filesystem> <transid> ...
198 */
199 void
hammer_cmd_snaprm(char ** av,int ac)200 hammer_cmd_snaprm(char **av, int ac)
201 {
202 struct stat st;
203 char linkbuf[1024];
204 intmax_t tid;
205 int fsfd = -1;
206 int i;
207 int delete;
208 enum snaprm_mode { none_m, path_m, tid_m } mode = none_m;
209 char *dirpath;
210 char *ptr, *ptr2;
211
212 if (ac == 0) {
213 snapshot_usage(1);
214 /* not reached */
215 }
216
217 for (i = 0; i < ac; ++i) {
218 if (lstat(av[i], &st) < 0) {
219 tid = strtoull(av[i], &ptr, 16);
220 if (*ptr) {
221 err(2, "hammer snaprm: not a file or tid: %s",
222 av[i]);
223 /* not reached */
224 }
225 if (mode == path_m) {
226 snapshot_usage(1);
227 /* not reached */
228 }
229 mode = tid_m;
230 if (fsfd < 0)
231 fsfd = open(".", O_RDONLY);
232 snapshot_del(fsfd, tid);
233 } else if (S_ISDIR(st.st_mode)) {
234 if (i != 0 || ac < 2) {
235 snapshot_usage(1);
236 /* not reached */
237 }
238 if (fsfd >= 0)
239 close(fsfd);
240 fsfd = open(av[i], O_RDONLY);
241 if (fsfd < 0) {
242 err(2, "hammer snaprm: cannot open dir %s",
243 av[i]);
244 /* not reached */
245 }
246 mode = tid_m;
247 } else if (S_ISLNK(st.st_mode)) {
248 dirpath = dirpart(av[i]);
249 bzero(linkbuf, sizeof(linkbuf));
250 if (readlink(av[i], linkbuf, sizeof(linkbuf) - 1) < 0) {
251 err(2, "hammer snaprm: cannot read softlink: "
252 "%s", av[i]);
253 /* not reached */
254 }
255 if (linkbuf[0] == '/') {
256 free(dirpath);
257 dirpath = dirpart(linkbuf);
258 } else {
259 asprintf(&ptr, "%s/%s", dirpath, linkbuf);
260 free(dirpath);
261 dirpath = dirpart(ptr);
262 free(ptr);
263 }
264
265 if (fsfd >= 0)
266 close(fsfd);
267 fsfd = open(dirpath, O_RDONLY);
268 if (fsfd < 0) {
269 err(2, "hammer snaprm: cannot open dir %s",
270 dirpath);
271 /* not reached */
272 }
273
274 delete = 1;
275 if (i == 0 && ac > 1) {
276 mode = path_m;
277 if (lstat(av[1], &st) < 0) {
278 tid = strtoull(av[1], &ptr, 16);
279 if (*ptr == '\0') {
280 delete = 0;
281 mode = tid_m;
282 }
283 }
284 } else {
285 if (mode == tid_m) {
286 snapshot_usage(1);
287 /* not reached */
288 }
289 mode = path_m;
290 }
291 if (delete && (ptr = strrchr(linkbuf, '@')) &&
292 ptr > linkbuf && ptr[-1] == '@' && ptr[1]) {
293 tid = strtoull(ptr + 1, &ptr2, 16);
294 if (*ptr2 == '\0') {
295 snapshot_del(fsfd, tid);
296 remove(av[i]);
297 }
298 }
299 free(dirpath);
300 } else {
301 err(2, "hammer snaprm: not directory or snapshot "
302 "softlink: %s", av[i]);
303 /* not reached */
304 }
305 }
306 if (fsfd >= 0)
307 close(fsfd);
308 }
309
310 /*
311 * snapshot <softlink-dir>
312 * snapshot <filesystem> <softlink-dir> [<note>]
313 */
314 void
hammer_cmd_snapshot(char ** av,int ac)315 hammer_cmd_snapshot(char **av, int ac)
316 {
317 const char *filesystem;
318 const char *softlink_dir;
319 char *softlink_fmt;
320 struct statfs buf;
321 struct stat st;
322 struct hammer_ioc_synctid synctid;
323 char *from;
324 char *to;
325 char *note = NULL;
326
327 if (ac == 1) {
328 filesystem = NULL;
329 softlink_dir = av[0];
330 } else if (ac == 2) {
331 filesystem = av[0];
332 softlink_dir = av[1];
333 } else if (ac == 3) {
334 filesystem = av[0];
335 softlink_dir = av[1];
336 note = av[2];
337 } else {
338 snapshot_usage(1);
339 /* not reached */
340 }
341
342 if (stat(softlink_dir, &st) == 0) {
343 if (!S_ISDIR(st.st_mode)) {
344 err(2, "File %s already exists", softlink_dir);
345 /* not reached */
346 }
347
348 if (filesystem == NULL) {
349 if (statfs(softlink_dir, &buf) != 0) {
350 err(2, "Unable to determine filesystem of %s",
351 softlink_dir);
352 /* not reached */
353 }
354 filesystem = buf.f_mntonname;
355 }
356
357 softlink_fmt = malloc(strlen(softlink_dir) + 1 + 1 +
358 sizeof(DEFAULT_SNAPSHOT_NAME));
359 if (softlink_fmt == NULL) {
360 err(2, "Failed to allocate string");
361 /* not reached */
362 }
363
364 strcpy(softlink_fmt, softlink_dir);
365 if (softlink_fmt[strlen(softlink_fmt)-1] != '/')
366 strcat(softlink_fmt, "/");
367 strcat(softlink_fmt, DEFAULT_SNAPSHOT_NAME);
368 } else {
369 softlink_fmt = strdup(softlink_dir);
370
371 if (filesystem == NULL) {
372 /*
373 * strip-off last '/path' segment to get the softlink
374 * directory, which we need to determine the filesystem
375 * we are on.
376 */
377 char *pos = strrchr(softlink_fmt, '/');
378 if (pos != NULL)
379 *pos = '\0';
380
381 if (stat(softlink_fmt, &st) != 0 ||
382 !S_ISDIR(st.st_mode)) {
383 err(2, "Unable to determine softlink dir %s",
384 softlink_fmt);
385 /* not reached */
386 }
387 if (statfs(softlink_fmt, &buf) != 0) {
388 err(2, "Unable to determine filesystem of %s",
389 softlink_fmt);
390 /* not reached */
391 }
392 filesystem = buf.f_mntonname;
393
394 /* restore '/' */
395 if (pos != NULL)
396 *pos = '/';
397 }
398 }
399
400 /*
401 * Synctid
402 */
403 bzero(&synctid, sizeof(synctid));
404 synctid.op = HAMMER_SYNCTID_SYNC2;
405
406 int fd = open(filesystem, O_RDONLY);
407 if (fd < 0) {
408 err(2, "Unable to open %s", filesystem);
409 /* not reached */
410 }
411 if (ioctl(fd, HAMMERIOC_SYNCTID, &synctid) < 0) {
412 err(2, "Synctid %s failed", filesystem);
413 /* not reached */
414 }
415
416 asprintf(&from, "%s/@@0x%016jx", filesystem, (uintmax_t)synctid.tid);
417 if (from == NULL) {
418 err(2, "Couldn't generate string");
419 /* not reached */
420 }
421
422 int sz = strlen(softlink_fmt) + 50;
423 to = malloc(sz);
424 if (to == NULL) {
425 err(2, "Failed to allocate string");
426 /* not reached */
427 }
428
429 time_t t = time(NULL);
430 if (strftime(to, sz, softlink_fmt, localtime(&t)) == 0) {
431 err(2, "String buffer too small");
432 /* not reached */
433 }
434
435 asprintf(&from, "%s/@@0x%016jx", filesystem, (uintmax_t)synctid.tid);
436
437 snapshot_add(fd, from, to, note, synctid.tid);
438
439 close(fd);
440 printf("%s\n", to);
441
442 free(softlink_fmt);
443 free(from);
444 free(to);
445 }
446
447 static
448 void
snapshot_add(int fd,const char * fsym,const char * tsym,const char * label,hammer_tid_t tid)449 snapshot_add(int fd, const char *fsym, const char *tsym, const char *label,
450 hammer_tid_t tid)
451 {
452 struct hammer_ioc_version version;
453 struct hammer_ioc_snapshot snapshot;
454
455 bzero(&version, sizeof(version));
456 bzero(&snapshot, sizeof(snapshot));
457
458 /*
459 * For HAMMER filesystem v3+ the snapshot is recorded in meta-data.
460 */
461 if (ioctl(fd, HAMMERIOC_GET_VERSION, &version) == 0 &&
462 version.cur_version >= 3) {
463 HammerVersion = version.cur_version;
464 snapshot.index = 0;
465 snapshot.count = 1;
466 snapshot.snaps[0].tid = tid;
467 snapshot.snaps[0].ts = time(NULL) * 1000000ULL;
468 if (label) {
469 snprintf(snapshot.snaps[0].label,
470 sizeof(snapshot.snaps[0].label),
471 "%s",
472 label);
473 }
474 if (ioctl(fd, HAMMERIOC_ADD_SNAPSHOT, &snapshot) < 0) {
475 err(2, "Unable to create snapshot");
476 /* not reached */
477 } else if (snapshot.head.error &&
478 snapshot.head.error != EEXIST) {
479 errx(2, "Unable to create snapshot: %s",
480 strerror(snapshot.head.error));
481 /* not reached */
482 }
483 }
484
485 /*
486 * Create a symlink for the snapshot. If a file exists with the same
487 * name the new symlink will replace it.
488 */
489 if (fsym && tsym) {
490 remove(tsym);
491 if (symlink(fsym, tsym) < 0) {
492 err(2, "Unable to create symlink %s", tsym);
493 /* not reached */
494 }
495 }
496 }
497
498 static
499 void
snapshot_ls(const char * path)500 snapshot_ls(const char *path)
501 {
502 struct hammer_ioc_info info;
503 struct hammer_ioc_snapshot snapshot;
504 struct hammer_ioc_pseudofs_rw pfs;
505 struct hammer_pseudofs_data pfs_od;
506 hammer_snapshot_data_t snap;
507 struct tm *tp;
508 time_t t;
509 uint32_t i;
510 int fd;
511 char snapts[64];
512
513 fd = open(path, O_RDONLY);
514 if (fd < 0) {
515 err(2, "hammer snapls: cannot open %s", path);
516 /* not reached */
517 }
518
519 clrpfs(&pfs, &pfs_od, -1);
520 if (ioctl(fd, HAMMERIOC_GET_PSEUDOFS, &pfs) < 0) {
521 err(2, "hammer snapls: cannot retrieve PFS info on %s", path);
522 /* not reached */
523 }
524
525 bzero(&info, sizeof(info));
526 if ((ioctl(fd, HAMMERIOC_GET_INFO, &info)) < 0) {
527 err(2, "hammer snapls: cannot retrieve HAMMER info");
528 /* not reached */
529 }
530
531 printf("Snapshots on %s\tPFS#%d\n", path, pfs.pfs_id);
532 printf("Transaction ID\t\tTimestamp\t\tNote\n");
533
534 bzero(&snapshot, sizeof(snapshot));
535 do {
536 if (ioctl(fd, HAMMERIOC_GET_SNAPSHOT, &snapshot) < 0) {
537 err(2, "hammer snapls: %s: not HAMMER fs or "
538 "version < 3", path);
539 /* not reached */
540 }
541 for (i = 0; i < snapshot.count; ++i) {
542 snap = &snapshot.snaps[i];
543
544 t = snap->ts / 1000000ULL;
545 tp = localtime(&t);
546 strftime(snapts, sizeof(snapts),
547 "%Y-%m-%d %H:%M:%S %Z", tp);
548 printf("0x%016jx\t%s\t%s\n",
549 (uintmax_t)snap->tid, snapts,
550 strlen(snap->label) ? snap->label : "-");
551 }
552 } while (snapshot.head.error == 0 && snapshot.count);
553 }
554
555 static
556 void
snapshot_del(int fsfd,hammer_tid_t tid)557 snapshot_del(int fsfd, hammer_tid_t tid)
558 {
559 struct hammer_ioc_snapshot snapshot;
560 struct hammer_ioc_version version;
561
562 bzero(&version, sizeof(version));
563
564 if (ioctl(fsfd, HAMMERIOC_GET_VERSION, &version) < 0) {
565 err(2, "hammer snaprm 0x%016jx", (uintmax_t)tid);
566 /* not reached */
567 }
568 HammerVersion = version.cur_version;
569 if (version.cur_version < 3) {
570 errx(2, "hammer snaprm 0x%016jx: You must upgrade to version "
571 " 3 to use this directive", (uintmax_t)tid);
572 /* not reached */
573 }
574
575 bzero(&snapshot, sizeof(snapshot));
576 snapshot.count = 1;
577 snapshot.snaps[0].tid = tid;
578
579 /*
580 * Do not abort if we are unable to remove the meta-data.
581 */
582 if (ioctl(fsfd, HAMMERIOC_DEL_SNAPSHOT, &snapshot) < 0) {
583 err(2, "hammer snaprm 0x%016jx",
584 (uintmax_t)tid);
585 /* not reached */
586 } else if (snapshot.head.error == ENOENT) {
587 fprintf(stderr, "Warning: hammer snaprm 0x%016jx: "
588 "meta-data not found\n",
589 (uintmax_t)tid);
590 } else if (snapshot.head.error) {
591 fprintf(stderr, "Warning: hammer snaprm 0x%016jx: %s\n",
592 (uintmax_t)tid, strerror(snapshot.head.error));
593 }
594 }
595
596 static
597 void
snapshot_usage(int exit_code)598 snapshot_usage(int exit_code)
599 {
600 fprintf(stderr,
601 "hammer snap <path> [<note>]\t\tcreate snapshot & link, points to\n"
602 "\t\t\t\t\tbase of PFS mount\n"
603 "hammer snaplo <path> [<note>]\t\tcreate snapshot & link, points to\n"
604 "\t\t\t\t\ttarget dir\n"
605 "hammer snapq <dir> [<note>]\t\tcreate snapshot, output path to stdout\n"
606 "hammer snaprm <path> ...\t\tdelete snapshots; filesystem is CWD\n"
607 "hammer snaprm <transid> ...\t\tdelete snapshots\n"
608 "hammer snaprm <filesystem> <transid> ...\tdelete snapshots\n"
609 "hammer snapls [<path> ...]\t\tlist available snapshots\n"
610 "\n"
611 "NOTE: Snapshots are created in filesystem meta-data, any directory\n"
612 " in a HAMMER filesystem or PFS may be specified. If the path\n"
613 " specified does not exist this function will also create a\n"
614 " softlink.\n"
615 "\n"
616 " When deleting snapshots transaction ids may be directly specified\n"
617 " or file paths to snapshot softlinks may be specified. If a\n"
618 " softlink is specified the softlink will also be deleted.\n"
619 "\n"
620 "NOTE: The old 'hammer snapshot [<filesystem>] <snapshot-dir>' form\n"
621 " is still accepted but is a deprecated form. This form will\n"
622 " work for older hammer versions. The new forms only work for\n"
623 " HAMMER version 3 or later filesystems. HAMMER can be upgraded\n"
624 " to version 3 in-place.\n"
625 );
626 exit(exit_code);
627 }
628
629 static
630 char *
dirpart(const char * path)631 dirpart(const char *path)
632 {
633 const char *ptr;
634 char *res;
635
636 ptr = strrchr(path, '/');
637 if (ptr) {
638 while (ptr > path && ptr[-1] == '/')
639 --ptr;
640 if (ptr == path)
641 ptr = NULL;
642 }
643 if (ptr == NULL) {
644 path = ".";
645 ptr = path + 1;
646 }
647 res = malloc(ptr - path + 1);
648 bcopy(path, res, ptr - path);
649 res[ptr - path] = 0;
650 return(res);
651 }
652