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, SMB_STRUCT_DIR *dirp)
118 SMB_STRUCT_DIRENT *result;
120 START_PROFILE(syscall_readdir);
121 result = sys_readdir(dirp);
122 END_PROFILE(syscall_readdir);
126 static void vfswrap_seekdir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp, long offset)
128 START_PROFILE(syscall_seekdir);
129 sys_seekdir(dirp, offset);
130 END_PROFILE(syscall_seekdir);
133 static long vfswrap_telldir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
136 START_PROFILE(syscall_telldir);
137 result = sys_telldir(dirp);
138 END_PROFILE(syscall_telldir);
142 static void vfswrap_rewinddir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
144 START_PROFILE(syscall_rewinddir);
146 END_PROFILE(syscall_rewinddir);
149 static int vfswrap_mkdir(vfs_handle_struct *handle, const char *path, mode_t mode)
152 bool has_dacl = False;
154 START_PROFILE(syscall_mkdir);
156 if (lp_inherit_acls(SNUM(handle->conn)) && (has_dacl = directory_has_default_acl(handle->conn, parent_dirname(path))))
159 result = mkdir(path, mode);
161 if (result == 0 && !has_dacl) {
163 * We need to do this as the default behavior of POSIX ACLs
164 * is to set the mask to be the requested group permission
165 * bits, not the group permission bits to be the requested
166 * group permission bits. This is not what we want, as it will
167 * mess up any inherited ACL bits that were set. JRA.
169 int saved_errno = errno; /* We may get ENOSYS */
170 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
174 END_PROFILE(syscall_mkdir);
178 static int vfswrap_rmdir(vfs_handle_struct *handle, const char *path)
182 START_PROFILE(syscall_rmdir);
183 result = rmdir(path);
184 END_PROFILE(syscall_rmdir);
188 static int vfswrap_closedir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
192 START_PROFILE(syscall_closedir);
193 result = sys_closedir(dirp);
194 END_PROFILE(syscall_closedir);
198 /* File operations */
200 static int vfswrap_open(vfs_handle_struct *handle, const char *fname,
201 files_struct *fsp, int flags, mode_t mode)
205 START_PROFILE(syscall_open);
206 result = sys_open(fname, flags, mode);
207 END_PROFILE(syscall_open);
211 static NTSTATUS vfswrap_create_file(vfs_handle_struct *handle,
212 struct smb_request *req,
213 uint16_t root_dir_fid,
215 uint32_t create_file_flags,
216 uint32_t access_mask,
217 uint32_t share_access,
218 uint32_t create_disposition,
219 uint32_t create_options,
220 uint32_t file_attributes,
221 uint32_t oplock_request,
222 uint64_t allocation_size,
223 struct security_descriptor *sd,
224 struct ea_list *ea_list,
225 files_struct **result,
227 SMB_STRUCT_STAT *psbuf)
229 return create_file_default(handle->conn, req, root_dir_fid, fname,
230 create_file_flags, access_mask, share_access,
231 create_disposition, create_options,
232 file_attributes, oplock_request,
233 allocation_size, sd, ea_list, result, pinfo,
237 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp)
241 START_PROFILE(syscall_close);
242 result = fd_close_posix(fsp);
243 END_PROFILE(syscall_close);
247 static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, void *data, size_t n)
251 START_PROFILE_BYTES(syscall_read, n);
252 result = sys_read(fsp->fh->fd, data, n);
253 END_PROFILE(syscall_read);
257 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, void *data,
258 size_t n, SMB_OFF_T offset)
262 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
263 START_PROFILE_BYTES(syscall_pread, n);
264 result = sys_pread(fsp->fh->fd, data, n, offset);
265 END_PROFILE(syscall_pread);
267 if (result == -1 && errno == ESPIPE) {
268 /* Maintain the fiction that pipes can be seeked (sought?) on. */
269 result = SMB_VFS_READ(fsp, data, n);
273 #else /* HAVE_PREAD */
277 curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
278 if (curr == -1 && errno == ESPIPE) {
279 /* Maintain the fiction that pipes can be seeked (sought?) on. */
280 result = SMB_VFS_READ(fsp, data, n);
285 if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
290 result = SMB_VFS_READ(fsp, data, n);
293 SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
296 #endif /* HAVE_PREAD */
301 static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t n)
305 START_PROFILE_BYTES(syscall_write, n);
306 result = sys_write(fsp->fh->fd, data, n);
307 END_PROFILE(syscall_write);
311 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data,
312 size_t n, SMB_OFF_T offset)
316 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
317 START_PROFILE_BYTES(syscall_pwrite, n);
318 result = sys_pwrite(fsp->fh->fd, data, n, offset);
319 END_PROFILE(syscall_pwrite);
321 if (result == -1 && errno == ESPIPE) {
322 /* Maintain the fiction that pipes can be sought on. */
323 result = SMB_VFS_WRITE(fsp, data, n);
326 #else /* HAVE_PWRITE */
330 curr = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
335 if (SMB_VFS_LSEEK(fsp, offset, SEEK_SET) == -1) {
339 result = SMB_VFS_WRITE(fsp, data, n);
342 SMB_VFS_LSEEK(fsp, curr, SEEK_SET);
345 #endif /* HAVE_PWRITE */
350 static SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T offset, int whence)
352 SMB_OFF_T result = 0;
354 START_PROFILE(syscall_lseek);
356 /* Cope with 'stat' file opens. */
357 if (fsp->fh->fd != -1)
358 result = sys_lseek(fsp->fh->fd, offset, whence);
361 * We want to maintain the fiction that we can seek
362 * on a fifo for file system purposes. This allows
363 * people to set up UNIX fifo's that feed data to Windows
367 if((result == -1) && (errno == ESPIPE)) {
372 END_PROFILE(syscall_lseek);
376 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fromfsp, const DATA_BLOB *hdr,
377 SMB_OFF_T offset, size_t n)
381 START_PROFILE_BYTES(syscall_sendfile, n);
382 result = sys_sendfile(tofd, fromfsp->fh->fd, hdr, offset, n);
383 END_PROFILE(syscall_sendfile);
387 static ssize_t vfswrap_recvfile(vfs_handle_struct *handle,
395 START_PROFILE_BYTES(syscall_recvfile, n);
396 result = sys_recvfile(fromfd, tofsp->fh->fd, offset, n);
397 END_PROFILE(syscall_recvfile);
401 /*********************************************************
402 For rename across filesystems Patch from Warren Birnbaum
403 <warrenb@hpcvscdp.cv.hp.com>
404 **********************************************************/
406 static int copy_reg(const char *source, const char *dest)
408 SMB_STRUCT_STAT source_stats;
413 if (sys_lstat (source, &source_stats) == -1)
416 if (!S_ISREG (source_stats.st_mode))
419 if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
422 if (unlink (dest) && errno != ENOENT)
426 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
428 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
432 if (transfer_file(ifd, ofd, (size_t)-1) == -1)
436 * Try to preserve ownership. For non-root it might fail, but that's ok.
437 * But root probably wants to know, e.g. if NFS disallows it.
441 if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
443 if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
448 * fchown turns off set[ug]id bits for non-root,
449 * so do the chmod last.
452 #if defined(HAVE_FCHMOD)
453 if (fchmod (ofd, source_stats.st_mode & 07777))
455 if (chmod (dest, source_stats.st_mode & 07777))
459 if (close (ifd) == -1)
462 if (close (ofd) == -1)
465 /* Try to copy the old file's modtime and access time. */
469 tv.actime = source_stats.st_atime;
470 tv.modtime = source_stats.st_mtime;
474 if (unlink (source) == -1)
490 static int vfswrap_rename(vfs_handle_struct *handle, const char *oldname, const char *newname)
494 START_PROFILE(syscall_rename);
495 result = rename(oldname, newname);
496 if ((result == -1) && (errno == EXDEV)) {
497 /* Rename across filesystems needed. */
498 result = copy_reg(oldname, newname);
501 END_PROFILE(syscall_rename);
505 static int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp)
510 START_PROFILE(syscall_fsync);
511 result = fsync(fsp->fh->fd);
512 END_PROFILE(syscall_fsync);
519 static int vfswrap_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
523 START_PROFILE(syscall_stat);
524 result = sys_stat(fname, sbuf);
525 END_PROFILE(syscall_stat);
529 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
533 START_PROFILE(syscall_fstat);
534 result = sys_fstat(fsp->fh->fd, sbuf);
535 END_PROFILE(syscall_fstat);
539 int vfswrap_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
543 START_PROFILE(syscall_lstat);
544 result = sys_lstat(path, sbuf);
545 END_PROFILE(syscall_lstat);
549 static int vfswrap_unlink(vfs_handle_struct *handle, const char *path)
553 START_PROFILE(syscall_unlink);
554 result = unlink(path);
555 END_PROFILE(syscall_unlink);
559 static int vfswrap_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
563 START_PROFILE(syscall_chmod);
566 * We need to do this due to the fact that the default POSIX ACL
567 * chmod modifies the ACL *mask* for the group owner, not the
568 * group owner bits directly. JRA.
573 int saved_errno = errno; /* We might get ENOSYS */
574 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
575 END_PROFILE(syscall_chmod);
578 /* Error - return the old errno. */
582 result = chmod(path, mode);
583 END_PROFILE(syscall_chmod);
587 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
591 START_PROFILE(syscall_fchmod);
594 * We need to do this due to the fact that the default POSIX ACL
595 * chmod modifies the ACL *mask* for the group owner, not the
596 * group owner bits directly. JRA.
600 int saved_errno = errno; /* We might get ENOSYS */
601 if ((result = SMB_VFS_FCHMOD_ACL(fsp, mode)) == 0) {
602 END_PROFILE(syscall_fchmod);
605 /* Error - return the old errno. */
609 #if defined(HAVE_FCHMOD)
610 result = fchmod(fsp->fh->fd, mode);
616 END_PROFILE(syscall_fchmod);
620 static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
624 START_PROFILE(syscall_chown);
625 result = chown(path, uid, gid);
626 END_PROFILE(syscall_chown);
630 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, uid_t uid, gid_t gid)
635 START_PROFILE(syscall_fchown);
636 result = fchown(fsp->fh->fd, uid, gid);
637 END_PROFILE(syscall_fchown);
645 static int vfswrap_lchown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
649 START_PROFILE(syscall_lchown);
650 result = lchown(path, uid, gid);
651 END_PROFILE(syscall_lchown);
655 static int vfswrap_chdir(vfs_handle_struct *handle, const char *path)
659 START_PROFILE(syscall_chdir);
660 result = chdir(path);
661 END_PROFILE(syscall_chdir);
665 static char *vfswrap_getwd(vfs_handle_struct *handle, char *path)
669 START_PROFILE(syscall_getwd);
670 result = sys_getwd(path);
671 END_PROFILE(syscall_getwd);
675 /*********************************************************************
676 nsec timestamp resolution call. Convert down to whatever the underlying
678 **********************************************************************/
680 static int vfswrap_ntimes(vfs_handle_struct *handle, const char *path, const struct timespec ts[2])
684 START_PROFILE(syscall_ntimes);
685 #if defined(HAVE_UTIMES)
687 struct timeval tv[2];
688 tv[0] = convert_timespec_to_timeval(ts[0]);
689 tv[1] = convert_timespec_to_timeval(ts[1]);
690 result = utimes(path, tv);
692 result = utimes(path, NULL);
694 #elif defined(HAVE_UTIME)
696 struct utimbuf times;
697 times.actime = convert_timespec_to_time_t(ts[0]);
698 times.modtime = convert_timespec_to_time_t(ts[1]);
699 result = utime(path, times);
701 result = utime(path, NULL);
707 END_PROFILE(syscall_ntimes);
711 /*********************************************************************
712 A version of ftruncate that will write the space on disk if strict
714 **********************************************************************/
716 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
719 SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
720 unsigned char zero_space[4096];
721 SMB_OFF_T space_to_write;
726 if (SMB_VFS_FSTAT(fsp, &st) == -1)
729 space_to_write = len - st.st_size;
732 if (S_ISFIFO(st.st_mode))
736 if (st.st_size == len)
739 /* Shrink - just ftruncate. */
740 if (st.st_size > len)
741 return sys_ftruncate(fsp->fh->fd, len);
743 /* available disk space is enough or not? */
744 if (lp_strict_allocate(SNUM(fsp->conn))){
745 uint64_t space_avail;
746 uint64_t bsize,dfree,dsize;
748 space_avail = get_dfree_info(conn,fsp->fsp_name,false,&bsize,&dfree,&dsize);
749 /* space_avail is 1k blocks */
750 if (space_avail == (SMB_BIG_UINT)-1 ||
751 ((SMB_BIG_UINT)space_to_write/1024 > space_avail) ) {
757 /* Write out the real space on disk. */
758 if (SMB_VFS_LSEEK(fsp, st.st_size, SEEK_SET) != st.st_size)
761 space_to_write = len - st.st_size;
763 memset(zero_space, '\0', sizeof(zero_space));
764 while ( space_to_write > 0) {
766 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
768 retlen = SMB_VFS_WRITE(fsp,(char *)zero_space,current_len_to_write);
772 space_to_write -= retlen;
775 /* Seek to where we were */
776 if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
782 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T len)
789 START_PROFILE(syscall_ftruncate);
791 if (lp_strict_allocate(SNUM(fsp->conn))) {
792 result = strict_allocate_ftruncate(handle, fsp, len);
793 END_PROFILE(syscall_ftruncate);
797 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
798 sys_ftruncate if the system supports it. Then I discovered that
799 you can have some filesystems that support ftruncate
800 expansion and some that don't! On Linux fat can't do
801 ftruncate extend but ext2 can. */
803 result = sys_ftruncate(fsp->fh->fd, len);
807 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
808 extend a file with ftruncate. Provide alternate implementation
810 currpos = SMB_VFS_LSEEK(fsp, 0, SEEK_CUR);
815 /* Do an fstat to see if the file is longer than the requested
816 size in which case the ftruncate above should have
817 succeeded or shorter, in which case seek to len - 1 and
818 write 1 byte of zero */
819 if (SMB_VFS_FSTAT(fsp, &st) == -1) {
824 if (S_ISFIFO(st.st_mode)) {
830 if (st.st_size == len) {
835 if (st.st_size > len) {
836 /* the sys_ftruncate should have worked */
840 if (SMB_VFS_LSEEK(fsp, len-1, SEEK_SET) != len -1)
843 if (SMB_VFS_WRITE(fsp, &c, 1)!=1)
846 /* Seek to where we were */
847 if (SMB_VFS_LSEEK(fsp, currpos, SEEK_SET) != currpos)
853 END_PROFILE(syscall_ftruncate);
857 static bool vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
861 START_PROFILE(syscall_fcntl_lock);
862 result = fcntl_lock(fsp->fh->fd, op, offset, count, type);
863 END_PROFILE(syscall_fcntl_lock);
867 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
870 START_PROFILE(syscall_kernel_flock);
871 kernel_flock(fsp->fh->fd, share_mode);
872 END_PROFILE(syscall_kernel_flock);
876 static bool vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
880 START_PROFILE(syscall_fcntl_getlock);
881 result = fcntl_getlock(fsp->fh->fd, poffset, pcount, ptype, ppid);
882 END_PROFILE(syscall_fcntl_getlock);
886 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp,
891 START_PROFILE(syscall_linux_setlease);
893 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
894 /* first set the signal handler */
895 if(linux_set_lease_sighandler(fsp->fh->fd) == -1) {
899 result = linux_setlease(fsp->fh->fd, leasetype);
903 END_PROFILE(syscall_linux_setlease);
907 static int vfswrap_symlink(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
911 START_PROFILE(syscall_symlink);
912 result = symlink(oldpath, newpath);
913 END_PROFILE(syscall_symlink);
917 static int vfswrap_readlink(vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
921 START_PROFILE(syscall_readlink);
922 result = readlink(path, buf, bufsiz);
923 END_PROFILE(syscall_readlink);
927 static int vfswrap_link(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
931 START_PROFILE(syscall_link);
932 result = link(oldpath, newpath);
933 END_PROFILE(syscall_link);
937 static int vfswrap_mknod(vfs_handle_struct *handle, const char *pathname, mode_t mode, SMB_DEV_T dev)
941 START_PROFILE(syscall_mknod);
942 result = sys_mknod(pathname, mode, dev);
943 END_PROFILE(syscall_mknod);
947 static char *vfswrap_realpath(vfs_handle_struct *handle, const char *path, char *resolved_path)
951 START_PROFILE(syscall_realpath);
952 result = realpath(path, resolved_path);
953 END_PROFILE(syscall_realpath);
957 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
958 struct sys_notify_context *ctx,
959 struct notify_entry *e,
960 void (*callback)(struct sys_notify_context *ctx,
962 struct notify_event *ev),
963 void *private_data, void *handle)
966 * So far inotify is the only supported default notify mechanism. If
967 * another platform like the the BSD's or a proprietary Unix comes
968 * along and wants another default, we can play the same trick we
969 * played with Posix ACLs.
971 * Until that is the case, hard-code inotify here.
974 if (lp_kernel_change_notify(ctx->conn->params)) {
975 return inotify_watch(ctx, e, callback, private_data, handle);
979 * Do nothing, leave everything to notify_internal.c
984 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path, int flags)
987 return chflags(path, flags);
994 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle, SMB_DEV_T dev, SMB_INO_T inode)
996 return file_id_create_dev(dev, inode);
999 static NTSTATUS vfswrap_streaminfo(vfs_handle_struct *handle,
1000 struct files_struct *fsp,
1002 TALLOC_CTX *mem_ctx,
1003 unsigned int *pnum_streams,
1004 struct stream_struct **pstreams)
1006 SMB_STRUCT_STAT sbuf;
1007 unsigned int num_streams = 0;
1008 struct stream_struct *streams = NULL;
1011 if ((fsp != NULL) && (fsp->is_directory)) {
1013 * No default streams on directories
1018 if ((fsp != NULL) && (fsp->fh->fd != -1)) {
1019 ret = SMB_VFS_FSTAT(fsp, &sbuf);
1022 ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
1026 return map_nt_error_from_unix(errno);
1029 if (S_ISDIR(sbuf.st_mode)) {
1033 streams = talloc(mem_ctx, struct stream_struct);
1035 if (streams == NULL) {
1036 return NT_STATUS_NO_MEMORY;
1039 streams->size = sbuf.st_size;
1040 streams->alloc_size = get_allocation_size(handle->conn, fsp, &sbuf);
1042 streams->name = talloc_strdup(streams, "::$DATA");
1043 if (streams->name == NULL) {
1044 TALLOC_FREE(streams);
1045 return NT_STATUS_NO_MEMORY;
1050 *pnum_streams = num_streams;
1051 *pstreams = streams;
1052 return NT_STATUS_OK;
1055 static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
1058 TALLOC_CTX *mem_ctx,
1061 return get_real_filename(handle->conn, path, name, mem_ctx,
1065 static NTSTATUS vfswrap_fget_nt_acl(vfs_handle_struct *handle,
1067 uint32 security_info, SEC_DESC **ppdesc)
1071 START_PROFILE(fget_nt_acl);
1072 result = posix_fget_nt_acl(fsp, security_info, ppdesc);
1073 END_PROFILE(fget_nt_acl);
1077 static NTSTATUS vfswrap_get_nt_acl(vfs_handle_struct *handle,
1079 uint32 security_info, SEC_DESC **ppdesc)
1083 START_PROFILE(get_nt_acl);
1084 result = posix_get_nt_acl(handle->conn, name, security_info, ppdesc);
1085 END_PROFILE(get_nt_acl);
1089 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32 security_info_sent, const SEC_DESC *psd)
1093 START_PROFILE(fset_nt_acl);
1094 result = set_nt_acl(fsp, security_info_sent, psd);
1095 END_PROFILE(fset_nt_acl);
1099 static int vfswrap_chmod_acl(vfs_handle_struct *handle, const char *name, mode_t mode)
1107 START_PROFILE(chmod_acl);
1108 result = chmod_acl(handle->conn, name, mode);
1109 END_PROFILE(chmod_acl);
1114 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
1122 START_PROFILE(fchmod_acl);
1123 result = fchmod_acl(fsp, mode);
1124 END_PROFILE(fchmod_acl);
1129 static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1131 return sys_acl_get_entry(theacl, entry_id, entry_p);
1134 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)
1136 return sys_acl_get_tag_type(entry_d, tag_type_p);
1139 static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1141 return sys_acl_get_permset(entry_d, permset_p);
1144 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d)
1146 return sys_acl_get_qualifier(entry_d);
1149 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle, const char *path_p, SMB_ACL_TYPE_T type)
1151 return sys_acl_get_file(handle, path_p, type);
1154 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp)
1156 return sys_acl_get_fd(handle, fsp);
1159 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset)
1161 return sys_acl_clear_perms(permset);
1164 static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1166 return sys_acl_add_perm(permset, perm);
1169 static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle, SMB_ACL_T theacl, ssize_t *plen)
1171 return sys_acl_to_text(theacl, plen);
1174 static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle, int count)
1176 return sys_acl_init(count);
1179 static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1181 return sys_acl_create_entry(pacl, pentry);
1184 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1186 return sys_acl_set_tag_type(entry, tagtype);
1189 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, void *qual)
1191 return sys_acl_set_qualifier(entry, qual);
1194 static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1196 return sys_acl_set_permset(entry, permset);
1199 static int vfswrap_sys_acl_valid(vfs_handle_struct *handle, SMB_ACL_T theacl )
1201 return sys_acl_valid(theacl );
1204 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1206 return sys_acl_set_file(handle, name, acltype, theacl);
1209 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, SMB_ACL_T theacl)
1211 return sys_acl_set_fd(handle, fsp, theacl);
1214 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, const char *path)
1216 return sys_acl_delete_def_file(handle, path);
1219 static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1221 return sys_acl_get_perm(permset, perm);
1224 static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle, char *text)
1226 return sys_acl_free_text(text);
1229 static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle, SMB_ACL_T posix_acl)
1231 return sys_acl_free_acl(posix_acl);
1234 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle, void *qualifier, SMB_ACL_TAG_T tagtype)
1236 return sys_acl_free_qualifier(qualifier, tagtype);
1239 /****************************************************************
1240 Extended attribute operations.
1241 *****************************************************************/
1243 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1245 return sys_getxattr(path, name, value, size);
1248 static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1250 return sys_lgetxattr(path, name, value, size);
1253 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, void *value, size_t size)
1255 return sys_fgetxattr(fsp->fh->fd, name, value, size);
1258 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1260 return sys_listxattr(path, list, size);
1263 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1265 return sys_llistxattr(path, list, size);
1268 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
1270 return sys_flistxattr(fsp->fh->fd, list, size);
1273 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1275 return sys_removexattr(path, name);
1278 static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1280 return sys_lremovexattr(path, name);
1283 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name)
1285 return sys_fremovexattr(fsp->fh->fd, name);
1288 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1290 return sys_setxattr(path, name, value, size, flags);
1293 static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1295 return sys_lsetxattr(path, name, value, size, flags);
1298 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, const char *name, const void *value, size_t size, int flags)
1300 return sys_fsetxattr(fsp->fh->fd, name, value, size, flags);
1303 static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1305 return sys_aio_read(aiocb);
1308 static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1310 return sys_aio_write(aiocb);
1313 static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1315 return sys_aio_return(aiocb);
1318 static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1320 return sys_aio_cancel(fsp->fh->fd, aiocb);
1323 static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1325 return sys_aio_error(aiocb);
1328 static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1330 return sys_aio_fsync(op, aiocb);
1333 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)
1335 return sys_aio_suspend(aiocb, n, timeout);
1338 static bool vfswrap_aio_force(struct vfs_handle_struct *handle, struct files_struct *fsp)
1343 static bool vfswrap_is_offline(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
1345 if (ISDOT(path) || ISDOTDOT(path)) {
1349 if (!lp_dmapi_support(SNUM(handle->conn)) || !dmapi_have_session()) {
1350 #if defined(ENOTSUP)
1356 return (dmapi_file_flags(path) & FILE_ATTRIBUTE_OFFLINE) != 0;
1359 static int vfswrap_set_offline(struct vfs_handle_struct *handle, const char *path)
1361 /* We don't know how to set offline bit by default, needs to be overriden in the vfs modules */
1362 #if defined(ENOTSUP)
1368 static vfs_op_tuple vfs_default_ops[] = {
1370 /* Disk operations */
1372 {SMB_VFS_OP(vfswrap_connect), SMB_VFS_OP_CONNECT,
1373 SMB_VFS_LAYER_OPAQUE},
1374 {SMB_VFS_OP(vfswrap_disconnect), SMB_VFS_OP_DISCONNECT,
1375 SMB_VFS_LAYER_OPAQUE},
1376 {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1377 SMB_VFS_LAYER_OPAQUE},
1378 {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1379 SMB_VFS_LAYER_OPAQUE},
1380 {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1381 SMB_VFS_LAYER_OPAQUE},
1382 {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1383 SMB_VFS_LAYER_OPAQUE},
1384 {SMB_VFS_OP(vfswrap_statvfs), SMB_VFS_OP_STATVFS,
1385 SMB_VFS_LAYER_OPAQUE},
1386 {SMB_VFS_OP(vfswrap_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES,
1387 SMB_VFS_LAYER_OPAQUE},
1389 /* Directory operations */
1391 {SMB_VFS_OP(vfswrap_opendir), SMB_VFS_OP_OPENDIR,
1392 SMB_VFS_LAYER_OPAQUE},
1393 {SMB_VFS_OP(vfswrap_readdir), SMB_VFS_OP_READDIR,
1394 SMB_VFS_LAYER_OPAQUE},
1395 {SMB_VFS_OP(vfswrap_seekdir), SMB_VFS_OP_SEEKDIR,
1396 SMB_VFS_LAYER_OPAQUE},
1397 {SMB_VFS_OP(vfswrap_telldir), SMB_VFS_OP_TELLDIR,
1398 SMB_VFS_LAYER_OPAQUE},
1399 {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1400 SMB_VFS_LAYER_OPAQUE},
1401 {SMB_VFS_OP(vfswrap_mkdir), SMB_VFS_OP_MKDIR,
1402 SMB_VFS_LAYER_OPAQUE},
1403 {SMB_VFS_OP(vfswrap_rmdir), SMB_VFS_OP_RMDIR,
1404 SMB_VFS_LAYER_OPAQUE},
1405 {SMB_VFS_OP(vfswrap_closedir), SMB_VFS_OP_CLOSEDIR,
1406 SMB_VFS_LAYER_OPAQUE},
1408 /* File operations */
1410 {SMB_VFS_OP(vfswrap_open), SMB_VFS_OP_OPEN,
1411 SMB_VFS_LAYER_OPAQUE},
1412 {SMB_VFS_OP(vfswrap_create_file), SMB_VFS_OP_CREATE_FILE,
1413 SMB_VFS_LAYER_OPAQUE},
1414 {SMB_VFS_OP(vfswrap_close), SMB_VFS_OP_CLOSE,
1415 SMB_VFS_LAYER_OPAQUE},
1416 {SMB_VFS_OP(vfswrap_read), SMB_VFS_OP_READ,
1417 SMB_VFS_LAYER_OPAQUE},
1418 {SMB_VFS_OP(vfswrap_pread), SMB_VFS_OP_PREAD,
1419 SMB_VFS_LAYER_OPAQUE},
1420 {SMB_VFS_OP(vfswrap_write), SMB_VFS_OP_WRITE,
1421 SMB_VFS_LAYER_OPAQUE},
1422 {SMB_VFS_OP(vfswrap_pwrite), SMB_VFS_OP_PWRITE,
1423 SMB_VFS_LAYER_OPAQUE},
1424 {SMB_VFS_OP(vfswrap_lseek), SMB_VFS_OP_LSEEK,
1425 SMB_VFS_LAYER_OPAQUE},
1426 {SMB_VFS_OP(vfswrap_sendfile), SMB_VFS_OP_SENDFILE,
1427 SMB_VFS_LAYER_OPAQUE},
1428 {SMB_VFS_OP(vfswrap_recvfile), SMB_VFS_OP_RECVFILE,
1429 SMB_VFS_LAYER_OPAQUE},
1430 {SMB_VFS_OP(vfswrap_rename), SMB_VFS_OP_RENAME,
1431 SMB_VFS_LAYER_OPAQUE},
1432 {SMB_VFS_OP(vfswrap_fsync), SMB_VFS_OP_FSYNC,
1433 SMB_VFS_LAYER_OPAQUE},
1434 {SMB_VFS_OP(vfswrap_stat), SMB_VFS_OP_STAT,
1435 SMB_VFS_LAYER_OPAQUE},
1436 {SMB_VFS_OP(vfswrap_fstat), SMB_VFS_OP_FSTAT,
1437 SMB_VFS_LAYER_OPAQUE},
1438 {SMB_VFS_OP(vfswrap_lstat), SMB_VFS_OP_LSTAT,
1439 SMB_VFS_LAYER_OPAQUE},
1440 {SMB_VFS_OP(vfswrap_unlink), SMB_VFS_OP_UNLINK,
1441 SMB_VFS_LAYER_OPAQUE},
1442 {SMB_VFS_OP(vfswrap_chmod), SMB_VFS_OP_CHMOD,
1443 SMB_VFS_LAYER_OPAQUE},
1444 {SMB_VFS_OP(vfswrap_fchmod), SMB_VFS_OP_FCHMOD,
1445 SMB_VFS_LAYER_OPAQUE},
1446 {SMB_VFS_OP(vfswrap_chown), SMB_VFS_OP_CHOWN,
1447 SMB_VFS_LAYER_OPAQUE},
1448 {SMB_VFS_OP(vfswrap_fchown), SMB_VFS_OP_FCHOWN,
1449 SMB_VFS_LAYER_OPAQUE},
1450 {SMB_VFS_OP(vfswrap_lchown), SMB_VFS_OP_LCHOWN,
1451 SMB_VFS_LAYER_OPAQUE},
1452 {SMB_VFS_OP(vfswrap_chdir), SMB_VFS_OP_CHDIR,
1453 SMB_VFS_LAYER_OPAQUE},
1454 {SMB_VFS_OP(vfswrap_getwd), SMB_VFS_OP_GETWD,
1455 SMB_VFS_LAYER_OPAQUE},
1456 {SMB_VFS_OP(vfswrap_ntimes), SMB_VFS_OP_NTIMES,
1457 SMB_VFS_LAYER_OPAQUE},
1458 {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1459 SMB_VFS_LAYER_OPAQUE},
1460 {SMB_VFS_OP(vfswrap_lock), SMB_VFS_OP_LOCK,
1461 SMB_VFS_LAYER_OPAQUE},
1462 {SMB_VFS_OP(vfswrap_kernel_flock), SMB_VFS_OP_KERNEL_FLOCK,
1463 SMB_VFS_LAYER_OPAQUE},
1464 {SMB_VFS_OP(vfswrap_linux_setlease), SMB_VFS_OP_LINUX_SETLEASE,
1465 SMB_VFS_LAYER_OPAQUE},
1466 {SMB_VFS_OP(vfswrap_getlock), SMB_VFS_OP_GETLOCK,
1467 SMB_VFS_LAYER_OPAQUE},
1468 {SMB_VFS_OP(vfswrap_symlink), SMB_VFS_OP_SYMLINK,
1469 SMB_VFS_LAYER_OPAQUE},
1470 {SMB_VFS_OP(vfswrap_readlink), SMB_VFS_OP_READLINK,
1471 SMB_VFS_LAYER_OPAQUE},
1472 {SMB_VFS_OP(vfswrap_link), SMB_VFS_OP_LINK,
1473 SMB_VFS_LAYER_OPAQUE},
1474 {SMB_VFS_OP(vfswrap_mknod), SMB_VFS_OP_MKNOD,
1475 SMB_VFS_LAYER_OPAQUE},
1476 {SMB_VFS_OP(vfswrap_realpath), SMB_VFS_OP_REALPATH,
1477 SMB_VFS_LAYER_OPAQUE},
1478 {SMB_VFS_OP(vfswrap_notify_watch), SMB_VFS_OP_NOTIFY_WATCH,
1479 SMB_VFS_LAYER_OPAQUE},
1480 {SMB_VFS_OP(vfswrap_chflags), SMB_VFS_OP_CHFLAGS,
1481 SMB_VFS_LAYER_OPAQUE},
1482 {SMB_VFS_OP(vfswrap_file_id_create), SMB_VFS_OP_FILE_ID_CREATE,
1483 SMB_VFS_LAYER_OPAQUE},
1484 {SMB_VFS_OP(vfswrap_streaminfo), SMB_VFS_OP_STREAMINFO,
1485 SMB_VFS_LAYER_OPAQUE},
1486 {SMB_VFS_OP(vfswrap_get_real_filename), SMB_VFS_OP_GET_REAL_FILENAME,
1487 SMB_VFS_LAYER_OPAQUE},
1489 /* NT ACL operations. */
1491 {SMB_VFS_OP(vfswrap_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL,
1492 SMB_VFS_LAYER_OPAQUE},
1493 {SMB_VFS_OP(vfswrap_get_nt_acl), SMB_VFS_OP_GET_NT_ACL,
1494 SMB_VFS_LAYER_OPAQUE},
1495 {SMB_VFS_OP(vfswrap_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL,
1496 SMB_VFS_LAYER_OPAQUE},
1498 /* POSIX ACL operations. */
1500 {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1501 SMB_VFS_LAYER_OPAQUE},
1502 {SMB_VFS_OP(vfswrap_fchmod_acl), SMB_VFS_OP_FCHMOD_ACL,
1503 SMB_VFS_LAYER_OPAQUE},
1504 {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1505 SMB_VFS_LAYER_OPAQUE},
1506 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1507 SMB_VFS_LAYER_OPAQUE},
1508 {SMB_VFS_OP(vfswrap_sys_acl_get_permset), SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1509 SMB_VFS_LAYER_OPAQUE},
1510 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1511 SMB_VFS_LAYER_OPAQUE},
1512 {SMB_VFS_OP(vfswrap_sys_acl_get_file), SMB_VFS_OP_SYS_ACL_GET_FILE,
1513 SMB_VFS_LAYER_OPAQUE},
1514 {SMB_VFS_OP(vfswrap_sys_acl_get_fd), SMB_VFS_OP_SYS_ACL_GET_FD,
1515 SMB_VFS_LAYER_OPAQUE},
1516 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1517 SMB_VFS_LAYER_OPAQUE},
1518 {SMB_VFS_OP(vfswrap_sys_acl_add_perm), SMB_VFS_OP_SYS_ACL_ADD_PERM,
1519 SMB_VFS_LAYER_OPAQUE},
1520 {SMB_VFS_OP(vfswrap_sys_acl_to_text), SMB_VFS_OP_SYS_ACL_TO_TEXT,
1521 SMB_VFS_LAYER_OPAQUE},
1522 {SMB_VFS_OP(vfswrap_sys_acl_init), SMB_VFS_OP_SYS_ACL_INIT,
1523 SMB_VFS_LAYER_OPAQUE},
1524 {SMB_VFS_OP(vfswrap_sys_acl_create_entry), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1525 SMB_VFS_LAYER_OPAQUE},
1526 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1527 SMB_VFS_LAYER_OPAQUE},
1528 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1529 SMB_VFS_LAYER_OPAQUE},
1530 {SMB_VFS_OP(vfswrap_sys_acl_set_permset), SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1531 SMB_VFS_LAYER_OPAQUE},
1532 {SMB_VFS_OP(vfswrap_sys_acl_valid), SMB_VFS_OP_SYS_ACL_VALID,
1533 SMB_VFS_LAYER_OPAQUE},
1534 {SMB_VFS_OP(vfswrap_sys_acl_set_file), SMB_VFS_OP_SYS_ACL_SET_FILE,
1535 SMB_VFS_LAYER_OPAQUE},
1536 {SMB_VFS_OP(vfswrap_sys_acl_set_fd), SMB_VFS_OP_SYS_ACL_SET_FD,
1537 SMB_VFS_LAYER_OPAQUE},
1538 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1539 SMB_VFS_LAYER_OPAQUE},
1540 {SMB_VFS_OP(vfswrap_sys_acl_get_perm), SMB_VFS_OP_SYS_ACL_GET_PERM,
1541 SMB_VFS_LAYER_OPAQUE},
1542 {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1543 SMB_VFS_LAYER_OPAQUE},
1544 {SMB_VFS_OP(vfswrap_sys_acl_free_acl), SMB_VFS_OP_SYS_ACL_FREE_ACL,
1545 SMB_VFS_LAYER_OPAQUE},
1546 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1547 SMB_VFS_LAYER_OPAQUE},
1549 /* EA operations. */
1551 {SMB_VFS_OP(vfswrap_getxattr), SMB_VFS_OP_GETXATTR,
1552 SMB_VFS_LAYER_OPAQUE},
1553 {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1554 SMB_VFS_LAYER_OPAQUE},
1555 {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1556 SMB_VFS_LAYER_OPAQUE},
1557 {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1558 SMB_VFS_LAYER_OPAQUE},
1559 {SMB_VFS_OP(vfswrap_llistxattr), SMB_VFS_OP_LLISTXATTR,
1560 SMB_VFS_LAYER_OPAQUE},
1561 {SMB_VFS_OP(vfswrap_flistxattr), SMB_VFS_OP_FLISTXATTR,
1562 SMB_VFS_LAYER_OPAQUE},
1563 {SMB_VFS_OP(vfswrap_removexattr), SMB_VFS_OP_REMOVEXATTR,
1564 SMB_VFS_LAYER_OPAQUE},
1565 {SMB_VFS_OP(vfswrap_lremovexattr), SMB_VFS_OP_LREMOVEXATTR,
1566 SMB_VFS_LAYER_OPAQUE},
1567 {SMB_VFS_OP(vfswrap_fremovexattr), SMB_VFS_OP_FREMOVEXATTR,
1568 SMB_VFS_LAYER_OPAQUE},
1569 {SMB_VFS_OP(vfswrap_setxattr), SMB_VFS_OP_SETXATTR,
1570 SMB_VFS_LAYER_OPAQUE},
1571 {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1572 SMB_VFS_LAYER_OPAQUE},
1573 {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1574 SMB_VFS_LAYER_OPAQUE},
1576 {SMB_VFS_OP(vfswrap_aio_read), SMB_VFS_OP_AIO_READ,
1577 SMB_VFS_LAYER_OPAQUE},
1578 {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1579 SMB_VFS_LAYER_OPAQUE},
1580 {SMB_VFS_OP(vfswrap_aio_return), SMB_VFS_OP_AIO_RETURN,
1581 SMB_VFS_LAYER_OPAQUE},
1582 {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1583 SMB_VFS_LAYER_OPAQUE},
1584 {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1585 SMB_VFS_LAYER_OPAQUE},
1586 {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1587 SMB_VFS_LAYER_OPAQUE},
1588 {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1589 SMB_VFS_LAYER_OPAQUE},
1591 {SMB_VFS_OP(vfswrap_aio_force), SMB_VFS_OP_AIO_FORCE,
1592 SMB_VFS_LAYER_OPAQUE},
1594 {SMB_VFS_OP(vfswrap_is_offline),SMB_VFS_OP_IS_OFFLINE,
1595 SMB_VFS_LAYER_OPAQUE},
1596 {SMB_VFS_OP(vfswrap_set_offline),SMB_VFS_OP_SET_OFFLINE,
1597 SMB_VFS_LAYER_OPAQUE},
1599 /* Finish VFS operations definition */
1601 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP,
1605 NTSTATUS vfs_default_init(void);
1606 NTSTATUS vfs_default_init(void)
1608 unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1610 if (ARRAY_SIZE(vfs_default_ops) != needed) {
1611 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1612 DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1613 smb_panic("operation(s) missing from default VFS module");
1616 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1617 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);