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 2 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, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #define DBGC_CLASS DBGC_VFS
27 /* Check for NULL pointer parameters in vfswrap_* functions */
29 /* We don't want to have NULL function pointers lying around. Someone
30 is sure to try and execute them. These stubs are used to prevent
33 static int vfswrap_connect(vfs_handle_struct
*handle
, const char *service
, const char *user
)
35 return 0; /* Return >= 0 for success */
38 static void vfswrap_disconnect(vfs_handle_struct
*handle
)
44 static SMB_BIG_UINT
vfswrap_disk_free(vfs_handle_struct
*handle
, const char *path
, BOOL small_query
, SMB_BIG_UINT
*bsize
,
45 SMB_BIG_UINT
*dfree
, SMB_BIG_UINT
*dsize
)
49 result
= sys_disk_free(handle
->conn
, path
, small_query
, bsize
, dfree
, dsize
);
53 static int vfswrap_get_quota(struct vfs_handle_struct
*handle
, enum SMB_QUOTA_TYPE qtype
, unid_t id
, SMB_DISK_QUOTA
*qt
)
55 #ifdef HAVE_SYS_QUOTAS
58 START_PROFILE(syscall_get_quota
);
59 result
= sys_get_quota(handle
->conn
->connectpath
, qtype
, id
, qt
);
60 END_PROFILE(syscall_get_quota
);
68 static int vfswrap_set_quota(struct vfs_handle_struct
*handle
, enum SMB_QUOTA_TYPE qtype
, unid_t id
, SMB_DISK_QUOTA
*qt
)
70 #ifdef HAVE_SYS_QUOTAS
73 START_PROFILE(syscall_set_quota
);
74 result
= sys_set_quota(handle
->conn
->connectpath
, qtype
, id
, qt
);
75 END_PROFILE(syscall_set_quota
);
83 static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SHADOW_COPY_DATA
*shadow_copy_data
, BOOL labels
)
86 return -1; /* Not implemented. */
89 static int vfswrap_statvfs(struct vfs_handle_struct
*handle
, const char *path
, vfs_statvfs_struct
*statbuf
)
91 return sys_statvfs(path
, statbuf
);
94 /* Directory operations */
96 static SMB_STRUCT_DIR
*vfswrap_opendir(vfs_handle_struct
*handle
, const char *fname
, const char *mask
, uint32 attr
)
98 SMB_STRUCT_DIR
*result
;
100 START_PROFILE(syscall_opendir
);
101 result
= sys_opendir(fname
);
102 END_PROFILE(syscall_opendir
);
106 static SMB_STRUCT_DIRENT
*vfswrap_readdir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
108 SMB_STRUCT_DIRENT
*result
;
110 START_PROFILE(syscall_readdir
);
111 result
= sys_readdir(dirp
);
112 END_PROFILE(syscall_readdir
);
116 static void vfswrap_seekdir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
, long offset
)
118 START_PROFILE(syscall_seekdir
);
119 sys_seekdir(dirp
, offset
);
120 END_PROFILE(syscall_seekdir
);
123 static long vfswrap_telldir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
126 START_PROFILE(syscall_telldir
);
127 result
= sys_telldir(dirp
);
128 END_PROFILE(syscall_telldir
);
132 static void vfswrap_rewinddir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
134 START_PROFILE(syscall_rewinddir
);
136 END_PROFILE(syscall_rewinddir
);
139 static int vfswrap_mkdir(vfs_handle_struct
*handle
, const char *path
, mode_t mode
)
142 BOOL has_dacl
= False
;
144 START_PROFILE(syscall_mkdir
);
146 if (lp_inherit_acls(SNUM(handle
->conn
)) && (has_dacl
= directory_has_default_acl(handle
->conn
, parent_dirname(path
))))
149 result
= mkdir(path
, mode
);
151 if (result
== 0 && !has_dacl
) {
153 * We need to do this as the default behavior of POSIX ACLs
154 * is to set the mask to be the requested group permission
155 * bits, not the group permission bits to be the requested
156 * group permission bits. This is not what we want, as it will
157 * mess up any inherited ACL bits that were set. JRA.
159 int saved_errno
= errno
; /* We may get ENOSYS */
160 if ((SMB_VFS_CHMOD_ACL(handle
->conn
, path
, mode
) == -1) && (errno
== ENOSYS
))
164 END_PROFILE(syscall_mkdir
);
168 static int vfswrap_rmdir(vfs_handle_struct
*handle
, const char *path
)
172 START_PROFILE(syscall_rmdir
);
173 result
= rmdir(path
);
174 END_PROFILE(syscall_rmdir
);
178 static int vfswrap_closedir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
182 START_PROFILE(syscall_closedir
);
183 result
= sys_closedir(dirp
);
184 END_PROFILE(syscall_closedir
);
188 /* File operations */
190 static int vfswrap_open(vfs_handle_struct
*handle
, const char *fname
,
191 files_struct
*fsp
, int flags
, mode_t mode
)
195 START_PROFILE(syscall_open
);
196 result
= sys_open(fname
, flags
, mode
);
197 END_PROFILE(syscall_open
);
201 static int vfswrap_close(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
)
205 START_PROFILE(syscall_close
);
208 END_PROFILE(syscall_close
);
212 static ssize_t
vfswrap_read(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, void *data
, size_t n
)
216 START_PROFILE_BYTES(syscall_read
, n
);
217 result
= sys_read(fd
, data
, n
);
218 END_PROFILE(syscall_read
);
222 static ssize_t
vfswrap_pread(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, void *data
,
223 size_t n
, SMB_OFF_T offset
)
227 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
228 START_PROFILE_BYTES(syscall_pread
, n
);
229 result
= sys_pread(fd
, data
, n
, offset
);
230 END_PROFILE(syscall_pread
);
232 if (result
== -1 && errno
== ESPIPE
) {
233 /* Maintain the fiction that pipes can be seeked (sought?) on. */
234 result
= SMB_VFS_READ(fsp
, fd
, data
, n
);
238 #else /* HAVE_PREAD */
242 curr
= SMB_VFS_LSEEK(fsp
, fd
, 0, SEEK_CUR
);
243 if (curr
== -1 && errno
== ESPIPE
) {
244 /* Maintain the fiction that pipes can be seeked (sought?) on. */
245 result
= SMB_VFS_READ(fsp
, fd
, data
, n
);
250 if (SMB_VFS_LSEEK(fsp
, fd
, offset
, SEEK_SET
) == -1) {
255 result
= SMB_VFS_READ(fsp
, fd
, data
, n
);
258 SMB_VFS_LSEEK(fsp
, fd
, curr
, SEEK_SET
);
261 #endif /* HAVE_PREAD */
266 static ssize_t
vfswrap_write(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, const void *data
, size_t n
)
270 START_PROFILE_BYTES(syscall_write
, n
);
271 result
= sys_write(fd
, data
, n
);
272 END_PROFILE(syscall_write
);
276 static ssize_t
vfswrap_pwrite(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, const void *data
,
277 size_t n
, SMB_OFF_T offset
)
281 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
282 START_PROFILE_BYTES(syscall_pwrite
, n
);
283 result
= sys_pwrite(fd
, data
, n
, offset
);
284 END_PROFILE(syscall_pwrite
);
286 if (result
== -1 && errno
== ESPIPE
) {
287 /* Maintain the fiction that pipes can be sought on. */
288 result
= SMB_VFS_WRITE(fsp
, fd
, data
, n
);
291 #else /* HAVE_PWRITE */
295 curr
= SMB_VFS_LSEEK(fsp
, fd
, 0, SEEK_CUR
);
300 if (SMB_VFS_LSEEK(fsp
, fd
, offset
, SEEK_SET
) == -1) {
304 result
= SMB_VFS_WRITE(fsp
, fd
, data
, n
);
307 SMB_VFS_LSEEK(fsp
, fd
, curr
, SEEK_SET
);
310 #endif /* HAVE_PWRITE */
315 static SMB_OFF_T
vfswrap_lseek(vfs_handle_struct
*handle
, files_struct
*fsp
, int filedes
, SMB_OFF_T offset
, int whence
)
317 SMB_OFF_T result
= 0;
319 START_PROFILE(syscall_lseek
);
321 /* Cope with 'stat' file opens. */
323 result
= sys_lseek(filedes
, offset
, whence
);
326 * We want to maintain the fiction that we can seek
327 * on a fifo for file system purposes. This allows
328 * people to set up UNIX fifo's that feed data to Windows
332 if((result
== -1) && (errno
== ESPIPE
)) {
337 END_PROFILE(syscall_lseek
);
341 static ssize_t
vfswrap_sendfile(vfs_handle_struct
*handle
, int tofd
, files_struct
*fsp
, int fromfd
, const DATA_BLOB
*hdr
,
342 SMB_OFF_T offset
, size_t n
)
346 START_PROFILE_BYTES(syscall_sendfile
, n
);
347 result
= sys_sendfile(tofd
, fromfd
, hdr
, offset
, n
);
348 END_PROFILE(syscall_sendfile
);
352 /*********************************************************
353 For rename across filesystems Patch from Warren Birnbaum
354 <warrenb@hpcvscdp.cv.hp.com>
355 **********************************************************/
357 static int copy_reg(const char *source
, const char *dest
)
359 SMB_STRUCT_STAT source_stats
;
364 if (sys_lstat (source
, &source_stats
) == -1)
367 if (!S_ISREG (source_stats
.st_mode
))
370 if((ifd
= sys_open (source
, O_RDONLY
, 0)) < 0)
373 if (unlink (dest
) && errno
!= ENOENT
)
377 if((ofd
= sys_open (dest
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_NOFOLLOW
, 0600)) < 0 )
379 if((ofd
= sys_open (dest
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0600)) < 0 )
383 if (transfer_file(ifd
, ofd
, (size_t)-1) == -1)
387 * Try to preserve ownership. For non-root it might fail, but that's ok.
388 * But root probably wants to know, e.g. if NFS disallows it.
392 if ((fchown(ofd
, source_stats
.st_uid
, source_stats
.st_gid
) == -1) && (errno
!= EPERM
))
394 if ((chown(dest
, source_stats
.st_uid
, source_stats
.st_gid
) == -1) && (errno
!= EPERM
))
399 * fchown turns off set[ug]id bits for non-root,
400 * so do the chmod last.
403 #if defined(HAVE_FCHMOD)
404 if (fchmod (ofd
, source_stats
.st_mode
& 07777))
406 if (chmod (dest
, source_stats
.st_mode
& 07777))
410 if (close (ifd
) == -1)
413 if (close (ofd
) == -1)
416 /* Try to copy the old file's modtime and access time. */
420 tv
.actime
= source_stats
.st_atime
;
421 tv
.modtime
= source_stats
.st_mtime
;
425 if (unlink (source
) == -1)
441 static int vfswrap_rename(vfs_handle_struct
*handle
, const char *oldname
, const char *newname
)
445 START_PROFILE(syscall_rename
);
446 result
= rename(oldname
, newname
);
447 if (errno
== EXDEV
) {
448 /* Rename across filesystems needed. */
449 result
= copy_reg(oldname
, newname
);
452 END_PROFILE(syscall_rename
);
456 static int vfswrap_fsync(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
)
461 START_PROFILE(syscall_fsync
);
463 END_PROFILE(syscall_fsync
);
470 static int vfswrap_stat(vfs_handle_struct
*handle
, const char *fname
, SMB_STRUCT_STAT
*sbuf
)
474 START_PROFILE(syscall_stat
);
475 result
= sys_stat(fname
, sbuf
);
476 END_PROFILE(syscall_stat
);
480 static int vfswrap_fstat(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, SMB_STRUCT_STAT
*sbuf
)
484 START_PROFILE(syscall_fstat
);
485 result
= sys_fstat(fd
, sbuf
);
486 END_PROFILE(syscall_fstat
);
490 int vfswrap_lstat(vfs_handle_struct
*handle
, const char *path
, SMB_STRUCT_STAT
*sbuf
)
494 START_PROFILE(syscall_lstat
);
495 result
= sys_lstat(path
, sbuf
);
496 END_PROFILE(syscall_lstat
);
500 static int vfswrap_unlink(vfs_handle_struct
*handle
, const char *path
)
504 START_PROFILE(syscall_unlink
);
505 result
= unlink(path
);
506 END_PROFILE(syscall_unlink
);
510 static int vfswrap_chmod(vfs_handle_struct
*handle
, const char *path
, mode_t mode
)
514 START_PROFILE(syscall_chmod
);
517 * We need to do this due to the fact that the default POSIX ACL
518 * chmod modifies the ACL *mask* for the group owner, not the
519 * group owner bits directly. JRA.
524 int saved_errno
= errno
; /* We might get ENOSYS */
525 if ((result
= SMB_VFS_CHMOD_ACL(handle
->conn
, path
, mode
)) == 0) {
526 END_PROFILE(syscall_chmod
);
529 /* Error - return the old errno. */
533 result
= chmod(path
, mode
);
534 END_PROFILE(syscall_chmod
);
538 static int vfswrap_fchmod(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, mode_t mode
)
542 START_PROFILE(syscall_fchmod
);
545 * We need to do this due to the fact that the default POSIX ACL
546 * chmod modifies the ACL *mask* for the group owner, not the
547 * group owner bits directly. JRA.
551 int saved_errno
= errno
; /* We might get ENOSYS */
552 if ((result
= SMB_VFS_FCHMOD_ACL(fsp
, fd
, mode
)) == 0) {
553 END_PROFILE(syscall_fchmod
);
556 /* Error - return the old errno. */
560 #if defined(HAVE_FCHMOD)
561 result
= fchmod(fd
, mode
);
567 END_PROFILE(syscall_fchmod
);
571 static int vfswrap_chown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
575 START_PROFILE(syscall_chown
);
576 result
= sys_chown(path
, uid
, gid
);
577 END_PROFILE(syscall_chown
);
581 static int vfswrap_fchown(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, uid_t uid
, gid_t gid
)
586 START_PROFILE(syscall_fchown
);
587 result
= fchown(fd
, uid
, gid
);
588 END_PROFILE(syscall_fchown
);
596 static int vfswrap_lchown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
600 START_PROFILE(syscall_lchown
);
601 result
= sys_lchown(path
, uid
, gid
);
602 END_PROFILE(syscall_lchown
);
606 static int vfswrap_chdir(vfs_handle_struct
*handle
, const char *path
)
610 START_PROFILE(syscall_chdir
);
611 result
= chdir(path
);
612 END_PROFILE(syscall_chdir
);
616 static char *vfswrap_getwd(vfs_handle_struct
*handle
, char *path
)
620 START_PROFILE(syscall_getwd
);
621 result
= sys_getwd(path
);
622 END_PROFILE(syscall_getwd
);
626 /*********************************************************************
627 nsec timestamp resolution call. Convert down to whatever the underlying
629 **********************************************************************/
631 static int vfswrap_ntimes(vfs_handle_struct
*handle
, const char *path
, const struct timespec ts
[2])
635 START_PROFILE(syscall_ntimes
);
636 #if defined(HAVE_UTIMES)
638 struct timeval tv
[2];
639 tv
[0] = convert_timespec_to_timeval(ts
[0]);
640 tv
[1] = convert_timespec_to_timeval(ts
[1]);
641 result
= utimes(path
, tv
);
643 #elif defined(HAVE_UTIME)
645 struct utimbuf times
;
646 times
.actime
= convert_timespec_to_time_t(ts
[0]);
647 times
.modtime
= convert_timespec_to_time_t(ts
[1]);
648 result
= utime(path
, times
);
654 END_PROFILE(syscall_ntimes
);
658 /*********************************************************************
659 A version of ftruncate that will write the space on disk if strict
661 **********************************************************************/
663 static int strict_allocate_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, SMB_OFF_T len
)
666 SMB_OFF_T currpos
= SMB_VFS_LSEEK(fsp
, fd
, 0, SEEK_CUR
);
667 unsigned char zero_space
[4096];
668 SMB_OFF_T space_to_write
;
673 if (SMB_VFS_FSTAT(fsp
, fd
, &st
) == -1)
676 space_to_write
= len
- st
.st_size
;
679 if (S_ISFIFO(st
.st_mode
))
683 if (st
.st_size
== len
)
686 /* Shrink - just ftruncate. */
687 if (st
.st_size
> len
)
688 return sys_ftruncate(fd
, len
);
690 /* Write out the real space on disk. */
691 if (SMB_VFS_LSEEK(fsp
, fd
, st
.st_size
, SEEK_SET
) != st
.st_size
)
694 space_to_write
= len
- st
.st_size
;
696 memset(zero_space
, '\0', sizeof(zero_space
));
697 while ( space_to_write
> 0) {
699 SMB_OFF_T current_len_to_write
= MIN(sizeof(zero_space
),space_to_write
);
701 retlen
= SMB_VFS_WRITE(fsp
,fsp
->fh
->fd
,(char *)zero_space
,current_len_to_write
);
705 space_to_write
-= retlen
;
708 /* Seek to where we were */
709 if (SMB_VFS_LSEEK(fsp
, fd
, currpos
, SEEK_SET
) != currpos
)
715 static int vfswrap_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, SMB_OFF_T len
)
722 START_PROFILE(syscall_ftruncate
);
724 if (lp_strict_allocate(SNUM(fsp
->conn
))) {
725 result
= strict_allocate_ftruncate(handle
, fsp
, fd
, len
);
726 END_PROFILE(syscall_ftruncate
);
730 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
731 sys_ftruncate if the system supports it. Then I discovered that
732 you can have some filesystems that support ftruncate
733 expansion and some that don't! On Linux fat can't do
734 ftruncate extend but ext2 can. */
736 result
= sys_ftruncate(fd
, len
);
740 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
741 extend a file with ftruncate. Provide alternate implementation
743 currpos
= SMB_VFS_LSEEK(fsp
, fd
, 0, SEEK_CUR
);
748 /* Do an fstat to see if the file is longer than the requested
749 size in which case the ftruncate above should have
750 succeeded or shorter, in which case seek to len - 1 and
751 write 1 byte of zero */
752 if (SMB_VFS_FSTAT(fsp
, fd
, &st
) == -1) {
757 if (S_ISFIFO(st
.st_mode
)) {
763 if (st
.st_size
== len
) {
768 if (st
.st_size
> len
) {
769 /* the sys_ftruncate should have worked */
773 if (SMB_VFS_LSEEK(fsp
, fd
, len
-1, SEEK_SET
) != len
-1)
776 if (SMB_VFS_WRITE(fsp
, fd
, &c
, 1)!=1)
779 /* Seek to where we were */
780 if (SMB_VFS_LSEEK(fsp
, fd
, currpos
, SEEK_SET
) != currpos
)
786 END_PROFILE(syscall_ftruncate
);
790 static BOOL
vfswrap_lock(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, int op
, SMB_OFF_T offset
, SMB_OFF_T count
, int type
)
794 START_PROFILE(syscall_fcntl_lock
);
796 /* SMB_VFS_GETLOCK should be used to query lock status. */
797 SMB_ASSERT(op
!= SMB_F_GETLK
);
799 result
= fcntl_lock(fd
, op
, offset
, count
, type
);
800 END_PROFILE(syscall_fcntl_lock
);
804 static int vfswrap_kernel_flock(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
,
807 START_PROFILE(syscall_kernel_flock
);
808 kernel_flock(fd
, share_mode
);
809 END_PROFILE(syscall_kernel_flock
);
813 static BOOL
vfswrap_getlock(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, SMB_OFF_T
*poffset
, SMB_OFF_T
*pcount
, int *ptype
, pid_t
*ppid
)
817 START_PROFILE(syscall_fcntl_getlock
);
818 result
= fcntl_getlock(fd
, poffset
, pcount
, ptype
, ppid
);
819 END_PROFILE(syscall_fcntl_getlock
);
823 static int vfswrap_linux_setlease(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
,
828 START_PROFILE(syscall_linux_setlease
);
831 /* first set the signal handler */
832 if(linux_set_lease_sighandler(fd
) == -1)
835 result
= linux_setlease(fd
, leasetype
);
839 END_PROFILE(syscall_linux_setlease
);
843 static int vfswrap_symlink(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
847 START_PROFILE(syscall_symlink
);
848 result
= sys_symlink(oldpath
, newpath
);
849 END_PROFILE(syscall_symlink
);
853 static int vfswrap_readlink(vfs_handle_struct
*handle
, const char *path
, char *buf
, size_t bufsiz
)
857 START_PROFILE(syscall_readlink
);
858 result
= sys_readlink(path
, buf
, bufsiz
);
859 END_PROFILE(syscall_readlink
);
863 static int vfswrap_link(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
867 START_PROFILE(syscall_link
);
868 result
= sys_link(oldpath
, newpath
);
869 END_PROFILE(syscall_link
);
873 static int vfswrap_mknod(vfs_handle_struct
*handle
, const char *pathname
, mode_t mode
, SMB_DEV_T dev
)
877 START_PROFILE(syscall_mknod
);
878 result
= sys_mknod(pathname
, mode
, dev
);
879 END_PROFILE(syscall_mknod
);
883 static char *vfswrap_realpath(vfs_handle_struct
*handle
, const char *path
, char *resolved_path
)
887 START_PROFILE(syscall_realpath
);
888 result
= sys_realpath(path
, resolved_path
);
889 END_PROFILE(syscall_realpath
);
893 static NTSTATUS
vfswrap_notify_watch(vfs_handle_struct
*vfs_handle
,
894 struct sys_notify_context
*ctx
,
895 struct notify_entry
*e
,
896 void (*callback
)(struct sys_notify_context
*ctx
,
898 struct notify_event
*ev
),
899 void *private_data
, void *handle
)
902 * So far inotify is the only supported default notify mechanism. If
903 * another platform like the the BSD's or a proprietary Unix comes
904 * along and wants another default, we can play the same trick we
905 * played with Posix ACLs.
907 * Until that is the case, hard-code inotify here.
910 if (lp_kernel_change_notify(ctx
->conn
->params
)) {
911 return inotify_watch(ctx
, e
, callback
, private_data
, handle
);
915 * Do nothing, leave everything to notify_internal.c
920 static int vfswrap_chflags(vfs_handle_struct
*handle
, const char *path
, int flags
)
923 return chflags(path
, flags
);
930 static size_t vfswrap_fget_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, uint32 security_info
, SEC_DESC
**ppdesc
)
934 START_PROFILE(fget_nt_acl
);
935 result
= get_nt_acl(fsp
, security_info
, ppdesc
);
936 END_PROFILE(fget_nt_acl
);
940 static size_t vfswrap_get_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, const char *name
, uint32 security_info
, SEC_DESC
**ppdesc
)
944 START_PROFILE(get_nt_acl
);
945 result
= get_nt_acl(fsp
, security_info
, ppdesc
);
946 END_PROFILE(get_nt_acl
);
950 static BOOL
vfswrap_fset_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, uint32 security_info_sent
, SEC_DESC
*psd
)
954 START_PROFILE(fset_nt_acl
);
955 result
= set_nt_acl(fsp
, security_info_sent
, psd
);
956 END_PROFILE(fset_nt_acl
);
960 static BOOL
vfswrap_set_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, const char *name
, uint32 security_info_sent
, SEC_DESC
*psd
)
964 START_PROFILE(set_nt_acl
);
965 result
= set_nt_acl(fsp
, security_info_sent
, psd
);
966 END_PROFILE(set_nt_acl
);
970 static int vfswrap_chmod_acl(vfs_handle_struct
*handle
, const char *name
, mode_t mode
)
978 START_PROFILE(chmod_acl
);
979 result
= chmod_acl(handle
->conn
, name
, mode
);
980 END_PROFILE(chmod_acl
);
985 static int vfswrap_fchmod_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, mode_t mode
)
993 START_PROFILE(fchmod_acl
);
994 result
= fchmod_acl(fsp
, fd
, mode
);
995 END_PROFILE(fchmod_acl
);
1000 static int vfswrap_sys_acl_get_entry(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, int entry_id
, SMB_ACL_ENTRY_T
*entry_p
)
1002 return sys_acl_get_entry(theacl
, entry_id
, entry_p
);
1005 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
)
1007 return sys_acl_get_tag_type(entry_d
, tag_type_p
);
1010 static int vfswrap_sys_acl_get_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
, SMB_ACL_PERMSET_T
*permset_p
)
1012 return sys_acl_get_permset(entry_d
, permset_p
);
1015 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
)
1017 return sys_acl_get_qualifier(entry_d
);
1020 static SMB_ACL_T
vfswrap_sys_acl_get_file(vfs_handle_struct
*handle
, const char *path_p
, SMB_ACL_TYPE_T type
)
1022 return sys_acl_get_file(handle
, path_p
, type
);
1025 static SMB_ACL_T
vfswrap_sys_acl_get_fd(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
)
1027 return sys_acl_get_fd(handle
, fsp
, fd
);
1030 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
)
1032 return sys_acl_clear_perms(permset
);
1035 static int vfswrap_sys_acl_add_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1037 return sys_acl_add_perm(permset
, perm
);
1040 static char * vfswrap_sys_acl_to_text(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, ssize_t
*plen
)
1042 return sys_acl_to_text(theacl
, plen
);
1045 static SMB_ACL_T
vfswrap_sys_acl_init(vfs_handle_struct
*handle
, int count
)
1047 return sys_acl_init(count
);
1050 static int vfswrap_sys_acl_create_entry(vfs_handle_struct
*handle
, SMB_ACL_T
*pacl
, SMB_ACL_ENTRY_T
*pentry
)
1052 return sys_acl_create_entry(pacl
, pentry
);
1055 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_TAG_T tagtype
)
1057 return sys_acl_set_tag_type(entry
, tagtype
);
1060 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, void *qual
)
1062 return sys_acl_set_qualifier(entry
, qual
);
1065 static int vfswrap_sys_acl_set_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_PERMSET_T permset
)
1067 return sys_acl_set_permset(entry
, permset
);
1070 static int vfswrap_sys_acl_valid(vfs_handle_struct
*handle
, SMB_ACL_T theacl
)
1072 return sys_acl_valid(theacl
);
1075 static int vfswrap_sys_acl_set_file(vfs_handle_struct
*handle
, const char *name
, SMB_ACL_TYPE_T acltype
, SMB_ACL_T theacl
)
1077 return sys_acl_set_file(handle
, name
, acltype
, theacl
);
1080 static int vfswrap_sys_acl_set_fd(vfs_handle_struct
*handle
, files_struct
*fsp
, int fd
, SMB_ACL_T theacl
)
1082 return sys_acl_set_fd(handle
, fsp
, fd
, theacl
);
1085 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct
*handle
, const char *path
)
1087 return sys_acl_delete_def_file(handle
, path
);
1090 static int vfswrap_sys_acl_get_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1092 return sys_acl_get_perm(permset
, perm
);
1095 static int vfswrap_sys_acl_free_text(vfs_handle_struct
*handle
, char *text
)
1097 return sys_acl_free_text(text
);
1100 static int vfswrap_sys_acl_free_acl(vfs_handle_struct
*handle
, SMB_ACL_T posix_acl
)
1102 return sys_acl_free_acl(posix_acl
);
1105 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct
*handle
, void *qualifier
, SMB_ACL_TAG_T tagtype
)
1107 return sys_acl_free_qualifier(qualifier
, tagtype
);
1110 /****************************************************************
1111 Extended attribute operations.
1112 *****************************************************************/
1114 static ssize_t
vfswrap_getxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1116 return sys_getxattr(path
, name
, value
, size
);
1119 static ssize_t
vfswrap_lgetxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1121 return sys_lgetxattr(path
, name
, value
, size
);
1124 static ssize_t
vfswrap_fgetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
,int fd
, const char *name
, void *value
, size_t size
)
1126 return sys_fgetxattr(fd
, name
, value
, size
);
1129 static ssize_t
vfswrap_listxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1131 return sys_listxattr(path
, list
, size
);
1134 ssize_t
vfswrap_llistxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1136 return sys_llistxattr(path
, list
, size
);
1139 ssize_t
vfswrap_flistxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
,int fd
, char *list
, size_t size
)
1141 return sys_flistxattr(fd
, list
, size
);
1144 static int vfswrap_removexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1146 return sys_removexattr(path
, name
);
1149 static int vfswrap_lremovexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1151 return sys_lremovexattr(path
, name
);
1154 static int vfswrap_fremovexattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
,int fd
, const char *name
)
1156 return sys_fremovexattr(fd
, name
);
1159 static int vfswrap_setxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1161 return sys_setxattr(path
, name
, value
, size
, flags
);
1164 static int vfswrap_lsetxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1166 return sys_lsetxattr(path
, name
, value
, size
, flags
);
1169 static int vfswrap_fsetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
,int fd
, const char *name
, const void *value
, size_t size
, int flags
)
1171 return sys_fsetxattr(fd
, name
, value
, size
, flags
);
1174 static int vfswrap_aio_read(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1176 return sys_aio_read(aiocb
);
1179 static int vfswrap_aio_write(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1181 return sys_aio_write(aiocb
);
1184 static ssize_t
vfswrap_aio_return(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1186 return sys_aio_return(aiocb
);
1189 static int vfswrap_aio_cancel(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, int fd
, SMB_STRUCT_AIOCB
*aiocb
)
1191 return sys_aio_cancel(fd
, aiocb
);
1194 static int vfswrap_aio_error(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1196 return sys_aio_error(aiocb
);
1199 static int vfswrap_aio_fsync(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, int op
, SMB_STRUCT_AIOCB
*aiocb
)
1201 return sys_aio_fsync(op
, aiocb
);
1204 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
)
1206 return sys_aio_suspend(aiocb
, n
, timeout
);
1209 static vfs_op_tuple vfs_default_ops
[] = {
1211 /* Disk operations */
1213 {SMB_VFS_OP(vfswrap_connect
), SMB_VFS_OP_CONNECT
,
1214 SMB_VFS_LAYER_OPAQUE
},
1215 {SMB_VFS_OP(vfswrap_disconnect
), SMB_VFS_OP_DISCONNECT
,
1216 SMB_VFS_LAYER_OPAQUE
},
1217 {SMB_VFS_OP(vfswrap_disk_free
), SMB_VFS_OP_DISK_FREE
,
1218 SMB_VFS_LAYER_OPAQUE
},
1219 {SMB_VFS_OP(vfswrap_get_quota
), SMB_VFS_OP_GET_QUOTA
,
1220 SMB_VFS_LAYER_OPAQUE
},
1221 {SMB_VFS_OP(vfswrap_set_quota
), SMB_VFS_OP_SET_QUOTA
,
1222 SMB_VFS_LAYER_OPAQUE
},
1223 {SMB_VFS_OP(vfswrap_get_shadow_copy_data
), SMB_VFS_OP_GET_SHADOW_COPY_DATA
,
1224 SMB_VFS_LAYER_OPAQUE
},
1225 {SMB_VFS_OP(vfswrap_statvfs
), SMB_VFS_OP_STATVFS
,
1226 SMB_VFS_LAYER_OPAQUE
},
1228 /* Directory operations */
1230 {SMB_VFS_OP(vfswrap_opendir
), SMB_VFS_OP_OPENDIR
,
1231 SMB_VFS_LAYER_OPAQUE
},
1232 {SMB_VFS_OP(vfswrap_readdir
), SMB_VFS_OP_READDIR
,
1233 SMB_VFS_LAYER_OPAQUE
},
1234 {SMB_VFS_OP(vfswrap_seekdir
), SMB_VFS_OP_SEEKDIR
,
1235 SMB_VFS_LAYER_OPAQUE
},
1236 {SMB_VFS_OP(vfswrap_telldir
), SMB_VFS_OP_TELLDIR
,
1237 SMB_VFS_LAYER_OPAQUE
},
1238 {SMB_VFS_OP(vfswrap_rewinddir
), SMB_VFS_OP_REWINDDIR
,
1239 SMB_VFS_LAYER_OPAQUE
},
1240 {SMB_VFS_OP(vfswrap_mkdir
), SMB_VFS_OP_MKDIR
,
1241 SMB_VFS_LAYER_OPAQUE
},
1242 {SMB_VFS_OP(vfswrap_rmdir
), SMB_VFS_OP_RMDIR
,
1243 SMB_VFS_LAYER_OPAQUE
},
1244 {SMB_VFS_OP(vfswrap_closedir
), SMB_VFS_OP_CLOSEDIR
,
1245 SMB_VFS_LAYER_OPAQUE
},
1247 /* File operations */
1249 {SMB_VFS_OP(vfswrap_open
), SMB_VFS_OP_OPEN
,
1250 SMB_VFS_LAYER_OPAQUE
},
1251 {SMB_VFS_OP(vfswrap_close
), SMB_VFS_OP_CLOSE
,
1252 SMB_VFS_LAYER_OPAQUE
},
1253 {SMB_VFS_OP(vfswrap_read
), SMB_VFS_OP_READ
,
1254 SMB_VFS_LAYER_OPAQUE
},
1255 {SMB_VFS_OP(vfswrap_pread
), SMB_VFS_OP_PREAD
,
1256 SMB_VFS_LAYER_OPAQUE
},
1257 {SMB_VFS_OP(vfswrap_write
), SMB_VFS_OP_WRITE
,
1258 SMB_VFS_LAYER_OPAQUE
},
1259 {SMB_VFS_OP(vfswrap_pwrite
), SMB_VFS_OP_PWRITE
,
1260 SMB_VFS_LAYER_OPAQUE
},
1261 {SMB_VFS_OP(vfswrap_lseek
), SMB_VFS_OP_LSEEK
,
1262 SMB_VFS_LAYER_OPAQUE
},
1263 {SMB_VFS_OP(vfswrap_sendfile
), SMB_VFS_OP_SENDFILE
,
1264 SMB_VFS_LAYER_OPAQUE
},
1265 {SMB_VFS_OP(vfswrap_rename
), SMB_VFS_OP_RENAME
,
1266 SMB_VFS_LAYER_OPAQUE
},
1267 {SMB_VFS_OP(vfswrap_fsync
), SMB_VFS_OP_FSYNC
,
1268 SMB_VFS_LAYER_OPAQUE
},
1269 {SMB_VFS_OP(vfswrap_stat
), SMB_VFS_OP_STAT
,
1270 SMB_VFS_LAYER_OPAQUE
},
1271 {SMB_VFS_OP(vfswrap_fstat
), SMB_VFS_OP_FSTAT
,
1272 SMB_VFS_LAYER_OPAQUE
},
1273 {SMB_VFS_OP(vfswrap_lstat
), SMB_VFS_OP_LSTAT
,
1274 SMB_VFS_LAYER_OPAQUE
},
1275 {SMB_VFS_OP(vfswrap_unlink
), SMB_VFS_OP_UNLINK
,
1276 SMB_VFS_LAYER_OPAQUE
},
1277 {SMB_VFS_OP(vfswrap_chmod
), SMB_VFS_OP_CHMOD
,
1278 SMB_VFS_LAYER_OPAQUE
},
1279 {SMB_VFS_OP(vfswrap_fchmod
), SMB_VFS_OP_FCHMOD
,
1280 SMB_VFS_LAYER_OPAQUE
},
1281 {SMB_VFS_OP(vfswrap_chown
), SMB_VFS_OP_CHOWN
,
1282 SMB_VFS_LAYER_OPAQUE
},
1283 {SMB_VFS_OP(vfswrap_fchown
), SMB_VFS_OP_FCHOWN
,
1284 SMB_VFS_LAYER_OPAQUE
},
1285 {SMB_VFS_OP(vfswrap_lchown
), SMB_VFS_OP_LCHOWN
,
1286 SMB_VFS_LAYER_OPAQUE
},
1287 {SMB_VFS_OP(vfswrap_chdir
), SMB_VFS_OP_CHDIR
,
1288 SMB_VFS_LAYER_OPAQUE
},
1289 {SMB_VFS_OP(vfswrap_getwd
), SMB_VFS_OP_GETWD
,
1290 SMB_VFS_LAYER_OPAQUE
},
1291 {SMB_VFS_OP(vfswrap_ntimes
), SMB_VFS_OP_NTIMES
,
1292 SMB_VFS_LAYER_OPAQUE
},
1293 {SMB_VFS_OP(vfswrap_ftruncate
), SMB_VFS_OP_FTRUNCATE
,
1294 SMB_VFS_LAYER_OPAQUE
},
1295 {SMB_VFS_OP(vfswrap_lock
), SMB_VFS_OP_LOCK
,
1296 SMB_VFS_LAYER_OPAQUE
},
1297 {SMB_VFS_OP(vfswrap_kernel_flock
), SMB_VFS_OP_KERNEL_FLOCK
,
1298 SMB_VFS_LAYER_OPAQUE
},
1299 {SMB_VFS_OP(vfswrap_linux_setlease
), SMB_VFS_OP_LINUX_SETLEASE
,
1300 SMB_VFS_LAYER_OPAQUE
},
1301 {SMB_VFS_OP(vfswrap_getlock
), SMB_VFS_OP_GETLOCK
,
1302 SMB_VFS_LAYER_OPAQUE
},
1303 {SMB_VFS_OP(vfswrap_symlink
), SMB_VFS_OP_SYMLINK
,
1304 SMB_VFS_LAYER_OPAQUE
},
1305 {SMB_VFS_OP(vfswrap_readlink
), SMB_VFS_OP_READLINK
,
1306 SMB_VFS_LAYER_OPAQUE
},
1307 {SMB_VFS_OP(vfswrap_link
), SMB_VFS_OP_LINK
,
1308 SMB_VFS_LAYER_OPAQUE
},
1309 {SMB_VFS_OP(vfswrap_mknod
), SMB_VFS_OP_MKNOD
,
1310 SMB_VFS_LAYER_OPAQUE
},
1311 {SMB_VFS_OP(vfswrap_realpath
), SMB_VFS_OP_REALPATH
,
1312 SMB_VFS_LAYER_OPAQUE
},
1313 {SMB_VFS_OP(vfswrap_notify_watch
), SMB_VFS_OP_NOTIFY_WATCH
,
1314 SMB_VFS_LAYER_OPAQUE
},
1315 {SMB_VFS_OP(vfswrap_chflags
), SMB_VFS_OP_CHFLAGS
,
1316 SMB_VFS_LAYER_OPAQUE
},
1318 /* NT ACL operations. */
1320 {SMB_VFS_OP(vfswrap_fget_nt_acl
), SMB_VFS_OP_FGET_NT_ACL
,
1321 SMB_VFS_LAYER_OPAQUE
},
1322 {SMB_VFS_OP(vfswrap_get_nt_acl
), SMB_VFS_OP_GET_NT_ACL
,
1323 SMB_VFS_LAYER_OPAQUE
},
1324 {SMB_VFS_OP(vfswrap_fset_nt_acl
), SMB_VFS_OP_FSET_NT_ACL
,
1325 SMB_VFS_LAYER_OPAQUE
},
1326 {SMB_VFS_OP(vfswrap_set_nt_acl
), SMB_VFS_OP_SET_NT_ACL
,
1327 SMB_VFS_LAYER_OPAQUE
},
1329 /* POSIX ACL operations. */
1331 {SMB_VFS_OP(vfswrap_chmod_acl
), SMB_VFS_OP_CHMOD_ACL
,
1332 SMB_VFS_LAYER_OPAQUE
},
1333 {SMB_VFS_OP(vfswrap_fchmod_acl
), SMB_VFS_OP_FCHMOD_ACL
,
1334 SMB_VFS_LAYER_OPAQUE
},
1335 {SMB_VFS_OP(vfswrap_sys_acl_get_entry
), SMB_VFS_OP_SYS_ACL_GET_ENTRY
,
1336 SMB_VFS_LAYER_OPAQUE
},
1337 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type
), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE
,
1338 SMB_VFS_LAYER_OPAQUE
},
1339 {SMB_VFS_OP(vfswrap_sys_acl_get_permset
), SMB_VFS_OP_SYS_ACL_GET_PERMSET
,
1340 SMB_VFS_LAYER_OPAQUE
},
1341 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier
), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER
,
1342 SMB_VFS_LAYER_OPAQUE
},
1343 {SMB_VFS_OP(vfswrap_sys_acl_get_file
), SMB_VFS_OP_SYS_ACL_GET_FILE
,
1344 SMB_VFS_LAYER_OPAQUE
},
1345 {SMB_VFS_OP(vfswrap_sys_acl_get_fd
), SMB_VFS_OP_SYS_ACL_GET_FD
,
1346 SMB_VFS_LAYER_OPAQUE
},
1347 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms
), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS
,
1348 SMB_VFS_LAYER_OPAQUE
},
1349 {SMB_VFS_OP(vfswrap_sys_acl_add_perm
), SMB_VFS_OP_SYS_ACL_ADD_PERM
,
1350 SMB_VFS_LAYER_OPAQUE
},
1351 {SMB_VFS_OP(vfswrap_sys_acl_to_text
), SMB_VFS_OP_SYS_ACL_TO_TEXT
,
1352 SMB_VFS_LAYER_OPAQUE
},
1353 {SMB_VFS_OP(vfswrap_sys_acl_init
), SMB_VFS_OP_SYS_ACL_INIT
,
1354 SMB_VFS_LAYER_OPAQUE
},
1355 {SMB_VFS_OP(vfswrap_sys_acl_create_entry
), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY
,
1356 SMB_VFS_LAYER_OPAQUE
},
1357 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type
), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE
,
1358 SMB_VFS_LAYER_OPAQUE
},
1359 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier
), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER
,
1360 SMB_VFS_LAYER_OPAQUE
},
1361 {SMB_VFS_OP(vfswrap_sys_acl_set_permset
), SMB_VFS_OP_SYS_ACL_SET_PERMSET
,
1362 SMB_VFS_LAYER_OPAQUE
},
1363 {SMB_VFS_OP(vfswrap_sys_acl_valid
), SMB_VFS_OP_SYS_ACL_VALID
,
1364 SMB_VFS_LAYER_OPAQUE
},
1365 {SMB_VFS_OP(vfswrap_sys_acl_set_file
), SMB_VFS_OP_SYS_ACL_SET_FILE
,
1366 SMB_VFS_LAYER_OPAQUE
},
1367 {SMB_VFS_OP(vfswrap_sys_acl_set_fd
), SMB_VFS_OP_SYS_ACL_SET_FD
,
1368 SMB_VFS_LAYER_OPAQUE
},
1369 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file
), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE
,
1370 SMB_VFS_LAYER_OPAQUE
},
1371 {SMB_VFS_OP(vfswrap_sys_acl_get_perm
), SMB_VFS_OP_SYS_ACL_GET_PERM
,
1372 SMB_VFS_LAYER_OPAQUE
},
1373 {SMB_VFS_OP(vfswrap_sys_acl_free_text
), SMB_VFS_OP_SYS_ACL_FREE_TEXT
,
1374 SMB_VFS_LAYER_OPAQUE
},
1375 {SMB_VFS_OP(vfswrap_sys_acl_free_acl
), SMB_VFS_OP_SYS_ACL_FREE_ACL
,
1376 SMB_VFS_LAYER_OPAQUE
},
1377 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier
), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER
,
1378 SMB_VFS_LAYER_OPAQUE
},
1380 /* EA operations. */
1382 {SMB_VFS_OP(vfswrap_getxattr
), SMB_VFS_OP_GETXATTR
,
1383 SMB_VFS_LAYER_OPAQUE
},
1384 {SMB_VFS_OP(vfswrap_lgetxattr
), SMB_VFS_OP_LGETXATTR
,
1385 SMB_VFS_LAYER_OPAQUE
},
1386 {SMB_VFS_OP(vfswrap_fgetxattr
), SMB_VFS_OP_FGETXATTR
,
1387 SMB_VFS_LAYER_OPAQUE
},
1388 {SMB_VFS_OP(vfswrap_listxattr
), SMB_VFS_OP_LISTXATTR
,
1389 SMB_VFS_LAYER_OPAQUE
},
1390 {SMB_VFS_OP(vfswrap_llistxattr
), SMB_VFS_OP_LLISTXATTR
,
1391 SMB_VFS_LAYER_OPAQUE
},
1392 {SMB_VFS_OP(vfswrap_flistxattr
), SMB_VFS_OP_FLISTXATTR
,
1393 SMB_VFS_LAYER_OPAQUE
},
1394 {SMB_VFS_OP(vfswrap_removexattr
), SMB_VFS_OP_REMOVEXATTR
,
1395 SMB_VFS_LAYER_OPAQUE
},
1396 {SMB_VFS_OP(vfswrap_lremovexattr
), SMB_VFS_OP_LREMOVEXATTR
,
1397 SMB_VFS_LAYER_OPAQUE
},
1398 {SMB_VFS_OP(vfswrap_fremovexattr
), SMB_VFS_OP_FREMOVEXATTR
,
1399 SMB_VFS_LAYER_OPAQUE
},
1400 {SMB_VFS_OP(vfswrap_setxattr
), SMB_VFS_OP_SETXATTR
,
1401 SMB_VFS_LAYER_OPAQUE
},
1402 {SMB_VFS_OP(vfswrap_lsetxattr
), SMB_VFS_OP_LSETXATTR
,
1403 SMB_VFS_LAYER_OPAQUE
},
1404 {SMB_VFS_OP(vfswrap_fsetxattr
), SMB_VFS_OP_FSETXATTR
,
1405 SMB_VFS_LAYER_OPAQUE
},
1407 {SMB_VFS_OP(vfswrap_aio_read
), SMB_VFS_OP_AIO_READ
,
1408 SMB_VFS_LAYER_OPAQUE
},
1409 {SMB_VFS_OP(vfswrap_aio_write
), SMB_VFS_OP_AIO_WRITE
,
1410 SMB_VFS_LAYER_OPAQUE
},
1411 {SMB_VFS_OP(vfswrap_aio_return
), SMB_VFS_OP_AIO_RETURN
,
1412 SMB_VFS_LAYER_OPAQUE
},
1413 {SMB_VFS_OP(vfswrap_aio_cancel
), SMB_VFS_OP_AIO_CANCEL
,
1414 SMB_VFS_LAYER_OPAQUE
},
1415 {SMB_VFS_OP(vfswrap_aio_error
), SMB_VFS_OP_AIO_ERROR
,
1416 SMB_VFS_LAYER_OPAQUE
},
1417 {SMB_VFS_OP(vfswrap_aio_fsync
), SMB_VFS_OP_AIO_FSYNC
,
1418 SMB_VFS_LAYER_OPAQUE
},
1419 {SMB_VFS_OP(vfswrap_aio_suspend
),SMB_VFS_OP_AIO_SUSPEND
,
1420 SMB_VFS_LAYER_OPAQUE
},
1422 /* Finish VFS operations definition */
1424 {SMB_VFS_OP(NULL
), SMB_VFS_OP_NOOP
,
1428 NTSTATUS
vfs_default_init(void);
1429 NTSTATUS
vfs_default_init(void)
1431 unsigned int needed
= SMB_VFS_OP_LAST
+ 1; /* convert from index to count */
1433 if (ARRAY_SIZE(vfs_default_ops
) != needed
) {
1434 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1435 DEFAULT_VFS_MODULE_NAME
, (unsigned int)ARRAY_SIZE(vfs_default_ops
), needed
));
1436 smb_panic("operation(s) missing from default VFS module");
1439 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION
,
1440 DEFAULT_VFS_MODULE_NAME
, vfs_default_ops
);