2 Unix SMB/CIFS implementation.
3 Wrap disk only vfs functions to sidestep dodgy compilers.
4 Copyright (C) Tim Potter 1998
5 Copyright (C) Jeremy Allison 2007
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #define DBGC_CLASS DBGC_VFS
26 /* Check for NULL pointer parameters in vfswrap_* functions */
28 /* We don't want to have NULL function pointers lying around. Someone
29 is sure to try and execute them. These stubs are used to prevent
32 static int vfswrap_connect(vfs_handle_struct *handle, const char *service, const char *user)
34 return 0; /* Return >= 0 for success */
37 static void vfswrap_disconnect(vfs_handle_struct *handle)
43 static SMB_BIG_UINT vfswrap_disk_free(vfs_handle_struct *handle, const char *path, BOOL small_query, SMB_BIG_UINT *bsize,
44 SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
48 result = sys_disk_free(handle->conn, path, small_query, bsize, dfree, dsize);
52 static int vfswrap_get_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
54 #ifdef HAVE_SYS_QUOTAS
57 START_PROFILE(syscall_get_quota);
58 result = sys_get_quota(handle->conn->connectpath, qtype, id, qt);
59 END_PROFILE(syscall_get_quota);
67 static int vfswrap_set_quota(struct vfs_handle_struct *handle, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *qt)
69 #ifdef HAVE_SYS_QUOTAS
72 START_PROFILE(syscall_set_quota);
73 result = sys_set_quota(handle->conn->connectpath, qtype, id, qt);
74 END_PROFILE(syscall_set_quota);
82 static int vfswrap_get_shadow_copy_data(struct vfs_handle_struct *handle, struct files_struct *fsp, SHADOW_COPY_DATA *shadow_copy_data, BOOL labels)
85 return -1; /* Not implemented. */
88 static int vfswrap_statvfs(struct vfs_handle_struct *handle, const char *path, vfs_statvfs_struct *statbuf)
90 return sys_statvfs(path, statbuf);
93 /* Directory operations */
95 static SMB_STRUCT_DIR *vfswrap_opendir(vfs_handle_struct *handle, const char *fname, const char *mask, uint32 attr)
97 SMB_STRUCT_DIR *result;
99 START_PROFILE(syscall_opendir);
100 result = sys_opendir(fname);
101 END_PROFILE(syscall_opendir);
105 static SMB_STRUCT_DIRENT *vfswrap_readdir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
107 SMB_STRUCT_DIRENT *result;
109 START_PROFILE(syscall_readdir);
110 result = sys_readdir(dirp);
111 END_PROFILE(syscall_readdir);
115 static void vfswrap_seekdir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp, long offset)
117 START_PROFILE(syscall_seekdir);
118 sys_seekdir(dirp, offset);
119 END_PROFILE(syscall_seekdir);
122 static long vfswrap_telldir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
125 START_PROFILE(syscall_telldir);
126 result = sys_telldir(dirp);
127 END_PROFILE(syscall_telldir);
131 static void vfswrap_rewinddir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
133 START_PROFILE(syscall_rewinddir);
135 END_PROFILE(syscall_rewinddir);
138 static int vfswrap_mkdir(vfs_handle_struct *handle, const char *path, mode_t mode)
141 BOOL has_dacl = False;
143 START_PROFILE(syscall_mkdir);
145 if (lp_inherit_acls(SNUM(handle->conn)) && (has_dacl = directory_has_default_acl(handle->conn, parent_dirname(path))))
148 result = mkdir(path, mode);
150 if (result == 0 && !has_dacl) {
152 * We need to do this as the default behavior of POSIX ACLs
153 * is to set the mask to be the requested group permission
154 * bits, not the group permission bits to be the requested
155 * group permission bits. This is not what we want, as it will
156 * mess up any inherited ACL bits that were set. JRA.
158 int saved_errno = errno; /* We may get ENOSYS */
159 if ((SMB_VFS_CHMOD_ACL(handle->conn, path, mode) == -1) && (errno == ENOSYS))
163 END_PROFILE(syscall_mkdir);
167 static int vfswrap_rmdir(vfs_handle_struct *handle, const char *path)
171 START_PROFILE(syscall_rmdir);
172 result = rmdir(path);
173 END_PROFILE(syscall_rmdir);
177 static int vfswrap_closedir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp)
181 START_PROFILE(syscall_closedir);
182 result = sys_closedir(dirp);
183 END_PROFILE(syscall_closedir);
187 /* File operations */
189 static int vfswrap_open(vfs_handle_struct *handle, const char *fname,
190 files_struct *fsp, int flags, mode_t mode)
194 START_PROFILE(syscall_open);
195 result = sys_open(fname, flags, mode);
196 END_PROFILE(syscall_open);
200 static int vfswrap_close(vfs_handle_struct *handle, files_struct *fsp, int fd)
204 START_PROFILE(syscall_close);
207 END_PROFILE(syscall_close);
211 static ssize_t vfswrap_read(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data, size_t n)
215 START_PROFILE_BYTES(syscall_read, n);
216 result = sys_read(fd, data, n);
217 END_PROFILE(syscall_read);
221 static ssize_t vfswrap_pread(vfs_handle_struct *handle, files_struct *fsp, int fd, void *data,
222 size_t n, SMB_OFF_T offset)
226 #if defined(HAVE_PREAD) || defined(HAVE_PREAD64)
227 START_PROFILE_BYTES(syscall_pread, n);
228 result = sys_pread(fd, data, n, offset);
229 END_PROFILE(syscall_pread);
231 if (result == -1 && errno == ESPIPE) {
232 /* Maintain the fiction that pipes can be seeked (sought?) on. */
233 result = SMB_VFS_READ(fsp, fd, data, n);
237 #else /* HAVE_PREAD */
241 curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
242 if (curr == -1 && errno == ESPIPE) {
243 /* Maintain the fiction that pipes can be seeked (sought?) on. */
244 result = SMB_VFS_READ(fsp, fd, data, n);
249 if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
254 result = SMB_VFS_READ(fsp, fd, data, n);
257 SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
260 #endif /* HAVE_PREAD */
265 static ssize_t vfswrap_write(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data, size_t n)
269 START_PROFILE_BYTES(syscall_write, n);
270 result = sys_write(fd, data, n);
271 END_PROFILE(syscall_write);
275 static ssize_t vfswrap_pwrite(vfs_handle_struct *handle, files_struct *fsp, int fd, const void *data,
276 size_t n, SMB_OFF_T offset)
280 #if defined(HAVE_PWRITE) || defined(HAVE_PRWITE64)
281 START_PROFILE_BYTES(syscall_pwrite, n);
282 result = sys_pwrite(fd, data, n, offset);
283 END_PROFILE(syscall_pwrite);
285 if (result == -1 && errno == ESPIPE) {
286 /* Maintain the fiction that pipes can be sought on. */
287 result = SMB_VFS_WRITE(fsp, fd, data, n);
290 #else /* HAVE_PWRITE */
294 curr = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
299 if (SMB_VFS_LSEEK(fsp, fd, offset, SEEK_SET) == -1) {
303 result = SMB_VFS_WRITE(fsp, fd, data, n);
306 SMB_VFS_LSEEK(fsp, fd, curr, SEEK_SET);
309 #endif /* HAVE_PWRITE */
314 static SMB_OFF_T vfswrap_lseek(vfs_handle_struct *handle, files_struct *fsp, int filedes, SMB_OFF_T offset, int whence)
316 SMB_OFF_T result = 0;
318 START_PROFILE(syscall_lseek);
320 /* Cope with 'stat' file opens. */
322 result = sys_lseek(filedes, offset, whence);
325 * We want to maintain the fiction that we can seek
326 * on a fifo for file system purposes. This allows
327 * people to set up UNIX fifo's that feed data to Windows
331 if((result == -1) && (errno == ESPIPE)) {
336 END_PROFILE(syscall_lseek);
340 static ssize_t vfswrap_sendfile(vfs_handle_struct *handle, int tofd, files_struct *fsp, int fromfd, const DATA_BLOB *hdr,
341 SMB_OFF_T offset, size_t n)
345 START_PROFILE_BYTES(syscall_sendfile, n);
346 result = sys_sendfile(tofd, fromfd, hdr, offset, n);
347 END_PROFILE(syscall_sendfile);
351 /*********************************************************
352 For rename across filesystems Patch from Warren Birnbaum
353 <warrenb@hpcvscdp.cv.hp.com>
354 **********************************************************/
356 static int copy_reg(const char *source, const char *dest)
358 SMB_STRUCT_STAT source_stats;
363 if (sys_lstat (source, &source_stats) == -1)
366 if (!S_ISREG (source_stats.st_mode))
369 if((ifd = sys_open (source, O_RDONLY, 0)) < 0)
372 if (unlink (dest) && errno != ENOENT)
376 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC | O_NOFOLLOW, 0600)) < 0 )
378 if((ofd = sys_open (dest, O_WRONLY | O_CREAT | O_TRUNC , 0600)) < 0 )
382 if (transfer_file(ifd, ofd, (size_t)-1) == -1)
386 * Try to preserve ownership. For non-root it might fail, but that's ok.
387 * But root probably wants to know, e.g. if NFS disallows it.
391 if ((fchown(ofd, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
393 if ((chown(dest, source_stats.st_uid, source_stats.st_gid) == -1) && (errno != EPERM))
398 * fchown turns off set[ug]id bits for non-root,
399 * so do the chmod last.
402 #if defined(HAVE_FCHMOD)
403 if (fchmod (ofd, source_stats.st_mode & 07777))
405 if (chmod (dest, source_stats.st_mode & 07777))
409 if (close (ifd) == -1)
412 if (close (ofd) == -1)
415 /* Try to copy the old file's modtime and access time. */
419 tv.actime = source_stats.st_atime;
420 tv.modtime = source_stats.st_mtime;
424 if (unlink (source) == -1)
440 static int vfswrap_rename(vfs_handle_struct *handle, const char *oldname, const char *newname)
444 START_PROFILE(syscall_rename);
445 result = rename(oldname, newname);
446 if (errno == EXDEV) {
447 /* Rename across filesystems needed. */
448 result = copy_reg(oldname, newname);
451 END_PROFILE(syscall_rename);
455 static int vfswrap_fsync(vfs_handle_struct *handle, files_struct *fsp, int fd)
460 START_PROFILE(syscall_fsync);
462 END_PROFILE(syscall_fsync);
469 static int vfswrap_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
473 START_PROFILE(syscall_stat);
474 result = sys_stat(fname, sbuf);
475 END_PROFILE(syscall_stat);
479 static int vfswrap_fstat(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_STRUCT_STAT *sbuf)
483 START_PROFILE(syscall_fstat);
484 result = sys_fstat(fd, sbuf);
485 END_PROFILE(syscall_fstat);
489 int vfswrap_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
493 START_PROFILE(syscall_lstat);
494 result = sys_lstat(path, sbuf);
495 END_PROFILE(syscall_lstat);
499 static int vfswrap_unlink(vfs_handle_struct *handle, const char *path)
503 START_PROFILE(syscall_unlink);
504 result = unlink(path);
505 END_PROFILE(syscall_unlink);
509 static int vfswrap_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
513 START_PROFILE(syscall_chmod);
516 * We need to do this due to the fact that the default POSIX ACL
517 * chmod modifies the ACL *mask* for the group owner, not the
518 * group owner bits directly. JRA.
523 int saved_errno = errno; /* We might get ENOSYS */
524 if ((result = SMB_VFS_CHMOD_ACL(handle->conn, path, mode)) == 0) {
525 END_PROFILE(syscall_chmod);
528 /* Error - return the old errno. */
532 result = chmod(path, mode);
533 END_PROFILE(syscall_chmod);
537 static int vfswrap_fchmod(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
541 START_PROFILE(syscall_fchmod);
544 * We need to do this due to the fact that the default POSIX ACL
545 * chmod modifies the ACL *mask* for the group owner, not the
546 * group owner bits directly. JRA.
550 int saved_errno = errno; /* We might get ENOSYS */
551 if ((result = SMB_VFS_FCHMOD_ACL(fsp, fd, mode)) == 0) {
552 END_PROFILE(syscall_fchmod);
555 /* Error - return the old errno. */
559 #if defined(HAVE_FCHMOD)
560 result = fchmod(fd, mode);
566 END_PROFILE(syscall_fchmod);
570 static int vfswrap_chown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
574 START_PROFILE(syscall_chown);
575 result = sys_chown(path, uid, gid);
576 END_PROFILE(syscall_chown);
580 static int vfswrap_fchown(vfs_handle_struct *handle, files_struct *fsp, int fd, uid_t uid, gid_t gid)
585 START_PROFILE(syscall_fchown);
586 result = fchown(fd, uid, gid);
587 END_PROFILE(syscall_fchown);
595 static int vfswrap_lchown(vfs_handle_struct *handle, const char *path, uid_t uid, gid_t gid)
599 START_PROFILE(syscall_lchown);
600 result = sys_lchown(path, uid, gid);
601 END_PROFILE(syscall_lchown);
605 static int vfswrap_chdir(vfs_handle_struct *handle, const char *path)
609 START_PROFILE(syscall_chdir);
610 result = chdir(path);
611 END_PROFILE(syscall_chdir);
615 static char *vfswrap_getwd(vfs_handle_struct *handle, char *path)
619 START_PROFILE(syscall_getwd);
620 result = sys_getwd(path);
621 END_PROFILE(syscall_getwd);
625 /*********************************************************************
626 nsec timestamp resolution call. Convert down to whatever the underlying
628 **********************************************************************/
630 static int vfswrap_ntimes(vfs_handle_struct *handle, const char *path, const struct timespec ts[2])
634 START_PROFILE(syscall_ntimes);
635 #if defined(HAVE_UTIMES)
637 struct timeval tv[2];
638 tv[0] = convert_timespec_to_timeval(ts[0]);
639 tv[1] = convert_timespec_to_timeval(ts[1]);
640 result = utimes(path, tv);
642 #elif defined(HAVE_UTIME)
644 struct utimbuf times;
645 times.actime = convert_timespec_to_time_t(ts[0]);
646 times.modtime = convert_timespec_to_time_t(ts[1]);
647 result = utime(path, times);
653 END_PROFILE(syscall_ntimes);
657 /*********************************************************************
658 A version of ftruncate that will write the space on disk if strict
660 **********************************************************************/
662 static int strict_allocate_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
665 SMB_OFF_T currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
666 unsigned char zero_space[4096];
667 SMB_OFF_T space_to_write;
672 if (SMB_VFS_FSTAT(fsp, fd, &st) == -1)
675 space_to_write = len - st.st_size;
678 if (S_ISFIFO(st.st_mode))
682 if (st.st_size == len)
685 /* Shrink - just ftruncate. */
686 if (st.st_size > len)
687 return sys_ftruncate(fd, len);
689 /* Write out the real space on disk. */
690 if (SMB_VFS_LSEEK(fsp, fd, st.st_size, SEEK_SET) != st.st_size)
693 space_to_write = len - st.st_size;
695 memset(zero_space, '\0', sizeof(zero_space));
696 while ( space_to_write > 0) {
698 SMB_OFF_T current_len_to_write = MIN(sizeof(zero_space),space_to_write);
700 retlen = SMB_VFS_WRITE(fsp,fsp->fh->fd,(char *)zero_space,current_len_to_write);
704 space_to_write -= retlen;
707 /* Seek to where we were */
708 if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
714 static int vfswrap_ftruncate(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T len)
721 START_PROFILE(syscall_ftruncate);
723 if (lp_strict_allocate(SNUM(fsp->conn))) {
724 result = strict_allocate_ftruncate(handle, fsp, fd, len);
725 END_PROFILE(syscall_ftruncate);
729 /* we used to just check HAVE_FTRUNCATE_EXTEND and only use
730 sys_ftruncate if the system supports it. Then I discovered that
731 you can have some filesystems that support ftruncate
732 expansion and some that don't! On Linux fat can't do
733 ftruncate extend but ext2 can. */
735 result = sys_ftruncate(fd, len);
739 /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
740 extend a file with ftruncate. Provide alternate implementation
742 currpos = SMB_VFS_LSEEK(fsp, fd, 0, SEEK_CUR);
747 /* Do an fstat to see if the file is longer than the requested
748 size in which case the ftruncate above should have
749 succeeded or shorter, in which case seek to len - 1 and
750 write 1 byte of zero */
751 if (SMB_VFS_FSTAT(fsp, fd, &st) == -1) {
756 if (S_ISFIFO(st.st_mode)) {
762 if (st.st_size == len) {
767 if (st.st_size > len) {
768 /* the sys_ftruncate should have worked */
772 if (SMB_VFS_LSEEK(fsp, fd, len-1, SEEK_SET) != len -1)
775 if (SMB_VFS_WRITE(fsp, fd, &c, 1)!=1)
778 /* Seek to where we were */
779 if (SMB_VFS_LSEEK(fsp, fd, currpos, SEEK_SET) != currpos)
785 END_PROFILE(syscall_ftruncate);
789 static BOOL vfswrap_lock(vfs_handle_struct *handle, files_struct *fsp, int fd, int op, SMB_OFF_T offset, SMB_OFF_T count, int type)
793 START_PROFILE(syscall_fcntl_lock);
794 result = fcntl_lock(fd, op, offset, count, type);
795 END_PROFILE(syscall_fcntl_lock);
799 static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp, int fd,
802 START_PROFILE(syscall_kernel_flock);
803 kernel_flock(fd, share_mode);
804 END_PROFILE(syscall_kernel_flock);
808 static BOOL vfswrap_getlock(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_OFF_T *poffset, SMB_OFF_T *pcount, int *ptype, pid_t *ppid)
812 START_PROFILE(syscall_fcntl_getlock);
813 result = fcntl_getlock(fd, poffset, pcount, ptype, ppid);
814 END_PROFILE(syscall_fcntl_getlock);
818 static int vfswrap_linux_setlease(vfs_handle_struct *handle, files_struct *fsp, int fd,
823 START_PROFILE(syscall_linux_setlease);
825 #ifdef HAVE_KERNEL_OPLOCKS_LINUX
826 /* first set the signal handler */
827 if(linux_set_lease_sighandler(fd) == -1) {
831 result = linux_setlease(fd, leasetype);
835 END_PROFILE(syscall_linux_setlease);
839 static int vfswrap_symlink(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
843 START_PROFILE(syscall_symlink);
844 result = sys_symlink(oldpath, newpath);
845 END_PROFILE(syscall_symlink);
849 static int vfswrap_readlink(vfs_handle_struct *handle, const char *path, char *buf, size_t bufsiz)
853 START_PROFILE(syscall_readlink);
854 result = sys_readlink(path, buf, bufsiz);
855 END_PROFILE(syscall_readlink);
859 static int vfswrap_link(vfs_handle_struct *handle, const char *oldpath, const char *newpath)
863 START_PROFILE(syscall_link);
864 result = sys_link(oldpath, newpath);
865 END_PROFILE(syscall_link);
869 static int vfswrap_mknod(vfs_handle_struct *handle, const char *pathname, mode_t mode, SMB_DEV_T dev)
873 START_PROFILE(syscall_mknod);
874 result = sys_mknod(pathname, mode, dev);
875 END_PROFILE(syscall_mknod);
879 static char *vfswrap_realpath(vfs_handle_struct *handle, const char *path, char *resolved_path)
883 START_PROFILE(syscall_realpath);
884 result = sys_realpath(path, resolved_path);
885 END_PROFILE(syscall_realpath);
889 static NTSTATUS vfswrap_notify_watch(vfs_handle_struct *vfs_handle,
890 struct sys_notify_context *ctx,
891 struct notify_entry *e,
892 void (*callback)(struct sys_notify_context *ctx,
894 struct notify_event *ev),
895 void *private_data, void *handle)
898 * So far inotify is the only supported default notify mechanism. If
899 * another platform like the the BSD's or a proprietary Unix comes
900 * along and wants another default, we can play the same trick we
901 * played with Posix ACLs.
903 * Until that is the case, hard-code inotify here.
906 if (lp_kernel_change_notify(ctx->conn->params)) {
907 return inotify_watch(ctx, e, callback, private_data, handle);
911 * Do nothing, leave everything to notify_internal.c
916 static int vfswrap_chflags(vfs_handle_struct *handle, const char *path, int flags)
919 return chflags(path, flags);
926 static struct file_id vfswrap_file_id_create(struct vfs_handle_struct *handle, SMB_DEV_T dev, SMB_INO_T inode)
928 return file_id_create_dev(dev, inode);
931 static size_t vfswrap_fget_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info, SEC_DESC **ppdesc)
935 START_PROFILE(fget_nt_acl);
936 result = get_nt_acl(fsp, security_info, ppdesc);
937 END_PROFILE(fget_nt_acl);
941 static size_t vfswrap_get_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info, SEC_DESC **ppdesc)
945 START_PROFILE(get_nt_acl);
946 result = get_nt_acl(fsp, security_info, ppdesc);
947 END_PROFILE(get_nt_acl);
951 static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, uint32 security_info_sent, SEC_DESC *psd)
955 START_PROFILE(fset_nt_acl);
956 result = set_nt_acl(fsp, security_info_sent, psd);
957 END_PROFILE(fset_nt_acl);
961 static NTSTATUS vfswrap_set_nt_acl(vfs_handle_struct *handle, files_struct *fsp, const char *name, uint32 security_info_sent, SEC_DESC *psd)
965 START_PROFILE(set_nt_acl);
966 result = set_nt_acl(fsp, security_info_sent, psd);
967 END_PROFILE(set_nt_acl);
971 static int vfswrap_chmod_acl(vfs_handle_struct *handle, const char *name, mode_t mode)
979 START_PROFILE(chmod_acl);
980 result = chmod_acl(handle->conn, name, mode);
981 END_PROFILE(chmod_acl);
986 static int vfswrap_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, int fd, mode_t mode)
994 START_PROFILE(fchmod_acl);
995 result = fchmod_acl(fsp, fd, mode);
996 END_PROFILE(fchmod_acl);
1001 static int vfswrap_sys_acl_get_entry(vfs_handle_struct *handle, SMB_ACL_T theacl, int entry_id, SMB_ACL_ENTRY_T *entry_p)
1003 return sys_acl_get_entry(theacl, entry_id, entry_p);
1006 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)
1008 return sys_acl_get_tag_type(entry_d, tag_type_p);
1011 static int vfswrap_sys_acl_get_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d, SMB_ACL_PERMSET_T *permset_p)
1013 return sys_acl_get_permset(entry_d, permset_p);
1016 static void * vfswrap_sys_acl_get_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry_d)
1018 return sys_acl_get_qualifier(entry_d);
1021 static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle, const char *path_p, SMB_ACL_TYPE_T type)
1023 return sys_acl_get_file(handle, path_p, type);
1026 static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle, files_struct *fsp, int fd)
1028 return sys_acl_get_fd(handle, fsp, fd);
1031 static int vfswrap_sys_acl_clear_perms(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset)
1033 return sys_acl_clear_perms(permset);
1036 static int vfswrap_sys_acl_add_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1038 return sys_acl_add_perm(permset, perm);
1041 static char * vfswrap_sys_acl_to_text(vfs_handle_struct *handle, SMB_ACL_T theacl, ssize_t *plen)
1043 return sys_acl_to_text(theacl, plen);
1046 static SMB_ACL_T vfswrap_sys_acl_init(vfs_handle_struct *handle, int count)
1048 return sys_acl_init(count);
1051 static int vfswrap_sys_acl_create_entry(vfs_handle_struct *handle, SMB_ACL_T *pacl, SMB_ACL_ENTRY_T *pentry)
1053 return sys_acl_create_entry(pacl, pentry);
1056 static int vfswrap_sys_acl_set_tag_type(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_TAG_T tagtype)
1058 return sys_acl_set_tag_type(entry, tagtype);
1061 static int vfswrap_sys_acl_set_qualifier(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, void *qual)
1063 return sys_acl_set_qualifier(entry, qual);
1066 static int vfswrap_sys_acl_set_permset(vfs_handle_struct *handle, SMB_ACL_ENTRY_T entry, SMB_ACL_PERMSET_T permset)
1068 return sys_acl_set_permset(entry, permset);
1071 static int vfswrap_sys_acl_valid(vfs_handle_struct *handle, SMB_ACL_T theacl )
1073 return sys_acl_valid(theacl );
1076 static int vfswrap_sys_acl_set_file(vfs_handle_struct *handle, const char *name, SMB_ACL_TYPE_T acltype, SMB_ACL_T theacl)
1078 return sys_acl_set_file(handle, name, acltype, theacl);
1081 static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle, files_struct *fsp, int fd, SMB_ACL_T theacl)
1083 return sys_acl_set_fd(handle, fsp, fd, theacl);
1086 static int vfswrap_sys_acl_delete_def_file(vfs_handle_struct *handle, const char *path)
1088 return sys_acl_delete_def_file(handle, path);
1091 static int vfswrap_sys_acl_get_perm(vfs_handle_struct *handle, SMB_ACL_PERMSET_T permset, SMB_ACL_PERM_T perm)
1093 return sys_acl_get_perm(permset, perm);
1096 static int vfswrap_sys_acl_free_text(vfs_handle_struct *handle, char *text)
1098 return sys_acl_free_text(text);
1101 static int vfswrap_sys_acl_free_acl(vfs_handle_struct *handle, SMB_ACL_T posix_acl)
1103 return sys_acl_free_acl(posix_acl);
1106 static int vfswrap_sys_acl_free_qualifier(vfs_handle_struct *handle, void *qualifier, SMB_ACL_TAG_T tagtype)
1108 return sys_acl_free_qualifier(qualifier, tagtype);
1111 /****************************************************************
1112 Extended attribute operations.
1113 *****************************************************************/
1115 static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1117 return sys_getxattr(path, name, value, size);
1120 static ssize_t vfswrap_lgetxattr(struct vfs_handle_struct *handle,const char *path, const char *name, void *value, size_t size)
1122 return sys_lgetxattr(path, name, value, size);
1125 static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, void *value, size_t size)
1127 return sys_fgetxattr(fd, name, value, size);
1130 static ssize_t vfswrap_listxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1132 return sys_listxattr(path, list, size);
1135 ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size)
1137 return sys_llistxattr(path, list, size);
1140 ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, char *list, size_t size)
1142 return sys_flistxattr(fd, list, size);
1145 static int vfswrap_removexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1147 return sys_removexattr(path, name);
1150 static int vfswrap_lremovexattr(struct vfs_handle_struct *handle, const char *path, const char *name)
1152 return sys_lremovexattr(path, name);
1155 static int vfswrap_fremovexattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name)
1157 return sys_fremovexattr(fd, name);
1160 static int vfswrap_setxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1162 return sys_setxattr(path, name, value, size, flags);
1165 static int vfswrap_lsetxattr(struct vfs_handle_struct *handle, const char *path, const char *name, const void *value, size_t size, int flags)
1167 return sys_lsetxattr(path, name, value, size, flags);
1170 static int vfswrap_fsetxattr(struct vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, const void *value, size_t size, int flags)
1172 return sys_fsetxattr(fd, name, value, size, flags);
1175 static int vfswrap_aio_read(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1177 return sys_aio_read(aiocb);
1180 static int vfswrap_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1182 return sys_aio_write(aiocb);
1185 static ssize_t vfswrap_aio_return(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1187 return sys_aio_return(aiocb);
1190 static int vfswrap_aio_cancel(struct vfs_handle_struct *handle, struct files_struct *fsp, int fd, SMB_STRUCT_AIOCB *aiocb)
1192 return sys_aio_cancel(fd, aiocb);
1195 static int vfswrap_aio_error(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb)
1197 return sys_aio_error(aiocb);
1200 static int vfswrap_aio_fsync(struct vfs_handle_struct *handle, struct files_struct *fsp, int op, SMB_STRUCT_AIOCB *aiocb)
1202 return sys_aio_fsync(op, aiocb);
1205 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)
1207 return sys_aio_suspend(aiocb, n, timeout);
1210 static vfs_op_tuple vfs_default_ops[] = {
1212 /* Disk operations */
1214 {SMB_VFS_OP(vfswrap_connect), SMB_VFS_OP_CONNECT,
1215 SMB_VFS_LAYER_OPAQUE},
1216 {SMB_VFS_OP(vfswrap_disconnect), SMB_VFS_OP_DISCONNECT,
1217 SMB_VFS_LAYER_OPAQUE},
1218 {SMB_VFS_OP(vfswrap_disk_free), SMB_VFS_OP_DISK_FREE,
1219 SMB_VFS_LAYER_OPAQUE},
1220 {SMB_VFS_OP(vfswrap_get_quota), SMB_VFS_OP_GET_QUOTA,
1221 SMB_VFS_LAYER_OPAQUE},
1222 {SMB_VFS_OP(vfswrap_set_quota), SMB_VFS_OP_SET_QUOTA,
1223 SMB_VFS_LAYER_OPAQUE},
1224 {SMB_VFS_OP(vfswrap_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,
1225 SMB_VFS_LAYER_OPAQUE},
1226 {SMB_VFS_OP(vfswrap_statvfs), SMB_VFS_OP_STATVFS,
1227 SMB_VFS_LAYER_OPAQUE},
1229 /* Directory operations */
1231 {SMB_VFS_OP(vfswrap_opendir), SMB_VFS_OP_OPENDIR,
1232 SMB_VFS_LAYER_OPAQUE},
1233 {SMB_VFS_OP(vfswrap_readdir), SMB_VFS_OP_READDIR,
1234 SMB_VFS_LAYER_OPAQUE},
1235 {SMB_VFS_OP(vfswrap_seekdir), SMB_VFS_OP_SEEKDIR,
1236 SMB_VFS_LAYER_OPAQUE},
1237 {SMB_VFS_OP(vfswrap_telldir), SMB_VFS_OP_TELLDIR,
1238 SMB_VFS_LAYER_OPAQUE},
1239 {SMB_VFS_OP(vfswrap_rewinddir), SMB_VFS_OP_REWINDDIR,
1240 SMB_VFS_LAYER_OPAQUE},
1241 {SMB_VFS_OP(vfswrap_mkdir), SMB_VFS_OP_MKDIR,
1242 SMB_VFS_LAYER_OPAQUE},
1243 {SMB_VFS_OP(vfswrap_rmdir), SMB_VFS_OP_RMDIR,
1244 SMB_VFS_LAYER_OPAQUE},
1245 {SMB_VFS_OP(vfswrap_closedir), SMB_VFS_OP_CLOSEDIR,
1246 SMB_VFS_LAYER_OPAQUE},
1248 /* File operations */
1250 {SMB_VFS_OP(vfswrap_open), SMB_VFS_OP_OPEN,
1251 SMB_VFS_LAYER_OPAQUE},
1252 {SMB_VFS_OP(vfswrap_close), SMB_VFS_OP_CLOSE,
1253 SMB_VFS_LAYER_OPAQUE},
1254 {SMB_VFS_OP(vfswrap_read), SMB_VFS_OP_READ,
1255 SMB_VFS_LAYER_OPAQUE},
1256 {SMB_VFS_OP(vfswrap_pread), SMB_VFS_OP_PREAD,
1257 SMB_VFS_LAYER_OPAQUE},
1258 {SMB_VFS_OP(vfswrap_write), SMB_VFS_OP_WRITE,
1259 SMB_VFS_LAYER_OPAQUE},
1260 {SMB_VFS_OP(vfswrap_pwrite), SMB_VFS_OP_PWRITE,
1261 SMB_VFS_LAYER_OPAQUE},
1262 {SMB_VFS_OP(vfswrap_lseek), SMB_VFS_OP_LSEEK,
1263 SMB_VFS_LAYER_OPAQUE},
1264 {SMB_VFS_OP(vfswrap_sendfile), SMB_VFS_OP_SENDFILE,
1265 SMB_VFS_LAYER_OPAQUE},
1266 {SMB_VFS_OP(vfswrap_rename), SMB_VFS_OP_RENAME,
1267 SMB_VFS_LAYER_OPAQUE},
1268 {SMB_VFS_OP(vfswrap_fsync), SMB_VFS_OP_FSYNC,
1269 SMB_VFS_LAYER_OPAQUE},
1270 {SMB_VFS_OP(vfswrap_stat), SMB_VFS_OP_STAT,
1271 SMB_VFS_LAYER_OPAQUE},
1272 {SMB_VFS_OP(vfswrap_fstat), SMB_VFS_OP_FSTAT,
1273 SMB_VFS_LAYER_OPAQUE},
1274 {SMB_VFS_OP(vfswrap_lstat), SMB_VFS_OP_LSTAT,
1275 SMB_VFS_LAYER_OPAQUE},
1276 {SMB_VFS_OP(vfswrap_unlink), SMB_VFS_OP_UNLINK,
1277 SMB_VFS_LAYER_OPAQUE},
1278 {SMB_VFS_OP(vfswrap_chmod), SMB_VFS_OP_CHMOD,
1279 SMB_VFS_LAYER_OPAQUE},
1280 {SMB_VFS_OP(vfswrap_fchmod), SMB_VFS_OP_FCHMOD,
1281 SMB_VFS_LAYER_OPAQUE},
1282 {SMB_VFS_OP(vfswrap_chown), SMB_VFS_OP_CHOWN,
1283 SMB_VFS_LAYER_OPAQUE},
1284 {SMB_VFS_OP(vfswrap_fchown), SMB_VFS_OP_FCHOWN,
1285 SMB_VFS_LAYER_OPAQUE},
1286 {SMB_VFS_OP(vfswrap_lchown), SMB_VFS_OP_LCHOWN,
1287 SMB_VFS_LAYER_OPAQUE},
1288 {SMB_VFS_OP(vfswrap_chdir), SMB_VFS_OP_CHDIR,
1289 SMB_VFS_LAYER_OPAQUE},
1290 {SMB_VFS_OP(vfswrap_getwd), SMB_VFS_OP_GETWD,
1291 SMB_VFS_LAYER_OPAQUE},
1292 {SMB_VFS_OP(vfswrap_ntimes), SMB_VFS_OP_NTIMES,
1293 SMB_VFS_LAYER_OPAQUE},
1294 {SMB_VFS_OP(vfswrap_ftruncate), SMB_VFS_OP_FTRUNCATE,
1295 SMB_VFS_LAYER_OPAQUE},
1296 {SMB_VFS_OP(vfswrap_lock), SMB_VFS_OP_LOCK,
1297 SMB_VFS_LAYER_OPAQUE},
1298 {SMB_VFS_OP(vfswrap_kernel_flock), SMB_VFS_OP_KERNEL_FLOCK,
1299 SMB_VFS_LAYER_OPAQUE},
1300 {SMB_VFS_OP(vfswrap_linux_setlease), SMB_VFS_OP_LINUX_SETLEASE,
1301 SMB_VFS_LAYER_OPAQUE},
1302 {SMB_VFS_OP(vfswrap_getlock), SMB_VFS_OP_GETLOCK,
1303 SMB_VFS_LAYER_OPAQUE},
1304 {SMB_VFS_OP(vfswrap_symlink), SMB_VFS_OP_SYMLINK,
1305 SMB_VFS_LAYER_OPAQUE},
1306 {SMB_VFS_OP(vfswrap_readlink), SMB_VFS_OP_READLINK,
1307 SMB_VFS_LAYER_OPAQUE},
1308 {SMB_VFS_OP(vfswrap_link), SMB_VFS_OP_LINK,
1309 SMB_VFS_LAYER_OPAQUE},
1310 {SMB_VFS_OP(vfswrap_mknod), SMB_VFS_OP_MKNOD,
1311 SMB_VFS_LAYER_OPAQUE},
1312 {SMB_VFS_OP(vfswrap_realpath), SMB_VFS_OP_REALPATH,
1313 SMB_VFS_LAYER_OPAQUE},
1314 {SMB_VFS_OP(vfswrap_notify_watch), SMB_VFS_OP_NOTIFY_WATCH,
1315 SMB_VFS_LAYER_OPAQUE},
1316 {SMB_VFS_OP(vfswrap_chflags), SMB_VFS_OP_CHFLAGS,
1317 SMB_VFS_LAYER_OPAQUE},
1318 {SMB_VFS_OP(vfswrap_file_id_create), SMB_VFS_OP_FILE_ID_CREATE,
1319 SMB_VFS_LAYER_OPAQUE},
1321 /* NT ACL operations. */
1323 {SMB_VFS_OP(vfswrap_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL,
1324 SMB_VFS_LAYER_OPAQUE},
1325 {SMB_VFS_OP(vfswrap_get_nt_acl), SMB_VFS_OP_GET_NT_ACL,
1326 SMB_VFS_LAYER_OPAQUE},
1327 {SMB_VFS_OP(vfswrap_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL,
1328 SMB_VFS_LAYER_OPAQUE},
1329 {SMB_VFS_OP(vfswrap_set_nt_acl), SMB_VFS_OP_SET_NT_ACL,
1330 SMB_VFS_LAYER_OPAQUE},
1332 /* POSIX ACL operations. */
1334 {SMB_VFS_OP(vfswrap_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
1335 SMB_VFS_LAYER_OPAQUE},
1336 {SMB_VFS_OP(vfswrap_fchmod_acl), SMB_VFS_OP_FCHMOD_ACL,
1337 SMB_VFS_LAYER_OPAQUE},
1338 {SMB_VFS_OP(vfswrap_sys_acl_get_entry), SMB_VFS_OP_SYS_ACL_GET_ENTRY,
1339 SMB_VFS_LAYER_OPAQUE},
1340 {SMB_VFS_OP(vfswrap_sys_acl_get_tag_type), SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
1341 SMB_VFS_LAYER_OPAQUE},
1342 {SMB_VFS_OP(vfswrap_sys_acl_get_permset), SMB_VFS_OP_SYS_ACL_GET_PERMSET,
1343 SMB_VFS_LAYER_OPAQUE},
1344 {SMB_VFS_OP(vfswrap_sys_acl_get_qualifier), SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
1345 SMB_VFS_LAYER_OPAQUE},
1346 {SMB_VFS_OP(vfswrap_sys_acl_get_file), SMB_VFS_OP_SYS_ACL_GET_FILE,
1347 SMB_VFS_LAYER_OPAQUE},
1348 {SMB_VFS_OP(vfswrap_sys_acl_get_fd), SMB_VFS_OP_SYS_ACL_GET_FD,
1349 SMB_VFS_LAYER_OPAQUE},
1350 {SMB_VFS_OP(vfswrap_sys_acl_clear_perms), SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
1351 SMB_VFS_LAYER_OPAQUE},
1352 {SMB_VFS_OP(vfswrap_sys_acl_add_perm), SMB_VFS_OP_SYS_ACL_ADD_PERM,
1353 SMB_VFS_LAYER_OPAQUE},
1354 {SMB_VFS_OP(vfswrap_sys_acl_to_text), SMB_VFS_OP_SYS_ACL_TO_TEXT,
1355 SMB_VFS_LAYER_OPAQUE},
1356 {SMB_VFS_OP(vfswrap_sys_acl_init), SMB_VFS_OP_SYS_ACL_INIT,
1357 SMB_VFS_LAYER_OPAQUE},
1358 {SMB_VFS_OP(vfswrap_sys_acl_create_entry), SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
1359 SMB_VFS_LAYER_OPAQUE},
1360 {SMB_VFS_OP(vfswrap_sys_acl_set_tag_type), SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
1361 SMB_VFS_LAYER_OPAQUE},
1362 {SMB_VFS_OP(vfswrap_sys_acl_set_qualifier), SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
1363 SMB_VFS_LAYER_OPAQUE},
1364 {SMB_VFS_OP(vfswrap_sys_acl_set_permset), SMB_VFS_OP_SYS_ACL_SET_PERMSET,
1365 SMB_VFS_LAYER_OPAQUE},
1366 {SMB_VFS_OP(vfswrap_sys_acl_valid), SMB_VFS_OP_SYS_ACL_VALID,
1367 SMB_VFS_LAYER_OPAQUE},
1368 {SMB_VFS_OP(vfswrap_sys_acl_set_file), SMB_VFS_OP_SYS_ACL_SET_FILE,
1369 SMB_VFS_LAYER_OPAQUE},
1370 {SMB_VFS_OP(vfswrap_sys_acl_set_fd), SMB_VFS_OP_SYS_ACL_SET_FD,
1371 SMB_VFS_LAYER_OPAQUE},
1372 {SMB_VFS_OP(vfswrap_sys_acl_delete_def_file), SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
1373 SMB_VFS_LAYER_OPAQUE},
1374 {SMB_VFS_OP(vfswrap_sys_acl_get_perm), SMB_VFS_OP_SYS_ACL_GET_PERM,
1375 SMB_VFS_LAYER_OPAQUE},
1376 {SMB_VFS_OP(vfswrap_sys_acl_free_text), SMB_VFS_OP_SYS_ACL_FREE_TEXT,
1377 SMB_VFS_LAYER_OPAQUE},
1378 {SMB_VFS_OP(vfswrap_sys_acl_free_acl), SMB_VFS_OP_SYS_ACL_FREE_ACL,
1379 SMB_VFS_LAYER_OPAQUE},
1380 {SMB_VFS_OP(vfswrap_sys_acl_free_qualifier), SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
1381 SMB_VFS_LAYER_OPAQUE},
1383 /* EA operations. */
1385 {SMB_VFS_OP(vfswrap_getxattr), SMB_VFS_OP_GETXATTR,
1386 SMB_VFS_LAYER_OPAQUE},
1387 {SMB_VFS_OP(vfswrap_lgetxattr), SMB_VFS_OP_LGETXATTR,
1388 SMB_VFS_LAYER_OPAQUE},
1389 {SMB_VFS_OP(vfswrap_fgetxattr), SMB_VFS_OP_FGETXATTR,
1390 SMB_VFS_LAYER_OPAQUE},
1391 {SMB_VFS_OP(vfswrap_listxattr), SMB_VFS_OP_LISTXATTR,
1392 SMB_VFS_LAYER_OPAQUE},
1393 {SMB_VFS_OP(vfswrap_llistxattr), SMB_VFS_OP_LLISTXATTR,
1394 SMB_VFS_LAYER_OPAQUE},
1395 {SMB_VFS_OP(vfswrap_flistxattr), SMB_VFS_OP_FLISTXATTR,
1396 SMB_VFS_LAYER_OPAQUE},
1397 {SMB_VFS_OP(vfswrap_removexattr), SMB_VFS_OP_REMOVEXATTR,
1398 SMB_VFS_LAYER_OPAQUE},
1399 {SMB_VFS_OP(vfswrap_lremovexattr), SMB_VFS_OP_LREMOVEXATTR,
1400 SMB_VFS_LAYER_OPAQUE},
1401 {SMB_VFS_OP(vfswrap_fremovexattr), SMB_VFS_OP_FREMOVEXATTR,
1402 SMB_VFS_LAYER_OPAQUE},
1403 {SMB_VFS_OP(vfswrap_setxattr), SMB_VFS_OP_SETXATTR,
1404 SMB_VFS_LAYER_OPAQUE},
1405 {SMB_VFS_OP(vfswrap_lsetxattr), SMB_VFS_OP_LSETXATTR,
1406 SMB_VFS_LAYER_OPAQUE},
1407 {SMB_VFS_OP(vfswrap_fsetxattr), SMB_VFS_OP_FSETXATTR,
1408 SMB_VFS_LAYER_OPAQUE},
1410 {SMB_VFS_OP(vfswrap_aio_read), SMB_VFS_OP_AIO_READ,
1411 SMB_VFS_LAYER_OPAQUE},
1412 {SMB_VFS_OP(vfswrap_aio_write), SMB_VFS_OP_AIO_WRITE,
1413 SMB_VFS_LAYER_OPAQUE},
1414 {SMB_VFS_OP(vfswrap_aio_return), SMB_VFS_OP_AIO_RETURN,
1415 SMB_VFS_LAYER_OPAQUE},
1416 {SMB_VFS_OP(vfswrap_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
1417 SMB_VFS_LAYER_OPAQUE},
1418 {SMB_VFS_OP(vfswrap_aio_error), SMB_VFS_OP_AIO_ERROR,
1419 SMB_VFS_LAYER_OPAQUE},
1420 {SMB_VFS_OP(vfswrap_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
1421 SMB_VFS_LAYER_OPAQUE},
1422 {SMB_VFS_OP(vfswrap_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
1423 SMB_VFS_LAYER_OPAQUE},
1425 /* Finish VFS operations definition */
1427 {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP,
1431 NTSTATUS vfs_default_init(void);
1432 NTSTATUS vfs_default_init(void)
1434 unsigned int needed = SMB_VFS_OP_LAST + 1; /* convert from index to count */
1436 if (ARRAY_SIZE(vfs_default_ops) != needed) {
1437 DEBUG(0, ("%s: %u ops registered, but %u ops are required\n",
1438 DEFAULT_VFS_MODULE_NAME, (unsigned int)ARRAY_SIZE(vfs_default_ops), needed));
1439 smb_panic("operation(s) missing from default VFS module");
1442 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1443 DEFAULT_VFS_MODULE_NAME, vfs_default_ops);