source: trunk/server/source3/modules/vfs_onefs_shadow_copy.c@ 898

Last change on this file since 898 was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 18.9 KB
Line 
1/*
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
4 * 2004.
5 *
6 * Copyright (C) Stefan Metzmacher 2003-2004
7 * Copyright (C) Tim Prouty 2009
8 *
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.
13 *
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.
18 *
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.
22 */
23
24#include "includes.h"
25#include "smbd/smbd.h"
26#include "onefs_shadow_copy.h"
27
28static int vfs_onefs_shadow_copy_debug_level = DBGC_VFS;
29
30#undef DBGC_CLASS
31#define DBGC_CLASS vfs_onefs_shadow_copy_debug_level
32
33#define SHADOW_COPY_PREFIX "@GMT-"
34#define SHADOW_COPY_SAMPLE "@GMT-2004.02.18-15.44.00"
35
36bool
37shadow_copy_match_name(const char *name, char **snap_component)
38{
39 uint32 i = 0;
40 char delim[] = SHADOW_COPY_PREFIX;
41 char* start;
42
43 start = strstr( name, delim );
44
45 /*
46 * The name could have SHADOW_COPY_PREFIX in it so we need to keep
47 * trying until we get something that is the full length of the
48 * SHADOW_COPY_SAMPLE.
49 */
50 while (start != NULL) {
51
52 DEBUG(10,("Processing %s\n", name));
53
54 /* size / correctness check */
55 *snap_component = start;
56 for ( i = sizeof(SHADOW_COPY_PREFIX);
57 i < sizeof(SHADOW_COPY_SAMPLE); i++) {
58 if (start[i] == '/') {
59 if (i == sizeof(SHADOW_COPY_SAMPLE) - 1)
60 return true;
61 else
62 break;
63 } else if (start[i] == '\0')
64 return (i == sizeof(SHADOW_COPY_SAMPLE) - 1);
65 }
66
67 start = strstr( start, delim );
68 }
69
70 return false;
71}
72
73static int
74onefs_shadow_copy_get_shadow_copy_data(vfs_handle_struct *handle,
75 files_struct *fsp,
76 SHADOW_COPY_DATA *shadow_copy_data,
77 bool labels)
78{
79 void *p = osc_version_opendir();
80 char *snap_component = NULL;
81 shadow_copy_data->num_volumes = 0;
82 shadow_copy_data->labels = NULL;
83
84 if (!p) {
85 DEBUG(0, ("shadow_copy_get_shadow_copy_data: osc_opendir() "
86 "failed for [%s]\n",fsp->conn->connectpath));
87 return -1;
88 }
89
90 while (true) {
91 SHADOW_COPY_LABEL *tlabels;
92 char *d;
93
94 d = osc_version_readdir(p);
95 if (d == NULL)
96 break;
97
98 if (!shadow_copy_match_name(d, &snap_component)) {
99 DEBUG(10,("shadow_copy_get_shadow_copy_data: ignore "
100 "[%s]\n",d));
101 continue;
102 }
103
104 DEBUG(7,("shadow_copy_get_shadow_copy_data: not ignore "
105 "[%s]\n",d));
106
107 if (!labels) {
108 shadow_copy_data->num_volumes++;
109 continue;
110 }
111
112 tlabels = (SHADOW_COPY_LABEL *)TALLOC_REALLOC(
113 shadow_copy_data->mem_ctx,
114 shadow_copy_data->labels,
115 (shadow_copy_data->num_volumes+1) *
116 sizeof(SHADOW_COPY_LABEL));
117
118 if (tlabels == NULL) {
119 DEBUG(0,("shadow_copy_get_shadow_copy_data: Out of "
120 "memory\n"));
121 osc_version_closedir(p);
122 return -1;
123 }
124
125 snprintf(tlabels[shadow_copy_data->num_volumes++],
126 sizeof(*tlabels), "%s",d);
127
128 shadow_copy_data->labels = tlabels;
129 }
130
131 osc_version_closedir(p);
132
133 return 0;
134}
135
136#define SHADOW_NEXT(op, args, rtype) do { \
137 char *cpath = NULL; \
138 char *snap_component = NULL; \
139 rtype ret; \
140 if (shadow_copy_match_name(path, &snap_component)) \
141 cpath = osc_canonicalize_path(path, snap_component); \
142 ret = SMB_VFS_NEXT_ ## op args; \
143 SAFE_FREE(cpath); \
144 return ret; \
145 } while (0) \
146
147/*
148 * XXX: Convert osc_canonicalize_path to use talloc instead of malloc.
149 */
150#define SHADOW_NEXT_SMB_FNAME(op, args, rtype) do { \
151 char *smb_base_name_tmp = NULL; \
152 char *cpath = NULL; \
153 char *snap_component = NULL; \
154 rtype ret; \
155 smb_base_name_tmp = smb_fname->base_name; \
156 if (shadow_copy_match_name(smb_fname->base_name, \
157 &snap_component)) { \
158 cpath = osc_canonicalize_path(smb_fname->base_name, \
159 snap_component); \
160 smb_fname->base_name = cpath; \
161 } \
162 ret = SMB_VFS_NEXT_ ## op args; \
163 smb_fname->base_name = smb_base_name_tmp; \
164 SAFE_FREE(cpath); \
165 return ret; \
166 } while (0) \
167
168static uint64_t
169onefs_shadow_copy_disk_free(vfs_handle_struct *handle, const char *path,
170 bool small_query, uint64_t *bsize, uint64_t *dfree,
171 uint64_t *dsize)
172{
173
174 SHADOW_NEXT(DISK_FREE,
175 (handle, cpath ?: path, small_query, bsize, dfree, dsize),
176 uint64_t);
177
178}
179
180static int
181onefs_shadow_copy_statvfs(struct vfs_handle_struct *handle, const char *path,
182 struct vfs_statvfs_struct *statbuf)
183{
184 SHADOW_NEXT(STATVFS,
185 (handle, cpath ?: path, statbuf),
186 int);
187}
188
189static SMB_STRUCT_DIR *
190onefs_shadow_copy_opendir(vfs_handle_struct *handle, const char *path,
191 const char *mask, uint32_t attr)
192{
193 SHADOW_NEXT(OPENDIR,
194 (handle, cpath ?: path, mask, attr),
195 SMB_STRUCT_DIR *);
196}
197
198static int
199onefs_shadow_copy_mkdir(vfs_handle_struct *handle, const char *path,
200 mode_t mode)
201{
202 SHADOW_NEXT(MKDIR,
203 (handle, cpath ?: path, mode),
204 int);
205}
206
207static int
208onefs_shadow_copy_rmdir(vfs_handle_struct *handle, const char *path)
209{
210 SHADOW_NEXT(RMDIR,
211 (handle, cpath ?: path),
212 int);
213}
214
215static int
216onefs_shadow_copy_open(vfs_handle_struct *handle,
217 struct smb_filename *smb_fname, files_struct *fsp,
218 int flags, mode_t mode)
219{
220 SHADOW_NEXT_SMB_FNAME(OPEN,
221 (handle, smb_fname, fsp, flags, mode),
222 int);
223}
224
225static NTSTATUS
226onefs_shadow_copy_create_file(vfs_handle_struct *handle,
227 struct smb_request *req,
228 uint16_t root_dir_fid,
229 struct smb_filename *smb_fname,
230 uint32_t access_mask,
231 uint32_t share_access,
232 uint32_t create_disposition,
233 uint32_t create_options,
234 uint32_t file_attributes,
235 uint32_t oplock_request,
236 uint64_t allocation_size,
237 uint32_t private_flags,
238 struct security_descriptor *sd,
239 struct ea_list *ea_list,
240 files_struct **result,
241 int *pinfo)
242{
243 SHADOW_NEXT_SMB_FNAME(CREATE_FILE,
244 (handle, req, root_dir_fid, smb_fname,
245 access_mask, share_access,
246 create_disposition, create_options,
247 file_attributes, oplock_request,
248 allocation_size, private_flags,
249 sd, ea_list, result, pinfo),
250 NTSTATUS);
251}
252
253/**
254 * XXX: macro-ize
255 */
256static int
257onefs_shadow_copy_rename(vfs_handle_struct *handle,
258 const struct smb_filename *smb_fname_src,
259 const struct smb_filename *smb_fname_dst)
260{
261 char *old_cpath = NULL;
262 char *old_snap_component = NULL;
263 char *new_cpath = NULL;
264 char *new_snap_component = NULL;
265 struct smb_filename *smb_fname_src_tmp = NULL;
266 struct smb_filename *smb_fname_dst_tmp = NULL;
267 NTSTATUS status;
268 int ret = -1;
269
270 status = copy_smb_filename(talloc_tos(), smb_fname_src,
271 &smb_fname_src_tmp);
272 if (!NT_STATUS_IS_OK(status)) {
273 errno = map_errno_from_nt_status(status);
274 goto out;
275 }
276 status = copy_smb_filename(talloc_tos(), smb_fname_dst,
277 &smb_fname_dst_tmp);
278 if (!NT_STATUS_IS_OK(status)) {
279 errno = map_errno_from_nt_status(status);
280 goto out;
281 }
282
283 if (shadow_copy_match_name(smb_fname_src_tmp->base_name,
284 &old_snap_component)) {
285 old_cpath = osc_canonicalize_path(smb_fname_src_tmp->base_name,
286 old_snap_component);
287 smb_fname_src_tmp->base_name = old_cpath;
288 }
289
290 if (shadow_copy_match_name(smb_fname_dst_tmp->base_name,
291 &new_snap_component)) {
292 new_cpath = osc_canonicalize_path(smb_fname_dst_tmp->base_name,
293 new_snap_component);
294 smb_fname_dst_tmp->base_name = new_cpath;
295 }
296
297 ret = SMB_VFS_NEXT_RENAME(handle, smb_fname_src_tmp,
298 smb_fname_dst_tmp);
299
300 out:
301 SAFE_FREE(old_cpath);
302 SAFE_FREE(new_cpath);
303 TALLOC_FREE(smb_fname_src_tmp);
304 TALLOC_FREE(smb_fname_dst_tmp);
305
306 return ret;
307}
308
309static int
310onefs_shadow_copy_stat(vfs_handle_struct *handle,
311 struct smb_filename *smb_fname)
312{
313 SHADOW_NEXT_SMB_FNAME(STAT,
314 (handle, smb_fname),
315 int);
316}
317
318static int
319onefs_shadow_copy_lstat(vfs_handle_struct *handle,
320 struct smb_filename *smb_fname)
321{
322 SHADOW_NEXT_SMB_FNAME(LSTAT,
323 (handle, smb_fname),
324 int);
325}
326
327static int
328onefs_shadow_copy_unlink(vfs_handle_struct *handle,
329 const struct smb_filename *smb_fname_in)
330{
331 struct smb_filename *smb_fname = NULL;
332 NTSTATUS status;
333
334 status = copy_smb_filename(talloc_tos(), smb_fname_in, &smb_fname);
335 if (!NT_STATUS_IS_OK(status)) {
336 errno = map_errno_from_nt_status(status);
337 return -1;
338 }
339
340 SHADOW_NEXT_SMB_FNAME(UNLINK,
341 (handle, smb_fname),
342 int);
343}
344
345static int
346onefs_shadow_copy_chmod(vfs_handle_struct *handle, const char *path,
347 mode_t mode)
348{
349 SHADOW_NEXT(CHMOD,
350 (handle, cpath ?: path, mode),
351 int);
352}
353
354static int
355onefs_shadow_copy_chown(vfs_handle_struct *handle, const char *path,
356 uid_t uid, gid_t gid)
357{
358 SHADOW_NEXT(CHOWN,
359 (handle, cpath ?: path, uid, gid),
360 int);
361}
362
363static int
364onefs_shadow_copy_lchown(vfs_handle_struct *handle, const char *path,
365 uid_t uid, gid_t gid)
366{
367 SHADOW_NEXT(LCHOWN,
368 (handle, cpath ?: path, uid, gid),
369 int);
370}
371
372static int
373onefs_shadow_copy_chdir(vfs_handle_struct *handle, const char *path)
374{
375 SHADOW_NEXT(CHDIR,
376 (handle, cpath ?: path),
377 int);
378}
379
380static int
381onefs_shadow_copy_ntimes(vfs_handle_struct *handle,
382 const struct smb_filename *smb_fname_in,
383 struct smb_file_time *ft)
384{
385 struct smb_filename *smb_fname = NULL;
386 NTSTATUS status;
387
388 status = copy_smb_filename(talloc_tos(), smb_fname_in, &smb_fname);
389 if (!NT_STATUS_IS_OK(status)) {
390 errno = map_errno_from_nt_status(status);
391 return -1;
392 }
393
394 SHADOW_NEXT_SMB_FNAME(NTIMES,
395 (handle, smb_fname, ft),
396 int);
397
398}
399
400/**
401 * XXX: macro-ize
402 */
403static int
404onefs_shadow_copy_symlink(vfs_handle_struct *handle,
405 const char *oldpath, const char *newpath)
406{
407 char *old_cpath = NULL;
408 char *old_snap_component = NULL;
409 char *new_cpath = NULL;
410 char *new_snap_component = NULL;
411 bool ret;
412
413 if (shadow_copy_match_name(oldpath, &old_snap_component))
414 old_cpath = osc_canonicalize_path(oldpath, old_snap_component);
415
416 if (shadow_copy_match_name(newpath, &new_snap_component))
417 new_cpath = osc_canonicalize_path(newpath, new_snap_component);
418
419 ret = SMB_VFS_NEXT_SYMLINK(handle, old_cpath ?: oldpath,
420 new_cpath ?: newpath);
421
422 SAFE_FREE(old_cpath);
423 SAFE_FREE(new_cpath);
424
425 return ret;
426}
427
428static int
429onefs_shadow_copy_readlink(vfs_handle_struct *handle, const char *path,
430 char *buf, size_t bufsiz)
431{
432 SHADOW_NEXT(READLINK,
433 (handle, cpath ?: path, buf, bufsiz),
434 int);
435}
436
437/**
438 * XXX: macro-ize
439 */
440static int
441onefs_shadow_copy_link(vfs_handle_struct *handle, const char *oldpath,
442 const char *newpath)
443{
444 char *old_cpath = NULL;
445 char *old_snap_component = NULL;
446 char *new_cpath = NULL;
447 char *new_snap_component = NULL;
448 int ret;
449
450 if (shadow_copy_match_name(oldpath, &old_snap_component))
451 old_cpath = osc_canonicalize_path(oldpath, old_snap_component);
452
453 if (shadow_copy_match_name(newpath, &new_snap_component))
454 new_cpath = osc_canonicalize_path(newpath, new_snap_component);
455
456 ret = SMB_VFS_NEXT_LINK(handle, old_cpath ?: oldpath,
457 new_cpath ?: newpath);
458
459 SAFE_FREE(old_cpath);
460 SAFE_FREE(new_cpath);
461
462 return ret;
463}
464
465static int
466onefs_shadow_copy_mknod(vfs_handle_struct *handle, const char *path,
467 mode_t mode, SMB_DEV_T dev)
468{
469 SHADOW_NEXT(MKNOD,
470 (handle, cpath ?: path, mode, dev),
471 int);
472}
473
474static char *
475onefs_shadow_copy_realpath(vfs_handle_struct *handle, const char *path)
476{
477 SHADOW_NEXT(REALPATH,
478 (handle, cpath ?: path),
479 char *);
480}
481
482static int onefs_shadow_copy_chflags(struct vfs_handle_struct *handle,
483 const char *path, unsigned int flags)
484{
485 SHADOW_NEXT(CHFLAGS,
486 (handle, cpath ?: path, flags),
487 int);
488}
489
490static NTSTATUS
491onefs_shadow_copy_streaminfo(struct vfs_handle_struct *handle,
492 struct files_struct *fsp,
493 const char *path,
494 TALLOC_CTX *mem_ctx,
495 unsigned int *num_streams,
496 struct stream_struct **streams)
497{
498 SHADOW_NEXT(STREAMINFO,
499 (handle, fsp, cpath ?: path, mem_ctx, num_streams,
500 streams),
501 NTSTATUS);
502}
503
504static int
505onefs_shadow_copy_get_real_filename(struct vfs_handle_struct *handle,
506 const char *full_path,
507 const char *path,
508 TALLOC_CTX *mem_ctx,
509 char **found_name)
510{
511 SHADOW_NEXT(GET_REAL_FILENAME,
512 (handle, full_path, cpath ?: path, mem_ctx, found_name),
513 int);
514}
515
516static NTSTATUS
517onefs_shadow_copy_get_nt_acl(struct vfs_handle_struct *handle,
518 const char *path, uint32 security_info,
519 struct security_descriptor **ppdesc)
520{
521 SHADOW_NEXT(GET_NT_ACL,
522 (handle, cpath ?: path, security_info, ppdesc),
523 NTSTATUS);
524}
525
526static int
527onefs_shadow_copy_chmod_acl(vfs_handle_struct *handle, const char *path,
528 mode_t mode)
529{
530 SHADOW_NEXT(CHMOD_ACL,
531 (handle, cpath ?: path, mode),
532 int);
533}
534
535static SMB_ACL_T
536onefs_shadow_copy_sys_acl_get_file(vfs_handle_struct *handle,
537 const char *path, SMB_ACL_TYPE_T type)
538{
539 SHADOW_NEXT(SYS_ACL_GET_FILE,
540 (handle, cpath ?: path, type),
541 SMB_ACL_T);
542}
543
544static int
545onefs_shadow_copy_sys_acl_set_file(vfs_handle_struct *handle, const char *path,
546 SMB_ACL_TYPE_T type, SMB_ACL_T theacl)
547{
548 SHADOW_NEXT(SYS_ACL_SET_FILE,
549 (handle, cpath ?: path, type, theacl),
550 int);
551}
552
553static int
554onefs_shadow_copy_sys_acl_delete_def_file(vfs_handle_struct *handle,
555 const char *path)
556{
557 SHADOW_NEXT(SYS_ACL_DELETE_DEF_FILE,
558 (handle, cpath ?: path),
559 int);
560}
561
562static ssize_t
563onefs_shadow_copy_getxattr(vfs_handle_struct *handle, const char *path,
564 const char *name, void *value, size_t size)
565{
566 SHADOW_NEXT(GETXATTR,
567 (handle, cpath ?: path, name, value, size),
568 ssize_t);
569}
570
571static ssize_t
572onefs_shadow_copy_lgetxattr(vfs_handle_struct *handle, const char *path,
573 const char *name, void *value, size_t size)
574{
575 SHADOW_NEXT(LGETXATTR,
576 (handle, cpath ?: path, name, value, size),
577 ssize_t);
578}
579
580static ssize_t
581onefs_shadow_copy_listxattr(vfs_handle_struct *handle, const char *path,
582 char *list, size_t size)
583{
584 SHADOW_NEXT(LISTXATTR,
585 (handle, cpath ?: path, list, size),
586 ssize_t);
587}
588
589static ssize_t
590onefs_shadow_copy_llistxattr(vfs_handle_struct *handle, const char *path,
591 char *list, size_t size)
592{
593 SHADOW_NEXT(LLISTXATTR,
594 (handle, cpath ?: path, list, size),
595 ssize_t);
596}
597
598static int
599onefs_shadow_copy_removexattr(vfs_handle_struct *handle, const char *path,
600 const char *name)
601{
602 SHADOW_NEXT(REMOVEXATTR,
603 (handle, cpath ?: path, name),
604 int);
605}
606
607static int
608onefs_shadow_copy_lremovexattr(vfs_handle_struct *handle, const char *path,
609 const char *name)
610{
611 SHADOW_NEXT(LREMOVEXATTR,
612 (handle, cpath ?: path, name),
613 int);
614}
615
616static int
617onefs_shadow_copy_setxattr(vfs_handle_struct *handle, const char *path,
618 const char *name, const void *value, size_t size,
619 int flags)
620{
621 SHADOW_NEXT(SETXATTR,
622 (handle, cpath ?: path, name, value, size, flags),
623 int);
624}
625
626static int
627onefs_shadow_copy_lsetxattr(vfs_handle_struct *handle, const char *path,
628 const char *name, const void *value, size_t size,
629 int flags)
630{
631 SHADOW_NEXT(LSETXATTR,
632 (handle, cpath ?: path, name, value, size, flags),
633 int);
634}
635
636static bool
637onefs_shadow_copy_is_offline(struct vfs_handle_struct *handle,
638 const struct smb_fname *fname,
639 SMB_STRUCT_STAT *sbuf)
640{
641#error Isilon, please convert "char *path" to "struct smb_fname *fname"
642 SHADOW_NEXT(IS_OFFLINE,
643 (handle, cpath ?: path, sbuf),
644 bool);
645}
646
647static int
648onefs_shadow_copy_set_offline(struct vfs_handle_struct *handle,
649 const struct smb_filename *fname)
650{
651#error Isilon, please convert "char *path" to "struct smb_fname *fname"
652 SHADOW_NEXT(SET_OFFLINE,
653 (handle, cpath ?: path),
654 int);
655}
656
657/* VFS operations structure */
658
659static struct vfs_fn_pointers onefs_shadow_copy_fns = {
660 .disk_free = onefs_shadow_copy_disk_free,
661 .get_shadow_copy_data = onefs_shadow_copy_get_shadow_copy_data,
662 .statvfs = onefs_shadow_copy_statvfs,
663 .opendir = onefs_shadow_copy_opendir,
664 .mkdir = onefs_shadow_copy_mkdir,
665 .rmdir = onefs_shadow_copy_rmdir,
666 .open_fn = onefs_shadow_copy_open,
667 .create_file = onefs_shadow_copy_create_file,
668 .rename = onefs_shadow_copy_rename,
669 .stat = onefs_shadow_copy_stat,
670 .stat = onefs_shadow_copy_stat,
671 .lstat = onefs_shadow_copy_lstat,
672 .unlink = onefs_shadow_copy_unlink,
673 .chmod = onefs_shadow_copy_chmod,
674 .chown = onefs_shadow_copy_chown,
675 .lchown = onefs_shadow_copy_lchown,
676 .chdir = onefs_shadow_copy_chdir,
677 .ntimes = onefs_shadow_copy_ntimes,
678 .symlink = onefs_shadow_copy_symlink,
679 .vfs_readlink = onefs_shadow_copy_readlink,
680 .link = onefs_shadow_copy_link,
681 .mknod = onefs_shadow_copy_mknod,
682 .realpath = onefs_shadow_copy_realpath,
683 .chflags = onefs_shadow_copy_chflags,
684 .streaminfo = onefs_shadow_copy_streaminfo,
685 .get_real_filename = onefs_shadow_copy_get_real_filename,
686 .get_nt_acl = onefs_shadow_copy_get_nt_acl,
687 .chmod_acl = onefs_shadow_copy_chmod_acl,
688 .sys_acl_get_file = onefs_shadow_copy_sys_acl_get_file,
689 .sys_acl_set_file = onefs_shadow_copy_sys_acl_set_file,
690 .sys_acl_delete_def_file = onefs_shadow_copy_sys_acl_delete_def_file,
691 .getxattr = onefs_shadow_copy_getxattr,
692 .lgetxattr = onefs_shadow_copy_lgetxattr,
693 .listxattr = onefs_shadow_copy_listxattr,
694 .llistxattr = onefs_shadow_copy_llistxattr,
695 .removexattr = onefs_shadow_copy_removexattr,
696 .lremovexattr = onefs_shadow_copy_lremovexattr,
697 .setxattr = onefs_shadow_copy_setxattr,
698 .lsetxattr = onefs_shadow_copy_lsetxattr,
699 .is_offline = onefs_shadow_copy_is_offline,
700 .set_offline = onefs_shadow_copy_set_offline,
701};
702
703NTSTATUS vfs_shadow_copy_init(void)
704{
705 NTSTATUS ret;
706
707 ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
708 "onefs_shadow_copy",
709 &onefs_shadow_copy_fns);
710
711 if (!NT_STATUS_IS_OK(ret))
712 return ret;
713
714 vfs_onefs_shadow_copy_debug_level = debug_add_class("onefs_shadow_copy");
715
716 if (vfs_onefs_shadow_copy_debug_level == -1) {
717 vfs_onefs_shadow_copy_debug_level = DBGC_VFS;
718 DEBUG(0, ("Couldn't register custom debugging class!\n"));
719 } else {
720 DEBUG(10, ("Debug class number of 'onefs_shadow_copy': %d\n",
721 vfs_onefs_shadow_copy_debug_level));
722 }
723
724 return ret;
725}
Note: See TracBrowser for help on using the repository browser.