2 * Unix SMB/CIFS implementation.
4 * OneFS shadow copy implementation that utilizes the file system's native
5 * snapshot support. This file does all of the heavy lifting.
7 * Copyright (C) Dave Richards, 2007
8 * Copyright (C) Tim Prouty, 2009
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 3 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, see <http://www.gnu.org/licenses/>.
24 #include <ifs/ifs_syscalls.h>
25 #include <sys/types.h>
26 #include <sys/isi_enc.h>
27 #include <sys/module.h>
29 #include <sys/syscall.h>
41 #include "onefs_shadow_copy.h"
43 /* Copied from ../include/proto.h */
44 void become_root(void);
45 void unbecome_root(void);
47 #define SNAPSHOT_DIRECTORY ".snapshot"
49 #define MAX_VERSIONS 64
54 * During snapshot enumeration, snapshots are represented by snapshot objects
55 * and are stored in a snapshot set. The snapshot object represents one
56 * snapshot within the set. An important thing to note about the set is that
57 * the key of the snapshot object is the tv_sec component of the is_time
58 * member. What this means is that we only store one snapshot for each
59 * second. If multiple snapshots were created within the same second, we'll
60 * keep the earliest one and ignore the rest. Thus, not all snapshots are
61 * necessarily retained.
65 struct timespec is_time;
66 struct osc_snapshot * is_next;
70 * A snapshot context object.
72 * Snapshot contexts are used to pass information throughout the snapshot
73 * enumeration routines. As a result, snapshot contexts are stored on the
74 * stack and are both created and destroyed within a single API function.
76 struct osc_snapshot_ctx {
78 struct timespec osc_mtime;
82 * A directory context.
84 * Directory contexts are the underlying data structured used to enumerate
85 * snapshot versions. An opendir()-, readdir()- and closedir()-like interface
86 * is provided that utilizes directory contexts. At the API level, directory
87 * contexts are passed around as void pointers. Directory contexts are
88 * allocated on the heap and their lifetime is dictated by the calling
91 struct osc_directory_ctx {
99 * Return a file descriptor to the STF names directory.
101 * Opens the STF names directory and returns a file descriptor to it.
102 * Subsequent calls return the same value (avoiding the need to re-open the
103 * directory repeatedly). Caveat caller: don't close the file descriptor or
107 osc_get_names_directory_fd(void)
113 fd = pctl2_lin_open(STF_NAMES_LIN, HEAD_SNAPID, O_RDONLY);
121 * Compare two time values.
123 * Accepts two struct timespecs and compares the tv_sec components of these
124 * values. It returns -1 if the first value preceeds the second, 0 if they
125 * are equal and +1 if the first values succeeds the second.
128 osc_time_compare(const struct timespec *tsp1, const struct timespec *tsp2)
130 return (tsp1->tv_sec < tsp2->tv_sec) ? -1 :
131 (tsp1->tv_sec > tsp2->tv_sec) ? +1 : 0;
135 * Compare two timespec values.
137 * Compares two timespec values. It returns -1 if the first value preceeds
138 * the second, 0 if they are equal and +1 if the first values succeeds the
142 osc_timespec_compare(const struct timespec *tsp1, const struct timespec *tsp2)
144 return (tsp1->tv_sec < tsp2->tv_sec) ? -1 :
145 (tsp1->tv_sec > tsp2->tv_sec) ? +1 :
146 (tsp1->tv_nsec < tsp2->tv_nsec) ? -1 :
147 (tsp1->tv_nsec > tsp2->tv_nsec) ? +1 : 0;
151 * Determine whether a timespec value is zero.
153 * Return 1 if the struct timespec provided is zero and 0 otherwise.
156 osc_timespec_is_zero(const struct timespec *tsp)
158 return (tsp->tv_sec == 0) &&
163 * Create a snapshot object.
165 * Allocates and initializes a new snapshot object. In addition to allocating
166 * space for the snapshot object itself, space is allocated for the snapshot
167 * name. Both the name and time are then copied to the new object.
169 static struct osc_snapshot *
170 osc_snapshot_create(const char *name, const struct timespec *tsp)
172 struct osc_snapshot *isp;
174 isp = malloc(sizeof *isp);
178 isp->is_name = malloc(strlen(name) + 1);
179 if (isp->is_name == NULL) {
185 strcpy(isp->is_name, name);
194 * Destroy a snapshot object.
196 * Frees both the name and the snapshot object itself. Appropriate NULL
197 * checking is performed because counting on free to do so is immoral.
200 osc_snapshot_destroy(struct osc_snapshot *isp)
203 if (isp->is_name != NULL)
210 * Destroy all snapshots in the snapshot list.
212 * Calls osc_snapshot_destroy() on each snapshot in the list.
215 osc_snapshot_destroy_list(struct osc_snapshot *isp)
217 struct osc_snapshot *tmp;
219 while (isp != NULL) {
222 osc_snapshot_destroy(tmp);
227 * Compare two snapshot objects.
229 * Compare two snapshot objects. It is really just a wrapper for
230 * osc_time_compare(), which compare the time value of the two snapshots.
231 * N.B. time value in this context refers only to the tv_sec component.
234 osc_snapshot_compare(const void *vp1, const void *vp2)
236 const struct osc_snapshot *isp1 = vp1;
237 const struct osc_snapshot *isp2 = vp2;
239 return -osc_time_compare(&isp1->is_time, &isp2->is_time);
243 * Insert a snapshot into the snapshot set.
245 * Inserts a new snapshot into the snapshot set. The key for snapshots is
246 * their creation time (it's actually the seconds portion of the creation
247 * time). If a duplicate snapshot is found in the set, the new snapshot is
248 * added to a linked list of snapshots for that second.
251 osc_snapshot_insert(struct osc_snapshot_ctx *oscp, const char *name,
252 const struct timespec *tsp, int *errorp)
254 struct osc_snapshot *isp1;
255 struct osc_snapshot **ispp;
257 isp1 = osc_snapshot_create(name, tsp);
263 ispp = tsearch(isp1, &oscp->osc_set, osc_snapshot_compare);
265 struct osc_snapshot *isp2 = *ispp;
267 /* If this is the only snapshot for this second, we're done. */
271 /* Collision: add the new snapshot to the list. */
272 isp1->is_next = isp2->is_next;
273 isp2->is_next = isp1;
281 * Process the next snapshot.
283 * Called for (almost) every entry in a .snapshot directory, ("." and ".." are
284 * ignored in osc_process_snapshot_directory()). All other entries are passed
285 * to osc_process_snapshot(), however. These entries can fall into one of two
286 * categories: snapshot names and snapshot aliases. We only care about
287 * snapshot names (as aliases are just redundant entries). Once it verifies
288 * that name represents a valid snapshot name, it calls fstat() to get the
289 * creation time of the snapshot and then calls osc_snapshot_insert() to add
290 * this entry to the snapshot set.
293 osc_process_snapshot(struct osc_snapshot_ctx *oscp, const char *name,
297 struct stf_stat stf_stat;
300 fd = osc_get_names_directory_fd();
304 fd = enc_openat(fd, name, ENC_DEFAULT, O_RDONLY);
308 memset(&stf_stat, 0, sizeof stf_stat);
309 if (ifs_snap_stat(fd, &stf_stat) == -1)
312 if (stf_stat.sf_type != SF_STF)
315 if (fstat(fd, &stbuf) == -1)
318 osc_snapshot_insert(oscp, name, &stbuf.st_birthtimespec, errorp);
326 * Process a snapshot directory.
328 * Opens the snapshot directory and calls osc_process_snapshot() for each
329 * entry. (Well ok, "." and ".." are ignored.) The goal here is to add all
330 * snapshots in the directory to the snapshot set.
333 osc_process_snapshot_directory(struct osc_snapshot_ctx *oscp, int *errorp)
340 fd = osc_get_names_directory_fd();
344 if (fstat(fd, &stbuf) == -1)
347 dirp = opendir(SNAPSHOT_DIRECTORY);
356 if (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' ||
357 (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
360 osc_process_snapshot(oscp, dp->d_name, errorp);
368 oscp->osc_mtime = stbuf.st_mtimespec;
375 * Initialize a snapshot context object.
377 * Clears all members of the context object.
380 osc_snapshot_ctx_init(struct osc_snapshot_ctx *oscp)
382 memset(oscp, 0, sizeof *oscp);
386 * Desoy a snapshot context object.
388 * Frees all snapshots associated with the snapshot context and then calls
389 * osc_snapshot_ctx_init() to re-initialize the context object.
392 osc_snapshot_ctx_clean(struct osc_snapshot_ctx *oscp)
394 struct osc_snapshot *tmp;
396 while (oscp->osc_set != NULL) {
397 tmp = *(void **)oscp->osc_set;
398 tdelete(tmp, &oscp->osc_set, osc_snapshot_compare);
399 osc_snapshot_destroy_list(tmp);
402 osc_snapshot_ctx_init(oscp);
406 * Return the "global" snapshot context.
408 * We maintain a single open snapshot context. Return a pointer to it.
410 static struct osc_snapshot_ctx *
411 osc_get_snapshot_ctx(void)
413 static struct osc_snapshot_ctx osc = { 0, { 0, 0 } };
419 * Determine whether a snapshot context is still valid.
421 * "Valid" in this context means "reusable". We can re-use a previous
422 * snapshot context iff we successfully built a previous snapshot context
423 * and no snapshots have been created or deleted since we did so.
424 * A "names" directory exists within our snapshot
425 * implementation in which all snapshot names are entered. Each time a
426 * snapshot is created or deleted, an entry must be added or removed.
427 * When this happens the modification time on the "names" directory
428 * changes. Therefore, a snapshot context is valid iff the context
429 * pointer is non-NULL, the cached modification time is non-zero
430 * (zero means uninitialized), and the modification time of the "names"
431 * directory matches the cached value.
434 osc_snapshot_ctx_is_valid(struct osc_snapshot_ctx *oscp)
442 if (osc_timespec_is_zero(&oscp->osc_mtime))
445 fd = osc_get_names_directory_fd();
449 if (fstat(fd, &stbuf) == -1)
452 if (osc_timespec_compare(&oscp->osc_mtime, &stbuf.st_mtimespec) != 0)
459 * Create and initialize a directory context.
461 * Allocates a directory context from the heap and initializes it.
463 static struct osc_directory_ctx *
464 osc_directory_ctx_create(void)
466 struct osc_directory_ctx *idcp;
468 idcp = malloc(sizeof *idcp);
470 memset(idcp, 0, sizeof *idcp);
476 * Destroy a directory context.
478 * Frees any versions associated with the directory context and then frees the
482 osc_directory_ctx_destroy(struct osc_directory_ctx *idcp)
489 for (i = 0; i < idcp->idc_len; i++)
490 free(idcp->idc_version[i]);
496 * Expand the size of a directory context's version list.
498 * If osc_directory_ctx_append_version() detects that the version list is too
499 * small to accomodate a new version string, it called
500 * osc_directory_ctx_expand_version_list() to expand the version list.
503 osc_directory_ctx_expand_version_list(struct osc_snapshot_ctx *oscp,
504 struct osc_directory_ctx *idcp, int *errorp)
509 size = idcp->idc_size * 2 ?: 1;
511 cpp = realloc(idcp->idc_version, size * sizeof (char *));
517 idcp->idc_size = size;
518 idcp->idc_version = cpp;
522 * Append a new version to a directory context.
524 * Appends a snapshot version to the
525 * directory context's version list.
528 osc_directory_ctx_append_version(struct osc_snapshot_ctx *oscp,
529 struct osc_directory_ctx *idcp, const struct timespec *tsp, int *errorp)
535 if (idcp->idc_len >= MAX_VERSIONS)
538 if (idcp->idc_len >= idcp->idc_size) {
539 osc_directory_ctx_expand_version_list(oscp, idcp, errorp);
544 tmp = gmtime(&tsp->tv_sec);
550 snprintf(text, sizeof text,
551 "@GMT-%04u.%02u.%02u-%02u.%02u.%02u",
559 cp = malloc(strlen(text) + 1);
567 idcp->idc_version[idcp->idc_len++] = cp;
571 * Make a directory context from a snapshot context.
573 * Once a snapshot context has been completely filled-in,
574 * osc_make_directory_ctx() is used to build a directory context from it. The
575 * idea here is to create version for each snapshot in the snapshot set.
578 osc_make_directory_ctx(struct osc_snapshot_ctx *oscp,
579 struct osc_directory_ctx *idcp, int *errorp)
582 walk(const void *vp, VISIT v, int level)
584 const struct osc_snapshot *isp;
586 if ((v != postorder && v != leaf) || *errorp)
589 isp = *(const struct osc_snapshot **)(u_long)vp;
591 osc_directory_ctx_append_version(oscp, idcp, &isp->is_time,
595 twalk(oscp->osc_set, walk);
599 * Open a version directory.
601 * Opens a version directory. What this really means is that
602 * osc_version_opendir() returns a handle to a directory context, which can be
603 * used to retrieve version strings.
606 osc_version_opendir(void)
609 struct osc_directory_ctx *idcp;
610 struct osc_snapshot_ctx *oscp;
612 idcp = osc_directory_ctx_create();
616 oscp = osc_get_snapshot_ctx();
618 if (!osc_snapshot_ctx_is_valid(oscp)) {
619 osc_snapshot_ctx_clean(oscp);
620 osc_process_snapshot_directory(oscp, &error);
625 osc_make_directory_ctx(oscp, idcp, &error);
633 osc_directory_ctx_destroy(idcp);
642 * Read the next version directory entry.
644 * Returns the name of the next version in the version directory, or NULL if
645 * we're at the end of the directory. What this really does is return the
646 * next version from the version list stored in the directory context.
649 osc_version_readdir(void *vp)
651 struct osc_directory_ctx *idcp = vp;
656 if (idcp->idc_pos >= idcp->idc_len)
659 return idcp->idc_version[idcp->idc_pos++];
663 * Close the version directory.
665 * Destroys the underlying directory context.
668 osc_version_closedir(void *vp)
670 struct osc_directory_ctx *idcp = vp;
673 osc_directory_ctx_destroy(idcp);
677 * Canonicalize a path.
679 * Converts paths of the form @GMT-.. to paths of the form ../.snapshot/..
680 * It's not the prettiest routine I've ever written, but what the heck?
683 osc_canonicalize_path(const char *path, char *snap_component)
686 struct osc_snapshot_ctx *oscp;
689 struct osc_snapshot is;
690 struct osc_snapshot **ispp;
691 struct osc_snapshot *isp;
694 const char *snap_component_orig = snap_component;
697 oscp = osc_get_snapshot_ctx();
699 if (!osc_snapshot_ctx_is_valid(oscp)) {
700 osc_snapshot_ctx_clean(oscp);
701 osc_process_snapshot_directory(oscp, &error);
706 memset(&tm, 0, sizeof tm);
707 n = sscanf(snap_component,
708 "@GMT-%4u.%2u.%2u-%2u.%2u.%2u",
722 is.is_time.tv_sec = timegm(&tm);
723 is.is_time.tv_nsec = 0;
725 ispp = tfind(&is, &oscp->osc_set, osc_snapshot_compare);
730 /* Determine the path after "@GMT-..." */
731 while (*snap_component != '/' && *snap_component != '\0')
734 while (*snap_component == '/')
737 cpath = malloc(strlen(SNAPSHOT_DIRECTORY) + strlen(isp->is_name) +
744 * Use the first snapshot that has a successful stat for the requested
749 sprintf(cpath, "%s/%s", SNAPSHOT_DIRECTORY, isp->is_name);
751 /* Append path before "@GMT-..." */
752 if (snap_component_orig != path) {
754 strncat(cpath, path, snap_component_orig - path);
757 /* Append path after "@GMT-..." */
758 if (*snap_component != '\0') {
760 strcat(cpath, snap_component);
763 /* If there is a valid snapshot for this file, we're done. */
764 if (stat(cpath, &sb) == 0)
767 /* Try the next snapshot. If this was the last one, give up. */
772 /* If the realloc fails, give up. */
773 cpath2 = realloc(cpath, strlen(SNAPSHOT_DIRECTORY) +
774 strlen(isp->is_name) + strlen(path) + 3);