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
,
218 struct smb_filename
*smb_fname
,
219 files_struct
*fsp
, int flags
, mode_t mode
)
225 START_PROFILE(syscall_open
);
228 * XXX: Should an error be returned if there is a stream rather than
229 * trying to open a filename with a ':'?
231 status
= get_full_smb_filename(talloc_tos(), smb_fname
,
233 if (!NT_STATUS_IS_OK(status
)) {
234 errno
= map_errno_from_nt_status(status
);
238 result
= sys_open(fname
, flags
, mode
);
242 END_PROFILE(syscall_open
);
246 static NTSTATUS
vfswrap_create_file(vfs_handle_struct
*handle
,
247 struct smb_request
*req
,
248 uint16_t root_dir_fid
,
249 struct smb_filename
*smb_fname
,
250 uint32_t access_mask
,
251 uint32_t share_access
,
252 uint32_t create_disposition
,
253 uint32_t create_options
,
254 uint32_t file_attributes
,
255 uint32_t oplock_request
,
256 uint64_t allocation_size
,
257 struct security_descriptor
*sd
,
258 struct ea_list
*ea_list
,
259 files_struct
**result
,
262 return create_file_default(handle
->conn
, req
, root_dir_fid
, smb_fname
,
263 access_mask
, share_access
,
264 create_disposition
, create_options
,
265 file_attributes
, oplock_request
,
266 allocation_size
, sd
, ea_list
, result
,
270 static int vfswrap_close(vfs_handle_struct
*handle
, files_struct
*fsp
)
274 START_PROFILE(syscall_close
);
275 result
= fd_close_posix(fsp
);
276 END_PROFILE(syscall_close
);
280 static ssize_t
vfswrap_read(vfs_handle_struct
*handle
, files_struct
*fsp
, void *data
, size_t n
)
284 START_PROFILE_BYTES(syscall_read
, n
);
285 result
= sys_read(fsp
->fh
->fd
, data
, n
);
286 END_PROFILE(syscall_read
);
290 static ssize_t
vfswrap_pread(vfs_handle_struct
*handle
, files_struct
*fsp
, void *data
,
291 size_t n
, SMB_OFF_T offset
)
295 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
296 START_PROFILE_BYTES(syscall_pread
, n
);
297 result
= sys_pread(fsp
->fh
->fd
, data
, n
, offset
);
298 END_PROFILE(syscall_pread
);
300 if (result
== -1 && errno
== ESPIPE
) {
301 /* Maintain the fiction that pipes can be seeked (sought?) on. */
302 result
= SMB_VFS_READ(fsp
, data
, n
);
306 #else /* HAVE_PREAD */
310 curr
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
311 if (curr
== -1 && errno
== ESPIPE
) {
312 /* Maintain the fiction that pipes can be seeked (sought?) on. */
313 result
= SMB_VFS_READ(fsp
, data
, n
);
318 if (SMB_VFS_LSEEK(fsp
, offset
, SEEK_SET
) == -1) {
323 result
= SMB_VFS_READ(fsp
, data
, n
);
326 SMB_VFS_LSEEK(fsp
, curr
, SEEK_SET
);
329 #endif /* HAVE_PREAD */
334 static ssize_t
vfswrap_write(vfs_handle_struct
*handle
, files_struct
*fsp
, const void *data
, size_t n
)
338 START_PROFILE_BYTES(syscall_write
, n
);
339 result
= sys_write(fsp
->fh
->fd
, data
, n
);
340 END_PROFILE(syscall_write
);
344 static ssize_t
vfswrap_pwrite(vfs_handle_struct
*handle
, files_struct
*fsp
, const void *data
,
345 size_t n
, SMB_OFF_T offset
)
349 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
350 START_PROFILE_BYTES(syscall_pwrite
, n
);
351 result
= sys_pwrite(fsp
->fh
->fd
, data
, n
, offset
);
352 END_PROFILE(syscall_pwrite
);
354 if (result
== -1 && errno
== ESPIPE
) {
355 /* Maintain the fiction that pipes can be sought on. */
356 result
= SMB_VFS_WRITE(fsp
, data
, n
);
359 #else /* HAVE_PWRITE */
363 curr
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
368 if (SMB_VFS_LSEEK(fsp
, offset
, SEEK_SET
) == -1) {
372 result
= SMB_VFS_WRITE(fsp
, data
, n
);
375 SMB_VFS_LSEEK(fsp
, curr
, SEEK_SET
);
378 #endif /* HAVE_PWRITE */
383 static SMB_OFF_T
vfswrap_lseek(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T offset
, int whence
)
385 SMB_OFF_T result
= 0;
387 START_PROFILE(syscall_lseek
);
389 /* Cope with 'stat' file opens. */
390 if (fsp
->fh
->fd
!= -1)
391 result
= sys_lseek(fsp
->fh
->fd
, offset
, whence
);
394 * We want to maintain the fiction that we can seek
395 * on a fifo for file system purposes. This allows
396 * people to set up UNIX fifo's that feed data to Windows
400 if((result
== -1) && (errno
== ESPIPE
)) {
405 END_PROFILE(syscall_lseek
);
409 static ssize_t
vfswrap_sendfile(vfs_handle_struct
*handle
, int tofd
, files_struct
*fromfsp
, const DATA_BLOB
*hdr
,
410 SMB_OFF_T offset
, size_t n
)
414 START_PROFILE_BYTES(syscall_sendfile
, n
);
415 result
= sys_sendfile(tofd
, fromfsp
->fh
->fd
, hdr
, offset
, n
);
416 END_PROFILE(syscall_sendfile
);
420 static ssize_t
vfswrap_recvfile(vfs_handle_struct
*handle
,
428 START_PROFILE_BYTES(syscall_recvfile
, n
);
429 result
= sys_recvfile(fromfd
, tofsp
->fh
->fd
, offset
, n
);
430 END_PROFILE(syscall_recvfile
);
434 /*********************************************************
435 For rename across filesystems Patch from Warren Birnbaum
436 <warrenb@hpcvscdp.cv.hp.com>
437 **********************************************************/
439 static int copy_reg(const char *source
, const char *dest
)
441 SMB_STRUCT_STAT source_stats
;
446 if (sys_lstat (source
, &source_stats
) == -1)
449 if (!S_ISREG (source_stats
.st_ex_mode
))
452 if((ifd
= sys_open (source
, O_RDONLY
, 0)) < 0)
455 if (unlink (dest
) && errno
!= ENOENT
)
459 if((ofd
= sys_open (dest
, O_WRONLY
| O_CREAT
| O_TRUNC
| O_NOFOLLOW
, 0600)) < 0 )
461 if((ofd
= sys_open (dest
, O_WRONLY
| O_CREAT
| O_TRUNC
, 0600)) < 0 )
465 if (transfer_file(ifd
, ofd
, (size_t)-1) == -1)
469 * Try to preserve ownership. For non-root it might fail, but that's ok.
470 * But root probably wants to know, e.g. if NFS disallows it.
474 if ((fchown(ofd
, source_stats
.st_ex_uid
, source_stats
.st_ex_gid
) == -1) && (errno
!= EPERM
))
476 if ((chown(dest
, source_stats
.st_ex_uid
, source_stats
.st_ex_gid
) == -1) && (errno
!= EPERM
))
481 * fchown turns off set[ug]id bits for non-root,
482 * so do the chmod last.
485 #if defined(HAVE_FCHMOD)
486 if (fchmod (ofd
, source_stats
.st_ex_mode
& 07777))
488 if (chmod (dest
, source_stats
.st_ex_mode
& 07777))
492 if (close (ifd
) == -1)
495 if (close (ofd
) == -1)
498 /* Try to copy the old file's modtime and access time. */
502 tv
.actime
= convert_timespec_to_time_t(source_stats
.st_ex_atime
);
503 tv
.modtime
= convert_timespec_to_time_t(source_stats
.st_ex_mtime
);
507 if (unlink (source
) == -1)
523 static int vfswrap_rename(vfs_handle_struct
*handle
,
524 const struct smb_filename
*smb_fname_src
,
525 const struct smb_filename
*smb_fname_dst
)
529 START_PROFILE(syscall_rename
);
531 if (smb_fname_src
->stream_name
|| smb_fname_dst
->stream_name
) {
536 result
= rename(smb_fname_src
->base_name
, smb_fname_dst
->base_name
);
537 if ((result
== -1) && (errno
== EXDEV
)) {
538 /* Rename across filesystems needed. */
539 result
= copy_reg(smb_fname_src
->base_name
,
540 smb_fname_dst
->base_name
);
544 END_PROFILE(syscall_rename
);
548 static int vfswrap_fsync(vfs_handle_struct
*handle
, files_struct
*fsp
)
553 START_PROFILE(syscall_fsync
);
554 result
= fsync(fsp
->fh
->fd
);
555 END_PROFILE(syscall_fsync
);
562 static int vfswrap_stat(vfs_handle_struct
*handle
,
563 struct smb_filename
*smb_fname
)
569 START_PROFILE(syscall_stat
);
571 status
= get_full_smb_filename(talloc_tos(), smb_fname
,
573 if (!NT_STATUS_IS_OK(status
)) {
574 errno
= map_errno_from_nt_status(status
);
578 result
= sys_stat(fname
, &smb_fname
->st
);
582 END_PROFILE(syscall_stat
);
586 static int vfswrap_fstat(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_STRUCT_STAT
*sbuf
)
590 START_PROFILE(syscall_fstat
);
591 result
= sys_fstat(fsp
->fh
->fd
, sbuf
);
592 END_PROFILE(syscall_fstat
);
596 static int vfswrap_lstat(vfs_handle_struct
*handle
,
597 struct smb_filename
*smb_fname
)
603 START_PROFILE(syscall_lstat
);
605 status
= get_full_smb_filename(talloc_tos(), smb_fname
,
607 if (!NT_STATUS_IS_OK(status
)) {
608 errno
= map_errno_from_nt_status(status
);
612 result
= sys_lstat(fname
, &smb_fname
->st
);
616 END_PROFILE(syscall_lstat
);
620 /********************************************************************
621 Given a stat buffer return the allocated size on disk, taking into
622 account sparse files.
623 ********************************************************************/
624 static uint64_t vfswrap_get_alloc_size(vfs_handle_struct
*handle
,
625 struct files_struct
*fsp
,
626 const SMB_STRUCT_STAT
*sbuf
)
630 START_PROFILE(syscall_get_alloc_size
);
632 if(S_ISDIR(sbuf
->st_ex_mode
)) {
637 #if defined(HAVE_STAT_ST_BLOCKS) && defined(STAT_ST_BLOCKSIZE)
638 result
= (uint64_t)STAT_ST_BLOCKSIZE
* (uint64_t)sbuf
->st_ex_blocks
;
640 result
= get_file_size_stat(sbuf
);
643 if (fsp
&& fsp
->initial_allocation_size
)
644 result
= MAX(result
,fsp
->initial_allocation_size
);
646 result
= smb_roundup(handle
->conn
, result
);
649 END_PROFILE(syscall_get_alloc_size
);
653 static int vfswrap_unlink(vfs_handle_struct
*handle
,
654 const struct smb_filename
*smb_fname
)
658 START_PROFILE(syscall_unlink
);
660 if (smb_fname
->stream_name
) {
664 result
= unlink(smb_fname
->base_name
);
667 END_PROFILE(syscall_unlink
);
671 static int vfswrap_chmod(vfs_handle_struct
*handle
, const char *path
, mode_t mode
)
675 START_PROFILE(syscall_chmod
);
678 * We need to do this due to the fact that the default POSIX ACL
679 * chmod modifies the ACL *mask* for the group owner, not the
680 * group owner bits directly. JRA.
685 int saved_errno
= errno
; /* We might get ENOSYS */
686 if ((result
= SMB_VFS_CHMOD_ACL(handle
->conn
, path
, mode
)) == 0) {
687 END_PROFILE(syscall_chmod
);
690 /* Error - return the old errno. */
694 result
= chmod(path
, mode
);
695 END_PROFILE(syscall_chmod
);
699 static int vfswrap_fchmod(vfs_handle_struct
*handle
, files_struct
*fsp
, mode_t mode
)
703 START_PROFILE(syscall_fchmod
);
706 * We need to do this due to the fact that the default POSIX ACL
707 * chmod modifies the ACL *mask* for the group owner, not the
708 * group owner bits directly. JRA.
712 int saved_errno
= errno
; /* We might get ENOSYS */
713 if ((result
= SMB_VFS_FCHMOD_ACL(fsp
, mode
)) == 0) {
714 END_PROFILE(syscall_fchmod
);
717 /* Error - return the old errno. */
721 #if defined(HAVE_FCHMOD)
722 result
= fchmod(fsp
->fh
->fd
, mode
);
728 END_PROFILE(syscall_fchmod
);
732 static int vfswrap_chown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
736 START_PROFILE(syscall_chown
);
737 result
= chown(path
, uid
, gid
);
738 END_PROFILE(syscall_chown
);
742 static int vfswrap_fchown(vfs_handle_struct
*handle
, files_struct
*fsp
, uid_t uid
, gid_t gid
)
747 START_PROFILE(syscall_fchown
);
748 result
= fchown(fsp
->fh
->fd
, uid
, gid
);
749 END_PROFILE(syscall_fchown
);
757 static int vfswrap_lchown(vfs_handle_struct
*handle
, const char *path
, uid_t uid
, gid_t gid
)
761 START_PROFILE(syscall_lchown
);
762 result
= lchown(path
, uid
, gid
);
763 END_PROFILE(syscall_lchown
);
767 static int vfswrap_chdir(vfs_handle_struct
*handle
, const char *path
)
771 START_PROFILE(syscall_chdir
);
772 result
= chdir(path
);
773 END_PROFILE(syscall_chdir
);
777 static char *vfswrap_getwd(vfs_handle_struct
*handle
, char *path
)
781 START_PROFILE(syscall_getwd
);
782 result
= sys_getwd(path
);
783 END_PROFILE(syscall_getwd
);
787 /*********************************************************************
788 nsec timestamp resolution call. Convert down to whatever the underlying
790 **********************************************************************/
792 static int vfswrap_ntimes(vfs_handle_struct
*handle
,
793 const struct smb_filename
*smb_fname
,
794 struct smb_file_time
*ft
)
798 START_PROFILE(syscall_ntimes
);
800 if (smb_fname
->stream_name
) {
805 #if defined(HAVE_UTIMES)
807 struct timeval tv
[2];
808 tv
[0] = convert_timespec_to_timeval(ft
->atime
);
809 tv
[1] = convert_timespec_to_timeval(ft
->mtime
);
810 result
= utimes(smb_fname
->base_name
, tv
);
812 result
= utimes(smb_fname
->base_name
, NULL
);
814 #elif defined(HAVE_UTIME)
816 struct utimbuf times
;
817 times
.actime
= convert_timespec_to_time_t(ft
->atime
);
818 times
.modtime
= convert_timespec_to_time_t(ft
->mtime
);
819 result
= utime(smb_fname
->base_name
, ×
);
821 result
= utime(smb_fname
->base_name
, NULL
);
828 END_PROFILE(syscall_ntimes
);
832 /*********************************************************************
833 A version of ftruncate that will write the space on disk if strict
835 **********************************************************************/
837 static int strict_allocate_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T len
)
840 SMB_OFF_T currpos
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
841 unsigned char zero_space
[4096];
842 SMB_OFF_T space_to_write
;
847 if (SMB_VFS_FSTAT(fsp
, &st
) == -1)
850 space_to_write
= len
- st
.st_ex_size
;
853 if (S_ISFIFO(st
.st_ex_mode
))
857 if (st
.st_ex_size
== len
)
860 /* Shrink - just ftruncate. */
861 if (st
.st_ex_size
> len
)
862 return sys_ftruncate(fsp
->fh
->fd
, len
);
864 /* available disk space is enough or not? */
865 if (lp_strict_allocate(SNUM(fsp
->conn
))){
866 uint64_t space_avail
;
867 uint64_t bsize
,dfree
,dsize
;
869 space_avail
= get_dfree_info(fsp
->conn
,fsp
->fsp_name
,false,&bsize
,&dfree
,&dsize
);
870 /* space_avail is 1k blocks */
871 if (space_avail
== (uint64_t)-1 ||
872 ((uint64_t)space_to_write
/1024 > space_avail
) ) {
878 /* Write out the real space on disk. */
879 if (SMB_VFS_LSEEK(fsp
, st
.st_ex_size
, SEEK_SET
) != st
.st_ex_size
)
882 space_to_write
= len
- st
.st_ex_size
;
884 memset(zero_space
, '\0', sizeof(zero_space
));
885 while ( space_to_write
> 0) {
887 SMB_OFF_T current_len_to_write
= MIN(sizeof(zero_space
),space_to_write
);
889 retlen
= SMB_VFS_WRITE(fsp
,(char *)zero_space
,current_len_to_write
);
893 space_to_write
-= retlen
;
896 /* Seek to where we were */
897 if (SMB_VFS_LSEEK(fsp
, currpos
, SEEK_SET
) != currpos
)
903 static int vfswrap_ftruncate(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T len
)
910 START_PROFILE(syscall_ftruncate
);
912 if (lp_strict_allocate(SNUM(fsp
->conn
))) {
913 result
= strict_allocate_ftruncate(handle
, fsp
, len
);
914 END_PROFILE(syscall_ftruncate
);
918 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
919 sys_ftruncate if the system supports it. Then I discovered that
920 you can have some filesystems that support ftruncate
921 expansion and some that don't! On Linux fat can't do
922 ftruncate extend but ext2 can. */
924 result
= sys_ftruncate(fsp
->fh
->fd
, len
);
928 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
929 extend a file with ftruncate. Provide alternate implementation
931 currpos
= SMB_VFS_LSEEK(fsp
, 0, SEEK_CUR
);
936 /* Do an fstat to see if the file is longer than the requested
937 size in which case the ftruncate above should have
938 succeeded or shorter, in which case seek to len - 1 and
939 write 1 byte of zero */
940 if (SMB_VFS_FSTAT(fsp
, &st
) == -1) {
945 if (S_ISFIFO(st
.st_ex_mode
)) {
951 if (st
.st_ex_size
== len
) {
956 if (st
.st_ex_size
> len
) {
957 /* the sys_ftruncate should have worked */
961 if (SMB_VFS_LSEEK(fsp
, len
-1, SEEK_SET
) != len
-1)
964 if (SMB_VFS_WRITE(fsp
, &c
, 1)!=1)
967 /* Seek to where we were */
968 if (SMB_VFS_LSEEK(fsp
, currpos
, SEEK_SET
) != currpos
)
974 END_PROFILE(syscall_ftruncate
);
978 static bool vfswrap_lock(vfs_handle_struct
*handle
, files_struct
*fsp
, int op
, SMB_OFF_T offset
, SMB_OFF_T count
, int type
)
982 START_PROFILE(syscall_fcntl_lock
);
983 result
= fcntl_lock(fsp
->fh
->fd
, op
, offset
, count
, type
);
984 END_PROFILE(syscall_fcntl_lock
);
988 static int vfswrap_kernel_flock(vfs_handle_struct
*handle
, files_struct
*fsp
,
991 START_PROFILE(syscall_kernel_flock
);
992 kernel_flock(fsp
->fh
->fd
, share_mode
);
993 END_PROFILE(syscall_kernel_flock
);
997 static bool vfswrap_getlock(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_OFF_T
*poffset
, SMB_OFF_T
*pcount
, int *ptype
, pid_t
*ppid
)
1001 START_PROFILE(syscall_fcntl_getlock
);
1002 result
= fcntl_getlock(fsp
->fh
->fd
, poffset
, pcount
, ptype
, ppid
);
1003 END_PROFILE(syscall_fcntl_getlock
);
1007 static int vfswrap_linux_setlease(vfs_handle_struct
*handle
, files_struct
*fsp
,
1012 START_PROFILE(syscall_linux_setlease
);
1014 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
1015 /* first set the signal handler */
1016 if(linux_set_lease_sighandler(fsp
->fh
->fd
) == -1) {
1020 result
= linux_setlease(fsp
->fh
->fd
, leasetype
);
1024 END_PROFILE(syscall_linux_setlease
);
1028 static int vfswrap_symlink(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
1032 START_PROFILE(syscall_symlink
);
1033 result
= symlink(oldpath
, newpath
);
1034 END_PROFILE(syscall_symlink
);
1038 static int vfswrap_readlink(vfs_handle_struct
*handle
, const char *path
, char *buf
, size_t bufsiz
)
1042 START_PROFILE(syscall_readlink
);
1043 result
= readlink(path
, buf
, bufsiz
);
1044 END_PROFILE(syscall_readlink
);
1048 static int vfswrap_link(vfs_handle_struct
*handle
, const char *oldpath
, const char *newpath
)
1052 START_PROFILE(syscall_link
);
1053 result
= link(oldpath
, newpath
);
1054 END_PROFILE(syscall_link
);
1058 static int vfswrap_mknod(vfs_handle_struct
*handle
, const char *pathname
, mode_t mode
, SMB_DEV_T dev
)
1062 START_PROFILE(syscall_mknod
);
1063 result
= sys_mknod(pathname
, mode
, dev
);
1064 END_PROFILE(syscall_mknod
);
1068 static char *vfswrap_realpath(vfs_handle_struct
*handle
, const char *path
, char *resolved_path
)
1072 START_PROFILE(syscall_realpath
);
1073 result
= realpath(path
, resolved_path
);
1074 END_PROFILE(syscall_realpath
);
1078 static NTSTATUS
vfswrap_notify_watch(vfs_handle_struct
*vfs_handle
,
1079 struct sys_notify_context
*ctx
,
1080 struct notify_entry
*e
,
1081 void (*callback
)(struct sys_notify_context
*ctx
,
1083 struct notify_event
*ev
),
1084 void *private_data
, void *handle
)
1087 * So far inotify is the only supported default notify mechanism. If
1088 * another platform like the the BSD's or a proprietary Unix comes
1089 * along and wants another default, we can play the same trick we
1090 * played with Posix ACLs.
1092 * Until that is the case, hard-code inotify here.
1095 if (lp_kernel_change_notify(ctx
->conn
->params
)) {
1096 return inotify_watch(ctx
, e
, callback
, private_data
, handle
);
1100 * Do nothing, leave everything to notify_internal.c
1102 return NT_STATUS_OK
;
1105 static int vfswrap_chflags(vfs_handle_struct
*handle
, const char *path
,
1109 return chflags(path
, flags
);
1116 static struct file_id
vfswrap_file_id_create(struct vfs_handle_struct
*handle
,
1117 const SMB_STRUCT_STAT
*sbuf
)
1121 /* the ZERO_STRUCT ensures padding doesn't break using the key as a
1125 key
.devid
= sbuf
->st_ex_dev
;
1126 key
.inode
= sbuf
->st_ex_ino
;
1127 /* key.extid is unused by default. */
1132 static NTSTATUS
vfswrap_streaminfo(vfs_handle_struct
*handle
,
1133 struct files_struct
*fsp
,
1135 TALLOC_CTX
*mem_ctx
,
1136 unsigned int *pnum_streams
,
1137 struct stream_struct
**pstreams
)
1139 SMB_STRUCT_STAT sbuf
;
1140 unsigned int num_streams
= 0;
1141 struct stream_struct
*streams
= NULL
;
1144 if ((fsp
!= NULL
) && (fsp
->is_directory
)) {
1146 * No default streams on directories
1151 if ((fsp
!= NULL
) && (fsp
->fh
->fd
!= -1)) {
1152 ret
= SMB_VFS_FSTAT(fsp
, &sbuf
);
1155 struct smb_filename
*smb_fname
= NULL
;
1158 status
= create_synthetic_smb_fname(talloc_tos(), fname
, NULL
,
1160 if (!NT_STATUS_IS_OK(status
)) {
1163 ret
= SMB_VFS_STAT(handle
->conn
, smb_fname
);
1164 sbuf
= smb_fname
->st
;
1165 TALLOC_FREE(smb_fname
);
1169 return map_nt_error_from_unix(errno
);
1172 if (S_ISDIR(sbuf
.st_ex_mode
)) {
1176 streams
= talloc(mem_ctx
, struct stream_struct
);
1178 if (streams
== NULL
) {
1179 return NT_STATUS_NO_MEMORY
;
1182 streams
->size
= sbuf
.st_ex_size
;
1183 streams
->alloc_size
= SMB_VFS_GET_ALLOC_SIZE(handle
->conn
, fsp
, &sbuf
);
1185 streams
->name
= talloc_strdup(streams
, "::$DATA");
1186 if (streams
->name
== NULL
) {
1187 TALLOC_FREE(streams
);
1188 return NT_STATUS_NO_MEMORY
;
1193 *pnum_streams
= num_streams
;
1194 *pstreams
= streams
;
1195 return NT_STATUS_OK
;
1198 static int vfswrap_get_real_filename(struct vfs_handle_struct
*handle
,
1201 TALLOC_CTX
*mem_ctx
,
1205 * Don't fall back to get_real_filename so callers can differentiate
1206 * between a full directory scan and an actual case-insensitive stat.
1212 static const char *vfswrap_connectpath(struct vfs_handle_struct
*handle
,
1215 return handle
->conn
->connectpath
;
1218 static NTSTATUS
vfswrap_brl_lock_windows(struct vfs_handle_struct
*handle
,
1219 struct byte_range_lock
*br_lck
,
1220 struct lock_struct
*plock
,
1222 struct blocking_lock_record
*blr
)
1224 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
1226 /* Note: blr is not used in the default implementation. */
1227 return brl_lock_windows_default(br_lck
, plock
, blocking_lock
);
1230 static bool vfswrap_brl_unlock_windows(struct vfs_handle_struct
*handle
,
1231 struct messaging_context
*msg_ctx
,
1232 struct byte_range_lock
*br_lck
,
1233 const struct lock_struct
*plock
)
1235 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
1237 return brl_unlock_windows_default(msg_ctx
, br_lck
, plock
);
1240 static bool vfswrap_brl_cancel_windows(struct vfs_handle_struct
*handle
,
1241 struct byte_range_lock
*br_lck
,
1242 struct lock_struct
*plock
,
1243 struct blocking_lock_record
*blr
)
1245 SMB_ASSERT(plock
->lock_flav
== WINDOWS_LOCK
);
1247 /* Note: blr is not used in the default implementation. */
1248 return brl_lock_cancel_default(br_lck
, plock
);
1251 static bool vfswrap_strict_lock(struct vfs_handle_struct
*handle
,
1253 struct lock_struct
*plock
)
1255 SMB_ASSERT(plock
->lock_type
== READ_LOCK
||
1256 plock
->lock_type
== WRITE_LOCK
);
1258 return strict_lock_default(fsp
, plock
);
1261 static void vfswrap_strict_unlock(struct vfs_handle_struct
*handle
,
1263 struct lock_struct
*plock
)
1265 SMB_ASSERT(plock
->lock_type
== READ_LOCK
||
1266 plock
->lock_type
== WRITE_LOCK
);
1268 strict_unlock_default(fsp
, plock
);
1271 /* NT ACL operations. */
1273 static NTSTATUS
vfswrap_fget_nt_acl(vfs_handle_struct
*handle
,
1275 uint32 security_info
, SEC_DESC
**ppdesc
)
1279 START_PROFILE(fget_nt_acl
);
1280 result
= posix_fget_nt_acl(fsp
, security_info
, ppdesc
);
1281 END_PROFILE(fget_nt_acl
);
1285 static NTSTATUS
vfswrap_get_nt_acl(vfs_handle_struct
*handle
,
1287 uint32 security_info
, SEC_DESC
**ppdesc
)
1291 START_PROFILE(get_nt_acl
);
1292 result
= posix_get_nt_acl(handle
->conn
, name
, security_info
, ppdesc
);
1293 END_PROFILE(get_nt_acl
);
1297 static NTSTATUS
vfswrap_fset_nt_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, uint32 security_info_sent
, const SEC_DESC
*psd
)
1301 START_PROFILE(fset_nt_acl
);
1302 result
= set_nt_acl(fsp
, security_info_sent
, psd
);
1303 END_PROFILE(fset_nt_acl
);
1307 static int vfswrap_chmod_acl(vfs_handle_struct
*handle
, const char *name
, mode_t mode
)
1315 START_PROFILE(chmod_acl
);
1316 result
= chmod_acl(handle
->conn
, name
, mode
);
1317 END_PROFILE(chmod_acl
);
1322 static int vfswrap_fchmod_acl(vfs_handle_struct
*handle
, files_struct
*fsp
, mode_t mode
)
1330 START_PROFILE(fchmod_acl
);
1331 result
= fchmod_acl(fsp
, mode
);
1332 END_PROFILE(fchmod_acl
);
1337 static int vfswrap_sys_acl_get_entry(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, int entry_id
, SMB_ACL_ENTRY_T
*entry_p
)
1339 return sys_acl_get_entry(theacl
, entry_id
, entry_p
);
1342 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
)
1344 return sys_acl_get_tag_type(entry_d
, tag_type_p
);
1347 static int vfswrap_sys_acl_get_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
, SMB_ACL_PERMSET_T
*permset_p
)
1349 return sys_acl_get_permset(entry_d
, permset_p
);
1352 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry_d
)
1354 return sys_acl_get_qualifier(entry_d
);
1357 static SMB_ACL_T
vfswrap_sys_acl_get_file(vfs_handle_struct
*handle
, const char *path_p
, SMB_ACL_TYPE_T type
)
1359 return sys_acl_get_file(handle
, path_p
, type
);
1362 static SMB_ACL_T
vfswrap_sys_acl_get_fd(vfs_handle_struct
*handle
, files_struct
*fsp
)
1364 return sys_acl_get_fd(handle
, fsp
);
1367 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
)
1369 return sys_acl_clear_perms(permset
);
1372 static int vfswrap_sys_acl_add_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1374 return sys_acl_add_perm(permset
, perm
);
1377 static char * vfswrap_sys_acl_to_text(vfs_handle_struct
*handle
, SMB_ACL_T theacl
, ssize_t
*plen
)
1379 return sys_acl_to_text(theacl
, plen
);
1382 static SMB_ACL_T
vfswrap_sys_acl_init(vfs_handle_struct
*handle
, int count
)
1384 return sys_acl_init(count
);
1387 static int vfswrap_sys_acl_create_entry(vfs_handle_struct
*handle
, SMB_ACL_T
*pacl
, SMB_ACL_ENTRY_T
*pentry
)
1389 return sys_acl_create_entry(pacl
, pentry
);
1392 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_TAG_T tagtype
)
1394 return sys_acl_set_tag_type(entry
, tagtype
);
1397 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, void *qual
)
1399 return sys_acl_set_qualifier(entry
, qual
);
1402 static int vfswrap_sys_acl_set_permset(vfs_handle_struct
*handle
, SMB_ACL_ENTRY_T entry
, SMB_ACL_PERMSET_T permset
)
1404 return sys_acl_set_permset(entry
, permset
);
1407 static int vfswrap_sys_acl_valid(vfs_handle_struct
*handle
, SMB_ACL_T theacl
)
1409 return sys_acl_valid(theacl
);
1412 static int vfswrap_sys_acl_set_file(vfs_handle_struct
*handle
, const char *name
, SMB_ACL_TYPE_T acltype
, SMB_ACL_T theacl
)
1414 return sys_acl_set_file(handle
, name
, acltype
, theacl
);
1417 static int vfswrap_sys_acl_set_fd(vfs_handle_struct
*handle
, files_struct
*fsp
, SMB_ACL_T theacl
)
1419 return sys_acl_set_fd(handle
, fsp
, theacl
);
1422 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct
*handle
, const char *path
)
1424 return sys_acl_delete_def_file(handle
, path
);
1427 static int vfswrap_sys_acl_get_perm(vfs_handle_struct
*handle
, SMB_ACL_PERMSET_T permset
, SMB_ACL_PERM_T perm
)
1429 return sys_acl_get_perm(permset
, perm
);
1432 static int vfswrap_sys_acl_free_text(vfs_handle_struct
*handle
, char *text
)
1434 return sys_acl_free_text(text
);
1437 static int vfswrap_sys_acl_free_acl(vfs_handle_struct
*handle
, SMB_ACL_T posix_acl
)
1439 return sys_acl_free_acl(posix_acl
);
1442 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct
*handle
, void *qualifier
, SMB_ACL_TAG_T tagtype
)
1444 return sys_acl_free_qualifier(qualifier
, tagtype
);
1447 /****************************************************************
1448 Extended attribute operations.
1449 *****************************************************************/
1451 static ssize_t
vfswrap_getxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1453 return sys_getxattr(path
, name
, value
, size
);
1456 static ssize_t
vfswrap_lgetxattr(struct vfs_handle_struct
*handle
,const char *path
, const char *name
, void *value
, size_t size
)
1458 return sys_lgetxattr(path
, name
, value
, size
);
1461 static ssize_t
vfswrap_fgetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
, void *value
, size_t size
)
1463 return sys_fgetxattr(fsp
->fh
->fd
, name
, value
, size
);
1466 static ssize_t
vfswrap_listxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1468 return sys_listxattr(path
, list
, size
);
1471 ssize_t
vfswrap_llistxattr(struct vfs_handle_struct
*handle
, const char *path
, char *list
, size_t size
)
1473 return sys_llistxattr(path
, list
, size
);
1476 ssize_t
vfswrap_flistxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, char *list
, size_t size
)
1478 return sys_flistxattr(fsp
->fh
->fd
, list
, size
);
1481 static int vfswrap_removexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1483 return sys_removexattr(path
, name
);
1486 static int vfswrap_lremovexattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
)
1488 return sys_lremovexattr(path
, name
);
1491 static int vfswrap_fremovexattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
)
1493 return sys_fremovexattr(fsp
->fh
->fd
, name
);
1496 static int vfswrap_setxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1498 return sys_setxattr(path
, name
, value
, size
, flags
);
1501 static int vfswrap_lsetxattr(struct vfs_handle_struct
*handle
, const char *path
, const char *name
, const void *value
, size_t size
, int flags
)
1503 return sys_lsetxattr(path
, name
, value
, size
, flags
);
1506 static int vfswrap_fsetxattr(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, const char *name
, const void *value
, size_t size
, int flags
)
1508 return sys_fsetxattr(fsp
->fh
->fd
, name
, value
, size
, flags
);
1511 static int vfswrap_aio_read(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1515 * aio_read must be done as root, because in the glibc aio
1516 * implementation the helper thread needs to be able to send a signal
1517 * to the main thread, even when it has done a seteuid() to a
1521 ret
= sys_aio_read(aiocb
);
1526 static int vfswrap_aio_write(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1530 * aio_write must be done as root, because in the glibc aio
1531 * implementation the helper thread needs to be able to send a signal
1532 * to the main thread, even when it has done a seteuid() to a
1536 ret
= sys_aio_write(aiocb
);
1541 static ssize_t
vfswrap_aio_return(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1543 return sys_aio_return(aiocb
);
1546 static int vfswrap_aio_cancel(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1548 return sys_aio_cancel(fsp
->fh
->fd
, aiocb
);
1551 static int vfswrap_aio_error(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, SMB_STRUCT_AIOCB
*aiocb
)
1553 return sys_aio_error(aiocb
);
1556 static int vfswrap_aio_fsync(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
, int op
, SMB_STRUCT_AIOCB
*aiocb
)
1558 return sys_aio_fsync(op
, aiocb
);
1561 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
)
1563 return sys_aio_suspend(aiocb
, n
, timeout
);
1566 static bool vfswrap_aio_force(struct vfs_handle_struct
*handle
, struct files_struct
*fsp
)
1571 static bool vfswrap_is_offline(struct vfs_handle_struct
*handle
, const char *path
, SMB_STRUCT_STAT
*sbuf
)
1573 if (ISDOT(path
) || ISDOTDOT(path
)) {
1577 if (!lp_dmapi_support(SNUM(handle
->conn
)) || !dmapi_have_session()) {
1578 #if defined(ENOTSUP)
1584 return (dmapi_file_flags(path
) & FILE_ATTRIBUTE_OFFLINE
) != 0;
1587 static int vfswrap_set_offline(struct vfs_handle_struct
*handle
, const char *path
)
1589 /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1590 #if defined(ENOTSUP)
1596 static vfs_op_tuple vfs_default_ops
[] = {
1598 /* Disk operations */
1600 {SMB_VFS_OP(vfswrap_connect
), SMB_VFS_OP_CONNECT
,
1601 SMB_VFS_LAYER_OPAQUE
},
1602 {SMB_VFS_OP(vfswrap_disconnect
), SMB_VFS_OP_DISCONNECT
,
1603 SMB_VFS_LAYER_OPAQUE
},
1604 {SMB_VFS_OP(vfswrap_disk_free
), SMB_VFS_OP_DISK_FREE
,
1605 SMB_VFS_LAYER_OPAQUE
},
1606 {SMB_VFS_OP(vfswrap_get_quota
), SMB_VFS_OP_GET_QUOTA
,
1607 SMB_VFS_LAYER_OPAQUE
},
1608 {SMB_VFS_OP(vfswrap_set_quota
), SMB_VFS_OP_SET_QUOTA
,
1609 SMB_VFS_LAYER_OPAQUE
},
1610 {SMB_VFS_OP(vfswrap_get_shadow_copy_data
), SMB_VFS_OP_GET_SHADOW_COPY_DATA
,
1611 SMB_VFS_LAYER_OPAQUE
},
1612 {SMB_VFS_OP(vfswrap_statvfs
), SMB_VFS_OP_STATVFS
,
1613 SMB_VFS_LAYER_OPAQUE
},
1614 {SMB_VFS_OP(vfswrap_fs_capabilities
), SMB_VFS_OP_FS_CAPABILITIES
,
1615 SMB_VFS_LAYER_OPAQUE
},
1617 /* Directory operations */
1619 {SMB_VFS_OP(vfswrap_opendir
), SMB_VFS_OP_OPENDIR
,
1620 SMB_VFS_LAYER_OPAQUE
},
1621 {SMB_VFS_OP(vfswrap_readdir
), SMB_VFS_OP_READDIR
,
1622 SMB_VFS_LAYER_OPAQUE
},
1623 {SMB_VFS_OP(vfswrap_seekdir
), SMB_VFS_OP_SEEKDIR
,
1624 SMB_VFS_LAYER_OPAQUE
},
1625 {SMB_VFS_OP(vfswrap_telldir
), SMB_VFS_OP_TELLDIR
,
1626 SMB_VFS_LAYER_OPAQUE
},
1627 {SMB_VFS_OP(vfswrap_rewinddir
), SMB_VFS_OP_REWINDDIR
,
1628 SMB_VFS_LAYER_OPAQUE
},
1629 {SMB_VFS_OP(vfswrap_mkdir
), SMB_VFS_OP_MKDIR
,
1630 SMB_VFS_LAYER_OPAQUE
},
1631 {SMB_VFS_OP(vfswrap_rmdir
), SMB_VFS_OP_RMDIR
,
1632 SMB_VFS_LAYER_OPAQUE
},
1633 {SMB_VFS_OP(vfswrap_closedir
), SMB_VFS_OP_CLOSEDIR
,
1634 SMB_VFS_LAYER_OPAQUE
},
1635 {SMB_VFS_OP(vfswrap_init_search_op
), SMB_VFS_OP_INIT_SEARCH_OP
,
1636 SMB_VFS_LAYER_OPAQUE
},
1638 /* File operations */
1640 {SMB_VFS_OP(vfswrap_open
), SMB_VFS_OP_OPEN
,
1641 SMB_VFS_LAYER_OPAQUE
},
1642 {SMB_VFS_OP(vfswrap_create_file
), SMB_VFS_OP_CREATE_FILE
,
1643 SMB_VFS_LAYER_OPAQUE
},
1644 {SMB_VFS_OP(vfswrap_close
), SMB_VFS_OP_CLOSE
,
1645 SMB_VFS_LAYER_OPAQUE
},
1646 {SMB_VFS_OP(vfswrap_read
), SMB_VFS_OP_READ
,
1647 SMB_VFS_LAYER_OPAQUE
},
1648 {SMB_VFS_OP(vfswrap_pread
), SMB_VFS_OP_PREAD
,
1649 SMB_VFS_LAYER_OPAQUE
},
1650 {SMB_VFS_OP(vfswrap_write
), SMB_VFS_OP_WRITE
,
1651 SMB_VFS_LAYER_OPAQUE
},
1652 {SMB_VFS_OP(vfswrap_pwrite
), SMB_VFS_OP_PWRITE
,
1653 SMB_VFS_LAYER_OPAQUE
},
1654 {SMB_VFS_OP(vfswrap_lseek
), SMB_VFS_OP_LSEEK
,
1655 SMB_VFS_LAYER_OPAQUE
},
1656 {SMB_VFS_OP(vfswrap_sendfile
), SMB_VFS_OP_SENDFILE
,
1657 SMB_VFS_LAYER_OPAQUE
},
1658 {SMB_VFS_OP(vfswrap_recvfile
), SMB_VFS_OP_RECVFILE
,
1659 SMB_VFS_LAYER_OPAQUE
},
1660 {SMB_VFS_OP(vfswrap_rename
), SMB_VFS_OP_RENAME
,
1661 SMB_VFS_LAYER_OPAQUE
},
1662 {SMB_VFS_OP(vfswrap_fsync
), SMB_VFS_OP_FSYNC
,
1663 SMB_VFS_LAYER_OPAQUE
},
1664 {SMB_VFS_OP(vfswrap_stat
), SMB_VFS_OP_STAT
,
1665 SMB_VFS_LAYER_OPAQUE
},
1666 {SMB_VFS_OP(vfswrap_fstat
), SMB_VFS_OP_FSTAT
,
1667 SMB_VFS_LAYER_OPAQUE
},
1668 {SMB_VFS_OP(vfswrap_lstat
), SMB_VFS_OP_LSTAT
,
1669 SMB_VFS_LAYER_OPAQUE
},
1670 {SMB_VFS_OP(vfswrap_get_alloc_size
), SMB_VFS_OP_GET_ALLOC_SIZE
,
1671 SMB_VFS_LAYER_OPAQUE
},
1672 {SMB_VFS_OP(vfswrap_unlink
), SMB_VFS_OP_UNLINK
,
1673 SMB_VFS_LAYER_OPAQUE
},
1674 {SMB_VFS_OP(vfswrap_chmod
), SMB_VFS_OP_CHMOD
,
1675 SMB_VFS_LAYER_OPAQUE
},
1676 {SMB_VFS_OP(vfswrap_fchmod
), SMB_VFS_OP_FCHMOD
,
1677 SMB_VFS_LAYER_OPAQUE
},
1678 {SMB_VFS_OP(vfswrap_chown
), SMB_VFS_OP_CHOWN
,
1679 SMB_VFS_LAYER_OPAQUE
},
1680 {SMB_VFS_OP(vfswrap_fchown
), SMB_VFS_OP_FCHOWN
,
1681 SMB_VFS_LAYER_OPAQUE
},
1682 {SMB_VFS_OP(vfswrap_lchown
), SMB_VFS_OP_LCHOWN
,
1683 SMB_VFS_LAYER_OPAQUE
},
1684 {SMB_VFS_OP(vfswrap_chdir
), SMB_VFS_OP_CHDIR
,
1685 SMB_VFS_LAYER_OPAQUE
},
1686 {SMB_VFS_OP(vfswrap_getwd
), SMB_VFS_OP_GETWD
,
1687 SMB_VFS_LAYER_OPAQUE
},
1688 {SMB_VFS_OP(vfswrap_ntimes
), SMB_VFS_OP_NTIMES
,
1689 SMB_VFS_LAYER_OPAQUE
},
1690 {SMB_VFS_OP(vfswrap_ftruncate
), SMB_VFS_OP_FTRUNCATE
,
1691 SMB_VFS_LAYER_OPAQUE
},
1692 {SMB_VFS_OP(vfswrap_lock
), SMB_VFS_OP_LOCK
,
1693 SMB_VFS_LAYER_OPAQUE
},
1694 {SMB_VFS_OP(vfswrap_kernel_flock
), SMB_VFS_OP_KERNEL_FLOCK
,
1695 SMB_VFS_LAYER_OPAQUE
},
1696 {SMB_VFS_OP(vfswrap_linux_setlease
), SMB_VFS_OP_LINUX_SETLEASE
,
1697 SMB_VFS_LAYER_OPAQUE
},
1698 {SMB_VFS_OP(vfswrap_getlock
), SMB_VFS_OP_GETLOCK
,
1699 SMB_VFS_LAYER_OPAQUE
},
1700 {SMB_VFS_OP(vfswrap_symlink
), SMB_VFS_OP_SYMLINK
,
1701 SMB_VFS_LAYER_OPAQUE
},
1702 {SMB_VFS_OP(vfswrap_readlink
), SMB_VFS_OP_READLINK
,
1703 SMB_VFS_LAYER_OPAQUE
},
1704 {SMB_VFS_OP(vfswrap_link
), SMB_VFS_OP_LINK
,
1705 SMB_VFS_LAYER_OPAQUE
},
1706 {SMB_VFS_OP(vfswrap_mknod
), SMB_VFS_OP_MKNOD
,
1707 SMB_VFS_LAYER_OPAQUE
},
1708 {SMB_VFS_OP(vfswrap_realpath
), SMB_VFS_OP_REALPATH
,
1709 SMB_VFS_LAYER_OPAQUE
},
1710 {SMB_VFS_OP(vfswrap_notify_watch
), SMB_VFS_OP_NOTIFY_WATCH
,
1711 SMB_VFS_LAYER_OPAQUE
},
1712 {SMB_VFS_OP(vfswrap_chflags
), SMB_VFS_OP_CHFLAGS
,
1713 SMB_VFS_LAYER_OPAQUE
},
1714 {SMB_VFS_OP(vfswrap_file_id_create
), SMB_VFS_OP_FILE_ID_CREATE
,
1715 SMB_VFS_LAYER_OPAQUE
},
1716 {SMB_VFS_OP(vfswrap_streaminfo
), SMB_VFS_OP_STREAMINFO
,
1717 SMB_VFS_LAYER_OPAQUE
},
1718 {SMB_VFS_OP(vfswrap_get_real_filename
), SMB_VFS_OP_GET_REAL_FILENAME
,
1719 SMB_VFS_LAYER_OPAQUE
},
1720 {SMB_VFS_OP(vfswrap_connectpath
), SMB_VFS_OP_CONNECTPATH
,
1721 SMB_VFS_LAYER_OPAQUE
},
1722 {SMB_VFS_OP(vfswrap_brl_lock_windows
), SMB_VFS_OP_BRL_LOCK_WINDOWS
,
1723 SMB_VFS_LAYER_OPAQUE
},
1724 {SMB_VFS_OP(vfswrap_brl_unlock_windows
),SMB_VFS_OP_BRL_UNLOCK_WINDOWS
,
1725 SMB_VFS_LAYER_OPAQUE
},
1726 {SMB_VFS_OP(vfswrap_brl_cancel_windows
),SMB_VFS_OP_BRL_CANCEL_WINDOWS
,
1727 SMB_VFS_LAYER_OPAQUE
},
1728 {SMB_VFS_OP(vfswrap_strict_lock
), SMB_VFS_OP_STRICT_LOCK
,
1729 SMB_VFS_LAYER_OPAQUE
},
1730 {SMB_VFS_OP(vfswrap_strict_unlock
), SMB_VFS_OP_STRICT_UNLOCK
,
1731 SMB_VFS_LAYER_OPAQUE
},
1733 /* NT ACL operations. */
1735 {SMB_VFS_OP(vfswrap_fget_nt_acl
), SMB_VFS_OP_FGET_NT_ACL
,
1736 SMB_VFS_LAYER_OPAQUE
},
1737 {SMB_VFS_OP(vfswrap_get_nt_acl
), SMB_VFS_OP_GET_NT_ACL
,
1738 SMB_VFS_LAYER_OPAQUE
},
1739 {SMB_VFS_OP(vfswrap_fset_nt_acl
), SMB_VFS_OP_FSET_NT_ACL
,
1740 SMB_VFS_LAYER_OPAQUE
},
1742 /* POSIX ACL operations. */
1744 {SMB_VFS_OP(vfswrap_chmod_acl
), SMB_VFS_OP_CHMOD_ACL
,
1745 SMB_VFS_LAYER_OPAQUE
},
1746 {SMB_VFS_OP(vfswrap_fchmod_acl
), SMB_VFS_OP_FCHMOD_ACL
,
1747 SMB_VFS_LAYER_OPAQUE
},
1748 {SMB_VFS_OP(vfswrap_sys_acl_get_entry
), SMB_VFS_OP_SYS_ACL_GET_ENTRY
,
1749 SMB_VFS_LAYER_OPAQUE
},
1750 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type
), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE
,
1751 SMB_VFS_LAYER_OPAQUE
},
1752 {SMB_VFS_OP(vfswrap_sys_acl_get_permset
), SMB_VFS_OP_SYS_ACL_GET_PERMSET
,
1753 SMB_VFS_LAYER_OPAQUE
},
1754 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier
), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER
,
1755 SMB_VFS_LAYER_OPAQUE
},
1756 {SMB_VFS_OP(vfswrap_sys_acl_get_file
), SMB_VFS_OP_SYS_ACL_GET_FILE
,
1757 SMB_VFS_LAYER_OPAQUE
},
1758 {SMB_VFS_OP(vfswrap_sys_acl_get_fd
), SMB_VFS_OP_SYS_ACL_GET_FD
,
1759 SMB_VFS_LAYER_OPAQUE
},
1760 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms
), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS
,
1761 SMB_VFS_LAYER_OPAQUE
},
1762 {SMB_VFS_OP(vfswrap_sys_acl_add_perm
), SMB_VFS_OP_SYS_ACL_ADD_PERM
,
1763 SMB_VFS_LAYER_OPAQUE
},
1764 {SMB_VFS_OP(vfswrap_sys_acl_to_text
), SMB_VFS_OP_SYS_ACL_TO_TEXT
,
1765 SMB_VFS_LAYER_OPAQUE
},
1766 {SMB_VFS_OP(vfswrap_sys_acl_init
), SMB_VFS_OP_SYS_ACL_INIT
,
1767 SMB_VFS_LAYER_OPAQUE
},
1768 {SMB_VFS_OP(vfswrap_sys_acl_create_entry
), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY
,
1769 SMB_VFS_LAYER_OPAQUE
},
1770 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type
), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE
,
1771 SMB_VFS_LAYER_OPAQUE
},
1772 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier
), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER
,
1773 SMB_VFS_LAYER_OPAQUE
},
1774 {SMB_VFS_OP(vfswrap_sys_acl_set_permset
), SMB_VFS_OP_SYS_ACL_SET_PERMSET
,
1775 SMB_VFS_LAYER_OPAQUE
},
1776 {SMB_VFS_OP(vfswrap_sys_acl_valid
), SMB_VFS_OP_SYS_ACL_VALID
,
1777 SMB_VFS_LAYER_OPAQUE
},
1778 {SMB_VFS_OP(vfswrap_sys_acl_set_file
), SMB_VFS_OP_SYS_ACL_SET_FILE
,
1779 SMB_VFS_LAYER_OPAQUE
},
1780 {SMB_VFS_OP(vfswrap_sys_acl_set_fd
), SMB_VFS_OP_SYS_ACL_SET_FD
,
1781 SMB_VFS_LAYER_OPAQUE
},
1782 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file
), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE
,
1783 SMB_VFS_LAYER_OPAQUE
},
1784 {SMB_VFS_OP(vfswrap_sys_acl_get_perm
), SMB_VFS_OP_SYS_ACL_GET_PERM
,
1785 SMB_VFS_LAYER_OPAQUE
},
1786 {SMB_VFS_OP(vfswrap_sys_acl_free_text
), SMB_VFS_OP_SYS_ACL_FREE_TEXT
,
1787 SMB_VFS_LAYER_OPAQUE
},
1788 {SMB_VFS_OP(vfswrap_sys_acl_free_acl
), SMB_VFS_OP_SYS_ACL_FREE_ACL
,
1789 SMB_VFS_LAYER_OPAQUE
},
1790 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier
), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER
,
1791 SMB_VFS_LAYER_OPAQUE
},
1793 /* EA operations. */
1795 {SMB_VFS_OP(vfswrap_getxattr
), SMB_VFS_OP_GETXATTR
,
1796 SMB_VFS_LAYER_OPAQUE
},
1797 {SMB_VFS_OP(vfswrap_lgetxattr
), SMB_VFS_OP_LGETXATTR
,
1798 SMB_VFS_LAYER_OPAQUE
},
1799 {SMB_VFS_OP(vfswrap_fgetxattr
), SMB_VFS_OP_FGETXATTR
,
1800 SMB_VFS_LAYER_OPAQUE
},
1801 {SMB_VFS_OP(vfswrap_listxattr
), SMB_VFS_OP_LISTXATTR
,
1802 SMB_VFS_LAYER_OPAQUE
},
1803 {SMB_VFS_OP(vfswrap_llistxattr
), SMB_VFS_OP_LLISTXATTR
,
1804 SMB_VFS_LAYER_OPAQUE
},
1805 {SMB_VFS_OP(vfswrap_flistxattr
), SMB_VFS_OP_FLISTXATTR
,
1806 SMB_VFS_LAYER_OPAQUE
},
1807 {SMB_VFS_OP(vfswrap_removexattr
), SMB_VFS_OP_REMOVEXATTR
,
1808 SMB_VFS_LAYER_OPAQUE
},
1809 {SMB_VFS_OP(vfswrap_lremovexattr
), SMB_VFS_OP_LREMOVEXATTR
,
1810 SMB_VFS_LAYER_OPAQUE
},
1811 {SMB_VFS_OP(vfswrap_fremovexattr
), SMB_VFS_OP_FREMOVEXATTR
,
1812 SMB_VFS_LAYER_OPAQUE
},
1813 {SMB_VFS_OP(vfswrap_setxattr
), SMB_VFS_OP_SETXATTR
,
1814 SMB_VFS_LAYER_OPAQUE
},
1815 {SMB_VFS_OP(vfswrap_lsetxattr
), SMB_VFS_OP_LSETXATTR
,
1816 SMB_VFS_LAYER_OPAQUE
},
1817 {SMB_VFS_OP(vfswrap_fsetxattr
), SMB_VFS_OP_FSETXATTR
,
1818 SMB_VFS_LAYER_OPAQUE
},
1820 {SMB_VFS_OP(vfswrap_aio_read
), SMB_VFS_OP_AIO_READ
,
1821 SMB_VFS_LAYER_OPAQUE
},
1822 {SMB_VFS_OP(vfswrap_aio_write
), SMB_VFS_OP_AIO_WRITE
,
1823 SMB_VFS_LAYER_OPAQUE
},
1824 {SMB_VFS_OP(vfswrap_aio_return
), SMB_VFS_OP_AIO_RETURN
,
1825 SMB_VFS_LAYER_OPAQUE
},
1826 {SMB_VFS_OP(vfswrap_aio_cancel
), SMB_VFS_OP_AIO_CANCEL
,
1827 SMB_VFS_LAYER_OPAQUE
},
1828 {SMB_VFS_OP(vfswrap_aio_error
), SMB_VFS_OP_AIO_ERROR
,
1829 SMB_VFS_LAYER_OPAQUE
},
1830 {SMB_VFS_OP(vfswrap_aio_fsync
), SMB_VFS_OP_AIO_FSYNC
,
1831 SMB_VFS_LAYER_OPAQUE
},
1832 {SMB_VFS_OP(vfswrap_aio_suspend
),SMB_VFS_OP_AIO_SUSPEND
,
1833 SMB_VFS_LAYER_OPAQUE
},
1835 {SMB_VFS_OP(vfswrap_aio_force
), SMB_VFS_OP_AIO_FORCE
,
1836 SMB_VFS_LAYER_OPAQUE
},
1838 {SMB_VFS_OP(vfswrap_is_offline
),SMB_VFS_OP_IS_OFFLINE
,
1839 SMB_VFS_LAYER_OPAQUE
},
1840 {SMB_VFS_OP(vfswrap_set_offline
),SMB_VFS_OP_SET_OFFLINE
,
1841 SMB_VFS_LAYER_OPAQUE
},
1843 /* Finish VFS operations definition */
1845 {SMB_VFS_OP(NULL
), SMB_VFS_OP_NOOP
,
1849 NTSTATUS
vfs_default_init(void);
1850 NTSTATUS
vfs_default_init(void)
1852 unsigned int needed
= SMB_VFS_OP_LAST
+ 1; /* convert from index to count */
1854 if (ARRAY_SIZE(vfs_default_ops
) != needed
) {
1855 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1856 DEFAULT_VFS_MODULE_NAME
, (unsigned int)ARRAY_SIZE(vfs_default_ops
), needed
));
1857 smb_panic("operation(s) missing from default VFS module");
1860 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION
,
1861 DEFAULT_VFS_MODULE_NAME
, vfs_default_ops
);