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