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 uint64_t vfswrap_disk_free(vfs_handle_struct
*handle
, const char *path
, bool small_query
, uint64_t *bsize
,
44 uint64_t *dfree
, uint64_t *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
,
117 SMB_STRUCT_DIR
*dirp
,
118 SMB_STRUCT_STAT
*sbuf
)
120 SMB_STRUCT_DIRENT
*result
;
122 START_PROFILE(syscall_readdir
);
123 result
= sys_readdir(dirp
);
124 /* Default Posix readdir() does not give us stat info.
125 * Set to invalid to indicate we didn't return this info. */
127 SET_STAT_INVALID(*sbuf
);
128 END_PROFILE(syscall_readdir
);
132 static void vfswrap_seekdir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
, long offset
)
134 START_PROFILE(syscall_seekdir
);
135 sys_seekdir(dirp
, offset
);
136 END_PROFILE(syscall_seekdir
);
139 static long vfswrap_telldir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
142 START_PROFILE(syscall_telldir
);
143 result
= sys_telldir(dirp
);
144 END_PROFILE(syscall_telldir
);
148 static void vfswrap_rewinddir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
150 START_PROFILE(syscall_rewinddir
);
152 END_PROFILE(syscall_rewinddir
);
155 static int vfswrap_mkdir(vfs_handle_struct
*handle
, const char *path
, mode_t mode
)
158 bool has_dacl
= False
;
161 START_PROFILE(syscall_mkdir
);
163 if (lp_inherit_acls(SNUM(handle
->conn
))
164 && parent_dirname(talloc_tos(), path
, &parent
, NULL
)
165 && (has_dacl
= directory_has_default_acl(handle
->conn
, parent
)))
170 result
= mkdir(path
, mode
);
172 if (result
== 0 && !has_dacl
) {
174 * We need to do this as the default behavior of POSIX ACLs
175 * is to set the mask to be the requested group permission
176 * bits, not the group permission bits to be the requested
177 * group permission bits. This is not what we want, as it will
178 * mess up any inherited ACL bits that were set. JRA.
180 int saved_errno
= errno
; /* We may get ENOSYS */
181 if ((SMB_VFS_CHMOD_ACL(handle
->conn
, path
, mode
) == -1) && (errno
== ENOSYS
))
185 END_PROFILE(syscall_mkdir
);
189 static int vfswrap_rmdir(vfs_handle_struct
*handle
, const char *path
)
193 START_PROFILE(syscall_rmdir
);
194 result
= rmdir(path
);
195 END_PROFILE(syscall_rmdir
);
199 static int vfswrap_closedir(vfs_handle_struct
*handle
, SMB_STRUCT_DIR
*dirp
)
203 START_PROFILE(syscall_closedir
);
204 result
= sys_closedir(dirp
);
205 END_PROFILE(syscall_closedir
);
209 static void vfswrap_init_search_op(vfs_handle_struct
*handle
,
210 SMB_STRUCT_DIR
*dirp
)
212 /* Default behavior is a NOOP */
215 /* File operations */
217 static int vfswrap_open(vfs_handle_struct
*handle
, const char *fname
,
218 files_struct
*fsp
, int flags
, mode_t mode
)
222 START_PROFILE(syscall_open
);
223 result
= sys_open(fname
, flags
, mode
);
224 END_PROFILE(syscall_open
);
228 static NTSTATUS
vfswrap_create_file(vfs_handle_struct
*handle
,
229 struct smb_request
*req
,
230 uint16_t root_dir_fid
,
232 uint32_t create_file_flags
,
233 uint32_t access_mask
,
234 uint32_t share_access
,
235 uint32_t create_disposition
,
236 uint32_t create_options
,
237 uint32_t file_attributes
,
238 uint32_t oplock_request
,
239 uint64_t allocation_size
,
240 struct security_descriptor
*sd
,
241 struct ea_list
*ea_list
,
242 files_struct
**result
,
244 SMB_STRUCT_STAT
*psbuf
)
246 return create_file_default(handle
->conn
, req
, root_dir_fid
, fname
,
247 create_file_flags
, access_mask
, share_access
,
248 create_disposition
, create_options
,
249 file_attributes
, oplock_request
,
250 allocation_size
, sd
, ea_list
, result
, pinfo
,
254 static int vfswrap_close(vfs_handle_struct
*handle
, files_struct
*fsp
)
258 START_PROFILE(syscall_close
);
259 result
= fd_close_posix(fsp
);
260 END_PROFILE(syscall_close
);
264 static ssize_t
vfswrap_read(vfs_handle_struct
*handle
, files_struct
*fsp
, void *data
, size_t n
)
268 START_PROFILE_BYTES(syscall_read
, n
);
269 result
= sys_read(fsp
->fh
->fd
, data
, n
);
270 END_PROFILE(syscall_read
);
274 static ssize_t
vfswrap_pread(vfs_handle_struct
*handle
, files_struct
*fsp
, void *data
,
275 size_t n
, SMB_OFF_T offset
)
279 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
280 START_PROFILE_BYTES(syscall_pread
, n
);
281 result
= sys_pread(fsp
->fh
->fd
, data
, n
, offset
);
282 END_PROFILE(syscall_pread
);
284 if (result
== -1 && errno
== ESPIPE
) {
285 /* Maintain the fiction that pipes can be seeked (sought?) on. */
286 result
= SMB_VFS_READ(fsp
, data
, n
);
290 #else /* HAVE_PREAD */
294 curr
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
295 if (curr
== -1 && errno
== ESPIPE
) {
296 /* Maintain the fiction that pipes can be seeked (sought?) on. */
297 result
= SMB_VFS_READ(fsp
, data
, n
);
302 if (SMB_VFS_LSEEK(fsp
, offset
, SEEK_SET
) == -1) {
307 result
= SMB_VFS_READ(fsp
, data
, n
);
310 SMB_VFS_LSEEK(fsp
, curr
, SEEK_SET
);
313 #endif /* HAVE_PREAD */
318 static ssize_t
vfswrap_write(vfs_handle_struct
*handle
, files_struct
*fsp
, const void *data
, size_t n
)
322 START_PROFILE_BYTES(syscall_write
, n
);
323 result
= sys_write(fsp
->fh
->fd
, data
, n
);
324 END_PROFILE(syscall_write
);
328 static ssize_t
vfswrap_pwrite(vfs_handle_struct
*handle
, files_struct
*fsp
, const void *data
,
329 size_t n
, SMB_OFF_T offset
)
333 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
334 START_PROFILE_BYTES(syscall_pwrite
, n
);
335 result
= sys_pwrite(fsp
->fh
->fd
, data
, n
, offset
);
336 END_PROFILE(syscall_pwrite
);
338 if (result
== -1 && errno
== ESPIPE
) {
339 /* Maintain the fiction that pipes can be sought on. */
340 result
= SMB_VFS_WRITE(fsp
, data
, n
);
343 #else /* HAVE_PWRITE */
347 curr
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
352 if (SMB_VFS_LSEEK(fsp
, offset
, SEEK_SET
) == -1) {
356 result
= SMB_VFS_WRITE(fsp
, data
, n
);
359 SMB_VFS_LSEEK(fsp
, curr
, SEEK_SET
);
362 #endif /* HAVE_PWRITE */
367 static SMB_OFF_T
vfswrap_lseek(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T offset
, int whence
)
369 SMB_OFF_T result
= 0;
371 START_PROFILE(syscall_lseek
);
373 /* Cope with 'stat' file opens. */
374 if (fsp
->fh
->fd
!= -1)
375 result
= sys_lseek(fsp
->fh
->fd
, offset
, whence
);
378 * We want to maintain the fiction that we can seek
379 * on a fifo for file system purposes. This allows
380 * people to set up UNIX fifo's that feed data to Windows
384 if((result
== -1) && (errno
== ESPIPE
)) {
389 END_PROFILE(syscall_lseek
);
393 static ssize_t
vfswrap_sendfile(vfs_handle_struct
*handle
, int tofd
, files_struct
*fromfsp
, const DATA_BLOB
*hdr
,
394 SMB_OFF_T offset
, size_t n
)
398 START_PROFILE_BYTES(syscall_sendfile
, n
);
399 result
= sys_sendfile(tofd
, fromfsp
->fh
->fd
, hdr
, offset
, n
);
400 END_PROFILE(syscall_sendfile
);
404 static ssize_t
vfswrap_recvfile(vfs_handle_struct
*handle
,
412 START_PROFILE_BYTES(syscall_recvfile
, n
);
413 result
= sys_recvfile(fromfd
, tofsp
->fh
->fd
, offset
, n
);
414 END_PROFILE(syscall_recvfile
);
418 /*********************************************************
419 For rename across filesystems Patch from Warren Birnbaum
420 <warrenb@hpcvscdp.cv.hp.com>
421 **********************************************************/
423 static int copy_reg(const char *source
, const char *dest
)
425 SMB_STRUCT_STAT source_stats
;
430 if (sys_lstat (source
, &source_stats
) == -1)
433 if (!S_ISREG (source_stats
.st_mode
))
436 if((ifd
= sys_open (source
, O_RDONLY
, 0)) < 0)
439 if (unlink (dest
) && errno
!= ENOENT
)
443 if((ofd
= sys_open (dest
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_NOFOLLOW
, 0600)) < 0 )
445 if((ofd
= sys_open (dest
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0600)) < 0 )
449 if (transfer_file(ifd
, ofd
, (size_t)-1) == -1)
453 * Try to preserve ownership. For non-root it might fail, but that's ok.
454 * But root probably wants to know, e.g. if NFS disallows it.
458 if ((fchown(ofd
, source_stats
.st_uid
, source_stats
.st_gid
) == -1) && (errno
!= EPERM
))
460 if ((chown(dest
, source_stats
.st_uid
, source_stats
.st_gid
) == -1) && (errno
!= EPERM
))
465 * fchown turns off set[ug]id bits for non-root,
466 * so do the chmod last.
469 #if defined(HAVE_FCHMOD)
470 if (fchmod (ofd
, source_stats
.st_mode
& 07777))
472 if (chmod (dest
, source_stats
.st_mode
& 07777))
476 if (close (ifd
) == -1)
479 if (close (ofd
) == -1)
482 /* Try to copy the old file's modtime and access time. */
486 tv
.actime
= source_stats
.st_atime
;
487 tv
.modtime
= source_stats
.st_mtime
;
491 if (unlink (source
) == -1)
507 static int vfswrap_rename(vfs_handle_struct
*handle
, const char *oldname
, const char *newname
)
511 START_PROFILE(syscall_rename
);
512 result
= rename(oldname
, newname
);
513 if ((result
== -1) && (errno
== EXDEV
)) {
514 /* Rename across filesystems needed. */
515 result
= copy_reg(oldname
, newname
);
518 END_PROFILE(syscall_rename
);
522 static int vfswrap_fsync(vfs_handle_struct
*handle
, files_struct
*fsp
)
527 START_PROFILE(syscall_fsync
);
528 result
= fsync(fsp
->fh
->fd
);
529 END_PROFILE(syscall_fsync
);
536 static int vfswrap_stat(vfs_handle_struct
*handle
, const char *fname
, SMB_STRUCT_STAT
*sbuf
)
540 START_PROFILE(syscall_stat
);
541 result
= sys_stat(fname
, sbuf
);
542 END_PROFILE(syscall_stat
);
546 static int vfswrap_fstat(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_STRUCT_STAT
*sbuf
)
550 START_PROFILE(syscall_fstat
);
551 result
= sys_fstat(fsp
->fh
->fd
, sbuf
);
552 END_PROFILE(syscall_fstat
);
556 int vfswrap_lstat(vfs_handle_struct
*handle
, const char *path
, SMB_STRUCT_STAT
*sbuf
)
560 START_PROFILE(syscall_lstat
);
561 result
= sys_lstat(path
, sbuf
);
562 END_PROFILE(syscall_lstat
);
566 /********************************************************************
567 Given a stat buffer return the allocated size on disk, taking into
568 account sparse files.
569 ********************************************************************/
570 static uint64_t vfswrap_get_alloc_size(vfs_handle_struct
*handle
,
571 struct files_struct
*fsp
,
572 const SMB_STRUCT_STAT
*sbuf
)
576 START_PROFILE(syscall_get_alloc_size
);
578 if(S_ISDIR(sbuf
->st_mode
)) {
583 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
584 result
= (uint64_t)STAT_ST_BLOCKSIZE
* (uint64_t)sbuf
->st_blocks
;
586 result
= get_file_size_stat(sbuf
);
589 if (fsp
&& fsp
->initial_allocation_size
)
590 result
= MAX(result
,fsp
->initial_allocation_size
);
592 result
= smb_roundup(handle
->conn
, result
);
595 END_PROFILE(syscall_get_alloc_size
);
599 static int vfswrap_unlink(vfs_handle_struct
*handle
, const char *path
)
603 START_PROFILE(syscall_unlink
);
604 result
= unlink(path
);
605 END_PROFILE(syscall_unlink
);
609 static int vfswrap_chmod(vfs_handle_struct
*handle
, const char *path
, mode_t mode
)
613 START_PROFILE(syscall_chmod
);
616 * We need to do this due to the fact that the default POSIX ACL
617 * chmod modifies the ACL *mask* for the group owner, not the
618 * group owner bits directly. JRA.
623 int saved_errno
= errno
; /* We might get ENOSYS */
624 if ((result
= SMB_VFS_CHMOD_ACL(handle
->conn
, path
, mode
)) == 0) {
625 END_PROFILE(syscall_chmod
);
628 /* Error - return the old errno. */
632 result
= chmod(path
, mode
);
633 END_PROFILE(syscall_chmod
);
637 static int vfswrap_fchmod(vfs_handle_struct
*handle
, files_struct
*fsp
, mode_t mode
)
641 START_PROFILE(syscall_fchmod
);
644 * We need to do this due to the fact that the default POSIX ACL
645 * chmod modifies the ACL *mask* for the group owner, not the
646 * group owner bits directly. JRA.
650 int saved_errno
= errno
; /* We might get ENOSYS */
651 if ((result
= SMB_VFS_FCHMOD_ACL(fsp
, mode
)) == 0) {
652 END_PROFILE(syscall_fchmod
);
655 /* Error - return the old errno. */
659 #if defined(HAVE_FCHMOD)
660 result
= fchmod(fsp
->fh
->fd
, mode
);
666 END_PROFILE(syscall_fchmod
);
670 static int vfswrap_chown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
674 START_PROFILE(syscall_chown
);
675 result
= chown(path
, uid
, gid
);
676 END_PROFILE(syscall_chown
);
680 static int vfswrap_fchown(vfs_handle_struct
*handle
, files_struct
*fsp
, uid_t uid
, gid_t gid
)
685 START_PROFILE(syscall_fchown
);
686 result
= fchown(fsp
->fh
->fd
, uid
, gid
);
687 END_PROFILE(syscall_fchown
);
695 static int vfswrap_lchown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
699 START_PROFILE(syscall_lchown
);
700 result
= lchown(path
, uid
, gid
);
701 END_PROFILE(syscall_lchown
);
705 static int vfswrap_chdir(vfs_handle_struct
*handle
, const char *path
)
709 START_PROFILE(syscall_chdir
);
710 result
= chdir(path
);
711 END_PROFILE(syscall_chdir
);
715 static char *vfswrap_getwd(vfs_handle_struct
*handle
, char *path
)
719 START_PROFILE(syscall_getwd
);
720 result
= sys_getwd(path
);
721 END_PROFILE(syscall_getwd
);
725 /*********************************************************************
726 nsec timestamp resolution call. Convert down to whatever the underlying
728 **********************************************************************/
730 static int vfswrap_ntimes(vfs_handle_struct
*handle
, const char *path
,
731 struct smb_file_time
*ft
)
735 START_PROFILE(syscall_ntimes
);
736 #if defined(HAVE_UTIMES)
738 struct timeval tv
[2];
739 tv
[0] = convert_timespec_to_timeval(ft
->atime
);
740 tv
[1] = convert_timespec_to_timeval(ft
->mtime
);
741 result
= utimes(path
, tv
);
743 result
= utimes(path
, NULL
);
745 #elif defined(HAVE_UTIME)
747 struct utimbuf times
;
748 times
.actime
= convert_timespec_to_time_t(ft
->atime
);
749 times
.modtime
= convert_timespec_to_time_t(ft
->mtime
);
750 result
= utime(path
, ×
);
752 result
= utime(path
, NULL
);
758 END_PROFILE(syscall_ntimes
);
762 /*********************************************************************
763 A version of ftruncate that will write the space on disk if strict
765 **********************************************************************/
767 static int strict_allocate_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T len
)
770 SMB_OFF_T currpos
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
771 unsigned char zero_space
[4096];
772 SMB_OFF_T space_to_write
;
777 if (SMB_VFS_FSTAT(fsp
, &st
) == -1)
780 space_to_write
= len
- st
.st_size
;
783 if (S_ISFIFO(st
.st_mode
))
787 if (st
.st_size
== len
)
790 /* Shrink - just ftruncate. */
791 if (st
.st_size
> len
)
792 return sys_ftruncate(fsp
->fh
->fd
, len
);
794 /* available disk space is enough or not? */
795 if (lp_strict_allocate(SNUM(fsp
->conn
))){
796 uint64_t space_avail
;
797 uint64_t bsize
,dfree
,dsize
;
799 space_avail
= get_dfree_info(fsp
->conn
,fsp
->fsp_name
,false,&bsize
,&dfree
,&dsize
);
800 /* space_avail is 1k blocks */
801 if (space_avail
== (uint64_t)-1 ||
802 ((uint64_t)space_to_write
/1024 > space_avail
) ) {
808 /* Write out the real space on disk. */
809 if (SMB_VFS_LSEEK(fsp
, st
.st_size
, SEEK_SET
) != st
.st_size
)
812 space_to_write
= len
- st
.st_size
;
814 memset(zero_space
, '\0', sizeof(zero_space
));
815 while ( space_to_write
> 0) {
817 SMB_OFF_T current_len_to_write
= MIN(sizeof(zero_space
),space_to_write
);
819 retlen
= SMB_VFS_WRITE(fsp
,(char *)zero_space
,current_len_to_write
);
823 space_to_write
-= retlen
;
826 /* Seek to where we were */
827 if (SMB_VFS_LSEEK(fsp
, currpos
, SEEK_SET
) != currpos
)
833 static int vfswrap_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T len
)
840 START_PROFILE(syscall_ftruncate
);
842 if (lp_strict_allocate(SNUM(fsp
->conn
))) {
843 result
= strict_allocate_ftruncate(handle
, fsp
, len
);
844 END_PROFILE(syscall_ftruncate
);
848 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
849 sys_ftruncate if the system supports it. Then I discovered that
850 you can have some filesystems that support ftruncate
851 expansion and some that don't! On Linux fat can't do
852 ftruncate extend but ext2 can. */
854 result
= sys_ftruncate(fsp
->fh
->fd
, len
);
858 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
859 extend a file with ftruncate. Provide alternate implementation
861 currpos
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
866 /* Do an fstat to see if the file is longer than the requested
867 size in which case the ftruncate above should have
868 succeeded or shorter, in which case seek to len - 1 and
869 write 1 byte of zero */
870 if (SMB_VFS_FSTAT(fsp
, &st
) == -1) {
875 if (S_ISFIFO(st
.st_mode
)) {
881 if (st
.st_size
== len
) {
886 if (st
.st_size
> len
) {
887 /* the sys_ftruncate should have worked */
891 if (SMB_VFS_LSEEK(fsp
, len
-1, SEEK_SET
) != len
-1)
894 if (SMB_VFS_WRITE(fsp
, &c
, 1)!=1)
897 /* Seek to where we were */
898 if (SMB_VFS_LSEEK(fsp
, currpos
, SEEK_SET
) != currpos
)
904 END_PROFILE(syscall_ftruncate
);
908 static bool vfswrap_lock(vfs_handle_struct
*handle
, files_struct
*fsp
, int op
, SMB_OFF_T offset
, SMB_OFF_T count
, int type
)
912 START_PROFILE(syscall_fcntl_lock
);
913 result
= fcntl_lock(fsp
->fh
->fd
, op
, offset
, count
, type
);
914 END_PROFILE(syscall_fcntl_lock
);
918 static int vfswrap_kernel_flock(vfs_handle_struct
*handle
, files_struct
*fsp
,
921 START_PROFILE(syscall_kernel_flock
);
922 kernel_flock(fsp
->fh
->fd
, share_mode
);
923 END_PROFILE(syscall_kernel_flock
);
927 static bool vfswrap_getlock(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T
*poffset
, SMB_OFF_T
*pcount
, int *ptype
, pid_t
*ppid
)
931 START_PROFILE(syscall_fcntl_getlock
);
932 result
= fcntl_getlock(fsp
->fh
->fd
, poffset
, pcount
, ptype
, ppid
);
933 END_PROFILE(syscall_fcntl_getlock
);
937 static int vfswrap_linux_setlease(vfs_handle_struct
*handle
, files_struct
*fsp
,
942 START_PROFILE(syscall_linux_setlease
);
944 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
945 /* first set the signal handler */
946 if(linux_set_lease_sighandler(fsp
->fh
->fd
) == -1) {
950 result
= linux_setlease(fsp
->fh
->fd
, leasetype
);
954 END_PROFILE(syscall_linux_setlease
);
958 static int vfswrap_symlink(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
962 START_PROFILE(syscall_symlink
);
963 result
= symlink(oldpath
, newpath
);
964 END_PROFILE(syscall_symlink
);
968 static int vfswrap_readlink(vfs_handle_struct
*handle
, const char *path
, char *buf
, size_t bufsiz
)
972 START_PROFILE(syscall_readlink
);
973 result
= readlink(path
, buf
, bufsiz
);
974 END_PROFILE(syscall_readlink
);
978 static int vfswrap_link(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
982 START_PROFILE(syscall_link
);
983 result
= link(oldpath
, newpath
);
984 END_PROFILE(syscall_link
);
988 static int vfswrap_mknod(vfs_handle_struct
*handle
, const char *pathname
, mode_t mode
, SMB_DEV_T dev
)
992 START_PROFILE(syscall_mknod
);
993 result
= sys_mknod(pathname
, mode
, dev
);
994 END_PROFILE(syscall_mknod
);
998 static char *vfswrap_realpath(vfs_handle_struct
*handle
, const char *path
, char *resolved_path
)
1002 START_PROFILE(syscall_realpath
);
1003 result
= realpath(path
, resolved_path
);
1004 END_PROFILE(syscall_realpath
);
1008 static NTSTATUS
vfswrap_notify_watch(vfs_handle_struct
*vfs_handle
,
1009 struct sys_notify_context
*ctx
,
1010 struct notify_entry
*e
,
1011 void (*callback
)(struct sys_notify_context
*ctx
,
1013 struct notify_event
*ev
),
1014 void *private_data
, void *handle
)
1017 * So far inotify is the only supported default notify mechanism. If
1018 * another platform like the the BSD's or a proprietary Unix comes
1019 * along and wants another default, we can play the same trick we
1020 * played with Posix ACLs.
1022 * Until that is the case, hard-code inotify here.
1025 if (lp_kernel_change_notify(ctx
->conn
->params
)) {
1026 return inotify_watch(ctx
, e
, callback
, private_data
, handle
);
1030 * Do nothing, leave everything to notify_internal.c
1032 return NT_STATUS_OK
;
1035 static int vfswrap_chflags(vfs_handle_struct
*handle
, const char *path
, int flags
)
1038 return chflags(path
, flags
);
1045 static struct file_id
vfswrap_file_id_create(struct vfs_handle_struct
*handle
,
1046 SMB_STRUCT_STAT
*sbuf
)
1050 /* the ZERO_STRUCT ensures padding doesn't break using the key as a
1054 key
.devid
= sbuf
->st_dev
;
1055 key
.inode
= sbuf
->st_ino
;
1056 /* key.extid is unused by default. */
1061 static NTSTATUS
vfswrap_streaminfo(vfs_handle_struct
*handle
,
1062 struct files_struct
*fsp
,
1064 TALLOC_CTX
*mem_ctx
,
1065 unsigned int *pnum_streams
,
1066 struct stream_struct
**pstreams
)
1068 SMB_STRUCT_STAT sbuf
;
1069 unsigned int num_streams
= 0;
1070 struct stream_struct
*streams
= NULL
;
1073 if ((fsp
!= NULL
) && (fsp
->is_directory
)) {
1075 * No default streams on directories
1080 if ((fsp
!= NULL
) && (fsp
->fh
->fd
!= -1)) {
1081 ret
= SMB_VFS_FSTAT(fsp
, &sbuf
);
1084 ret
= SMB_VFS_STAT(handle
->conn
, fname
, &sbuf
);
1088 return map_nt_error_from_unix(errno
);
1091 if (S_ISDIR(sbuf
.st_mode
)) {
1095 streams
= talloc(mem_ctx
, struct stream_struct
);
1097 if (streams
== NULL
) {
1098 return NT_STATUS_NO_MEMORY
;
1101 streams
->size
= sbuf
.st_size
;
1102 streams
->alloc_size
= SMB_VFS_GET_ALLOC_SIZE(handle
->conn
, fsp
, &sbuf
);
1104 streams
->name
= talloc_strdup(streams
, "::$DATA");
1105 if (streams
->name
== NULL
) {
1106 TALLOC_FREE(streams
);
1107 return NT_STATUS_NO_MEMORY
;
1112 *pnum_streams
= num_streams
;
1113 *pstreams
= streams
;
1114 return NT_STATUS_OK
;
1117 static int vfswrap_get_real_filename(struct vfs_handle_struct
*handle
,
1120 TALLOC_CTX
*mem_ctx
,
1123 return get_real_filename(handle
->conn
, path
, name
, mem_ctx
,
1127 static NTSTATUS
vfswrap_brl_lock_windows(struct vfs_handle_struct
*handle
,
1128 struct byte_range_lock
*br_lck
,
1129 struct lock_struct
*plock
,
1131 struct blocking_lock_record
*blr
)
1133 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
1135 /* Note: blr is not used in the default implementation. */
1136 return brl_lock_windows_default(br_lck
, plock
, blocking_lock
);
1139 static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct
*handle
,
1140 struct messaging_context
*msg_ctx
,
1141 struct byte_range_lock
*br_lck
,
1142 const struct lock_struct
*plock
)
1144 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
1146 return brl_unlock_windows_default(msg_ctx
, br_lck
, plock
);
1149 static bool vfswrap_brl_cancel_windows(struct vfs_handle_struct
*handle
,
1150 struct byte_range_lock
*br_lck
,
1151 struct lock_struct
*plock
,
1152 struct blocking_lock_record
*blr
)
1154 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
1156 /* Note: blr is not used in the default implementation. */
1157 return brl_lock_cancel_default(br_lck
, plock
);
1160 static bool vfswrap_strict_lock(struct vfs_handle_struct
*handle
,
1162 struct lock_struct
*plock
)
1164 SMB_ASSERT(plock
->lock_type
== READ_LOCK
||
1165 plock
->lock_type
== WRITE_LOCK
);
1167 return strict_lock_default(fsp
, plock
);
1170 static void vfswrap_strict_unlock(struct vfs_handle_struct
*handle
,
1172 struct lock_struct
*plock
)
1174 SMB_ASSERT(plock
->lock_type
== READ_LOCK
||
1175 plock
->lock_type
== WRITE_LOCK
);
1177 strict_unlock_default(fsp
, plock
);
1180 /* NT ACL operations. */
1182 static NTSTATUS
vfswrap_fget_nt_acl(vfs_handle_struct
*handle
,
1184 uint32 security_info
, SEC_DESC
**ppdesc
)
1188 START_PROFILE(fget_nt_acl
);
1189 result
= posix_fget_nt_acl(fsp
, security_info
, ppdesc
);
1190 END_PROFILE(fget_nt_acl
);
1194 static NTSTATUS
vfswrap_get_nt_acl(vfs_handle_struct
*handle
,
1196 uint32 security_info
, SEC_DESC
**ppdesc
)
1200 START_PROFILE(get_nt_acl
);
1201 result
= posix_get_nt_acl(handle
->conn
, name
, security_info
, ppdesc
);
1202 END_PROFILE(get_nt_acl
);
1206 static NTSTATUS
vfswrap_fset_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, uint32 security_info_sent
, const SEC_DESC
*psd
)
1210 START_PROFILE(fset_nt_acl
);
1211 result
= set_nt_acl(fsp
, security_info_sent
, psd
);
1212 END_PROFILE(fset_nt_acl
);
1216 static int vfswrap_chmod_acl(vfs_handle_struct
*handle
, const char *name
, mode_t mode
)
1224 START_PROFILE(chmod_acl
);
1225 result
= chmod_acl(handle
->conn
, name
, mode
);
1226 END_PROFILE(chmod_acl
);
1231 static int vfswrap_fchmod_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, mode_t mode
)
1239 START_PROFILE(fchmod_acl
);
1240 result
= fchmod_acl(fsp
, mode
);
1241 END_PROFILE(fchmod_acl
);
1246 static int vfswrap_sys_acl_get_entry(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, int entry_id
, SMB_ACL_ENTRY_T
*entry_p
)
1248 return sys_acl_get_entry(theacl
, entry_id
, entry_p
);
1251 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
)
1253 return sys_acl_get_tag_type(entry_d
, tag_type_p
);
1256 static int vfswrap_sys_acl_get_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
, SMB_ACL_PERMSET_T
*permset_p
)
1258 return sys_acl_get_permset(entry_d
, permset_p
);
1261 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
)
1263 return sys_acl_get_qualifier(entry_d
);
1266 static SMB_ACL_T
vfswrap_sys_acl_get_file(vfs_handle_struct
*handle
, const char *path_p
, SMB_ACL_TYPE_T type
)
1268 return sys_acl_get_file(handle
, path_p
, type
);
1271 static SMB_ACL_T
vfswrap_sys_acl_get_fd(vfs_handle_struct
*handle
, files_struct
*fsp
)
1273 return sys_acl_get_fd(handle
, fsp
);
1276 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
)
1278 return sys_acl_clear_perms(permset
);
1281 static int vfswrap_sys_acl_add_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1283 return sys_acl_add_perm(permset
, perm
);
1286 static char * vfswrap_sys_acl_to_text(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, ssize_t
*plen
)
1288 return sys_acl_to_text(theacl
, plen
);
1291 static SMB_ACL_T
vfswrap_sys_acl_init(vfs_handle_struct
*handle
, int count
)
1293 return sys_acl_init(count
);
1296 static int vfswrap_sys_acl_create_entry(vfs_handle_struct
*handle
, SMB_ACL_T
*pacl
, SMB_ACL_ENTRY_T
*pentry
)
1298 return sys_acl_create_entry(pacl
, pentry
);
1301 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_TAG_T tagtype
)
1303 return sys_acl_set_tag_type(entry
, tagtype
);
1306 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, void *qual
)
1308 return sys_acl_set_qualifier(entry
, qual
);
1311 static int vfswrap_sys_acl_set_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_PERMSET_T permset
)
1313 return sys_acl_set_permset(entry
, permset
);
1316 static int vfswrap_sys_acl_valid(vfs_handle_struct
*handle
, SMB_ACL_T theacl
)
1318 return sys_acl_valid(theacl
);
1321 static int vfswrap_sys_acl_set_file(vfs_handle_struct
*handle
, const char *name
, SMB_ACL_TYPE_T acltype
, SMB_ACL_T theacl
)
1323 return sys_acl_set_file(handle
, name
, acltype
, theacl
);
1326 static int vfswrap_sys_acl_set_fd(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_ACL_T theacl
)
1328 return sys_acl_set_fd(handle
, fsp
, theacl
);
1331 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct
*handle
, const char *path
)
1333 return sys_acl_delete_def_file(handle
, path
);
1336 static int vfswrap_sys_acl_get_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1338 return sys_acl_get_perm(permset
, perm
);
1341 static int vfswrap_sys_acl_free_text(vfs_handle_struct
*handle
, char *text
)
1343 return sys_acl_free_text(text
);
1346 static int vfswrap_sys_acl_free_acl(vfs_handle_struct
*handle
, SMB_ACL_T posix_acl
)
1348 return sys_acl_free_acl(posix_acl
);
1351 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct
*handle
, void *qualifier
, SMB_ACL_TAG_T tagtype
)
1353 return sys_acl_free_qualifier(qualifier
, tagtype
);
1356 /****************************************************************
1357 Extended attribute operations.
1358 *****************************************************************/
1360 static ssize_t
vfswrap_getxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1362 return sys_getxattr(path
, name
, value
, size
);
1365 static ssize_t
vfswrap_lgetxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1367 return sys_lgetxattr(path
, name
, value
, size
);
1370 static ssize_t
vfswrap_fgetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
, void *value
, size_t size
)
1372 return sys_fgetxattr(fsp
->fh
->fd
, name
, value
, size
);
1375 static ssize_t
vfswrap_listxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1377 return sys_listxattr(path
, list
, size
);
1380 ssize_t
vfswrap_llistxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1382 return sys_llistxattr(path
, list
, size
);
1385 ssize_t
vfswrap_flistxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, char *list
, size_t size
)
1387 return sys_flistxattr(fsp
->fh
->fd
, list
, size
);
1390 static int vfswrap_removexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1392 return sys_removexattr(path
, name
);
1395 static int vfswrap_lremovexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1397 return sys_lremovexattr(path
, name
);
1400 static int vfswrap_fremovexattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
)
1402 return sys_fremovexattr(fsp
->fh
->fd
, name
);
1405 static int vfswrap_setxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1407 return sys_setxattr(path
, name
, value
, size
, flags
);
1410 static int vfswrap_lsetxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1412 return sys_lsetxattr(path
, name
, value
, size
, flags
);
1415 static int vfswrap_fsetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
, const void *value
, size_t size
, int flags
)
1417 return sys_fsetxattr(fsp
->fh
->fd
, name
, value
, size
, flags
);
1420 static int vfswrap_aio_read(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1422 return sys_aio_read(aiocb
);
1425 static int vfswrap_aio_write(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1427 return sys_aio_write(aiocb
);
1430 static ssize_t
vfswrap_aio_return(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1432 return sys_aio_return(aiocb
);
1435 static int vfswrap_aio_cancel(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1437 return sys_aio_cancel(fsp
->fh
->fd
, aiocb
);
1440 static int vfswrap_aio_error(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1442 return sys_aio_error(aiocb
);
1445 static int vfswrap_aio_fsync(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, int op
, SMB_STRUCT_AIOCB
*aiocb
)
1447 return sys_aio_fsync(op
, aiocb
);
1450 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
)
1452 return sys_aio_suspend(aiocb
, n
, timeout
);
1455 static bool vfswrap_aio_force(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
)
1460 static bool vfswrap_is_offline(struct vfs_handle_struct
*handle
, const char *path
, SMB_STRUCT_STAT
*sbuf
)
1462 if (ISDOT(path
) || ISDOTDOT(path
)) {
1466 if (!lp_dmapi_support(SNUM(handle
->conn
)) || !dmapi_have_session()) {
1467 #if defined(ENOTSUP)
1473 return (dmapi_file_flags(path
) & FILE_ATTRIBUTE_OFFLINE
) != 0;
1476 static int vfswrap_set_offline(struct vfs_handle_struct
*handle
, const char *path
)
1478 /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1479 #if defined(ENOTSUP)
1485 static vfs_op_tuple vfs_default_ops
[] = {
1487 /* Disk operations */
1489 {SMB_VFS_OP(vfswrap_connect
), SMB_VFS_OP_CONNECT
,
1490 SMB_VFS_LAYER_OPAQUE
},
1491 {SMB_VFS_OP(vfswrap_disconnect
), SMB_VFS_OP_DISCONNECT
,
1492 SMB_VFS_LAYER_OPAQUE
},
1493 {SMB_VFS_OP(vfswrap_disk_free
), SMB_VFS_OP_DISK_FREE
,
1494 SMB_VFS_LAYER_OPAQUE
},
1495 {SMB_VFS_OP(vfswrap_get_quota
), SMB_VFS_OP_GET_QUOTA
,
1496 SMB_VFS_LAYER_OPAQUE
},
1497 {SMB_VFS_OP(vfswrap_set_quota
), SMB_VFS_OP_SET_QUOTA
,
1498 SMB_VFS_LAYER_OPAQUE
},
1499 {SMB_VFS_OP(vfswrap_get_shadow_copy_data
), SMB_VFS_OP_GET_SHADOW_COPY_DATA
,
1500 SMB_VFS_LAYER_OPAQUE
},
1501 {SMB_VFS_OP(vfswrap_statvfs
), SMB_VFS_OP_STATVFS
,
1502 SMB_VFS_LAYER_OPAQUE
},
1503 {SMB_VFS_OP(vfswrap_fs_capabilities
), SMB_VFS_OP_FS_CAPABILITIES
,
1504 SMB_VFS_LAYER_OPAQUE
},
1506 /* Directory operations */
1508 {SMB_VFS_OP(vfswrap_opendir
), SMB_VFS_OP_OPENDIR
,
1509 SMB_VFS_LAYER_OPAQUE
},
1510 {SMB_VFS_OP(vfswrap_readdir
), SMB_VFS_OP_READDIR
,
1511 SMB_VFS_LAYER_OPAQUE
},
1512 {SMB_VFS_OP(vfswrap_seekdir
), SMB_VFS_OP_SEEKDIR
,
1513 SMB_VFS_LAYER_OPAQUE
},
1514 {SMB_VFS_OP(vfswrap_telldir
), SMB_VFS_OP_TELLDIR
,
1515 SMB_VFS_LAYER_OPAQUE
},
1516 {SMB_VFS_OP(vfswrap_rewinddir
), SMB_VFS_OP_REWINDDIR
,
1517 SMB_VFS_LAYER_OPAQUE
},
1518 {SMB_VFS_OP(vfswrap_mkdir
), SMB_VFS_OP_MKDIR
,
1519 SMB_VFS_LAYER_OPAQUE
},
1520 {SMB_VFS_OP(vfswrap_rmdir
), SMB_VFS_OP_RMDIR
,
1521 SMB_VFS_LAYER_OPAQUE
},
1522 {SMB_VFS_OP(vfswrap_closedir
), SMB_VFS_OP_CLOSEDIR
,
1523 SMB_VFS_LAYER_OPAQUE
},
1524 {SMB_VFS_OP(vfswrap_init_search_op
), SMB_VFS_OP_INIT_SEARCH_OP
,
1525 SMB_VFS_LAYER_OPAQUE
},
1527 /* File operations */
1529 {SMB_VFS_OP(vfswrap_open
), SMB_VFS_OP_OPEN
,
1530 SMB_VFS_LAYER_OPAQUE
},
1531 {SMB_VFS_OP(vfswrap_create_file
), SMB_VFS_OP_CREATE_FILE
,
1532 SMB_VFS_LAYER_OPAQUE
},
1533 {SMB_VFS_OP(vfswrap_close
), SMB_VFS_OP_CLOSE
,
1534 SMB_VFS_LAYER_OPAQUE
},
1535 {SMB_VFS_OP(vfswrap_read
), SMB_VFS_OP_READ
,
1536 SMB_VFS_LAYER_OPAQUE
},
1537 {SMB_VFS_OP(vfswrap_pread
), SMB_VFS_OP_PREAD
,
1538 SMB_VFS_LAYER_OPAQUE
},
1539 {SMB_VFS_OP(vfswrap_write
), SMB_VFS_OP_WRITE
,
1540 SMB_VFS_LAYER_OPAQUE
},
1541 {SMB_VFS_OP(vfswrap_pwrite
), SMB_VFS_OP_PWRITE
,
1542 SMB_VFS_LAYER_OPAQUE
},
1543 {SMB_VFS_OP(vfswrap_lseek
), SMB_VFS_OP_LSEEK
,
1544 SMB_VFS_LAYER_OPAQUE
},
1545 {SMB_VFS_OP(vfswrap_sendfile
), SMB_VFS_OP_SENDFILE
,
1546 SMB_VFS_LAYER_OPAQUE
},
1547 {SMB_VFS_OP(vfswrap_recvfile
), SMB_VFS_OP_RECVFILE
,
1548 SMB_VFS_LAYER_OPAQUE
},
1549 {SMB_VFS_OP(vfswrap_rename
), SMB_VFS_OP_RENAME
,
1550 SMB_VFS_LAYER_OPAQUE
},
1551 {SMB_VFS_OP(vfswrap_fsync
), SMB_VFS_OP_FSYNC
,
1552 SMB_VFS_LAYER_OPAQUE
},
1553 {SMB_VFS_OP(vfswrap_stat
), SMB_VFS_OP_STAT
,
1554 SMB_VFS_LAYER_OPAQUE
},
1555 {SMB_VFS_OP(vfswrap_fstat
), SMB_VFS_OP_FSTAT
,
1556 SMB_VFS_LAYER_OPAQUE
},
1557 {SMB_VFS_OP(vfswrap_lstat
), SMB_VFS_OP_LSTAT
,
1558 SMB_VFS_LAYER_OPAQUE
},
1559 {SMB_VFS_OP(vfswrap_get_alloc_size
), SMB_VFS_OP_GET_ALLOC_SIZE
,
1560 SMB_VFS_LAYER_OPAQUE
},
1561 {SMB_VFS_OP(vfswrap_unlink
), SMB_VFS_OP_UNLINK
,
1562 SMB_VFS_LAYER_OPAQUE
},
1563 {SMB_VFS_OP(vfswrap_chmod
), SMB_VFS_OP_CHMOD
,
1564 SMB_VFS_LAYER_OPAQUE
},
1565 {SMB_VFS_OP(vfswrap_fchmod
), SMB_VFS_OP_FCHMOD
,
1566 SMB_VFS_LAYER_OPAQUE
},
1567 {SMB_VFS_OP(vfswrap_chown
), SMB_VFS_OP_CHOWN
,
1568 SMB_VFS_LAYER_OPAQUE
},
1569 {SMB_VFS_OP(vfswrap_fchown
), SMB_VFS_OP_FCHOWN
,
1570 SMB_VFS_LAYER_OPAQUE
},
1571 {SMB_VFS_OP(vfswrap_lchown
), SMB_VFS_OP_LCHOWN
,
1572 SMB_VFS_LAYER_OPAQUE
},
1573 {SMB_VFS_OP(vfswrap_chdir
), SMB_VFS_OP_CHDIR
,
1574 SMB_VFS_LAYER_OPAQUE
},
1575 {SMB_VFS_OP(vfswrap_getwd
), SMB_VFS_OP_GETWD
,
1576 SMB_VFS_LAYER_OPAQUE
},
1577 {SMB_VFS_OP(vfswrap_ntimes
), SMB_VFS_OP_NTIMES
,
1578 SMB_VFS_LAYER_OPAQUE
},
1579 {SMB_VFS_OP(vfswrap_ftruncate
), SMB_VFS_OP_FTRUNCATE
,
1580 SMB_VFS_LAYER_OPAQUE
},
1581 {SMB_VFS_OP(vfswrap_lock
), SMB_VFS_OP_LOCK
,
1582 SMB_VFS_LAYER_OPAQUE
},
1583 {SMB_VFS_OP(vfswrap_kernel_flock
), SMB_VFS_OP_KERNEL_FLOCK
,
1584 SMB_VFS_LAYER_OPAQUE
},
1585 {SMB_VFS_OP(vfswrap_linux_setlease
), SMB_VFS_OP_LINUX_SETLEASE
,
1586 SMB_VFS_LAYER_OPAQUE
},
1587 {SMB_VFS_OP(vfswrap_getlock
), SMB_VFS_OP_GETLOCK
,
1588 SMB_VFS_LAYER_OPAQUE
},
1589 {SMB_VFS_OP(vfswrap_symlink
), SMB_VFS_OP_SYMLINK
,
1590 SMB_VFS_LAYER_OPAQUE
},
1591 {SMB_VFS_OP(vfswrap_readlink
), SMB_VFS_OP_READLINK
,
1592 SMB_VFS_LAYER_OPAQUE
},
1593 {SMB_VFS_OP(vfswrap_link
), SMB_VFS_OP_LINK
,
1594 SMB_VFS_LAYER_OPAQUE
},
1595 {SMB_VFS_OP(vfswrap_mknod
), SMB_VFS_OP_MKNOD
,
1596 SMB_VFS_LAYER_OPAQUE
},
1597 {SMB_VFS_OP(vfswrap_realpath
), SMB_VFS_OP_REALPATH
,
1598 SMB_VFS_LAYER_OPAQUE
},
1599 {SMB_VFS_OP(vfswrap_notify_watch
), SMB_VFS_OP_NOTIFY_WATCH
,
1600 SMB_VFS_LAYER_OPAQUE
},
1601 {SMB_VFS_OP(vfswrap_chflags
), SMB_VFS_OP_CHFLAGS
,
1602 SMB_VFS_LAYER_OPAQUE
},
1603 {SMB_VFS_OP(vfswrap_file_id_create
), SMB_VFS_OP_FILE_ID_CREATE
,
1604 SMB_VFS_LAYER_OPAQUE
},
1605 {SMB_VFS_OP(vfswrap_streaminfo
), SMB_VFS_OP_STREAMINFO
,
1606 SMB_VFS_LAYER_OPAQUE
},
1607 {SMB_VFS_OP(vfswrap_get_real_filename
), SMB_VFS_OP_GET_REAL_FILENAME
,
1608 SMB_VFS_LAYER_OPAQUE
},
1609 {SMB_VFS_OP(vfswrap_brl_lock_windows
), SMB_VFS_OP_BRL_LOCK_WINDOWS
,
1610 SMB_VFS_LAYER_OPAQUE
},
1611 {SMB_VFS_OP(vfswrap_brl_unlock_windows
),SMB_VFS_OP_BRL_UNLOCK_WINDOWS
,
1612 SMB_VFS_LAYER_OPAQUE
},
1613 {SMB_VFS_OP(vfswrap_brl_cancel_windows
),SMB_VFS_OP_BRL_CANCEL_WINDOWS
,
1614 SMB_VFS_LAYER_OPAQUE
},
1615 {SMB_VFS_OP(vfswrap_strict_lock
), SMB_VFS_OP_STRICT_LOCK
,
1616 SMB_VFS_LAYER_OPAQUE
},
1617 {SMB_VFS_OP(vfswrap_strict_unlock
), SMB_VFS_OP_STRICT_UNLOCK
,
1618 SMB_VFS_LAYER_OPAQUE
},
1620 /* NT ACL operations. */
1622 {SMB_VFS_OP(vfswrap_fget_nt_acl
), SMB_VFS_OP_FGET_NT_ACL
,
1623 SMB_VFS_LAYER_OPAQUE
},
1624 {SMB_VFS_OP(vfswrap_get_nt_acl
), SMB_VFS_OP_GET_NT_ACL
,
1625 SMB_VFS_LAYER_OPAQUE
},
1626 {SMB_VFS_OP(vfswrap_fset_nt_acl
), SMB_VFS_OP_FSET_NT_ACL
,
1627 SMB_VFS_LAYER_OPAQUE
},
1629 /* POSIX ACL operations. */
1631 {SMB_VFS_OP(vfswrap_chmod_acl
), SMB_VFS_OP_CHMOD_ACL
,
1632 SMB_VFS_LAYER_OPAQUE
},
1633 {SMB_VFS_OP(vfswrap_fchmod_acl
), SMB_VFS_OP_FCHMOD_ACL
,
1634 SMB_VFS_LAYER_OPAQUE
},
1635 {SMB_VFS_OP(vfswrap_sys_acl_get_entry
), SMB_VFS_OP_SYS_ACL_GET_ENTRY
,
1636 SMB_VFS_LAYER_OPAQUE
},
1637 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type
), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE
,
1638 SMB_VFS_LAYER_OPAQUE
},
1639 {SMB_VFS_OP(vfswrap_sys_acl_get_permset
), SMB_VFS_OP_SYS_ACL_GET_PERMSET
,
1640 SMB_VFS_LAYER_OPAQUE
},
1641 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier
), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER
,
1642 SMB_VFS_LAYER_OPAQUE
},
1643 {SMB_VFS_OP(vfswrap_sys_acl_get_file
), SMB_VFS_OP_SYS_ACL_GET_FILE
,
1644 SMB_VFS_LAYER_OPAQUE
},
1645 {SMB_VFS_OP(vfswrap_sys_acl_get_fd
), SMB_VFS_OP_SYS_ACL_GET_FD
,
1646 SMB_VFS_LAYER_OPAQUE
},
1647 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms
), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS
,
1648 SMB_VFS_LAYER_OPAQUE
},
1649 {SMB_VFS_OP(vfswrap_sys_acl_add_perm
), SMB_VFS_OP_SYS_ACL_ADD_PERM
,
1650 SMB_VFS_LAYER_OPAQUE
},
1651 {SMB_VFS_OP(vfswrap_sys_acl_to_text
), SMB_VFS_OP_SYS_ACL_TO_TEXT
,
1652 SMB_VFS_LAYER_OPAQUE
},
1653 {SMB_VFS_OP(vfswrap_sys_acl_init
), SMB_VFS_OP_SYS_ACL_INIT
,
1654 SMB_VFS_LAYER_OPAQUE
},
1655 {SMB_VFS_OP(vfswrap_sys_acl_create_entry
), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY
,
1656 SMB_VFS_LAYER_OPAQUE
},
1657 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type
), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE
,
1658 SMB_VFS_LAYER_OPAQUE
},
1659 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier
), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER
,
1660 SMB_VFS_LAYER_OPAQUE
},
1661 {SMB_VFS_OP(vfswrap_sys_acl_set_permset
), SMB_VFS_OP_SYS_ACL_SET_PERMSET
,
1662 SMB_VFS_LAYER_OPAQUE
},
1663 {SMB_VFS_OP(vfswrap_sys_acl_valid
), SMB_VFS_OP_SYS_ACL_VALID
,
1664 SMB_VFS_LAYER_OPAQUE
},
1665 {SMB_VFS_OP(vfswrap_sys_acl_set_file
), SMB_VFS_OP_SYS_ACL_SET_FILE
,
1666 SMB_VFS_LAYER_OPAQUE
},
1667 {SMB_VFS_OP(vfswrap_sys_acl_set_fd
), SMB_VFS_OP_SYS_ACL_SET_FD
,
1668 SMB_VFS_LAYER_OPAQUE
},
1669 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file
), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE
,
1670 SMB_VFS_LAYER_OPAQUE
},
1671 {SMB_VFS_OP(vfswrap_sys_acl_get_perm
), SMB_VFS_OP_SYS_ACL_GET_PERM
,
1672 SMB_VFS_LAYER_OPAQUE
},
1673 {SMB_VFS_OP(vfswrap_sys_acl_free_text
), SMB_VFS_OP_SYS_ACL_FREE_TEXT
,
1674 SMB_VFS_LAYER_OPAQUE
},
1675 {SMB_VFS_OP(vfswrap_sys_acl_free_acl
), SMB_VFS_OP_SYS_ACL_FREE_ACL
,
1676 SMB_VFS_LAYER_OPAQUE
},
1677 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier
), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER
,
1678 SMB_VFS_LAYER_OPAQUE
},
1680 /* EA operations. */
1682 {SMB_VFS_OP(vfswrap_getxattr
), SMB_VFS_OP_GETXATTR
,
1683 SMB_VFS_LAYER_OPAQUE
},
1684 {SMB_VFS_OP(vfswrap_lgetxattr
), SMB_VFS_OP_LGETXATTR
,
1685 SMB_VFS_LAYER_OPAQUE
},
1686 {SMB_VFS_OP(vfswrap_fgetxattr
), SMB_VFS_OP_FGETXATTR
,
1687 SMB_VFS_LAYER_OPAQUE
},
1688 {SMB_VFS_OP(vfswrap_listxattr
), SMB_VFS_OP_LISTXATTR
,
1689 SMB_VFS_LAYER_OPAQUE
},
1690 {SMB_VFS_OP(vfswrap_llistxattr
), SMB_VFS_OP_LLISTXATTR
,
1691 SMB_VFS_LAYER_OPAQUE
},
1692 {SMB_VFS_OP(vfswrap_flistxattr
), SMB_VFS_OP_FLISTXATTR
,
1693 SMB_VFS_LAYER_OPAQUE
},
1694 {SMB_VFS_OP(vfswrap_removexattr
), SMB_VFS_OP_REMOVEXATTR
,
1695 SMB_VFS_LAYER_OPAQUE
},
1696 {SMB_VFS_OP(vfswrap_lremovexattr
), SMB_VFS_OP_LREMOVEXATTR
,
1697 SMB_VFS_LAYER_OPAQUE
},
1698 {SMB_VFS_OP(vfswrap_fremovexattr
), SMB_VFS_OP_FREMOVEXATTR
,
1699 SMB_VFS_LAYER_OPAQUE
},
1700 {SMB_VFS_OP(vfswrap_setxattr
), SMB_VFS_OP_SETXATTR
,
1701 SMB_VFS_LAYER_OPAQUE
},
1702 {SMB_VFS_OP(vfswrap_lsetxattr
), SMB_VFS_OP_LSETXATTR
,
1703 SMB_VFS_LAYER_OPAQUE
},
1704 {SMB_VFS_OP(vfswrap_fsetxattr
), SMB_VFS_OP_FSETXATTR
,
1705 SMB_VFS_LAYER_OPAQUE
},
1707 {SMB_VFS_OP(vfswrap_aio_read
), SMB_VFS_OP_AIO_READ
,
1708 SMB_VFS_LAYER_OPAQUE
},
1709 {SMB_VFS_OP(vfswrap_aio_write
), SMB_VFS_OP_AIO_WRITE
,
1710 SMB_VFS_LAYER_OPAQUE
},
1711 {SMB_VFS_OP(vfswrap_aio_return
), SMB_VFS_OP_AIO_RETURN
,
1712 SMB_VFS_LAYER_OPAQUE
},
1713 {SMB_VFS_OP(vfswrap_aio_cancel
), SMB_VFS_OP_AIO_CANCEL
,
1714 SMB_VFS_LAYER_OPAQUE
},
1715 {SMB_VFS_OP(vfswrap_aio_error
), SMB_VFS_OP_AIO_ERROR
,
1716 SMB_VFS_LAYER_OPAQUE
},
1717 {SMB_VFS_OP(vfswrap_aio_fsync
), SMB_VFS_OP_AIO_FSYNC
,
1718 SMB_VFS_LAYER_OPAQUE
},
1719 {SMB_VFS_OP(vfswrap_aio_suspend
),SMB_VFS_OP_AIO_SUSPEND
,
1720 SMB_VFS_LAYER_OPAQUE
},
1722 {SMB_VFS_OP(vfswrap_aio_force
), SMB_VFS_OP_AIO_FORCE
,
1723 SMB_VFS_LAYER_OPAQUE
},
1725 {SMB_VFS_OP(vfswrap_is_offline
),SMB_VFS_OP_IS_OFFLINE
,
1726 SMB_VFS_LAYER_OPAQUE
},
1727 {SMB_VFS_OP(vfswrap_set_offline
),SMB_VFS_OP_SET_OFFLINE
,
1728 SMB_VFS_LAYER_OPAQUE
},
1730 /* Finish VFS operations definition */
1732 {SMB_VFS_OP(NULL
), SMB_VFS_OP_NOOP
,
1736 NTSTATUS
vfs_default_init(void);
1737 NTSTATUS
vfs_default_init(void)
1739 unsigned int needed
= SMB_VFS_OP_LAST
+ 1; /* convert from index to count */
1741 if (ARRAY_SIZE(vfs_default_ops
) != needed
) {
1742 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1743 DEFAULT_VFS_MODULE_NAME
, (unsigned int)ARRAY_SIZE(vfs_default_ops
), needed
));
1744 smb_panic("operation(s) missing from default VFS module");
1747 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION
,
1748 DEFAULT_VFS_MODULE_NAME
, vfs_default_ops
);