2 Unix SMB/CIFS implementation.
3 Wrap disk only vfs functions to sidestep dodgy compilers.
4 Copyright (C) Tim Potter 1998
5 Copyright (C) Jeremy Allison 2007
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #define DBGC_CLASS DBGC_VFS
26 /* Check for NULL pointer parameters in vfswrap_* functions */
28 /* We don't want to have NULL function pointers lying around. Someone
29 is sure to try and execute them. These stubs are used to prevent
32 static int vfswrap_connect(vfs_handle_struct
*handle
, const char *service
, const char *user
)
34 return 0; /* Return >= 0 for success */
37 static void vfswrap_disconnect(vfs_handle_struct
*handle
)
43 static SMB_BIG_UINT
vfswrap_disk_free(vfs_handle_struct
*handle
, const char *path
, bool small_query
, SMB_BIG_UINT
*bsize
,
44 SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
48 result
= sys_disk_free(handle
->conn
, path
, small_query
, bsize
, dfree
, dsize
);
52 static int vfswrap_get_quota(struct vfs_handle_struct
*handle
, enum SMB_QUOTA_TYPE qtype
, unid_t id
, SMB_DISK_QUOTA
*qt
)
54 #ifdef HAVE_SYS_QUOTAS
57 START_PROFILE(syscall_get_quota
);
58 result
= sys_get_quota(handle
->conn
->connectpath
, qtype
, id
, qt
);
59 END_PROFILE(syscall_get_quota
);
67 static int vfswrap_set_quota(struct vfs_handle_struct
*handle
, enum SMB_QUOTA_TYPE qtype
, unid_t id
, SMB_DISK_QUOTA
*qt
)
69 #ifdef HAVE_SYS_QUOTAS
72 START_PROFILE(syscall_set_quota
);
73 result
= sys_set_quota(handle
->conn
->connectpath
, qtype
, id
, qt
);
74 END_PROFILE(syscall_set_quota
);
82 static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SHADOW_COPY_DATA
*shadow_copy_data
, bool labels
)
85 return -1; /* Not implemented. */
88 static int vfswrap_statvfs(struct vfs_handle_struct
*handle
, const char *path
, vfs_statvfs_struct
*statbuf
)
90 return sys_statvfs(path
, statbuf
);
93 static uint32_t vfswrap_fs_capabilities(struct vfs_handle_struct
*handle
)
96 struct vfs_statvfs_struct statbuf
;
98 sys_statvfs(handle
->conn
->connectpath
, &statbuf
);
99 return statbuf
.FsCapabilities
;
101 return FILE_CASE_SENSITIVE_SEARCH
| FILE_CASE_PRESERVED_NAMES
;
104 /* Directory operations */
106 static SMB_STRUCT_DIR
*vfswrap_opendir(vfs_handle_struct
*handle
, const char *fname
, const char *mask
, uint32 attr
)
108 SMB_STRUCT_DIR
*result
;
110 START_PROFILE(syscall_opendir
);
111 result
= sys_opendir(fname
);
112 END_PROFILE(syscall_opendir
);
116 static SMB_STRUCT_DIRENT
*vfswrap_readdir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
118 SMB_STRUCT_DIRENT
*result
;
120 START_PROFILE(syscall_readdir
);
121 result
= sys_readdir(dirp
);
122 END_PROFILE(syscall_readdir
);
126 static void vfswrap_seekdir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
, long offset
)
128 START_PROFILE(syscall_seekdir
);
129 sys_seekdir(dirp
, offset
);
130 END_PROFILE(syscall_seekdir
);
133 static long vfswrap_telldir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
136 START_PROFILE(syscall_telldir
);
137 result
= sys_telldir(dirp
);
138 END_PROFILE(syscall_telldir
);
142 static void vfswrap_rewinddir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
144 START_PROFILE(syscall_rewinddir
);
146 END_PROFILE(syscall_rewinddir
);
149 static int vfswrap_mkdir(vfs_handle_struct
*handle
, const char *path
, mode_t mode
)
152 bool has_dacl
= False
;
154 START_PROFILE(syscall_mkdir
);
156 if (lp_inherit_acls(SNUM(handle
->conn
)) && (has_dacl
= directory_has_default_acl(handle
->conn
, parent_dirname(path
))))
159 result
= mkdir(path
, mode
);
161 if (result
== 0 && !has_dacl
) {
163 * We need to do this as the default behavior of POSIX ACLs
164 * is to set the mask to be the requested group permission
165 * bits, not the group permission bits to be the requested
166 * group permission bits. This is not what we want, as it will
167 * mess up any inherited ACL bits that were set. JRA.
169 int saved_errno
= errno
; /* We may get ENOSYS */
170 if ((SMB_VFS_CHMOD_ACL(handle
->conn
, path
, mode
) == -1) && (errno
== ENOSYS
))
174 END_PROFILE(syscall_mkdir
);
178 static int vfswrap_rmdir(vfs_handle_struct
*handle
, const char *path
)
182 START_PROFILE(syscall_rmdir
);
183 result
= rmdir(path
);
184 END_PROFILE(syscall_rmdir
);
188 static int vfswrap_closedir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
192 START_PROFILE(syscall_closedir
);
193 result
= sys_closedir(dirp
);
194 END_PROFILE(syscall_closedir
);
198 /* File operations */
200 static int vfswrap_open(vfs_handle_struct
*handle
, const char *fname
,
201 files_struct
*fsp
, int flags
, mode_t mode
)
205 START_PROFILE(syscall_open
);
206 result
= sys_open(fname
, flags
, mode
);
207 END_PROFILE(syscall_open
);
211 static int vfswrap_close(vfs_handle_struct
*handle
, files_struct
*fsp
)
215 START_PROFILE(syscall_close
);
216 result
= fd_close_posix(fsp
);
217 END_PROFILE(syscall_close
);
221 static ssize_t
vfswrap_read(vfs_handle_struct
*handle
, files_struct
*fsp
, void *data
, size_t n
)
225 START_PROFILE_BYTES(syscall_read
, n
);
226 result
= sys_read(fsp
->fh
->fd
, data
, n
);
227 END_PROFILE(syscall_read
);
231 static ssize_t
vfswrap_pread(vfs_handle_struct
*handle
, files_struct
*fsp
, void *data
,
232 size_t n
, SMB_OFF_T offset
)
236 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
237 START_PROFILE_BYTES(syscall_pread
, n
);
238 result
= sys_pread(fsp
->fh
->fd
, data
, n
, offset
);
239 END_PROFILE(syscall_pread
);
241 if (result
== -1 && errno
== ESPIPE
) {
242 /* Maintain the fiction that pipes can be seeked (sought?) on. */
243 result
= SMB_VFS_READ(fsp
, data
, n
);
247 #else /* HAVE_PREAD */
251 curr
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
252 if (curr
== -1 && errno
== ESPIPE
) {
253 /* Maintain the fiction that pipes can be seeked (sought?) on. */
254 result
= SMB_VFS_READ(fsp
, data
, n
);
259 if (SMB_VFS_LSEEK(fsp
, offset
, SEEK_SET
) == -1) {
264 result
= SMB_VFS_READ(fsp
, data
, n
);
267 SMB_VFS_LSEEK(fsp
, curr
, SEEK_SET
);
270 #endif /* HAVE_PREAD */
275 static ssize_t
vfswrap_write(vfs_handle_struct
*handle
, files_struct
*fsp
, const void *data
, size_t n
)
279 START_PROFILE_BYTES(syscall_write
, n
);
280 result
= sys_write(fsp
->fh
->fd
, data
, n
);
281 END_PROFILE(syscall_write
);
285 static ssize_t
vfswrap_pwrite(vfs_handle_struct
*handle
, files_struct
*fsp
, const void *data
,
286 size_t n
, SMB_OFF_T offset
)
290 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
291 START_PROFILE_BYTES(syscall_pwrite
, n
);
292 result
= sys_pwrite(fsp
->fh
->fd
, data
, n
, offset
);
293 END_PROFILE(syscall_pwrite
);
295 if (result
== -1 && errno
== ESPIPE
) {
296 /* Maintain the fiction that pipes can be sought on. */
297 result
= SMB_VFS_WRITE(fsp
, data
, n
);
300 #else /* HAVE_PWRITE */
304 curr
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
309 if (SMB_VFS_LSEEK(fsp
, offset
, SEEK_SET
) == -1) {
313 result
= SMB_VFS_WRITE(fsp
, data
, n
);
316 SMB_VFS_LSEEK(fsp
, curr
, SEEK_SET
);
319 #endif /* HAVE_PWRITE */
324 static SMB_OFF_T
vfswrap_lseek(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T offset
, int whence
)
326 SMB_OFF_T result
= 0;
328 START_PROFILE(syscall_lseek
);
330 /* Cope with 'stat' file opens. */
331 if (fsp
->fh
->fd
!= -1)
332 result
= sys_lseek(fsp
->fh
->fd
, offset
, whence
);
335 * We want to maintain the fiction that we can seek
336 * on a fifo for file system purposes. This allows
337 * people to set up UNIX fifo's that feed data to Windows
341 if((result
== -1) && (errno
== ESPIPE
)) {
346 END_PROFILE(syscall_lseek
);
350 static ssize_t
vfswrap_sendfile(vfs_handle_struct
*handle
, int tofd
, files_struct
*fromfsp
, const DATA_BLOB
*hdr
,
351 SMB_OFF_T offset
, size_t n
)
355 START_PROFILE_BYTES(syscall_sendfile
, n
);
356 result
= sys_sendfile(tofd
, fromfsp
->fh
->fd
, hdr
, offset
, n
);
357 END_PROFILE(syscall_sendfile
);
361 static ssize_t
vfswrap_recvfile(vfs_handle_struct
*handle
,
369 START_PROFILE_BYTES(syscall_recvfile
, n
);
370 result
= sys_recvfile(fromfd
, tofsp
->fh
->fd
, offset
, n
);
371 END_PROFILE(syscall_recvfile
);
375 /*********************************************************
376 For rename across filesystems Patch from Warren Birnbaum
377 <warrenb@hpcvscdp.cv.hp.com>
378 **********************************************************/
380 static int copy_reg(const char *source
, const char *dest
)
382 SMB_STRUCT_STAT source_stats
;
387 if (sys_lstat (source
, &source_stats
) == -1)
390 if (!S_ISREG (source_stats
.st_mode
))
393 if((ifd
= sys_open (source
, O_RDONLY
, 0)) < 0)
396 if (unlink (dest
) && errno
!= ENOENT
)
400 if((ofd
= sys_open (dest
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_NOFOLLOW
, 0600)) < 0 )
402 if((ofd
= sys_open (dest
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0600)) < 0 )
406 if (transfer_file(ifd
, ofd
, (size_t)-1) == -1)
410 * Try to preserve ownership. For non-root it might fail, but that's ok.
411 * But root probably wants to know, e.g. if NFS disallows it.
415 if ((fchown(ofd
, source_stats
.st_uid
, source_stats
.st_gid
) == -1) && (errno
!= EPERM
))
417 if ((chown(dest
, source_stats
.st_uid
, source_stats
.st_gid
) == -1) && (errno
!= EPERM
))
422 * fchown turns off set[ug]id bits for non-root,
423 * so do the chmod last.
426 #if defined(HAVE_FCHMOD)
427 if (fchmod (ofd
, source_stats
.st_mode
& 07777))
429 if (chmod (dest
, source_stats
.st_mode
& 07777))
433 if (close (ifd
) == -1)
436 if (close (ofd
) == -1)
439 /* Try to copy the old file's modtime and access time. */
443 tv
.actime
= source_stats
.st_atime
;
444 tv
.modtime
= source_stats
.st_mtime
;
448 if (unlink (source
) == -1)
464 static int vfswrap_rename(vfs_handle_struct
*handle
, const char *oldname
, const char *newname
)
468 START_PROFILE(syscall_rename
);
469 result
= rename(oldname
, newname
);
470 if ((result
== -1) && (errno
== EXDEV
)) {
471 /* Rename across filesystems needed. */
472 result
= copy_reg(oldname
, newname
);
475 END_PROFILE(syscall_rename
);
479 static int vfswrap_fsync(vfs_handle_struct
*handle
, files_struct
*fsp
)
484 START_PROFILE(syscall_fsync
);
485 result
= fsync(fsp
->fh
->fd
);
486 END_PROFILE(syscall_fsync
);
493 static int vfswrap_stat(vfs_handle_struct
*handle
, const char *fname
, SMB_STRUCT_STAT
*sbuf
)
497 START_PROFILE(syscall_stat
);
498 result
= sys_stat(fname
, sbuf
);
499 END_PROFILE(syscall_stat
);
503 static int vfswrap_fstat(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_STRUCT_STAT
*sbuf
)
507 START_PROFILE(syscall_fstat
);
508 result
= sys_fstat(fsp
->fh
->fd
, sbuf
);
509 END_PROFILE(syscall_fstat
);
513 int vfswrap_lstat(vfs_handle_struct
*handle
, const char *path
, SMB_STRUCT_STAT
*sbuf
)
517 START_PROFILE(syscall_lstat
);
518 result
= sys_lstat(path
, sbuf
);
519 END_PROFILE(syscall_lstat
);
523 static int vfswrap_unlink(vfs_handle_struct
*handle
, const char *path
)
527 START_PROFILE(syscall_unlink
);
528 result
= unlink(path
);
529 END_PROFILE(syscall_unlink
);
533 static int vfswrap_chmod(vfs_handle_struct
*handle
, const char *path
, mode_t mode
)
537 START_PROFILE(syscall_chmod
);
540 * We need to do this due to the fact that the default POSIX ACL
541 * chmod modifies the ACL *mask* for the group owner, not the
542 * group owner bits directly. JRA.
547 int saved_errno
= errno
; /* We might get ENOSYS */
548 if ((result
= SMB_VFS_CHMOD_ACL(handle
->conn
, path
, mode
)) == 0) {
549 END_PROFILE(syscall_chmod
);
552 /* Error - return the old errno. */
556 result
= chmod(path
, mode
);
557 END_PROFILE(syscall_chmod
);
561 static int vfswrap_fchmod(vfs_handle_struct
*handle
, files_struct
*fsp
, mode_t mode
)
565 START_PROFILE(syscall_fchmod
);
568 * We need to do this due to the fact that the default POSIX ACL
569 * chmod modifies the ACL *mask* for the group owner, not the
570 * group owner bits directly. JRA.
574 int saved_errno
= errno
; /* We might get ENOSYS */
575 if ((result
= SMB_VFS_FCHMOD_ACL(fsp
, mode
)) == 0) {
576 END_PROFILE(syscall_fchmod
);
579 /* Error - return the old errno. */
583 #if defined(HAVE_FCHMOD)
584 result
= fchmod(fsp
->fh
->fd
, mode
);
590 END_PROFILE(syscall_fchmod
);
594 static int vfswrap_chown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
598 START_PROFILE(syscall_chown
);
599 result
= sys_chown(path
, uid
, gid
);
600 END_PROFILE(syscall_chown
);
604 static int vfswrap_fchown(vfs_handle_struct
*handle
, files_struct
*fsp
, uid_t uid
, gid_t gid
)
609 START_PROFILE(syscall_fchown
);
610 result
= fchown(fsp
->fh
->fd
, uid
, gid
);
611 END_PROFILE(syscall_fchown
);
619 static int vfswrap_lchown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
623 START_PROFILE(syscall_lchown
);
624 result
= sys_lchown(path
, uid
, gid
);
625 END_PROFILE(syscall_lchown
);
629 static int vfswrap_chdir(vfs_handle_struct
*handle
, const char *path
)
633 START_PROFILE(syscall_chdir
);
634 result
= chdir(path
);
635 END_PROFILE(syscall_chdir
);
639 static char *vfswrap_getwd(vfs_handle_struct
*handle
, char *path
)
643 START_PROFILE(syscall_getwd
);
644 result
= sys_getwd(path
);
645 END_PROFILE(syscall_getwd
);
649 /*********************************************************************
650 nsec timestamp resolution call. Convert down to whatever the underlying
652 **********************************************************************/
654 static int vfswrap_ntimes(vfs_handle_struct
*handle
, const char *path
, const struct timespec ts
[2])
658 START_PROFILE(syscall_ntimes
);
659 #if defined(HAVE_UTIMES)
661 struct timeval tv
[2];
662 tv
[0] = convert_timespec_to_timeval(ts
[0]);
663 tv
[1] = convert_timespec_to_timeval(ts
[1]);
664 result
= utimes(path
, tv
);
666 result
= utimes(path
, NULL
);
668 #elif defined(HAVE_UTIME)
670 struct utimbuf times
;
671 times
.actime
= convert_timespec_to_time_t(ts
[0]);
672 times
.modtime
= convert_timespec_to_time_t(ts
[1]);
673 result
= utime(path
, times
);
675 result
= utime(path
, NULL
);
681 END_PROFILE(syscall_ntimes
);
685 /*********************************************************************
686 A version of ftruncate that will write the space on disk if strict
688 **********************************************************************/
690 static int strict_allocate_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T len
)
693 SMB_OFF_T currpos
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
694 unsigned char zero_space
[4096];
695 SMB_OFF_T space_to_write
;
700 if (SMB_VFS_FSTAT(fsp
, &st
) == -1)
703 space_to_write
= len
- st
.st_size
;
706 if (S_ISFIFO(st
.st_mode
))
710 if (st
.st_size
== len
)
713 /* Shrink - just ftruncate. */
714 if (st
.st_size
> len
)
715 return sys_ftruncate(fsp
->fh
->fd
, len
);
717 /* Write out the real space on disk. */
718 if (SMB_VFS_LSEEK(fsp
, st
.st_size
, SEEK_SET
) != st
.st_size
)
721 space_to_write
= len
- st
.st_size
;
723 memset(zero_space
, '\0', sizeof(zero_space
));
724 while ( space_to_write
> 0) {
726 SMB_OFF_T current_len_to_write
= MIN(sizeof(zero_space
),space_to_write
);
728 retlen
= SMB_VFS_WRITE(fsp
,(char *)zero_space
,current_len_to_write
);
732 space_to_write
-= retlen
;
735 /* Seek to where we were */
736 if (SMB_VFS_LSEEK(fsp
, currpos
, SEEK_SET
) != currpos
)
742 static int vfswrap_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T len
)
749 START_PROFILE(syscall_ftruncate
);
751 if (lp_strict_allocate(SNUM(fsp
->conn
))) {
752 result
= strict_allocate_ftruncate(handle
, fsp
, len
);
753 END_PROFILE(syscall_ftruncate
);
757 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
758 sys_ftruncate if the system supports it. Then I discovered that
759 you can have some filesystems that support ftruncate
760 expansion and some that don't! On Linux fat can't do
761 ftruncate extend but ext2 can. */
763 result
= sys_ftruncate(fsp
->fh
->fd
, len
);
767 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
768 extend a file with ftruncate. Provide alternate implementation
770 currpos
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
775 /* Do an fstat to see if the file is longer than the requested
776 size in which case the ftruncate above should have
777 succeeded or shorter, in which case seek to len - 1 and
778 write 1 byte of zero */
779 if (SMB_VFS_FSTAT(fsp
, &st
) == -1) {
784 if (S_ISFIFO(st
.st_mode
)) {
790 if (st
.st_size
== len
) {
795 if (st
.st_size
> len
) {
796 /* the sys_ftruncate should have worked */
800 if (SMB_VFS_LSEEK(fsp
, len
-1, SEEK_SET
) != len
-1)
803 if (SMB_VFS_WRITE(fsp
, &c
, 1)!=1)
806 /* Seek to where we were */
807 if (SMB_VFS_LSEEK(fsp
, currpos
, SEEK_SET
) != currpos
)
813 END_PROFILE(syscall_ftruncate
);
817 static bool vfswrap_lock(vfs_handle_struct
*handle
, files_struct
*fsp
, int op
, SMB_OFF_T offset
, SMB_OFF_T count
, int type
)
821 START_PROFILE(syscall_fcntl_lock
);
822 result
= fcntl_lock(fsp
->fh
->fd
, op
, offset
, count
, type
);
823 END_PROFILE(syscall_fcntl_lock
);
827 static int vfswrap_kernel_flock(vfs_handle_struct
*handle
, files_struct
*fsp
,
830 START_PROFILE(syscall_kernel_flock
);
831 kernel_flock(fsp
->fh
->fd
, share_mode
);
832 END_PROFILE(syscall_kernel_flock
);
836 static bool vfswrap_getlock(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T
*poffset
, SMB_OFF_T
*pcount
, int *ptype
, pid_t
*ppid
)
840 START_PROFILE(syscall_fcntl_getlock
);
841 result
= fcntl_getlock(fsp
->fh
->fd
, poffset
, pcount
, ptype
, ppid
);
842 END_PROFILE(syscall_fcntl_getlock
);
846 static int vfswrap_linux_setlease(vfs_handle_struct
*handle
, files_struct
*fsp
,
851 START_PROFILE(syscall_linux_setlease
);
853 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
854 /* first set the signal handler */
855 if(linux_set_lease_sighandler(fsp
->fh
->fd
) == -1) {
859 result
= linux_setlease(fsp
->fh
->fd
, leasetype
);
863 END_PROFILE(syscall_linux_setlease
);
867 static int vfswrap_symlink(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
871 START_PROFILE(syscall_symlink
);
872 result
= sys_symlink(oldpath
, newpath
);
873 END_PROFILE(syscall_symlink
);
877 static int vfswrap_readlink(vfs_handle_struct
*handle
, const char *path
, char *buf
, size_t bufsiz
)
881 START_PROFILE(syscall_readlink
);
882 result
= sys_readlink(path
, buf
, bufsiz
);
883 END_PROFILE(syscall_readlink
);
887 static int vfswrap_link(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
891 START_PROFILE(syscall_link
);
892 result
= sys_link(oldpath
, newpath
);
893 END_PROFILE(syscall_link
);
897 static int vfswrap_mknod(vfs_handle_struct
*handle
, const char *pathname
, mode_t mode
, SMB_DEV_T dev
)
901 START_PROFILE(syscall_mknod
);
902 result
= sys_mknod(pathname
, mode
, dev
);
903 END_PROFILE(syscall_mknod
);
907 static char *vfswrap_realpath(vfs_handle_struct
*handle
, const char *path
, char *resolved_path
)
911 START_PROFILE(syscall_realpath
);
912 result
= sys_realpath(path
, resolved_path
);
913 END_PROFILE(syscall_realpath
);
917 static NTSTATUS
vfswrap_notify_watch(vfs_handle_struct
*vfs_handle
,
918 struct sys_notify_context
*ctx
,
919 struct notify_entry
*e
,
920 void (*callback
)(struct sys_notify_context
*ctx
,
922 struct notify_event
*ev
),
923 void *private_data
, void *handle
)
926 * So far inotify is the only supported default notify mechanism. If
927 * another platform like the the BSD's or a proprietary Unix comes
928 * along and wants another default, we can play the same trick we
929 * played with Posix ACLs.
931 * Until that is the case, hard-code inotify here.
934 if (lp_kernel_change_notify(ctx
->conn
->params
)) {
935 return inotify_watch(ctx
, e
, callback
, private_data
, handle
);
939 * Do nothing, leave everything to notify_internal.c
944 static int vfswrap_chflags(vfs_handle_struct
*handle
, const char *path
, int flags
)
947 return chflags(path
, flags
);
954 static struct file_id
vfswrap_file_id_create(struct vfs_handle_struct
*handle
, SMB_DEV_T dev
, SMB_INO_T inode
)
956 return file_id_create_dev(dev
, inode
);
959 static NTSTATUS
vfswrap_streaminfo(vfs_handle_struct
*handle
,
960 struct files_struct
*fsp
,
963 unsigned int *pnum_streams
,
964 struct stream_struct
**pstreams
)
966 SMB_STRUCT_STAT sbuf
;
967 unsigned int num_streams
= 0;
968 struct stream_struct
*streams
= NULL
;
971 if ((fsp
!= NULL
) && (fsp
->is_directory
)) {
973 * No default streams on directories
978 if ((fsp
!= NULL
) && (fsp
->fh
->fd
!= -1)) {
979 ret
= SMB_VFS_FSTAT(fsp
, &sbuf
);
982 ret
= SMB_VFS_STAT(handle
->conn
, fname
, &sbuf
);
986 return map_nt_error_from_unix(errno
);
989 if (S_ISDIR(sbuf
.st_mode
)) {
993 streams
= talloc(mem_ctx
, struct stream_struct
);
995 if (streams
== NULL
) {
996 return NT_STATUS_NO_MEMORY
;
999 streams
->size
= sbuf
.st_size
;
1000 streams
->alloc_size
= get_allocation_size(handle
->conn
, fsp
, &sbuf
);
1002 streams
->name
= talloc_strdup(streams
, "::$DATA");
1003 if (streams
->name
== NULL
) {
1004 TALLOC_FREE(streams
);
1005 return NT_STATUS_NO_MEMORY
;
1010 *pnum_streams
= num_streams
;
1011 *pstreams
= streams
;
1012 return NT_STATUS_OK
;
1015 static NTSTATUS
vfswrap_fget_nt_acl(vfs_handle_struct
*handle
,
1017 uint32 security_info
, SEC_DESC
**ppdesc
)
1021 START_PROFILE(fget_nt_acl
);
1022 result
= posix_fget_nt_acl(fsp
, security_info
, ppdesc
);
1023 END_PROFILE(fget_nt_acl
);
1027 static NTSTATUS
vfswrap_get_nt_acl(vfs_handle_struct
*handle
,
1029 uint32 security_info
, SEC_DESC
**ppdesc
)
1033 START_PROFILE(get_nt_acl
);
1034 result
= posix_get_nt_acl(handle
->conn
, name
, security_info
, ppdesc
);
1035 END_PROFILE(get_nt_acl
);
1039 static NTSTATUS
vfswrap_fset_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, uint32 security_info_sent
, SEC_DESC
*psd
)
1043 START_PROFILE(fset_nt_acl
);
1044 result
= set_nt_acl(fsp
, security_info_sent
, psd
);
1045 END_PROFILE(fset_nt_acl
);
1049 static int vfswrap_chmod_acl(vfs_handle_struct
*handle
, const char *name
, mode_t mode
)
1057 START_PROFILE(chmod_acl
);
1058 result
= chmod_acl(handle
->conn
, name
, mode
);
1059 END_PROFILE(chmod_acl
);
1064 static int vfswrap_fchmod_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, mode_t mode
)
1072 START_PROFILE(fchmod_acl
);
1073 result
= fchmod_acl(fsp
, mode
);
1074 END_PROFILE(fchmod_acl
);
1079 static int vfswrap_sys_acl_get_entry(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, int entry_id
, SMB_ACL_ENTRY_T
*entry_p
)
1081 return sys_acl_get_entry(theacl
, entry_id
, entry_p
);
1084 static int vfswrap_sys_acl_get_tag_type(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
, SMB_ACL_TAG_T
*tag_type_p
)
1086 return sys_acl_get_tag_type(entry_d
, tag_type_p
);
1089 static int vfswrap_sys_acl_get_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
, SMB_ACL_PERMSET_T
*permset_p
)
1091 return sys_acl_get_permset(entry_d
, permset_p
);
1094 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
)
1096 return sys_acl_get_qualifier(entry_d
);
1099 static SMB_ACL_T
vfswrap_sys_acl_get_file(vfs_handle_struct
*handle
, const char *path_p
, SMB_ACL_TYPE_T type
)
1101 return sys_acl_get_file(handle
, path_p
, type
);
1104 static SMB_ACL_T
vfswrap_sys_acl_get_fd(vfs_handle_struct
*handle
, files_struct
*fsp
)
1106 return sys_acl_get_fd(handle
, fsp
);
1109 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
)
1111 return sys_acl_clear_perms(permset
);
1114 static int vfswrap_sys_acl_add_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1116 return sys_acl_add_perm(permset
, perm
);
1119 static char * vfswrap_sys_acl_to_text(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, ssize_t
*plen
)
1121 return sys_acl_to_text(theacl
, plen
);
1124 static SMB_ACL_T
vfswrap_sys_acl_init(vfs_handle_struct
*handle
, int count
)
1126 return sys_acl_init(count
);
1129 static int vfswrap_sys_acl_create_entry(vfs_handle_struct
*handle
, SMB_ACL_T
*pacl
, SMB_ACL_ENTRY_T
*pentry
)
1131 return sys_acl_create_entry(pacl
, pentry
);
1134 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_TAG_T tagtype
)
1136 return sys_acl_set_tag_type(entry
, tagtype
);
1139 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, void *qual
)
1141 return sys_acl_set_qualifier(entry
, qual
);
1144 static int vfswrap_sys_acl_set_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_PERMSET_T permset
)
1146 return sys_acl_set_permset(entry
, permset
);
1149 static int vfswrap_sys_acl_valid(vfs_handle_struct
*handle
, SMB_ACL_T theacl
)
1151 return sys_acl_valid(theacl
);
1154 static int vfswrap_sys_acl_set_file(vfs_handle_struct
*handle
, const char *name
, SMB_ACL_TYPE_T acltype
, SMB_ACL_T theacl
)
1156 return sys_acl_set_file(handle
, name
, acltype
, theacl
);
1159 static int vfswrap_sys_acl_set_fd(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_ACL_T theacl
)
1161 return sys_acl_set_fd(handle
, fsp
, theacl
);
1164 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct
*handle
, const char *path
)
1166 return sys_acl_delete_def_file(handle
, path
);
1169 static int vfswrap_sys_acl_get_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1171 return sys_acl_get_perm(permset
, perm
);
1174 static int vfswrap_sys_acl_free_text(vfs_handle_struct
*handle
, char *text
)
1176 return sys_acl_free_text(text
);
1179 static int vfswrap_sys_acl_free_acl(vfs_handle_struct
*handle
, SMB_ACL_T posix_acl
)
1181 return sys_acl_free_acl(posix_acl
);
1184 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct
*handle
, void *qualifier
, SMB_ACL_TAG_T tagtype
)
1186 return sys_acl_free_qualifier(qualifier
, tagtype
);
1189 /****************************************************************
1190 Extended attribute operations.
1191 *****************************************************************/
1193 static ssize_t
vfswrap_getxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1195 return sys_getxattr(path
, name
, value
, size
);
1198 static ssize_t
vfswrap_lgetxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1200 return sys_lgetxattr(path
, name
, value
, size
);
1203 static ssize_t
vfswrap_fgetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
, void *value
, size_t size
)
1205 return sys_fgetxattr(fsp
->fh
->fd
, name
, value
, size
);
1208 static ssize_t
vfswrap_listxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1210 return sys_listxattr(path
, list
, size
);
1213 ssize_t
vfswrap_llistxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1215 return sys_llistxattr(path
, list
, size
);
1218 ssize_t
vfswrap_flistxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, char *list
, size_t size
)
1220 return sys_flistxattr(fsp
->fh
->fd
, list
, size
);
1223 static int vfswrap_removexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1225 return sys_removexattr(path
, name
);
1228 static int vfswrap_lremovexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1230 return sys_lremovexattr(path
, name
);
1233 static int vfswrap_fremovexattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
)
1235 return sys_fremovexattr(fsp
->fh
->fd
, name
);
1238 static int vfswrap_setxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1240 return sys_setxattr(path
, name
, value
, size
, flags
);
1243 static int vfswrap_lsetxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1245 return sys_lsetxattr(path
, name
, value
, size
, flags
);
1248 static int vfswrap_fsetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
, const void *value
, size_t size
, int flags
)
1250 return sys_fsetxattr(fsp
->fh
->fd
, name
, value
, size
, flags
);
1253 static int vfswrap_aio_read(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1255 return sys_aio_read(aiocb
);
1258 static int vfswrap_aio_write(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1260 return sys_aio_write(aiocb
);
1263 static ssize_t
vfswrap_aio_return(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1265 return sys_aio_return(aiocb
);
1268 static int vfswrap_aio_cancel(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1270 return sys_aio_cancel(fsp
->fh
->fd
, aiocb
);
1273 static int vfswrap_aio_error(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1275 return sys_aio_error(aiocb
);
1278 static int vfswrap_aio_fsync(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, int op
, SMB_STRUCT_AIOCB
*aiocb
)
1280 return sys_aio_fsync(op
, aiocb
);
1283 static int vfswrap_aio_suspend(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const SMB_STRUCT_AIOCB
* const aiocb
[], int n
, const struct timespec
*timeout
)
1285 return sys_aio_suspend(aiocb
, n
, timeout
);
1288 static bool vfswrap_aio_force(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
)
1293 static bool vfswrap_is_offline(struct vfs_handle_struct
*handle
, const char *path
, SMB_STRUCT_STAT
*sbuf
)
1295 if (ISDOT(path
) || ISDOTDOT(path
)) {
1299 if (!lp_dmapi_support(SNUM(handle
->conn
)) || !dmapi_have_session()) {
1300 #if defined(ENOTSUP)
1306 return (dmapi_file_flags(path
) & FILE_ATTRIBUTE_OFFLINE
) != 0;
1309 static int vfswrap_set_offline(struct vfs_handle_struct
*handle
, const char *path
)
1311 /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1312 #if defined(ENOTSUP)
1318 static vfs_op_tuple vfs_default_ops
[] = {
1320 /* Disk operations */
1322 {SMB_VFS_OP(vfswrap_connect
), SMB_VFS_OP_CONNECT
,
1323 SMB_VFS_LAYER_OPAQUE
},
1324 {SMB_VFS_OP(vfswrap_disconnect
), SMB_VFS_OP_DISCONNECT
,
1325 SMB_VFS_LAYER_OPAQUE
},
1326 {SMB_VFS_OP(vfswrap_disk_free
), SMB_VFS_OP_DISK_FREE
,
1327 SMB_VFS_LAYER_OPAQUE
},
1328 {SMB_VFS_OP(vfswrap_get_quota
), SMB_VFS_OP_GET_QUOTA
,
1329 SMB_VFS_LAYER_OPAQUE
},
1330 {SMB_VFS_OP(vfswrap_set_quota
), SMB_VFS_OP_SET_QUOTA
,
1331 SMB_VFS_LAYER_OPAQUE
},
1332 {SMB_VFS_OP(vfswrap_get_shadow_copy_data
), SMB_VFS_OP_GET_SHADOW_COPY_DATA
,
1333 SMB_VFS_LAYER_OPAQUE
},
1334 {SMB_VFS_OP(vfswrap_statvfs
), SMB_VFS_OP_STATVFS
,
1335 SMB_VFS_LAYER_OPAQUE
},
1336 {SMB_VFS_OP(vfswrap_fs_capabilities
), SMB_VFS_OP_FS_CAPABILITIES
,
1337 SMB_VFS_LAYER_OPAQUE
},
1339 /* Directory operations */
1341 {SMB_VFS_OP(vfswrap_opendir
), SMB_VFS_OP_OPENDIR
,
1342 SMB_VFS_LAYER_OPAQUE
},
1343 {SMB_VFS_OP(vfswrap_readdir
), SMB_VFS_OP_READDIR
,
1344 SMB_VFS_LAYER_OPAQUE
},
1345 {SMB_VFS_OP(vfswrap_seekdir
), SMB_VFS_OP_SEEKDIR
,
1346 SMB_VFS_LAYER_OPAQUE
},
1347 {SMB_VFS_OP(vfswrap_telldir
), SMB_VFS_OP_TELLDIR
,
1348 SMB_VFS_LAYER_OPAQUE
},
1349 {SMB_VFS_OP(vfswrap_rewinddir
), SMB_VFS_OP_REWINDDIR
,
1350 SMB_VFS_LAYER_OPAQUE
},
1351 {SMB_VFS_OP(vfswrap_mkdir
), SMB_VFS_OP_MKDIR
,
1352 SMB_VFS_LAYER_OPAQUE
},
1353 {SMB_VFS_OP(vfswrap_rmdir
), SMB_VFS_OP_RMDIR
,
1354 SMB_VFS_LAYER_OPAQUE
},
1355 {SMB_VFS_OP(vfswrap_closedir
), SMB_VFS_OP_CLOSEDIR
,
1356 SMB_VFS_LAYER_OPAQUE
},
1358 /* File operations */
1360 {SMB_VFS_OP(vfswrap_open
), SMB_VFS_OP_OPEN
,
1361 SMB_VFS_LAYER_OPAQUE
},
1362 {SMB_VFS_OP(vfswrap_close
), SMB_VFS_OP_CLOSE
,
1363 SMB_VFS_LAYER_OPAQUE
},
1364 {SMB_VFS_OP(vfswrap_read
), SMB_VFS_OP_READ
,
1365 SMB_VFS_LAYER_OPAQUE
},
1366 {SMB_VFS_OP(vfswrap_pread
), SMB_VFS_OP_PREAD
,
1367 SMB_VFS_LAYER_OPAQUE
},
1368 {SMB_VFS_OP(vfswrap_write
), SMB_VFS_OP_WRITE
,
1369 SMB_VFS_LAYER_OPAQUE
},
1370 {SMB_VFS_OP(vfswrap_pwrite
), SMB_VFS_OP_PWRITE
,
1371 SMB_VFS_LAYER_OPAQUE
},
1372 {SMB_VFS_OP(vfswrap_lseek
), SMB_VFS_OP_LSEEK
,
1373 SMB_VFS_LAYER_OPAQUE
},
1374 {SMB_VFS_OP(vfswrap_sendfile
), SMB_VFS_OP_SENDFILE
,
1375 SMB_VFS_LAYER_OPAQUE
},
1376 {SMB_VFS_OP(vfswrap_recvfile
), SMB_VFS_OP_RECVFILE
,
1377 SMB_VFS_LAYER_OPAQUE
},
1378 {SMB_VFS_OP(vfswrap_rename
), SMB_VFS_OP_RENAME
,
1379 SMB_VFS_LAYER_OPAQUE
},
1380 {SMB_VFS_OP(vfswrap_fsync
), SMB_VFS_OP_FSYNC
,
1381 SMB_VFS_LAYER_OPAQUE
},
1382 {SMB_VFS_OP(vfswrap_stat
), SMB_VFS_OP_STAT
,
1383 SMB_VFS_LAYER_OPAQUE
},
1384 {SMB_VFS_OP(vfswrap_fstat
), SMB_VFS_OP_FSTAT
,
1385 SMB_VFS_LAYER_OPAQUE
},
1386 {SMB_VFS_OP(vfswrap_lstat
), SMB_VFS_OP_LSTAT
,
1387 SMB_VFS_LAYER_OPAQUE
},
1388 {SMB_VFS_OP(vfswrap_unlink
), SMB_VFS_OP_UNLINK
,
1389 SMB_VFS_LAYER_OPAQUE
},
1390 {SMB_VFS_OP(vfswrap_chmod
), SMB_VFS_OP_CHMOD
,
1391 SMB_VFS_LAYER_OPAQUE
},
1392 {SMB_VFS_OP(vfswrap_fchmod
), SMB_VFS_OP_FCHMOD
,
1393 SMB_VFS_LAYER_OPAQUE
},
1394 {SMB_VFS_OP(vfswrap_chown
), SMB_VFS_OP_CHOWN
,
1395 SMB_VFS_LAYER_OPAQUE
},
1396 {SMB_VFS_OP(vfswrap_fchown
), SMB_VFS_OP_FCHOWN
,
1397 SMB_VFS_LAYER_OPAQUE
},
1398 {SMB_VFS_OP(vfswrap_lchown
), SMB_VFS_OP_LCHOWN
,
1399 SMB_VFS_LAYER_OPAQUE
},
1400 {SMB_VFS_OP(vfswrap_chdir
), SMB_VFS_OP_CHDIR
,
1401 SMB_VFS_LAYER_OPAQUE
},
1402 {SMB_VFS_OP(vfswrap_getwd
), SMB_VFS_OP_GETWD
,
1403 SMB_VFS_LAYER_OPAQUE
},
1404 {SMB_VFS_OP(vfswrap_ntimes
), SMB_VFS_OP_NTIMES
,
1405 SMB_VFS_LAYER_OPAQUE
},
1406 {SMB_VFS_OP(vfswrap_ftruncate
), SMB_VFS_OP_FTRUNCATE
,
1407 SMB_VFS_LAYER_OPAQUE
},
1408 {SMB_VFS_OP(vfswrap_lock
), SMB_VFS_OP_LOCK
,
1409 SMB_VFS_LAYER_OPAQUE
},
1410 {SMB_VFS_OP(vfswrap_kernel_flock
), SMB_VFS_OP_KERNEL_FLOCK
,
1411 SMB_VFS_LAYER_OPAQUE
},
1412 {SMB_VFS_OP(vfswrap_linux_setlease
), SMB_VFS_OP_LINUX_SETLEASE
,
1413 SMB_VFS_LAYER_OPAQUE
},
1414 {SMB_VFS_OP(vfswrap_getlock
), SMB_VFS_OP_GETLOCK
,
1415 SMB_VFS_LAYER_OPAQUE
},
1416 {SMB_VFS_OP(vfswrap_symlink
), SMB_VFS_OP_SYMLINK
,
1417 SMB_VFS_LAYER_OPAQUE
},
1418 {SMB_VFS_OP(vfswrap_readlink
), SMB_VFS_OP_READLINK
,
1419 SMB_VFS_LAYER_OPAQUE
},
1420 {SMB_VFS_OP(vfswrap_link
), SMB_VFS_OP_LINK
,
1421 SMB_VFS_LAYER_OPAQUE
},
1422 {SMB_VFS_OP(vfswrap_mknod
), SMB_VFS_OP_MKNOD
,
1423 SMB_VFS_LAYER_OPAQUE
},
1424 {SMB_VFS_OP(vfswrap_realpath
), SMB_VFS_OP_REALPATH
,
1425 SMB_VFS_LAYER_OPAQUE
},
1426 {SMB_VFS_OP(vfswrap_notify_watch
), SMB_VFS_OP_NOTIFY_WATCH
,
1427 SMB_VFS_LAYER_OPAQUE
},
1428 {SMB_VFS_OP(vfswrap_chflags
), SMB_VFS_OP_CHFLAGS
,
1429 SMB_VFS_LAYER_OPAQUE
},
1430 {SMB_VFS_OP(vfswrap_file_id_create
), SMB_VFS_OP_FILE_ID_CREATE
,
1431 SMB_VFS_LAYER_OPAQUE
},
1432 {SMB_VFS_OP(vfswrap_streaminfo
), SMB_VFS_OP_STREAMINFO
,
1433 SMB_VFS_LAYER_OPAQUE
},
1435 /* NT ACL operations. */
1437 {SMB_VFS_OP(vfswrap_fget_nt_acl
), SMB_VFS_OP_FGET_NT_ACL
,
1438 SMB_VFS_LAYER_OPAQUE
},
1439 {SMB_VFS_OP(vfswrap_get_nt_acl
), SMB_VFS_OP_GET_NT_ACL
,
1440 SMB_VFS_LAYER_OPAQUE
},
1441 {SMB_VFS_OP(vfswrap_fset_nt_acl
), SMB_VFS_OP_FSET_NT_ACL
,
1442 SMB_VFS_LAYER_OPAQUE
},
1444 /* POSIX ACL operations. */
1446 {SMB_VFS_OP(vfswrap_chmod_acl
), SMB_VFS_OP_CHMOD_ACL
,
1447 SMB_VFS_LAYER_OPAQUE
},
1448 {SMB_VFS_OP(vfswrap_fchmod_acl
), SMB_VFS_OP_FCHMOD_ACL
,
1449 SMB_VFS_LAYER_OPAQUE
},
1450 {SMB_VFS_OP(vfswrap_sys_acl_get_entry
), SMB_VFS_OP_SYS_ACL_GET_ENTRY
,
1451 SMB_VFS_LAYER_OPAQUE
},
1452 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type
), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE
,
1453 SMB_VFS_LAYER_OPAQUE
},
1454 {SMB_VFS_OP(vfswrap_sys_acl_get_permset
), SMB_VFS_OP_SYS_ACL_GET_PERMSET
,
1455 SMB_VFS_LAYER_OPAQUE
},
1456 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier
), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER
,
1457 SMB_VFS_LAYER_OPAQUE
},
1458 {SMB_VFS_OP(vfswrap_sys_acl_get_file
), SMB_VFS_OP_SYS_ACL_GET_FILE
,
1459 SMB_VFS_LAYER_OPAQUE
},
1460 {SMB_VFS_OP(vfswrap_sys_acl_get_fd
), SMB_VFS_OP_SYS_ACL_GET_FD
,
1461 SMB_VFS_LAYER_OPAQUE
},
1462 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms
), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS
,
1463 SMB_VFS_LAYER_OPAQUE
},
1464 {SMB_VFS_OP(vfswrap_sys_acl_add_perm
), SMB_VFS_OP_SYS_ACL_ADD_PERM
,
1465 SMB_VFS_LAYER_OPAQUE
},
1466 {SMB_VFS_OP(vfswrap_sys_acl_to_text
), SMB_VFS_OP_SYS_ACL_TO_TEXT
,
1467 SMB_VFS_LAYER_OPAQUE
},
1468 {SMB_VFS_OP(vfswrap_sys_acl_init
), SMB_VFS_OP_SYS_ACL_INIT
,
1469 SMB_VFS_LAYER_OPAQUE
},
1470 {SMB_VFS_OP(vfswrap_sys_acl_create_entry
), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY
,
1471 SMB_VFS_LAYER_OPAQUE
},
1472 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type
), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE
,
1473 SMB_VFS_LAYER_OPAQUE
},
1474 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier
), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER
,
1475 SMB_VFS_LAYER_OPAQUE
},
1476 {SMB_VFS_OP(vfswrap_sys_acl_set_permset
), SMB_VFS_OP_SYS_ACL_SET_PERMSET
,
1477 SMB_VFS_LAYER_OPAQUE
},
1478 {SMB_VFS_OP(vfswrap_sys_acl_valid
), SMB_VFS_OP_SYS_ACL_VALID
,
1479 SMB_VFS_LAYER_OPAQUE
},
1480 {SMB_VFS_OP(vfswrap_sys_acl_set_file
), SMB_VFS_OP_SYS_ACL_SET_FILE
,
1481 SMB_VFS_LAYER_OPAQUE
},
1482 {SMB_VFS_OP(vfswrap_sys_acl_set_fd
), SMB_VFS_OP_SYS_ACL_SET_FD
,
1483 SMB_VFS_LAYER_OPAQUE
},
1484 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file
), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE
,
1485 SMB_VFS_LAYER_OPAQUE
},
1486 {SMB_VFS_OP(vfswrap_sys_acl_get_perm
), SMB_VFS_OP_SYS_ACL_GET_PERM
,
1487 SMB_VFS_LAYER_OPAQUE
},
1488 {SMB_VFS_OP(vfswrap_sys_acl_free_text
), SMB_VFS_OP_SYS_ACL_FREE_TEXT
,
1489 SMB_VFS_LAYER_OPAQUE
},
1490 {SMB_VFS_OP(vfswrap_sys_acl_free_acl
), SMB_VFS_OP_SYS_ACL_FREE_ACL
,
1491 SMB_VFS_LAYER_OPAQUE
},
1492 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier
), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER
,
1493 SMB_VFS_LAYER_OPAQUE
},
1495 /* EA operations. */
1497 {SMB_VFS_OP(vfswrap_getxattr
), SMB_VFS_OP_GETXATTR
,
1498 SMB_VFS_LAYER_OPAQUE
},
1499 {SMB_VFS_OP(vfswrap_lgetxattr
), SMB_VFS_OP_LGETXATTR
,
1500 SMB_VFS_LAYER_OPAQUE
},
1501 {SMB_VFS_OP(vfswrap_fgetxattr
), SMB_VFS_OP_FGETXATTR
,
1502 SMB_VFS_LAYER_OPAQUE
},
1503 {SMB_VFS_OP(vfswrap_listxattr
), SMB_VFS_OP_LISTXATTR
,
1504 SMB_VFS_LAYER_OPAQUE
},
1505 {SMB_VFS_OP(vfswrap_llistxattr
), SMB_VFS_OP_LLISTXATTR
,
1506 SMB_VFS_LAYER_OPAQUE
},
1507 {SMB_VFS_OP(vfswrap_flistxattr
), SMB_VFS_OP_FLISTXATTR
,
1508 SMB_VFS_LAYER_OPAQUE
},
1509 {SMB_VFS_OP(vfswrap_removexattr
), SMB_VFS_OP_REMOVEXATTR
,
1510 SMB_VFS_LAYER_OPAQUE
},
1511 {SMB_VFS_OP(vfswrap_lremovexattr
), SMB_VFS_OP_LREMOVEXATTR
,
1512 SMB_VFS_LAYER_OPAQUE
},
1513 {SMB_VFS_OP(vfswrap_fremovexattr
), SMB_VFS_OP_FREMOVEXATTR
,
1514 SMB_VFS_LAYER_OPAQUE
},
1515 {SMB_VFS_OP(vfswrap_setxattr
), SMB_VFS_OP_SETXATTR
,
1516 SMB_VFS_LAYER_OPAQUE
},
1517 {SMB_VFS_OP(vfswrap_lsetxattr
), SMB_VFS_OP_LSETXATTR
,
1518 SMB_VFS_LAYER_OPAQUE
},
1519 {SMB_VFS_OP(vfswrap_fsetxattr
), SMB_VFS_OP_FSETXATTR
,
1520 SMB_VFS_LAYER_OPAQUE
},
1522 {SMB_VFS_OP(vfswrap_aio_read
), SMB_VFS_OP_AIO_READ
,
1523 SMB_VFS_LAYER_OPAQUE
},
1524 {SMB_VFS_OP(vfswrap_aio_write
), SMB_VFS_OP_AIO_WRITE
,
1525 SMB_VFS_LAYER_OPAQUE
},
1526 {SMB_VFS_OP(vfswrap_aio_return
), SMB_VFS_OP_AIO_RETURN
,
1527 SMB_VFS_LAYER_OPAQUE
},
1528 {SMB_VFS_OP(vfswrap_aio_cancel
), SMB_VFS_OP_AIO_CANCEL
,
1529 SMB_VFS_LAYER_OPAQUE
},
1530 {SMB_VFS_OP(vfswrap_aio_error
), SMB_VFS_OP_AIO_ERROR
,
1531 SMB_VFS_LAYER_OPAQUE
},
1532 {SMB_VFS_OP(vfswrap_aio_fsync
), SMB_VFS_OP_AIO_FSYNC
,
1533 SMB_VFS_LAYER_OPAQUE
},
1534 {SMB_VFS_OP(vfswrap_aio_suspend
),SMB_VFS_OP_AIO_SUSPEND
,
1535 SMB_VFS_LAYER_OPAQUE
},
1537 {SMB_VFS_OP(vfswrap_aio_force
), SMB_VFS_OP_AIO_FORCE
,
1538 SMB_VFS_LAYER_OPAQUE
},
1540 {SMB_VFS_OP(vfswrap_is_offline
),SMB_VFS_OP_IS_OFFLINE
,
1541 SMB_VFS_LAYER_OPAQUE
},
1542 {SMB_VFS_OP(vfswrap_set_offline
),SMB_VFS_OP_SET_OFFLINE
,
1543 SMB_VFS_LAYER_OPAQUE
},
1545 /* Finish VFS operations definition */
1547 {SMB_VFS_OP(NULL
), SMB_VFS_OP_NOOP
,
1551 NTSTATUS
vfs_default_init(void);
1552 NTSTATUS
vfs_default_init(void)
1554 unsigned int needed
= SMB_VFS_OP_LAST
+ 1; /* convert from index to count */
1556 if (ARRAY_SIZE(vfs_default_ops
) != needed
) {
1557 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1558 DEFAULT_VFS_MODULE_NAME
, (unsigned int)ARRAY_SIZE(vfs_default_ops
), needed
));
1559 smb_panic("operation(s) missing from default VFS module");
1562 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION
,
1563 DEFAULT_VFS_MODULE_NAME
, vfs_default_ops
);