cfc113ba46de04796e3a1d904d332e06933ad49f
[dragonfly.git] / sbin / hammer / cmd_snapshot.c
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 #include <sys/param.h>
39 #include <sys/mount.h>
40 #include <sys/types.h>
41 #include <sys/stat.h>
42 #include <unistd.h>
43 #include <string.h>
44 #include <time.h>
45
46 #define DEFAULT_SNAPSHOT_NAME "snap-%Y%m%d-%H%M"
47
48 static void snapshot_usage(int exit_code);
49 static void snapshot_add(int fd, const char *fsym, const char *tsym,
50                 const char *label, hammer_tid_t tid);
51 static void snapshot_ls(const char *path);
52 static void snapshot_del(int fsfd, hammer_tid_t tid);
53 static char *dirpart(const char *path);
54
55 /*
56  * hammer snap path ["note"]
57  *
58  * Path may be a directory, softlink, or non-existant (a softlink will be
59  * created).
60  */
61 void
62 hammer_cmd_snap(char **av, int ac, int tostdout, int fsbase)
63 {
64         struct hammer_ioc_synctid synctid;
65         struct hammer_ioc_version version;
66         char *dirpath;
67         char *fsym;
68         char *tsym;
69         struct stat st;
70         char note[64];
71         int fsfd;
72
73         if (ac == 0 || ac > 2) {
74                 snapshot_usage(1);
75                 /* not reached */
76                 exit(1);
77         }
78
79         if (ac == 2)
80                 snprintf(note, sizeof(note), "%s", av[1]);
81         else
82                 note[0] = 0;
83
84         /*
85          * Figure out the softlink path and directory path
86          */
87         if (stat(av[0], &st) < 0) {
88                 dirpath = dirpart(av[0]);
89                 tsym = av[0];
90         } else if (S_ISLNK(st.st_mode)) {
91                 dirpath = dirpart(av[0]);
92                 tsym = av[0];
93         } else if (S_ISDIR(st.st_mode)) {
94                 time_t t = time(NULL);
95                 struct tm *tp;
96                 char extbuf[64];
97
98                 tp = localtime(&t);
99                 strftime(extbuf, sizeof(extbuf), DEFAULT_SNAPSHOT_NAME, tp);
100
101                 dirpath = strdup(av[0]);
102                 asprintf(&tsym, "%s/%s", dirpath, extbuf);
103         } else {
104                 err(2, "hammer snap: File %s exists and is not a softlink\n",
105                     av[0]);
106                 /* not reached */
107         }
108
109         /*
110          * Get a handle on some directory in the filesystem for the
111          * ioctl (so it is stored in the correct PFS).
112          */
113         fsfd = open(dirpath, O_RDONLY);
114         if (fsfd < 0) {
115                 err(2, "hammder snap: Cannot open directory %s\n", dirpath);
116                 /* not reached */
117         }
118
119         /*
120          * Must be at least version 3 to use this command.
121          */
122         bzero(&version, sizeof(version));
123
124         if (ioctl(fsfd, HAMMERIOC_GET_VERSION, &version) < 0) {
125                 err(2, "Unable to create snapshot");
126                 /* not reached */
127         } else if (version.cur_version < 3) {
128                 errx(2, "Unable to create snapshot: This directive requires "
129                         "you to upgrade the filesystem\n"
130                         "to version 3.  Use 'hammer snapshot' for legacy "
131                         "operation");
132                 /* not reached */
133         }
134
135         /*
136          * Synctid to get a transaction id for the snapshot.
137          */
138         bzero(&synctid, sizeof(synctid));
139         synctid.op = HAMMER_SYNCTID_SYNC2;
140         if (ioctl(fsfd, HAMMERIOC_SYNCTID, &synctid) < 0) {
141                 err(2, "hammer snap: Synctid %s failed",
142                     dirpath);
143         }
144         if (tostdout) {
145                 printf("%s/@@%016jx\n", dirpath, (uintmax_t)synctid.tid);
146                 fsym = NULL;
147                 tsym = NULL;
148         }
149
150         /*
151          * Contents of the symlink being created.
152          */
153         if (fsbase) {
154                 struct statfs buf;
155
156                 if (statfs(dirpath, &buf) < 0) {
157                         err(2, "hammer snapfs: Cannot determine mount for %s",
158                             dirpath);
159                 }
160                 asprintf(&fsym, "%s/@@0x%016jx",
161                          buf.f_mntonname, (uintmax_t)synctid.tid);
162         } else {
163                 asprintf(&fsym, "%s/@@0x%016jx",
164                          dirpath, (uintmax_t)synctid.tid);
165         }
166
167         /*
168          * Create the snapshot.
169          */
170         snapshot_add(fsfd, fsym, tsym, note, synctid.tid);
171         free(dirpath);
172 }
173
174 /*
175  * hammer snapls [path]*
176  *
177  * If no arguments are specified snapshots for the PFS containing the
178  * current directory are listed.
179  */
180 void
181 hammer_cmd_snapls(char **av, int ac)
182 {
183         int i;
184
185         for (i = 0; i < ac; ++i)
186                 snapshot_ls(av[i]);
187         if (ac == 0)
188                 snapshot_ls(".");
189 }
190
191 /*
192  * hammer snaprm [fsdir] [path/transid]*
193  */
194 void
195 hammer_cmd_snaprm(char **av, int ac)
196 {
197         struct stat st;
198         char linkbuf[1024];
199         intmax_t tid;
200         int fsfd = -1;
201         int i;
202         char *dirpath;
203         char *ptr;
204
205         for (i = 0; i < ac; ++i) {
206                 if (lstat(av[i], &st) < 0) {
207                         tid = strtoull(av[i], &ptr, 16);
208                         if (tid == 0 || *ptr) {
209                                 err(2, "hammer snaprm: not a file or tid: %s",
210                                     av[i]);
211                                 /* not reached */
212                         }
213                         snapshot_del(fsfd, tid);
214                 } else if (S_ISDIR(st.st_mode)) {
215                         if (fsfd >= 0)
216                                 close(fsfd);
217                         fsfd = open(av[i], O_RDONLY);
218                         if (fsfd < 0) {
219                                 err(2, "hammer snaprm: cannot open dir %s",
220                                     av[i]);
221                                 /* not reached */
222                         }
223                 } else if (S_ISLNK(st.st_mode)) {
224                         dirpath = dirpart(av[i]);
225                         bzero(linkbuf, sizeof(linkbuf));
226                         if (readlink(av[i], linkbuf, sizeof(linkbuf) - 1) < 0) {
227                                 err(2, "hammer snaprm: cannot read softlink: "
228                                        "%s", av[i]);
229                                 /* not reached */
230                         }
231                         if (linkbuf[0] == '/') {
232                                 free(dirpath);
233                                 dirpath = dirpart(linkbuf);
234                         } else {
235                                 asprintf(&ptr, "%s/%s", dirpath, linkbuf);
236                                 free(dirpath);
237                                 dirpath = dirpart(ptr);
238                         }
239
240                         if (fsfd >= 0)
241                                 close(fsfd);
242                         fsfd = open(dirpath, O_RDONLY);
243                         if (fsfd < 0) {
244                                 err(2, "hammer snaprm: cannot open dir %s",
245                                     dirpath);
246                                 /* not reached */
247                         }
248
249                         if ((ptr = strrchr(linkbuf, '@')) &&
250                             ptr > linkbuf && ptr[-1] == '@') {
251                                 tid = strtoull(ptr + 1, NULL, 16);
252                                 snapshot_del(fsfd, tid);
253                         }
254                         remove(av[i]);
255                         free(dirpath);
256                 } else {
257                         err(2, "hammer snaprm: not directory or snapshot "
258                                "softlink: %s", av[i]);
259                         /* not reached */
260                 }
261         }
262         if (fsfd >= 0)
263                 close(fsfd);
264 }
265
266 /*
267  * snapshot <softlink-dir-in-filesystem>
268  * snapshot <filesystem> <softlink-dir>
269  */
270 void
271 hammer_cmd_snapshot(char **av, int ac)
272 {
273         const char *filesystem;
274         const char *softlink_dir;
275         char *softlink_fmt;
276         struct statfs buf;
277         struct stat st;
278         struct hammer_ioc_synctid synctid;
279         char *from;
280         char *to;
281         char *note = NULL;
282
283         if (ac == 1) {
284                 filesystem = NULL;
285                 softlink_dir = av[0];
286         } else if (ac == 2) {
287                 filesystem = av[0];
288                 softlink_dir = av[1];
289         } else if (ac == 3) {
290                 filesystem = av[0];
291                 softlink_dir = av[1];
292                 note = av[2];
293         } else {
294                 snapshot_usage(1);
295                 /* not reached */
296                 softlink_dir = NULL;
297                 filesystem = NULL;
298         }
299
300         if (stat(softlink_dir, &st) == 0) {
301                 if (!S_ISDIR(st.st_mode)) 
302                         err(2, "File %s already exists", softlink_dir);
303
304                 if (filesystem == NULL) {
305                         if (statfs(softlink_dir, &buf) != 0) {
306                                 err(2, "Unable to determine filesystem of %s",
307                                     softlink_dir);
308                         }
309                         filesystem = buf.f_mntonname;
310                 }
311
312                 softlink_fmt = malloc(strlen(softlink_dir) + 1 + 1 +
313                                       sizeof(DEFAULT_SNAPSHOT_NAME));
314                 if (softlink_fmt == NULL)
315                         err(2, "Failed to allocate string");
316         
317                 strcpy(softlink_fmt, softlink_dir);
318                 if (softlink_fmt[strlen(softlink_fmt)-1] != '/')
319                         strcat(softlink_fmt, "/");
320                 strcat(softlink_fmt, DEFAULT_SNAPSHOT_NAME); 
321         } else {
322                 softlink_fmt = strdup(softlink_dir);
323
324                 if (filesystem == NULL) {
325                         /* 
326                          * strip-off last '/path' segment to get the softlink
327                          * directory, which we need to determine the filesystem
328                          * we are on.
329                          */
330                         char *pos = strrchr(softlink_fmt, '/');
331                         if (pos != NULL)
332                                 *pos = '\0';
333
334                         if (stat(softlink_fmt, &st) != 0 ||
335                             !S_ISDIR(st.st_mode)) {
336                                 err(2, "Unable to determine softlink dir %s",
337                                     softlink_fmt);
338                         }
339                         if (statfs(softlink_fmt, &buf) != 0) {
340                                 err(2, "Unable to determine filesystem of %s",
341                                     softlink_fmt);
342                         }
343                         filesystem = buf.f_mntonname;
344
345                         /* restore '/' */
346                         if (pos != NULL)
347                                 *pos = '/';
348                 }
349         }
350         
351         /*
352          * Synctid 
353          */
354         bzero(&synctid, sizeof(synctid));
355         synctid.op = HAMMER_SYNCTID_SYNC2;
356
357         int fd = open(filesystem, O_RDONLY);
358         if (fd < 0)
359                 err(2, "Unable to open %s", filesystem);
360         if (ioctl(fd, HAMMERIOC_SYNCTID, &synctid) < 0)
361                 err(2, "Synctid %s failed", filesystem);
362
363         asprintf(&from, "%s/@@0x%016jx", filesystem, (uintmax_t)synctid.tid);
364         if (from == NULL)
365                 err(2, "Couldn't generate string");
366         
367         int sz = strlen(softlink_fmt) + 50;
368         to = malloc(sz);
369         if (to == NULL)
370                 err(2, "Failed to allocate string");
371         
372         time_t t = time(NULL);
373         if (strftime(to, sz, softlink_fmt, localtime(&t)) == 0)
374                 err(2, "String buffer too small");
375
376         asprintf(&from, "%s/@@0x%016jx", filesystem, (uintmax_t)synctid.tid);
377
378         snapshot_add(fd, from, to, note, synctid.tid);
379
380         close(fd);
381         printf("%s\n", to);
382
383         free(softlink_fmt);
384         free(from);
385         free(to);
386 }
387
388 static
389 void
390 snapshot_add(int fd, const char *fsym, const char *tsym, const char *label,
391              hammer_tid_t tid)
392 {
393         struct hammer_ioc_version version;
394         struct hammer_ioc_snapshot snapshot;
395
396         bzero(&version, sizeof(version));
397         bzero(&snapshot, sizeof(snapshot));
398
399         /*
400          * For HAMMER filesystem v3+ the snapshot is recorded in meta-data.
401          */
402         if (ioctl(fd, HAMMERIOC_GET_VERSION, &version) == 0 &&
403             version.cur_version >= 3) {
404                 snapshot.index = 0;
405                 snapshot.count = 1;
406                 snapshot.snaps[0].tid = tid;
407                 snapshot.snaps[0].ts = time(NULL) * 1000000ULL;
408                 if (label) {
409                         snprintf(snapshot.snaps[0].label,
410                                  sizeof(snapshot.snaps[0].label),
411                                  "%s",
412                                  label);
413                 }
414                 if (ioctl(fd, HAMMERIOC_ADD_SNAPSHOT, &snapshot) < 0) {
415                         err(2, "Unable to create snapshot");
416                 } else if (snapshot.head.error &&
417                            snapshot.head.error != EEXIST) {
418                         errx(2, "Unable to create snapshot: %s\n",
419                                 strerror(snapshot.head.error));
420                 }
421         }
422
423         /*
424          * Create a symlink for the snapshot.  If a file exists with the same
425          * name the new symlink will replace it.
426          */
427         if (fsym && tsym) {
428                 remove(tsym);
429                 if (symlink(fsym, tsym) < 0) {
430                         err(2, "Unable to create symlink %s", tsym);
431                 }
432         }
433 }
434
435 static
436 void
437 snapshot_ls(const char *path)
438 {
439         /*struct hammer_ioc_version version;*/
440         struct hammer_ioc_snapshot snapshot;
441         struct hammer_ioc_pseudofs_rw pfs;
442         struct hammer_snapshot_data *snap;
443         struct tm *tp;
444         time_t t;
445         u_int32_t i;
446         int fd;
447         char snapts[64];
448
449         fd = open(path, O_RDONLY);
450         if (fd < 0) {
451                 err(2, "hammer snapls: cannot open %s", path);
452                 /* not reached */
453         }
454
455         bzero(&pfs, sizeof(pfs));
456         pfs.pfs_id = -1;
457         pfs.bytes = sizeof(struct hammer_pseudofs_data);
458         if (ioctl(fd, HAMMERIOC_GET_PSEUDOFS, &pfs) < 0) {
459                 err(2, "hammer snapls: cannot retrieve PFS info on %s", path);
460                 /* not reached */
461         }
462
463         printf("snapshots on pfs %d\n", pfs.pfs_id);
464
465         bzero(&snapshot, sizeof(snapshot));
466         do {
467                 if (ioctl(fd, HAMMERIOC_GET_SNAPSHOT, &snapshot) < 0) {
468                         err(2, "hammer snapls: %s: not HAMMER fs or "
469                                 "version < 3", path);
470                         /* not reached */
471                 }
472                 for (i = 0; i < snapshot.count; ++i) {
473                         snap = &snapshot.snaps[i];
474
475                         t = snap->ts / 1000000ULL;
476                         tp = localtime(&t);
477                         strftime(snapts, sizeof(snapts),
478                                  "%Y-%m-%d %H:%M:%S %Z", tp);
479                         printf("0x%016jx\t%s\t%s\n",
480                                 (uintmax_t)snap->tid, snapts, snap->label);
481                 }
482         } while (snapshot.head.error == 0 && snapshot.count);
483 }
484
485 static
486 void
487 snapshot_del(int fsfd, hammer_tid_t tid)
488 {
489         struct hammer_ioc_snapshot snapshot;
490         struct hammer_ioc_version version;
491
492         bzero(&version, sizeof(version));
493
494         if (ioctl(fsfd, HAMMERIOC_GET_VERSION, &version) < 0) {
495                 err(2, "hammer snaprm 0x%016jx", (uintmax_t)tid);
496         }
497         if (version.cur_version < 3) {
498                 errx(2, "hammer snaprm 0x%016jx: You must upgrade to version "
499                         " 3 to use this directive", (uintmax_t)tid);
500         }
501
502         bzero(&snapshot, sizeof(snapshot));
503         snapshot.count = 1;
504         snapshot.snaps[0].tid = tid;
505
506         if (ioctl(fsfd, HAMMERIOC_DEL_SNAPSHOT, &snapshot) < 0) {
507                 err(2, "hammer snaprm 0x%016jx", (uintmax_t)tid);
508         } else if (snapshot.head.error) {
509                 fprintf(stderr, "hammer snaprm 0x%016jx: %s\n",
510                         (uintmax_t)tid, strerror(snapshot.head.error));
511         }
512 }
513
514 static
515 void
516 snapshot_usage(int exit_code)
517 {
518         fprintf(stderr,
519     "hammer snap path [\"note\"]\t- create snapshot & link, "
520                                 "points to base of PFS mount\n"
521     "hammer snaplo path [\"note\"]\t- create snapshot & link, "
522                                 "points to target dir\n"
523     "hammer snapq  path [\"note\"]\t- create snapshot, output path to stdout\n"
524     "hammer snapls [<fs>]\t\t- list available snapshots.\n"
525     "hammer snaprm [<fs>] [path/transid]*\t- delete snapshots.\n"
526     "\n"
527     "NOTE: Snapshots are created in filesystem meta-data, any directory\n"
528     "      in a HAMMER filesystem or PFS may be specified.  If the path\n"
529     "      specified does not exist this function will also create a\n"
530     "      softlink.\n"
531     "\n"
532     "      When deleting snapshots transaction ids may be directly specified\n"
533     "      or file paths to snapshoft softlinks may be specified.  If a\n"
534     "      softlink is specified the softlink will also be deleted\n"
535     "\n"
536     "NOTE: The old 'hammer snapshot [<filesystem>] <snapshot-dir>' form\n"
537     "      is still accepted but is a deprecated form.  This form will\n"
538     "      work for older hammer versions.  The new forms only work for\n"
539     "      HAMMER version 3 or later filesystems.  HAMMER can be upgraded\n"
540     "      to version 3 in-place\n"
541         );
542         exit(exit_code);
543 }
544
545 static
546 char *
547 dirpart(const char *path)
548 {
549         const char *ptr;
550         char *res;
551
552         ptr = strrchr(path, '/');
553         if (ptr) {
554                 while (ptr > path && ptr[-1] == '/')
555                         --ptr;
556                 if (ptr == path)
557                         ptr = NULL;
558         }
559         if (ptr == NULL) {
560                 path = ".";
561                 ptr = path + 1;
562         }
563         res = malloc(ptr - path + 1);
564         bcopy(path, res, ptr - path);
565         res[ptr - path] = 0;
566         return(res);
567 }