2 * OneFS shadow copy implementation that utilizes the file system's native
3 * snapshot support. This is based on the original shadow copy module from
6 * Copyright (C) Stefan Metzmacher 2003-2004
7 * Copyright (C) Tim Prouty 2009
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "onefs_shadow_copy.h"
27 static int vfs_onefs_shadow_copy_debug_level = DBGC_VFS;
30 #define DBGC_CLASS vfs_onefs_shadow_copy_debug_level
32 #define SHADOW_COPY_PREFIX "@GMT-"
33 #define SHADOW_COPY_SAMPLE "@GMT-2004.02.18-15.44.00"
36 shadow_copy_match_name(const char *name, char **snap_component)
39 char delim[] = SHADOW_COPY_PREFIX;
42 start = strstr( name, delim );
45 * The name could have SHADOW_COPY_PREFIX in it so we need to keep
46 * trying until we get something that is the full length of the
49 while (start != NULL) {
51 DEBUG(10,("Processing %s\n", name));
53 /* size / correctness check */
54 *snap_component = start;
55 for ( i = sizeof(SHADOW_COPY_PREFIX);
56 i < sizeof(SHADOW_COPY_SAMPLE); i++) {
57 if (start[i] == '/') {
58 if (i == sizeof(SHADOW_COPY_SAMPLE) - 1)
62 } else if (start[i] == '\0')
63 return (i == sizeof(SHADOW_COPY_SAMPLE) - 1);
66 start = strstr( start, delim );
73 onefs_shadow_copy_get_shadow_copy_data(vfs_handle_struct *handle,
75 SHADOW_COPY_DATA *shadow_copy_data,
78 void *p = osc_version_opendir();
79 char *snap_component = NULL;
80 shadow_copy_data->num_volumes = 0;
81 shadow_copy_data->labels = NULL;
84 DEBUG(0, ("shadow_copy_get_shadow_copy_data: osc_opendir() "
85 "failed for [%s]\n",fsp->conn->connectpath));
90 SHADOW_COPY_LABEL *tlabels;
93 d = osc_version_readdir(p);
97 if (!shadow_copy_match_name(d, &snap_component)) {
98 DEBUG(10,("shadow_copy_get_shadow_copy_data: ignore "
103 DEBUG(7,("shadow_copy_get_shadow_copy_data: not ignore "
107 shadow_copy_data->num_volumes++;
111 tlabels = (SHADOW_COPY_LABEL *)TALLOC_REALLOC(
112 shadow_copy_data->mem_ctx,
113 shadow_copy_data->labels,
114 (shadow_copy_data->num_volumes+1) *
115 sizeof(SHADOW_COPY_LABEL));
117 if (tlabels == NULL) {
118 DEBUG(0,("shadow_copy_get_shadow_copy_data: Out of "
120 osc_version_closedir(p);
124 snprintf(tlabels[shadow_copy_data->num_volumes++],
125 sizeof(*tlabels), "%s",d);
127 shadow_copy_data->labels = tlabels;
130 osc_version_closedir(p);
135 #define SHADOW_NEXT(op, args, rtype) do { \
136 char *cpath = NULL; \
137 char *snap_component = NULL; \
139 if (shadow_copy_match_name(path, &snap_component)) \
140 cpath = osc_canonicalize_path(path, snap_component); \
141 ret = SMB_VFS_NEXT_ ## op args; \
147 * XXX: Convert osc_canonicalize_path to use talloc instead of malloc.
149 #define SHADOW_NEXT_SMB_FNAME(op, args, rtype) do { \
150 char *smb_base_name_tmp = NULL; \
151 char *cpath = NULL; \
152 char *snap_component = NULL; \
154 smb_base_name_tmp = smb_fname->base_name; \
155 if (shadow_copy_match_name(smb_fname->base_name, \
156 &snap_component)) { \
157 cpath = osc_canonicalize_path(smb_fname->base_name, \
159 smb_fname->base_name = cpath; \
161 ret = SMB_VFS_NEXT_ ## op args; \
162 smb_fname->base_name = smb_base_name_tmp; \
168 onefs_shadow_copy_disk_free(vfs_handle_struct *handle, const char *path,
169 bool small_query, uint64_t *bsize, uint64_t *dfree,
173 SHADOW_NEXT(DISK_FREE,
174 (handle, cpath ?: path, small_query, bsize, dfree, dsize),
180 onefs_shadow_copy_statvfs(struct vfs_handle_struct *handle, const char *path,
181 struct vfs_statvfs_struct *statbuf)
184 (handle, cpath ?: path, statbuf),
188 static SMB_STRUCT_DIR *
189 onefs_shadow_copy_opendir(vfs_handle_struct *handle, const char *path,
190 const char *mask, uint32_t attr)
193 (handle, cpath ?: path, mask, attr),
198 onefs_shadow_copy_mkdir(vfs_handle_struct *handle, const char *path,
202 (handle, cpath ?: path, mode),
207 onefs_shadow_copy_rmdir(vfs_handle_struct *handle, const char *path)
210 (handle, cpath ?: path),
215 onefs_shadow_copy_open(vfs_handle_struct *handle,
216 struct smb_filename *smb_fname, files_struct *fsp,
217 int flags, mode_t mode)
219 SHADOW_NEXT_SMB_FNAME(OPEN,
220 (handle, smb_fname, fsp, flags, mode),
225 onefs_shadow_copy_create_file(vfs_handle_struct *handle,
226 struct smb_request *req,
227 uint16_t root_dir_fid,
228 struct smb_filename *smb_fname,
229 uint32_t access_mask,
230 uint32_t share_access,
231 uint32_t create_disposition,
232 uint32_t create_options,
233 uint32_t file_attributes,
234 uint32_t oplock_request,
235 uint64_t allocation_size,
236 struct security_descriptor *sd,
237 struct ea_list *ea_list,
238 files_struct **result,
241 SHADOW_NEXT_SMB_FNAME(CREATE_FILE,
242 (handle, req, root_dir_fid, smb_fname,
243 access_mask, share_access,
244 create_disposition, create_options,
245 file_attributes, oplock_request,
246 allocation_size, sd, ea_list, result, pinfo),
254 onefs_shadow_copy_rename(vfs_handle_struct *handle,
255 const struct smb_filename *smb_fname_src,
256 const struct smb_filename *smb_fname_dst)
258 char *old_cpath = NULL;
259 char *old_snap_component = NULL;
260 char *new_cpath = NULL;
261 char *new_snap_component = NULL;
262 struct smb_filename *smb_fname_src_tmp = NULL;
263 struct smb_filename *smb_fname_dst_tmp = NULL;
267 status = copy_smb_filename(talloc_tos(), smb_fname_src,
269 if (!NT_STATUS_IS_OK(status)) {
270 errno = map_errno_from_nt_status(status);
273 status = copy_smb_filename(talloc_tos(), smb_fname_dst,
275 if (!NT_STATUS_IS_OK(status)) {
276 errno = map_errno_from_nt_status(status);
280 if (shadow_copy_match_name(smb_fname_src_tmp->base_name,
281 &old_snap_component)) {
282 old_cpath = osc_canonicalize_path(smb_fname_src_tmp->base_name,
284 smb_fname_src_tmp->base_name = old_cpath;
287 if (shadow_copy_match_name(smb_fname_dst_tmp->base_name,
288 &new_snap_component)) {
289 new_cpath = osc_canonicalize_path(smb_fname_dst_tmp->base_name,
291 smb_fname_dst_tmp->base_name = new_cpath;
294 ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp,
298 SAFE_FREE(old_cpath);
299 SAFE_FREE(new_cpath);
300 TALLOC_FREE(smb_fname_src_tmp);
301 TALLOC_FREE(smb_fname_dst_tmp);
307 onefs_shadow_copy_stat(vfs_handle_struct *handle,
308 struct smb_filename *smb_fname)
310 SHADOW_NEXT_SMB_FNAME(STAT,
316 onefs_shadow_copy_lstat(vfs_handle_struct *handle,
317 struct smb_filename *smb_fname)
319 SHADOW_NEXT_SMB_FNAME(LSTAT,
325 onefs_shadow_copy_unlink(vfs_handle_struct *handle,
326 const struct smb_filename *smb_fname_in)
328 struct smb_filename *smb_fname = NULL;
331 status = copy_smb_filename(talloc_tos(), smb_fname_in, &smb_fname);
332 if (!NT_STATUS_IS_OK(status)) {
333 errno = map_errno_from_nt_status(status);
337 SHADOW_NEXT_SMB_FNAME(UNLINK,
343 onefs_shadow_copy_chmod(vfs_handle_struct *handle, const char *path,
347 (handle, cpath ?: path, mode),
352 onefs_shadow_copy_chown(vfs_handle_struct *handle, const char *path,
353 uid_t uid, gid_t gid)
356 (handle, cpath ?: path, uid, gid),
361 onefs_shadow_copy_lchown(vfs_handle_struct *handle, const char *path,
362 uid_t uid, gid_t gid)
365 (handle, cpath ?: path, uid, gid),
370 onefs_shadow_copy_chdir(vfs_handle_struct *handle, const char *path)
373 (handle, cpath ?: path),
378 onefs_shadow_copy_ntimes(vfs_handle_struct *handle,
379 const struct smb_filename *smb_fname_in,
380 struct smb_file_time *ft)
382 struct smb_filename *smb_fname = NULL;
385 status = copy_smb_filename(talloc_tos(), smb_fname_in, &smb_fname);
386 if (!NT_STATUS_IS_OK(status)) {
387 errno = map_errno_from_nt_status(status);
391 SHADOW_NEXT_SMB_FNAME(NTIMES,
392 (handle, smb_fname, ft),
401 onefs_shadow_copy_symlink(vfs_handle_struct *handle,
402 const char *oldpath, const char *newpath)
404 char *old_cpath = NULL;
405 char *old_snap_component = NULL;
406 char *new_cpath = NULL;
407 char *new_snap_component = NULL;
410 if (shadow_copy_match_name(oldpath, &old_snap_component))
411 old_cpath = osc_canonicalize_path(oldpath, old_snap_component);
413 if (shadow_copy_match_name(newpath, &new_snap_component))
414 new_cpath = osc_canonicalize_path(newpath, new_snap_component);
416 ret = SMB_VFS_NEXT_SYMLINK(handle, old_cpath ?: oldpath,
417 new_cpath ?: newpath);
419 SAFE_FREE(old_cpath);
420 SAFE_FREE(new_cpath);
426 onefs_shadow_copy_readlink(vfs_handle_struct *handle, const char *path,
427 char *buf, size_t bufsiz)
429 SHADOW_NEXT(READLINK,
430 (handle, cpath ?: path, buf, bufsiz),
438 onefs_shadow_copy_link(vfs_handle_struct *handle, const char *oldpath,
441 char *old_cpath = NULL;
442 char *old_snap_component = NULL;
443 char *new_cpath = NULL;
444 char *new_snap_component = NULL;
447 if (shadow_copy_match_name(oldpath, &old_snap_component))
448 old_cpath = osc_canonicalize_path(oldpath, old_snap_component);
450 if (shadow_copy_match_name(newpath, &new_snap_component))
451 new_cpath = osc_canonicalize_path(newpath, new_snap_component);
453 ret = SMB_VFS_NEXT_LINK(handle, old_cpath ?: oldpath,
454 new_cpath ?: newpath);
456 SAFE_FREE(old_cpath);
457 SAFE_FREE(new_cpath);
463 onefs_shadow_copy_mknod(vfs_handle_struct *handle, const char *path,
464 mode_t mode, SMB_DEV_T dev)
467 (handle, cpath ?: path, mode, dev),
472 onefs_shadow_copy_realpath(vfs_handle_struct *handle, const char *path,
475 SHADOW_NEXT(REALPATH,
476 (handle, cpath ?: path, resolved_path),
480 static int onefs_shadow_copy_chflags(struct vfs_handle_struct *handle,
481 const char *path, unsigned int flags)
484 (handle, cpath ?: path, flags),
489 onefs_shadow_copy_streaminfo(struct vfs_handle_struct *handle,
490 struct files_struct *fsp,
493 unsigned int *num_streams,
494 struct stream_struct **streams)
496 SHADOW_NEXT(STREAMINFO,
497 (handle, fsp, cpath ?: path, mem_ctx, num_streams,
503 onefs_shadow_copy_get_real_filename(struct vfs_handle_struct *handle,
504 const char *full_path,
509 SHADOW_NEXT(GET_REAL_FILENAME,
510 (handle, full_path, cpath ?: path, mem_ctx, found_name),
515 onefs_shadow_copy_get_nt_acl(struct vfs_handle_struct *handle,
516 const char *path, uint32 security_info,
517 struct security_descriptor **ppdesc)
519 SHADOW_NEXT(GET_NT_ACL,
520 (handle, cpath ?: path, security_info, ppdesc),
525 onefs_shadow_copy_chmod_acl(vfs_handle_struct *handle, const char *path,
528 SHADOW_NEXT(CHMOD_ACL,
529 (handle, cpath ?: path, mode),
534 onefs_shadow_copy_sys_acl_get_file(vfs_handle_struct *handle,
535 const char *path, SMB_ACL_TYPE_T type)
537 SHADOW_NEXT(SYS_ACL_GET_FILE,
538 (handle, cpath ?: path, type),
543 onefs_shadow_copy_sys_acl_set_file(vfs_handle_struct *handle, const char *path,
544 SMB_ACL_TYPE_T type, SMB_ACL_T theacl)
546 SHADOW_NEXT(SYS_ACL_SET_FILE,
547 (handle, cpath ?: path, type, theacl),
552 onefs_shadow_copy_sys_acl_delete_def_file(vfs_handle_struct *handle,
555 SHADOW_NEXT(SYS_ACL_DELETE_DEF_FILE,
556 (handle, cpath ?: path),
561 onefs_shadow_copy_getxattr(vfs_handle_struct *handle, const char *path,
562 const char *name, void *value, size_t size)
564 SHADOW_NEXT(GETXATTR,
565 (handle, cpath ?: path, name, value, size),
570 onefs_shadow_copy_lgetxattr(vfs_handle_struct *handle, const char *path,
571 const char *name, void *value, size_t size)
573 SHADOW_NEXT(LGETXATTR,
574 (handle, cpath ?: path, name, value, size),
579 onefs_shadow_copy_listxattr(vfs_handle_struct *handle, const char *path,
580 char *list, size_t size)
582 SHADOW_NEXT(LISTXATTR,
583 (handle, cpath ?: path, list, size),
588 onefs_shadow_copy_llistxattr(vfs_handle_struct *handle, const char *path,
589 char *list, size_t size)
591 SHADOW_NEXT(LLISTXATTR,
592 (handle, cpath ?: path, list, size),
597 onefs_shadow_copy_removexattr(vfs_handle_struct *handle, const char *path,
600 SHADOW_NEXT(REMOVEXATTR,
601 (handle, cpath ?: path, name),
606 onefs_shadow_copy_lremovexattr(vfs_handle_struct *handle, const char *path,
609 SHADOW_NEXT(LREMOVEXATTR,
610 (handle, cpath ?: path, name),
615 onefs_shadow_copy_setxattr(vfs_handle_struct *handle, const char *path,
616 const char *name, const void *value, size_t size,
619 SHADOW_NEXT(SETXATTR,
620 (handle, cpath ?: path, name, value, size, flags),
625 onefs_shadow_copy_lsetxattr(vfs_handle_struct *handle, const char *path,
626 const char *name, const void *value, size_t size,
629 SHADOW_NEXT(LSETXATTR,
630 (handle, cpath ?: path, name, value, size, flags),
635 onefs_shadow_copy_is_offline(struct vfs_handle_struct *handle,
636 const char *path, SMB_STRUCT_STAT *sbuf)
638 SHADOW_NEXT(IS_OFFLINE,
639 (handle, cpath ?: path, sbuf),
644 onefs_shadow_copy_set_offline(struct vfs_handle_struct *handle,
647 SHADOW_NEXT(SET_OFFLINE,
648 (handle, cpath ?: path),
652 /* VFS operations structure */
654 static vfs_op_tuple onefs_shadow_copy_ops[] = {
656 /* Disk operations */
658 {SMB_VFS_OP(onefs_shadow_copy_disk_free), SMB_VFS_OP_DISK_FREE,
659 SMB_VFS_LAYER_TRANSPARENT},
660 {SMB_VFS_OP(onefs_shadow_copy_get_shadow_copy_data),
661 SMB_VFS_OP_GET_SHADOW_COPY_DATA, SMB_VFS_LAYER_OPAQUE},
662 {SMB_VFS_OP(onefs_shadow_copy_statvfs), SMB_VFS_OP_STATVFS,
663 SMB_VFS_LAYER_TRANSPARENT},
665 /* Directory operations */
667 {SMB_VFS_OP(onefs_shadow_copy_opendir), SMB_VFS_OP_OPENDIR,
668 SMB_VFS_LAYER_TRANSPARENT},
669 {SMB_VFS_OP(onefs_shadow_copy_mkdir), SMB_VFS_OP_MKDIR,
670 SMB_VFS_LAYER_TRANSPARENT},
671 {SMB_VFS_OP(onefs_shadow_copy_rmdir), SMB_VFS_OP_RMDIR,
672 SMB_VFS_LAYER_TRANSPARENT},
674 /* File operations */
676 {SMB_VFS_OP(onefs_shadow_copy_open), SMB_VFS_OP_OPEN,
677 SMB_VFS_LAYER_TRANSPARENT},
678 {SMB_VFS_OP(onefs_shadow_copy_create_file), SMB_VFS_OP_CREATE_FILE,
679 SMB_VFS_LAYER_TRANSPARENT},
680 {SMB_VFS_OP(onefs_shadow_copy_rename), SMB_VFS_OP_RENAME,
681 SMB_VFS_LAYER_TRANSPARENT},
682 {SMB_VFS_OP(onefs_shadow_copy_stat), SMB_VFS_OP_STAT,
683 SMB_VFS_LAYER_TRANSPARENT},
684 {SMB_VFS_OP(onefs_shadow_copy_stat), SMB_VFS_OP_STAT,
685 SMB_VFS_LAYER_TRANSPARENT},
686 {SMB_VFS_OP(onefs_shadow_copy_lstat), SMB_VFS_OP_LSTAT,
687 SMB_VFS_LAYER_TRANSPARENT},
688 {SMB_VFS_OP(onefs_shadow_copy_unlink), SMB_VFS_OP_UNLINK,
689 SMB_VFS_LAYER_TRANSPARENT},
690 {SMB_VFS_OP(onefs_shadow_copy_chmod), SMB_VFS_OP_CHMOD,
691 SMB_VFS_LAYER_TRANSPARENT},
692 {SMB_VFS_OP(onefs_shadow_copy_chown), SMB_VFS_OP_CHOWN,
693 SMB_VFS_LAYER_TRANSPARENT},
694 {SMB_VFS_OP(onefs_shadow_copy_lchown), SMB_VFS_OP_LCHOWN,
695 SMB_VFS_LAYER_TRANSPARENT},
696 {SMB_VFS_OP(onefs_shadow_copy_chdir), SMB_VFS_OP_CHDIR,
697 SMB_VFS_LAYER_TRANSPARENT},
698 {SMB_VFS_OP(onefs_shadow_copy_ntimes), SMB_VFS_OP_NTIMES,
699 SMB_VFS_LAYER_TRANSPARENT},
700 {SMB_VFS_OP(onefs_shadow_copy_symlink), SMB_VFS_OP_SYMLINK,
701 SMB_VFS_LAYER_TRANSPARENT},
702 {SMB_VFS_OP(onefs_shadow_copy_readlink), SMB_VFS_OP_READLINK,
703 SMB_VFS_LAYER_TRANSPARENT},
704 {SMB_VFS_OP(onefs_shadow_copy_link), SMB_VFS_OP_LINK,
705 SMB_VFS_LAYER_TRANSPARENT},
706 {SMB_VFS_OP(onefs_shadow_copy_mknod), SMB_VFS_OP_MKNOD,
707 SMB_VFS_LAYER_TRANSPARENT},
708 {SMB_VFS_OP(onefs_shadow_copy_realpath), SMB_VFS_OP_REALPATH,
709 SMB_VFS_LAYER_TRANSPARENT},
710 {SMB_VFS_OP(onefs_shadow_copy_chflags), SMB_VFS_OP_CHFLAGS,
711 SMB_VFS_LAYER_TRANSPARENT},
712 {SMB_VFS_OP(onefs_shadow_copy_streaminfo), SMB_VFS_OP_STREAMINFO,
713 SMB_VFS_LAYER_TRANSPARENT},
714 {SMB_VFS_OP(onefs_shadow_copy_get_real_filename),
715 SMB_VFS_OP_GET_REAL_FILENAME, SMB_VFS_LAYER_TRANSPARENT},
717 /* NT File ACL operations */
719 {SMB_VFS_OP(onefs_shadow_copy_get_nt_acl), SMB_VFS_OP_GET_NT_ACL,
720 SMB_VFS_LAYER_TRANSPARENT},
722 /* POSIX ACL operations */
724 {SMB_VFS_OP(onefs_shadow_copy_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
725 SMB_VFS_LAYER_TRANSPARENT},
726 {SMB_VFS_OP(onefs_shadow_copy_sys_acl_get_file),
727 SMB_VFS_OP_SYS_ACL_GET_FILE, SMB_VFS_LAYER_TRANSPARENT},
728 {SMB_VFS_OP(onefs_shadow_copy_sys_acl_set_file),
729 SMB_VFS_OP_SYS_ACL_SET_FILE, SMB_VFS_LAYER_TRANSPARENT},
730 {SMB_VFS_OP(onefs_shadow_copy_sys_acl_delete_def_file),
731 SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE, SMB_VFS_LAYER_TRANSPARENT},
735 {SMB_VFS_OP(onefs_shadow_copy_getxattr), SMB_VFS_OP_GETXATTR,
736 SMB_VFS_LAYER_TRANSPARENT},
737 {SMB_VFS_OP(onefs_shadow_copy_lgetxattr), SMB_VFS_OP_LGETXATTR,
738 SMB_VFS_LAYER_TRANSPARENT},
739 {SMB_VFS_OP(onefs_shadow_copy_listxattr), SMB_VFS_OP_LISTXATTR,
740 SMB_VFS_LAYER_TRANSPARENT},
741 {SMB_VFS_OP(onefs_shadow_copy_llistxattr), SMB_VFS_OP_LLISTXATTR,
742 SMB_VFS_LAYER_TRANSPARENT},
743 {SMB_VFS_OP(onefs_shadow_copy_removexattr), SMB_VFS_OP_REMOVEXATTR,
744 SMB_VFS_LAYER_TRANSPARENT},
745 {SMB_VFS_OP(onefs_shadow_copy_lremovexattr), SMB_VFS_OP_LREMOVEXATTR,
746 SMB_VFS_LAYER_TRANSPARENT},
747 {SMB_VFS_OP(onefs_shadow_copy_setxattr), SMB_VFS_OP_SETXATTR,
748 SMB_VFS_LAYER_TRANSPARENT},
749 {SMB_VFS_OP(onefs_shadow_copy_lsetxattr), SMB_VFS_OP_LSETXATTR,
750 SMB_VFS_LAYER_TRANSPARENT},
752 /* offline operations */
753 {SMB_VFS_OP(onefs_shadow_copy_is_offline), SMB_VFS_OP_IS_OFFLINE,
754 SMB_VFS_LAYER_TRANSPARENT},
755 {SMB_VFS_OP(onefs_shadow_copy_set_offline), SMB_VFS_OP_SET_OFFLINE,
756 SMB_VFS_LAYER_TRANSPARENT},
758 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP}
761 NTSTATUS vfs_shadow_copy_init(void)
765 ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
767 onefs_shadow_copy_ops);
769 if (!NT_STATUS_IS_OK(ret))
772 vfs_onefs_shadow_copy_debug_level = debug_add_class("onefs_shadow_copy");
774 if (vfs_onefs_shadow_copy_debug_level == -1) {
775 vfs_onefs_shadow_copy_debug_level = DBGC_VFS;
776 DEBUG(0, ("Couldn't register custom debugging class!\n"));
778 DEBUG(10, ("Debug class number of 'onefs_shadow_copy': %d\n",
779 vfs_onefs_shadow_copy_debug_level));