--- /dev/null
+/*
+ * Time auditing VFS module for samba. Log time taken for VFS call to syslog
+ * facility.
+ *
+ * Copyright (C) Abhidnya Chirmule <achirmul@in.ibm.com> 2009
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * This module implements logging for time taken for all Samba VFS operations.
+ *
+ * vfs objects = time_audit
+ */
+
+
+#include "includes.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_VFS
+
+static double audit_timeout;
+
+static int smb_time_audit_connect(vfs_handle_struct *handle,
+ const char *svc, const char *user)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ if (!handle) {
+ return -1;
+ }
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CONNECT(handle, svc, user);
+ timediff = timeval_elapsed(&tv);
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("connect: Took %.2f seconds\n", timediff));
+ }
+ return result;
+}
+
+static void smb_time_audit_disconnect(vfs_handle_struct *handle)
+{
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ SMB_VFS_NEXT_DISCONNECT(handle);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("disconnect: Took %.2f seconds\n", timediff));
+ }
+
+ return;
+}
+
+static uint64_t smb_time_audit_disk_free(vfs_handle_struct *handle,
+ const char *path,
+ bool small_query, uint64_t *bsize,
+ uint64_t *dfree, uint64_t *dsize)
+{
+ uint64_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_DISK_FREE(handle, path, small_query, bsize,
+ dfree, dsize);
+ timediff = timeval_elapsed(&tv);
+
+ /* Don't have a reasonable notion of failure here */
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("disk_free: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_get_quota(struct vfs_handle_struct *handle,
+ enum SMB_QUOTA_TYPE qtype, unid_t id,
+ SMB_DISK_QUOTA *qt)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_GET_QUOTA(handle, qtype, id, qt);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("get_quota: Took %.2f seconds\n", timediff));
+ }
+ return result;
+}
+
+static int smb_time_audit_set_quota(struct vfs_handle_struct *handle,
+ enum SMB_QUOTA_TYPE qtype, unid_t id,
+ SMB_DISK_QUOTA *qt)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SET_QUOTA(handle, qtype, id, qt);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("set_quota: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_get_shadow_copy_data(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ SHADOW_COPY_DATA *shadow_copy_data,
+ bool labels)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle, fsp,
+ shadow_copy_data, labels);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("get_shadow_copy_data: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_statvfs(struct vfs_handle_struct *handle,
+ const char *path,
+ struct vfs_statvfs_struct *statbuf)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_STATVFS(handle, path, statbuf);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("statvfs: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_fs_capabilities(struct vfs_handle_struct *handle)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FS_CAPABILITIES(handle);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fs_capabilities: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static SMB_STRUCT_DIR *smb_time_audit_opendir(vfs_handle_struct *handle,
+ const char *fname,
+ const char *mask, uint32 attr)
+{
+ SMB_STRUCT_DIR *result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_OPENDIR(handle, fname, mask, attr);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("opendir: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static SMB_STRUCT_DIRENT *smb_time_audit_readdir(vfs_handle_struct *handle,
+ SMB_STRUCT_DIR *dirp,
+ SMB_STRUCT_STAT *sbuf)
+{
+ SMB_STRUCT_DIRENT *result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_READDIR(handle, dirp, sbuf);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("readdir: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static void smb_time_audit_seekdir(vfs_handle_struct *handle,
+ SMB_STRUCT_DIR *dirp, long offset)
+{
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ SMB_VFS_NEXT_SEEKDIR(handle, dirp, offset);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("seekdir: Took %.2f seconds\n", timediff));
+ }
+
+ return;
+}
+
+static long smb_time_audit_telldir(vfs_handle_struct *handle,
+ SMB_STRUCT_DIR *dirp)
+{
+ long result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_TELLDIR(handle, dirp);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("telldir: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static void smb_time_audit_rewinddir(vfs_handle_struct *handle,
+ SMB_STRUCT_DIR *dirp)
+{
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ SMB_VFS_NEXT_REWINDDIR(handle, dirp);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("rewinddir: Took %.2f seconds\n", timediff));
+ }
+
+ return;
+}
+
+static int smb_time_audit_mkdir(vfs_handle_struct *handle,
+ const char *path, mode_t mode)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_MKDIR(handle, path, mode);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("mkdir: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_rmdir(vfs_handle_struct *handle,
+ const char *path)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_RMDIR(handle, path);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("rmdir: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_closedir(vfs_handle_struct *handle,
+ SMB_STRUCT_DIR *dirp)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CLOSEDIR(handle, dirp);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("closedir: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static void smb_time_audit_init_search_op(vfs_handle_struct *handle,
+ SMB_STRUCT_DIR *dirp)
+{
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ SMB_VFS_NEXT_INIT_SEARCH_OP(handle, dirp);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("init_search_op: Took %.2f seconds\n", timediff));
+ }
+ return;
+}
+
+static int smb_time_audit_open(vfs_handle_struct *handle,
+ const char *fname, files_struct *fsp,
+ int flags, mode_t mode)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("open: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_create_file(vfs_handle_struct *handle,
+ struct smb_request *req,
+ uint16_t root_dir_fid,
+ const char *fname,
+ uint32_t create_file_flags,
+ uint32_t access_mask,
+ uint32_t share_access,
+ uint32_t create_disposition,
+ uint32_t create_options,
+ uint32_t file_attributes,
+ uint32_t oplock_request,
+ uint64_t allocation_size,
+ struct security_descriptor *sd,
+ struct ea_list *ea_list,
+ files_struct **result_fsp,
+ int *pinfo,
+ SMB_STRUCT_STAT *psbuf)
+{
+ NTSTATUS result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CREATE_FILE(
+ handle, /* handle */
+ req, /* req */
+ root_dir_fid, /* root_dir_fid */
+ fname, /* fname */
+ create_file_flags, /* create_file_flags */
+ access_mask, /* access_mask */
+ share_access, /* share_access */
+ create_disposition, /* create_disposition*/
+ create_options, /* create_options */
+ file_attributes, /* file_attributes */
+ oplock_request, /* oplock_request */
+ allocation_size, /* allocation_size */
+ sd, /* sd */
+ ea_list, /* ea_list */
+ result_fsp, /* result */
+ pinfo, /* pinfo */
+ psbuf); /* psbuf */
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("create_file: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_close(vfs_handle_struct *handle, files_struct *fsp)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CLOSE(handle, fsp);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("close: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_read(vfs_handle_struct *handle,
+ files_struct *fsp, void *data, size_t n)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_READ(handle, fsp, data, n);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("read: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_pread(vfs_handle_struct *handle,
+ files_struct *fsp,
+ void *data, size_t n, SMB_OFF_T offset)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("pread: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_write(vfs_handle_struct *handle,
+ files_struct *fsp,
+ const void *data, size_t n)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_WRITE(handle, fsp, data, n);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("write: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_pwrite(vfs_handle_struct *handle,
+ files_struct *fsp,
+ const void *data, size_t n,
+ SMB_OFF_T offset)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("pwrite: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static SMB_OFF_T smb_time_audit_lseek(vfs_handle_struct *handle,
+ files_struct *fsp,
+ SMB_OFF_T offset, int whence)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("lseek: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_sendfile(vfs_handle_struct *handle, int tofd,
+ files_struct *fromfsp,
+ const DATA_BLOB *hdr, SMB_OFF_T offset,
+ size_t n)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SENDFILE(handle, tofd, fromfsp, hdr, offset, n);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sendfile: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_recvfile(vfs_handle_struct *handle, int fromfd,
+ files_struct *tofsp,
+ SMB_OFF_T offset,
+ size_t n)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, n);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("recvfile: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_rename(vfs_handle_struct *handle,
+ const char *oldname, const char *newname)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_RENAME(handle, oldname, newname);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("rename: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_fsync(vfs_handle_struct *handle, files_struct *fsp)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FSYNC(handle, fsp);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fsync: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_stat(vfs_handle_struct *handle,
+ const char *fname, SMB_STRUCT_STAT *sbuf)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_STAT(handle, fname, sbuf);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("stat: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_fstat(vfs_handle_struct *handle, files_struct *fsp,
+ SMB_STRUCT_STAT *sbuf)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fstat: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_lstat(vfs_handle_struct *handle,
+ const char *path, SMB_STRUCT_STAT *sbuf)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LSTAT(handle, path, sbuf);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("lstat: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_get_alloc_size(vfs_handle_struct *handle,
+ files_struct *fsp,
+ const SMB_STRUCT_STAT *sbuf)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_GET_ALLOC_SIZE(handle, fsp, sbuf);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("get_alloc_size: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_unlink(vfs_handle_struct *handle,
+ const char *path)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_UNLINK(handle, path);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("unlink: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_chmod(vfs_handle_struct *handle,
+ const char *path, mode_t mode)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CHMOD(handle, path, mode);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("chmod: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_fchmod(vfs_handle_struct *handle, files_struct *fsp,
+ mode_t mode)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fchmod: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_chown(vfs_handle_struct *handle,
+ const char *path, uid_t uid, gid_t gid)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CHOWN(handle, path, uid, gid);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("chown: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_fchown(vfs_handle_struct *handle, files_struct *fsp,
+ uid_t uid, gid_t gid)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FCHOWN(handle, fsp, uid, gid);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fchown: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_lchown(vfs_handle_struct *handle,
+ const char *path, uid_t uid, gid_t gid)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LCHOWN(handle, path, uid, gid);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("lchown: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_chdir(vfs_handle_struct *handle, const char *path)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CHDIR(handle, path);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("chdir: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static char *smb_time_audit_getwd(vfs_handle_struct *handle, char *path)
+{
+ char *result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_GETWD(handle, path);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("getwd: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_ntimes(vfs_handle_struct *handle,
+ const char *path, struct smb_file_time *ft)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_NTIMES(handle, path, ft);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("ntimes: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_ftruncate(vfs_handle_struct *handle,
+ files_struct *fsp,
+ SMB_OFF_T len)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("ftruncate: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static bool smb_time_audit_lock(vfs_handle_struct *handle, files_struct *fsp,
+ int op, SMB_OFF_T offset, SMB_OFF_T count,
+ int type)
+{
+ bool result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("lock: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_kernel_flock(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ uint32 share_mode, uint32 access_mask)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode,
+ access_mask);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("kernel_flock: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_linux_setlease(vfs_handle_struct *handle,
+ files_struct *fsp,
+ int leasetype)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("linux_setlease: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static bool smb_time_audit_getlock(vfs_handle_struct *handle,
+ files_struct *fsp,
+ SMB_OFF_T *poffset, SMB_OFF_T *pcount,
+ int *ptype, pid_t *ppid)
+{
+ bool result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype,
+ ppid);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("getlock: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_symlink(vfs_handle_struct *handle,
+ const char *oldpath, const char *newpath)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYMLINK(handle, oldpath, newpath);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("symlink: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_readlink(vfs_handle_struct *handle,
+ const char *path, char *buf, size_t bufsiz)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_READLINK(handle, path, buf, bufsiz);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("readlink: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_link(vfs_handle_struct *handle,
+ const char *oldpath, const char *newpath)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LINK(handle, oldpath, newpath);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("link: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_mknod(vfs_handle_struct *handle,
+ const char *pathname, mode_t mode,
+ SMB_DEV_T dev)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_MKNOD(handle, pathname, mode, dev);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("mknod: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static char *smb_time_audit_realpath(vfs_handle_struct *handle,
+ const char *path, char *resolved_path)
+{
+ char *result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_REALPATH(handle, path, resolved_path);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("realpath: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_notify_watch(struct vfs_handle_struct *handle,
+ struct sys_notify_context *ctx,
+ struct notify_entry *e,
+ void (*callback)(struct sys_notify_context *ctx,
+ void *private_data,
+ struct notify_event *ev),
+ void *private_data, void *handle_p)
+{
+ NTSTATUS result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_NOTIFY_WATCH(handle, ctx, e, callback,
+ private_data, handle_p);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("notify_watch: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_chflags(vfs_handle_struct *handle,
+ const char *path, unsigned int flags)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CHFLAGS(handle, path, flags);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("chflags: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static struct file_id smb_time_audit_file_id_create(struct vfs_handle_struct *handle,
+ const SMB_STRUCT_STAT *sbuf)
+{
+ struct file_id id_zero;
+ struct file_id result;
+ struct timeval tv;
+ double timediff;
+
+ ZERO_STRUCT(id_zero);
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FILE_ID_CREATE(handle, sbuf);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("file_id_create: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_streaminfo(vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ const char *fname,
+ TALLOC_CTX *mem_ctx,
+ unsigned int *pnum_streams,
+ struct stream_struct **pstreams)
+{
+ NTSTATUS result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_STREAMINFO(handle, fsp, fname, mem_ctx,
+ pnum_streams, pstreams);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("streaminfo: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_get_real_filename(struct vfs_handle_struct *handle,
+ const char *path,
+ const char *name,
+ TALLOC_CTX *mem_ctx,
+ char **found_name)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name, mem_ctx,
+ found_name);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("get_real_filename: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static const char *smb_time_audit_connectpath(vfs_handle_struct *handle,
+ const char *fname)
+{
+ const char *result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CONNECTPATH(handle, fname);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("connectpath: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_brl_lock_windows(struct vfs_handle_struct *handle,
+ struct byte_range_lock *br_lck,
+ struct lock_struct *plock,
+ bool blocking_lock,
+ struct blocking_lock_record *blr)
+{
+ NTSTATUS result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle, br_lck, plock,
+ blocking_lock, blr);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("brl_lock_windows: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static bool smb_time_audit_brl_unlock_windows(struct vfs_handle_struct *handle,
+ struct messaging_context *msg_ctx,
+ struct byte_range_lock *br_lck,
+ const struct lock_struct *plock)
+{
+ bool result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle, msg_ctx, br_lck,
+ plock);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("brl_unlock_windows: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static bool smb_time_audit_brl_cancel_windows(struct vfs_handle_struct *handle,
+ struct byte_range_lock *br_lck,
+ struct lock_struct *plock,
+ struct blocking_lock_record *blr)
+{
+ bool result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle, br_lck, plock, blr);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("brl_cancel_windows: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static bool smb_time_audit_strict_lock(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ struct lock_struct *plock)
+{
+ bool result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_STRICT_LOCK(handle, fsp, plock);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("strict_lock: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static void smb_time_audit_strict_unlock(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ struct lock_struct *plock)
+{
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("strict_unlock: Took %.2f seconds\n", timediff));
+ }
+
+ return;
+}
+
+static NTSTATUS smb_time_audit_fget_nt_acl(vfs_handle_struct *handle,
+ files_struct *fsp,
+ uint32 security_info,
+ SEC_DESC **ppdesc)
+{
+ NTSTATUS result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info, ppdesc);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fget_nt_acl: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_get_nt_acl(vfs_handle_struct *handle,
+ const char *name,
+ uint32 security_info,
+ SEC_DESC **ppdesc)
+{
+ NTSTATUS result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_GET_NT_ACL(handle, name, security_info, ppdesc);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("get_nt_acl: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_fset_nt_acl(vfs_handle_struct *handle,
+ files_struct *fsp,
+ uint32 security_info_sent,
+ const SEC_DESC *psd)
+{
+ NTSTATUS result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent,
+ psd);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fset_nt_acl: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_chmod_acl(vfs_handle_struct *handle,
+ const char *path, mode_t mode)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_CHMOD_ACL(handle, path, mode);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("chmod_acl: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_fchmod_acl(vfs_handle_struct *handle,
+ files_struct *fsp, mode_t mode)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FCHMOD_ACL(handle, fsp, mode);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fchmod_acl: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_get_entry(vfs_handle_struct *handle,
+ SMB_ACL_T theacl, int entry_id,
+ SMB_ACL_ENTRY_T *entry_p)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_GET_ENTRY(handle, theacl, entry_id,
+ entry_p);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_get_entry: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_get_tag_type(vfs_handle_struct *handle,
+ SMB_ACL_ENTRY_T entry_d,
+ SMB_ACL_TAG_T *tag_type_p)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_GET_TAG_TYPE(handle, entry_d,
+ tag_type_p);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_get_tag_type: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_get_permset(vfs_handle_struct *handle,
+ SMB_ACL_ENTRY_T entry_d,
+ SMB_ACL_PERMSET_T *permset_p)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_GET_PERMSET(handle, entry_d,
+ permset_p);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_get_permset: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static void * smb_time_audit_sys_acl_get_qualifier(vfs_handle_struct *handle,
+ SMB_ACL_ENTRY_T entry_d)
+{
+ void *result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_GET_QUALIFIER(handle, entry_d);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_get_qualifier: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static SMB_ACL_T smb_time_audit_sys_acl_get_file(vfs_handle_struct *handle,
+ const char *path_p,
+ SMB_ACL_TYPE_T type)
+{
+ SMB_ACL_T result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, path_p, type);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_get_file: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static SMB_ACL_T smb_time_audit_sys_acl_get_fd(vfs_handle_struct *handle,
+ files_struct *fsp)
+{
+ SMB_ACL_T result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_get_fd: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_clear_perms(vfs_handle_struct *handle,
+ SMB_ACL_PERMSET_T permset)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_CLEAR_PERMS(handle, permset);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_clear_perms: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_add_perm(vfs_handle_struct *handle,
+ SMB_ACL_PERMSET_T permset,
+ SMB_ACL_PERM_T perm)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_ADD_PERM(handle, permset, perm);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_add_perm: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static char * smb_time_audit_sys_acl_to_text(vfs_handle_struct *handle,
+ SMB_ACL_T theacl,
+ ssize_t *plen)
+{
+ char * result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_TO_TEXT(handle, theacl, plen);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_to_text: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static SMB_ACL_T smb_time_audit_sys_acl_init(vfs_handle_struct *handle,
+ int count)
+{
+ SMB_ACL_T result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_INIT(handle, count);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_init: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_create_entry(vfs_handle_struct *handle,
+ SMB_ACL_T *pacl,
+ SMB_ACL_ENTRY_T *pentry)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_CREATE_ENTRY(handle, pacl, pentry);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_create_entry: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_set_tag_type(vfs_handle_struct *handle,
+ SMB_ACL_ENTRY_T entry,
+ SMB_ACL_TAG_T tagtype)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_SET_TAG_TYPE(handle, entry,
+ tagtype);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_set_tag_type: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_set_qualifier(vfs_handle_struct *handle,
+ SMB_ACL_ENTRY_T entry,
+ void *qual)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_SET_QUALIFIER(handle, entry, qual);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_set_qualifier: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_set_permset(vfs_handle_struct *handle,
+ SMB_ACL_ENTRY_T entry,
+ SMB_ACL_PERMSET_T permset)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_SET_PERMSET(handle, entry, permset);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_set_permset: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_valid(vfs_handle_struct *handle,
+ SMB_ACL_T theacl)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_VALID(handle, theacl);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_valid: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_set_file(vfs_handle_struct *handle,
+ const char *name,
+ SMB_ACL_TYPE_T acltype,
+ SMB_ACL_T theacl)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, name, acltype,
+ theacl);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_set_file: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_set_fd(vfs_handle_struct *handle,
+ files_struct *fsp,
+ SMB_ACL_T theacl)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_set_fd: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_delete_def_file(vfs_handle_struct *handle,
+ const char *path)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, path);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_delete_def_file: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_get_perm(vfs_handle_struct *handle,
+ SMB_ACL_PERMSET_T permset,
+ SMB_ACL_PERM_T perm)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_GET_PERM(handle, permset, perm);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_get_perm: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_free_text(vfs_handle_struct *handle,
+ char *text)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_FREE_TEXT(handle, text);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_free_text: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_free_acl(vfs_handle_struct *handle,
+ SMB_ACL_T posix_acl)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_FREE_ACL(handle, posix_acl);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_free_acl: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_sys_acl_free_qualifier(vfs_handle_struct *handle,
+ void *qualifier,
+ SMB_ACL_TAG_T tagtype)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SYS_ACL_FREE_QUALIFIER(handle, qualifier,
+ tagtype);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("sys_acl_free_qualifier: Took %.2f seconds\n",
+ timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_getxattr(struct vfs_handle_struct *handle,
+ const char *path, const char *name,
+ void *value, size_t size)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_GETXATTR(handle, path, name, value, size);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("getxattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_lgetxattr(struct vfs_handle_struct *handle,
+ const char *path, const char *name,
+ void *value, size_t size)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LGETXATTR(handle, path, name, value, size);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("lgetxattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_fgetxattr(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ const char *name, void *value,
+ size_t size)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FGETXATTR(handle, fsp, name, value, size);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fgetxattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_listxattr(struct vfs_handle_struct *handle,
+ const char *path, char *list,
+ size_t size)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LISTXATTR(handle, path, list, size);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("listxattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_llistxattr(struct vfs_handle_struct *handle,
+ const char *path, char *list,
+ size_t size)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LLISTXATTR(handle, path, list, size);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("llistxattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_flistxattr(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, char *list,
+ size_t size)
+{
+ ssize_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FLISTXATTR(handle, fsp, list, size);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("flistxattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_removexattr(struct vfs_handle_struct *handle,
+ const char *path, const char *name)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_REMOVEXATTR(handle, path, name);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("removexattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_lremovexattr(struct vfs_handle_struct *handle,
+ const char *path, const char *name)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LREMOVEXATTR(handle, path, name);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("lremovexattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_fremovexattr(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ const char *name)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fremovexattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_setxattr(struct vfs_handle_struct *handle,
+ const char *path, const char *name,
+ const void *value, size_t size,
+ int flags)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_SETXATTR(handle, path, name, value, size,
+ flags);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("setxattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_lsetxattr(struct vfs_handle_struct *handle,
+ const char *path, const char *name,
+ const void *value, size_t size,
+ int flags)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LSETXATTR(handle, path, name, value, size,
+ flags);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("lsetxattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_fsetxattr(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, const char *name,
+ const void *value, size_t size, int flags)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FSETXATTR(handle, fsp, name, value, size, flags);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("fsetxattr: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_aio_read(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ SMB_STRUCT_AIOCB *aiocb)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_AIO_READ(handle, fsp, aiocb);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("aio_read: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_aio_write(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ SMB_STRUCT_AIOCB *aiocb)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_AIO_WRITE(handle, fsp, aiocb);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("aio_write: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static ssize_t smb_time_audit_aio_return(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ SMB_STRUCT_AIOCB *aiocb)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_AIO_RETURN(handle, fsp, aiocb);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("aio_return: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_aio_cancel(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ SMB_STRUCT_AIOCB *aiocb)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_AIO_CANCEL(handle, fsp, aiocb);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("aio_cancel: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_aio_error(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ SMB_STRUCT_AIOCB *aiocb)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_AIO_ERROR(handle, fsp, aiocb);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("aio_error: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_aio_fsync(struct vfs_handle_struct *handle,
+ struct files_struct *fsp, int op,
+ SMB_STRUCT_AIOCB *aiocb)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_AIO_FSYNC(handle, fsp, op, aiocb);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("aio_fsync: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static int smb_time_audit_aio_suspend(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ const SMB_STRUCT_AIOCB * const aiocb[],
+ int n, const struct timespec *ts)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_AIO_SUSPEND(handle, fsp, aiocb, n, ts);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("aio_suspend: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+static bool smb_time_audit_aio_force(struct vfs_handle_struct *handle,
+ struct files_struct *fsp)
+{
+ bool result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_AIO_FORCE(handle, fsp);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ DEBUG(0, ("aio_force: Took %.2f seconds\n", timediff));
+ }
+
+ return result;
+}
+
+
+
+/* VFS operations */
+
+static vfs_op_tuple audit_op_tuples[] = {
+
+ /* Disk operations */
+
+ {SMB_VFS_OP(smb_time_audit_connect), SMB_VFS_OP_CONNECT,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_disconnect), SMB_VFS_OP_DISCONNECT,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_disk_free), SMB_VFS_OP_DISK_FREE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_get_quota), SMB_VFS_OP_GET_QUOTA,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_set_quota), SMB_VFS_OP_SET_QUOTA,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_get_shadow_copy_data),
+ SMB_VFS_OP_GET_SHADOW_COPY_DATA,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_statvfs), SMB_VFS_OP_STATVFS,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fs_capabilities),
+ SMB_VFS_OP_FS_CAPABILITIES,
+ SMB_VFS_LAYER_LOGGER},
+
+ /* Directory operations */
+
+ {SMB_VFS_OP(smb_time_audit_opendir), SMB_VFS_OP_OPENDIR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_readdir), SMB_VFS_OP_READDIR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_seekdir), SMB_VFS_OP_SEEKDIR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_telldir), SMB_VFS_OP_TELLDIR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_rewinddir), SMB_VFS_OP_REWINDDIR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_mkdir), SMB_VFS_OP_MKDIR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_rmdir), SMB_VFS_OP_RMDIR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_closedir), SMB_VFS_OP_CLOSEDIR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_init_search_op), SMB_VFS_OP_INIT_SEARCH_OP,
+ SMB_VFS_LAYER_LOGGER},
+
+ /* File operations */
+
+ {SMB_VFS_OP(smb_time_audit_open), SMB_VFS_OP_OPEN,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_create_file),SMB_VFS_OP_CREATE_FILE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_close), SMB_VFS_OP_CLOSE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_read), SMB_VFS_OP_READ,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_pread), SMB_VFS_OP_PREAD,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_write), SMB_VFS_OP_WRITE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_pwrite), SMB_VFS_OP_PWRITE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_lseek), SMB_VFS_OP_LSEEK,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sendfile), SMB_VFS_OP_SENDFILE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_recvfile), SMB_VFS_OP_RECVFILE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_rename), SMB_VFS_OP_RENAME,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fsync), SMB_VFS_OP_FSYNC,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_stat), SMB_VFS_OP_STAT,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fstat), SMB_VFS_OP_FSTAT,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_lstat), SMB_VFS_OP_LSTAT,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_get_alloc_size),
+ SMB_VFS_OP_GET_ALLOC_SIZE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_unlink), SMB_VFS_OP_UNLINK,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_chmod), SMB_VFS_OP_CHMOD,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fchmod), SMB_VFS_OP_FCHMOD,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_chown), SMB_VFS_OP_CHOWN,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fchown), SMB_VFS_OP_FCHOWN,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_lchown), SMB_VFS_OP_LCHOWN,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_chdir), SMB_VFS_OP_CHDIR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_getwd), SMB_VFS_OP_GETWD,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_ntimes), SMB_VFS_OP_NTIMES,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_ftruncate), SMB_VFS_OP_FTRUNCATE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_lock), SMB_VFS_OP_LOCK,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_kernel_flock),
+ SMB_VFS_OP_KERNEL_FLOCK,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_linux_setlease),
+ SMB_VFS_OP_LINUX_SETLEASE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_getlock), SMB_VFS_OP_GETLOCK,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_symlink), SMB_VFS_OP_SYMLINK,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_readlink), SMB_VFS_OP_READLINK,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_link), SMB_VFS_OP_LINK,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_mknod), SMB_VFS_OP_MKNOD,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_realpath), SMB_VFS_OP_REALPATH,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_notify_watch),SMB_VFS_OP_NOTIFY_WATCH,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_chflags), SMB_VFS_OP_CHFLAGS,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_file_id_create),
+ SMB_VFS_OP_FILE_ID_CREATE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_streaminfo), SMB_VFS_OP_STREAMINFO,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_get_real_filename),
+ SMB_VFS_OP_GET_REAL_FILENAME,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_connectpath), SMB_VFS_OP_CONNECTPATH,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_brl_lock_windows),
+ SMB_VFS_OP_BRL_LOCK_WINDOWS,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_brl_unlock_windows),
+ SMB_VFS_OP_BRL_UNLOCK_WINDOWS,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_brl_cancel_windows),
+ SMB_VFS_OP_BRL_CANCEL_WINDOWS,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_strict_lock), SMB_VFS_OP_STRICT_LOCK,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_strict_unlock), SMB_VFS_OP_STRICT_UNLOCK,
+ SMB_VFS_LAYER_LOGGER},
+
+ /* NT ACL operations. */
+
+ {SMB_VFS_OP(smb_time_audit_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_get_nt_acl), SMB_VFS_OP_GET_NT_ACL,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL,
+ SMB_VFS_LAYER_LOGGER},
+
+ /* POSIX ACL operations. */
+
+ {SMB_VFS_OP(smb_time_audit_chmod_acl), SMB_VFS_OP_CHMOD_ACL,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fchmod_acl), SMB_VFS_OP_FCHMOD_ACL,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_get_entry),
+ SMB_VFS_OP_SYS_ACL_GET_ENTRY,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_get_tag_type),
+ SMB_VFS_OP_SYS_ACL_GET_TAG_TYPE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_get_permset),
+ SMB_VFS_OP_SYS_ACL_GET_PERMSET,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_get_qualifier),
+ SMB_VFS_OP_SYS_ACL_GET_QUALIFIER,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_get_file),
+ SMB_VFS_OP_SYS_ACL_GET_FILE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_get_fd),
+ SMB_VFS_OP_SYS_ACL_GET_FD,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_clear_perms),
+ SMB_VFS_OP_SYS_ACL_CLEAR_PERMS,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_add_perm),
+ SMB_VFS_OP_SYS_ACL_ADD_PERM,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_to_text),
+ SMB_VFS_OP_SYS_ACL_TO_TEXT,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_init),
+ SMB_VFS_OP_SYS_ACL_INIT,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_create_entry),
+ SMB_VFS_OP_SYS_ACL_CREATE_ENTRY,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_set_tag_type),
+ SMB_VFS_OP_SYS_ACL_SET_TAG_TYPE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_set_qualifier),
+ SMB_VFS_OP_SYS_ACL_SET_QUALIFIER,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_set_permset),
+ SMB_VFS_OP_SYS_ACL_SET_PERMSET,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_valid),
+ SMB_VFS_OP_SYS_ACL_VALID,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_set_file),
+ SMB_VFS_OP_SYS_ACL_SET_FILE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_set_fd),
+ SMB_VFS_OP_SYS_ACL_SET_FD,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_delete_def_file),
+ SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_get_perm),
+ SMB_VFS_OP_SYS_ACL_GET_PERM,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_free_text),
+ SMB_VFS_OP_SYS_ACL_FREE_TEXT,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_free_acl),
+ SMB_VFS_OP_SYS_ACL_FREE_ACL,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_sys_acl_free_qualifier),
+ SMB_VFS_OP_SYS_ACL_FREE_QUALIFIER,
+ SMB_VFS_LAYER_LOGGER},
+
+ /* EA operations. */
+
+ {SMB_VFS_OP(smb_time_audit_getxattr), SMB_VFS_OP_GETXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_lgetxattr), SMB_VFS_OP_LGETXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fgetxattr), SMB_VFS_OP_FGETXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_listxattr), SMB_VFS_OP_LISTXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_llistxattr), SMB_VFS_OP_LLISTXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_flistxattr), SMB_VFS_OP_FLISTXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_removexattr),
+ SMB_VFS_OP_REMOVEXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_lremovexattr),
+ SMB_VFS_OP_LREMOVEXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fremovexattr),
+ SMB_VFS_OP_FREMOVEXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_setxattr), SMB_VFS_OP_SETXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_lsetxattr), SMB_VFS_OP_LSETXATTR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_fsetxattr), SMB_VFS_OP_FSETXATTR,
+ SMB_VFS_LAYER_LOGGER},
+
+ {SMB_VFS_OP(smb_time_audit_aio_read), SMB_VFS_OP_AIO_READ,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_aio_write), SMB_VFS_OP_AIO_WRITE,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_aio_return), SMB_VFS_OP_AIO_RETURN,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_aio_cancel), SMB_VFS_OP_AIO_CANCEL,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_aio_error), SMB_VFS_OP_AIO_ERROR,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_aio_fsync), SMB_VFS_OP_AIO_FSYNC,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_aio_suspend),SMB_VFS_OP_AIO_SUSPEND,
+ SMB_VFS_LAYER_LOGGER},
+ {SMB_VFS_OP(smb_time_audit_aio_force),SMB_VFS_OP_AIO_FORCE,
+ SMB_VFS_LAYER_LOGGER},
+
+ /* Finish VFS operations definition */
+
+ {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP,
+ SMB_VFS_LAYER_NOOP}
+};
+
+
+NTSTATUS vfs_time_audit_init(void);
+NTSTATUS vfs_time_audit_init(void)
+{
+ audit_timeout = (double)lp_parm_int(-1, "time_audit", "timeout",
+ 10000) / 1000.0;
+ return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "time_audit",
+ audit_op_tuples);
+}
git.samba.org / obnox / samba-ctdb.git / commitdiff