2 * implementation of an Shadow Copy module - version 2
4 * Copyright (C) Andrew Tridgell 2007
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 This is a 2nd implemetation of a shadow copy module for exposing
26 snapshots to windows clients as shadow copies. This version has the
29 1) you don't need to populate your shares with symlinks to the
30 snapshots. This can be very important when you have thousands of
31 shares, or use [homes]
33 2) the inode number of the files is altered so it is different
34 from the original. This allows the 'restore' button to work
35 without a sharing violation
39 shadow:snapdir = <directory where snapshots are kept>
41 This is the directory containing the @GMT-* snapshot directories. If it is an absolute
42 path it is used as-is. If it is a relative path, then it is taken relative to the mount
43 point of the filesystem that the root of this share is on
45 shadow:basedir = <base directory that snapshots are from>
47 This is an optional parameter that specifies the directory that
48 the snapshots are relative to. It defaults to the filesystem
51 shadow:fixinodes = yes/no
53 If you enable shadow:fixinodes then this module will modify the
54 apparent inode number of files in the snapshot directories using
55 a hash of the files path. This is needed for snapshot systems
56 where the snapshots have the same device:inode number as the
57 original files (such as happens with GPFS snapshots). If you
58 don't set this option then the 'restore' button in the shadow
59 copy UI will fail with a sharing violation.
61 Note that the directory names in the snapshot directory must take the form
62 @GMT-YYYY.MM.DD-HH.MM.SS
64 The following command would generate a correctly formatted directory name:
65 date -u +@GMT-%Y.%m.%d-%H.%M.%S
69 static int vfs_shadow_copy2_debug_level = DBGC_VFS;
72 #define DBGC_CLASS vfs_shadow_copy2_debug_level
74 #define GMT_NAME_LEN 24 /* length of a @GMT- name */
77 make very sure it is one of our special names
79 static inline bool shadow_copy2_match_name(const char *name)
81 unsigned year, month, day, hr, min, sec;
82 if (name[0] != '@') return False;
83 if (strncmp(name, "@GMT-", 5) != 0) return False;
84 if (sscanf(name, "@GMT-%04u.%02u.%02u-%02u.%02u.%02u", &year, &month,
85 &day, &hr, &min, &sec) != 6) {
88 if (name[24] != 0 && name[24] != '/') {
95 convert a name to the shadow directory
98 #define _SHADOW2_NEXT(op, args, rtype, eret, extra) do { \
99 const char *name = fname; \
100 if (shadow_copy2_match_name(fname)) { \
103 name2 = convert_shadow2_name(handle, fname); \
104 if (name2 == NULL) { \
109 ret = SMB_VFS_NEXT_ ## op args; \
110 talloc_free(name2); \
111 if (ret != eret) extra; \
114 return SMB_VFS_NEXT_ ## op args; \
119 convert a name to the shadow directory: NTSTATUS-specific handling
122 #define _SHADOW2_NTSTATUS_NEXT(op, args, eret, extra) do { \
123 const char *name = fname; \
124 if (shadow_copy2_match_name(fname)) { \
127 name2 = convert_shadow2_name(handle, fname); \
128 if (name2 == NULL) { \
133 ret = SMB_VFS_NEXT_ ## op args; \
134 talloc_free(name2); \
135 if (!NT_STATUS_EQUAL(ret, eret)) extra; \
138 return SMB_VFS_NEXT_ ## op args; \
142 #define SHADOW2_NTSTATUS_NEXT(op, args, eret) _SHADOW2_NTSTATUS_NEXT(op, args, eret, )
144 #define SHADOW2_NEXT(op, args, rtype, eret) _SHADOW2_NEXT(op, args, rtype, eret, )
146 #define SHADOW2_NEXT2(op, args) do { \
147 if (shadow_copy2_match_name(oldname) || shadow_copy2_match_name(newname)) { \
151 return SMB_VFS_NEXT_ ## op args; \
157 find the mount point of a filesystem
159 static char *find_mount_point(TALLOC_CTX *mem_ctx, vfs_handle_struct *handle)
161 char *path = talloc_strdup(mem_ctx, handle->conn->connectpath);
166 if (stat(path, &st) != 0) {
173 while ((p = strrchr(path, '/')) && p > path) {
175 if (stat(path, &st) != 0) {
179 if (st.st_dev != dev) {
189 work out the location of the snapshot for this share
191 static const char *shadow_copy2_find_snapdir(TALLOC_CTX *mem_ctx, vfs_handle_struct *handle)
197 snapdir = lp_parm_const_string(SNUM(handle->conn), "shadow", "snapdir", NULL);
198 if (snapdir == NULL) {
201 /* if its an absolute path, we're done */
202 if (*snapdir == '/') {
206 /* other its relative to the filesystem mount point */
207 mount_point = find_mount_point(mem_ctx, handle);
208 if (mount_point == NULL) {
212 ret = talloc_asprintf(mem_ctx, "%s/%s", mount_point, snapdir);
213 talloc_free(mount_point);
218 work out the location of the base directory for snapshots of this share
220 static const char *shadow_copy2_find_basedir(TALLOC_CTX *mem_ctx, vfs_handle_struct *handle)
222 const char *basedir = lp_parm_const_string(SNUM(handle->conn), "shadow", "basedir", NULL);
224 /* other its the filesystem mount point */
225 if (basedir == NULL) {
226 basedir = find_mount_point(mem_ctx, handle);
233 convert a filename from a share relative path, to a path in the
236 static char *convert_shadow2_name(vfs_handle_struct *handle, const char *fname)
238 TALLOC_CTX *tmp_ctx = talloc_new(handle->data);
239 const char *snapdir, *relpath, *baseoffset, *basedir;
243 snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle);
244 if (snapdir == NULL) {
245 DEBUG(2,("no snapdir found for share at %s\n", handle->conn->connectpath));
246 talloc_free(tmp_ctx);
250 basedir = shadow_copy2_find_basedir(tmp_ctx, handle);
251 if (basedir == NULL) {
252 DEBUG(2,("no basedir found for share at %s\n", handle->conn->connectpath));
253 talloc_free(tmp_ctx);
257 relpath = fname + GMT_NAME_LEN;
258 baselen = strlen(basedir);
259 baseoffset = handle->conn->connectpath + baselen;
261 /* some sanity checks */
262 if (strncmp(basedir, handle->conn->connectpath, baselen) != 0 ||
263 (handle->conn->connectpath[baselen] != 0 && handle->conn->connectpath[baselen] != '/')) {
264 DEBUG(0,("convert_shadow2_name: basedir %s is not a parent of %s\n",
265 basedir, handle->conn->connectpath));
266 talloc_free(tmp_ctx);
270 if (*relpath == '/') relpath++;
271 if (*baseoffset == '/') baseoffset++;
273 ret = talloc_asprintf(handle->data, "%s/%.*s/%s/%s",
278 DEBUG(6,("convert_shadow2_name: '%s' -> '%s'\n", fname, ret));
279 talloc_free(tmp_ctx);
287 static uint32 string_hash(const char *s)
291 n = ((n << 5) + n) ^ (uint32)(*s++);
297 modify a sbuf return to ensure that inodes in the shadow directory
298 are different from those in the main directory
300 static void convert_sbuf(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
302 if (lp_parm_bool(SNUM(handle->conn), "shadow", "fixinodes", False)) {
303 /* some snapshot systems, like GPFS, return the name
304 device:inode for the snapshot files as the current
305 files. That breaks the 'restore' button in the shadow copy
306 GUI, as the client gets a sharing violation.
308 This is a crude way of allowing both files to be
309 open at once. It has a slight chance of inode
310 number collision, but I can't see a better approach
311 without significant VFS changes
313 uint32_t shash = string_hash(fname) & 0xFF000000;
317 sbuf->st_ino ^= shash;
321 static int shadow_copy2_rename(vfs_handle_struct *handle,
322 const char *oldname, const char *newname)
324 SHADOW2_NEXT2(RENAME, (handle, oldname, newname));
327 static int shadow_copy2_symlink(vfs_handle_struct *handle,
328 const char *oldname, const char *newname)
330 SHADOW2_NEXT2(SYMLINK, (handle, oldname, newname));
333 static int shadow_copy2_link(vfs_handle_struct *handle,
334 const char *oldname, const char *newname)
336 SHADOW2_NEXT2(LINK, (handle, oldname, newname));
339 static int shadow_copy2_open(vfs_handle_struct *handle,
340 const char *fname, files_struct *fsp, int flags, mode_t mode)
342 SHADOW2_NEXT(OPEN, (handle, name, fsp, flags, mode), int, -1);
345 static SMB_STRUCT_DIR *shadow_copy2_opendir(vfs_handle_struct *handle,
346 const char *fname, const char *mask, uint32 attr)
348 SHADOW2_NEXT(OPENDIR, (handle, name, mask, attr), SMB_STRUCT_DIR *, NULL);
351 static int shadow_copy2_stat(vfs_handle_struct *handle,
352 const char *fname, SMB_STRUCT_STAT *sbuf)
354 _SHADOW2_NEXT(STAT, (handle, name, sbuf), int, -1, convert_sbuf(handle, fname, sbuf));
357 static int shadow_copy2_lstat(vfs_handle_struct *handle,
358 const char *fname, SMB_STRUCT_STAT *sbuf)
360 _SHADOW2_NEXT(LSTAT, (handle, name, sbuf), int, -1, convert_sbuf(handle, fname, sbuf));
363 static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
365 int ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
366 if (ret == 0 && shadow_copy2_match_name(fsp->fsp_name)) {
367 convert_sbuf(handle, fsp->fsp_name, sbuf);
372 static int shadow_copy2_unlink(vfs_handle_struct *handle, const char *fname)
374 SHADOW2_NEXT(UNLINK, (handle, name), int, -1);
377 static int shadow_copy2_chmod(vfs_handle_struct *handle,
378 const char *fname, mode_t mode)
380 SHADOW2_NEXT(CHMOD, (handle, name, mode), int, -1);
383 static int shadow_copy2_chown(vfs_handle_struct *handle,
384 const char *fname, uid_t uid, gid_t gid)
386 SHADOW2_NEXT(CHOWN, (handle, name, uid, gid), int, -1);
389 static int shadow_copy2_chdir(vfs_handle_struct *handle,
392 SHADOW2_NEXT(CHDIR, (handle, name), int, -1);
395 static int shadow_copy2_ntimes(vfs_handle_struct *handle,
396 const char *fname, const struct timespec ts[2])
398 SHADOW2_NEXT(NTIMES, (handle, name, ts), int, -1);
401 static int shadow_copy2_readlink(vfs_handle_struct *handle,
402 const char *fname, char *buf, size_t bufsiz)
404 SHADOW2_NEXT(READLINK, (handle, name, buf, bufsiz), int, -1);
407 static int shadow_copy2_mknod(vfs_handle_struct *handle,
408 const char *fname, mode_t mode, SMB_DEV_T dev)
410 SHADOW2_NEXT(MKNOD, (handle, name, mode, dev), int, -1);
413 static char *shadow_copy2_realpath(vfs_handle_struct *handle,
414 const char *fname, char *resolved_path)
417 * This one here is a bit subtle. SMB_VFS_REALPATH is used in
418 * smbd in two places: To canonicalize the connection path at
419 * tree connect time, and in the check for wide links.
421 * When the shadow_copy2 module is active it might happen that
422 * the base directory for the snapshots lies outside the share
423 * path, so the test for wide links fails.
425 * For this reason, in case we hit a shadow copy name, the
426 * SMB_VFS_REALPATH lies: We just ignore the @GMT- prefix for
427 * the realpath calculation, pretending the path is indeed
428 * inside the share path.
430 * For the tree connect use of REALPATH this will never match
431 * as here all paths start with "/", not with "@"
433 if (shadow_copy2_match_name(fname)) {
434 fname += GMT_NAME_LEN+1;
436 return SMB_VFS_NEXT_REALPATH(handle, fname, resolved_path);
439 static NTSTATUS shadow_copy2_get_nt_acl(vfs_handle_struct *handle,
440 const char *fname, uint32 security_info,
441 struct security_descriptor **ppdesc)
443 SHADOW2_NTSTATUS_NEXT(GET_NT_ACL, (handle, name, security_info, ppdesc), NT_STATUS_ACCESS_DENIED);
446 static NTSTATUS shadow_copy2_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp,
447 const char *fname, uint32 security_info_sent,
448 struct security_descriptor *psd)
450 SHADOW2_NTSTATUS_NEXT(SET_NT_ACL, (handle, fsp, name, security_info_sent, psd), NT_STATUS_ACCESS_DENIED);
453 static int shadow_copy2_mkdir(vfs_handle_struct *handle, const char *fname, mode_t mode)
455 SHADOW2_NEXT(MKDIR, (handle, name, mode), int, -1);
458 static int shadow_copy2_rmdir(vfs_handle_struct *handle, const char *fname)
460 SHADOW2_NEXT(RMDIR, (handle, name), int, -1);
463 static int shadow_copy2_chflags(vfs_handle_struct *handle, const char *fname, int flags)
465 SHADOW2_NEXT(CHFLAGS, (handle, name, flags), int, -1);
468 static ssize_t shadow_copy2_getxattr(vfs_handle_struct *handle,
469 const char *fname, const char *aname, void *value, size_t size)
471 SHADOW2_NEXT(GETXATTR, (handle, name, aname, value, size), ssize_t, -1);
474 static ssize_t shadow_copy2_lgetxattr(vfs_handle_struct *handle,
475 const char *fname, const char *aname, void *value, size_t size)
477 SHADOW2_NEXT(LGETXATTR, (handle, name, aname, value, size), ssize_t, -1);
480 static ssize_t shadow_copy2_listxattr(struct vfs_handle_struct *handle, const char *fname,
481 char *list, size_t size)
483 SHADOW2_NEXT(LISTXATTR, (handle, name, list, size), ssize_t, -1);
486 static int shadow_copy2_removexattr(struct vfs_handle_struct *handle, const char *fname,
489 SHADOW2_NEXT(REMOVEXATTR, (handle, name, aname), int, -1);
492 static int shadow_copy2_lremovexattr(struct vfs_handle_struct *handle, const char *fname,
495 SHADOW2_NEXT(LREMOVEXATTR, (handle, name, aname), int, -1);
498 static int shadow_copy2_setxattr(struct vfs_handle_struct *handle, const char *fname,
499 const char *aname, const void *value, size_t size, int flags)
501 SHADOW2_NEXT(SETXATTR, (handle, name, aname, value, size, flags), int, -1);
504 static int shadow_copy2_lsetxattr(struct vfs_handle_struct *handle, const char *fname,
505 const char *aname, const void *value, size_t size, int flags)
507 SHADOW2_NEXT(LSETXATTR, (handle, name, aname, value, size, flags), int, -1);
510 static int shadow_copy2_chmod_acl(vfs_handle_struct *handle,
511 const char *fname, mode_t mode)
513 /* If the underlying VFS doesn't have ACL support... */
514 if (!handle->vfs_next.ops.chmod_acl) {
518 SHADOW2_NEXT(CHMOD_ACL, (handle, name, mode), int, -1);
521 static int shadow_copy2_get_shadow_copy2_data(vfs_handle_struct *handle,
523 SHADOW_COPY_DATA *shadow_copy2_data,
528 SMB_STRUCT_DIRENT *d;
529 TALLOC_CTX *tmp_ctx = talloc_new(handle->data);
531 snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle);
532 if (snapdir == NULL) {
533 DEBUG(0,("shadow:snapdir not found for %s in get_shadow_copy_data\n",
534 handle->conn->connectpath));
536 talloc_free(tmp_ctx);
540 p = SMB_VFS_NEXT_OPENDIR(handle, snapdir, NULL, 0);
543 DEBUG(0,("shadow_copy2: SMB_VFS_NEXT_OPENDIR() failed for '%s' - %s\n",
544 snapdir, strerror(errno)));
545 talloc_free(tmp_ctx);
549 talloc_free(tmp_ctx);
551 shadow_copy2_data->num_volumes = 0;
552 shadow_copy2_data->labels = NULL;
554 while ((d = SMB_VFS_NEXT_READDIR(handle, p))) {
555 SHADOW_COPY_LABEL *tlabels;
557 /* ignore names not of the right form in the snapshot directory */
558 if (!shadow_copy2_match_name(d->d_name)) {
563 /* the caller doesn't want the labels */
564 shadow_copy2_data->num_volumes++;
568 tlabels = talloc_realloc(shadow_copy2_data->mem_ctx,
569 shadow_copy2_data->labels,
570 SHADOW_COPY_LABEL, shadow_copy2_data->num_volumes+1);
571 if (tlabels == NULL) {
572 DEBUG(0,("shadow_copy2: out of memory\n"));
573 SMB_VFS_NEXT_CLOSEDIR(handle, p);
577 strlcpy(tlabels[shadow_copy2_data->num_volumes], d->d_name, sizeof(*tlabels));
578 shadow_copy2_data->num_volumes++;
579 shadow_copy2_data->labels = tlabels;
582 SMB_VFS_NEXT_CLOSEDIR(handle,p);
586 /* VFS operations structure */
588 static vfs_op_tuple shadow_copy2_ops[] = {
589 {SMB_VFS_OP(shadow_copy2_opendir), SMB_VFS_OP_OPENDIR, SMB_VFS_LAYER_TRANSPARENT},
591 /* directory operations */
592 {SMB_VFS_OP(shadow_copy2_mkdir), SMB_VFS_OP_MKDIR, SMB_VFS_LAYER_TRANSPARENT},
593 {SMB_VFS_OP(shadow_copy2_rmdir), SMB_VFS_OP_RMDIR, SMB_VFS_LAYER_TRANSPARENT},
595 /* xattr and flags operations */
596 {SMB_VFS_OP(shadow_copy2_chflags), SMB_VFS_OP_CHFLAGS, SMB_VFS_LAYER_TRANSPARENT},
597 {SMB_VFS_OP(shadow_copy2_getxattr), SMB_VFS_OP_GETXATTR, SMB_VFS_LAYER_TRANSPARENT},
598 {SMB_VFS_OP(shadow_copy2_lgetxattr), SMB_VFS_OP_LGETXATTR, SMB_VFS_LAYER_TRANSPARENT},
599 {SMB_VFS_OP(shadow_copy2_listxattr), SMB_VFS_OP_LISTXATTR, SMB_VFS_LAYER_TRANSPARENT},
600 {SMB_VFS_OP(shadow_copy2_removexattr), SMB_VFS_OP_REMOVEXATTR, SMB_VFS_LAYER_TRANSPARENT},
601 {SMB_VFS_OP(shadow_copy2_lremovexattr),SMB_VFS_OP_LREMOVEXATTR,SMB_VFS_LAYER_TRANSPARENT},
602 {SMB_VFS_OP(shadow_copy2_setxattr), SMB_VFS_OP_SETXATTR, SMB_VFS_LAYER_TRANSPARENT},
603 {SMB_VFS_OP(shadow_copy2_lsetxattr), SMB_VFS_OP_LSETXATTR, SMB_VFS_LAYER_TRANSPARENT},
605 /* File operations */
606 {SMB_VFS_OP(shadow_copy2_open), SMB_VFS_OP_OPEN, SMB_VFS_LAYER_TRANSPARENT},
607 {SMB_VFS_OP(shadow_copy2_rename), SMB_VFS_OP_RENAME, SMB_VFS_LAYER_TRANSPARENT},
608 {SMB_VFS_OP(shadow_copy2_stat), SMB_VFS_OP_STAT, SMB_VFS_LAYER_TRANSPARENT},
609 {SMB_VFS_OP(shadow_copy2_lstat), SMB_VFS_OP_LSTAT, SMB_VFS_LAYER_TRANSPARENT},
610 {SMB_VFS_OP(shadow_copy2_fstat), SMB_VFS_OP_FSTAT, SMB_VFS_LAYER_TRANSPARENT},
611 {SMB_VFS_OP(shadow_copy2_unlink), SMB_VFS_OP_UNLINK, SMB_VFS_LAYER_TRANSPARENT},
612 {SMB_VFS_OP(shadow_copy2_chmod), SMB_VFS_OP_CHMOD, SMB_VFS_LAYER_TRANSPARENT},
613 {SMB_VFS_OP(shadow_copy2_chown), SMB_VFS_OP_CHOWN, SMB_VFS_LAYER_TRANSPARENT},
614 {SMB_VFS_OP(shadow_copy2_chdir), SMB_VFS_OP_CHDIR, SMB_VFS_LAYER_TRANSPARENT},
615 {SMB_VFS_OP(shadow_copy2_ntimes), SMB_VFS_OP_NTIMES, SMB_VFS_LAYER_TRANSPARENT},
616 {SMB_VFS_OP(shadow_copy2_symlink), SMB_VFS_OP_SYMLINK, SMB_VFS_LAYER_TRANSPARENT},
617 {SMB_VFS_OP(shadow_copy2_readlink), SMB_VFS_OP_READLINK, SMB_VFS_LAYER_TRANSPARENT},
618 {SMB_VFS_OP(shadow_copy2_link), SMB_VFS_OP_LINK, SMB_VFS_LAYER_TRANSPARENT},
619 {SMB_VFS_OP(shadow_copy2_mknod), SMB_VFS_OP_MKNOD, SMB_VFS_LAYER_TRANSPARENT},
620 {SMB_VFS_OP(shadow_copy2_realpath), SMB_VFS_OP_REALPATH, SMB_VFS_LAYER_TRANSPARENT},
622 /* NT File ACL operations */
623 {SMB_VFS_OP(shadow_copy2_get_nt_acl), SMB_VFS_OP_GET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT},
624 {SMB_VFS_OP(shadow_copy2_set_nt_acl), SMB_VFS_OP_SET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT},
626 /* POSIX ACL operations */
627 {SMB_VFS_OP(shadow_copy2_chmod_acl), SMB_VFS_OP_CHMOD_ACL, SMB_VFS_LAYER_TRANSPARENT},
629 /* special shadown copy op */
630 {SMB_VFS_OP(shadow_copy2_get_shadow_copy2_data),
631 SMB_VFS_OP_GET_SHADOW_COPY_DATA,SMB_VFS_LAYER_OPAQUE},
633 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP}
636 NTSTATUS vfs_shadow_copy2_init(void);
637 NTSTATUS vfs_shadow_copy2_init(void)
641 ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "shadow_copy2", shadow_copy2_ops);
643 if (!NT_STATUS_IS_OK(ret))
646 vfs_shadow_copy2_debug_level = debug_add_class("shadow_copy2");
647 if (vfs_shadow_copy2_debug_level == -1) {
648 vfs_shadow_copy2_debug_level = DBGC_VFS;
649 DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
650 "vfs_shadow_copy2_init"));
652 DEBUG(10, ("%s: Debug class number of '%s': %d\n",
653 "vfs_shadow_copy2_init","shadow_copy2",vfs_shadow_copy2_debug_level));