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 }