--- /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 void smb_time_audit_log(const char *syscallname, double elapsed)
+{
+ DEBUG(0, ("WARNING: System call \"%s\" took unexpectedly long "
+ "(%.2f seconds) -- Validate that file and storage "
+ "subsystems are operating normally\n", syscallname,
+ elapsed));
+}
+
+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) {
+ smb_time_audit_log("connect", 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) {
+ smb_time_audit_log("disconnect", 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) {
+ smb_time_audit_log("disk_free", 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) {
+ smb_time_audit_log("get_quota", 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) {
+ smb_time_audit_log("set_quota", 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) {
+ smb_time_audit_log("get_shadow_copy_data", 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) {
+ smb_time_audit_log("statvfs", timediff);
+ }
+
+ return result;
+}
+
+static uint32_t smb_time_audit_fs_capabilities(struct vfs_handle_struct *handle,
+ enum timestamp_set_resolution *p_ts_res)
+{
+ uint32_t result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ smb_time_audit_log("fs_capabilities", 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) {
+ smb_time_audit_log("opendir", 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) {
+ smb_time_audit_log("readdir", 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) {
+ smb_time_audit_log("seekdir", 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) {
+ smb_time_audit_log("telldir", 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) {
+ smb_time_audit_log("rewinddir", 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) {
+ smb_time_audit_log("mkdir", 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) {
+ smb_time_audit_log("rmdir", 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) {
+ smb_time_audit_log("closedir", 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) {
+ smb_time_audit_log("init_search_op", timediff);
+ }
+ return;
+}
+
+static int smb_time_audit_open(vfs_handle_struct *handle,
+ struct smb_filename *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) {
+ smb_time_audit_log("open", timediff);
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_create_file(vfs_handle_struct *handle,
+ struct smb_request *req,
+ uint16_t root_dir_fid,
+ struct smb_filename *fname,
+ 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,
+ uint32_t private_flags,
+ struct security_descriptor *sd,
+ struct ea_list *ea_list,
+ files_struct **result_fsp,
+ int *pinfo)
+{
+ 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 */
+ 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 */
+ private_flags,
+ sd, /* sd */
+ ea_list, /* ea_list */
+ result_fsp, /* result */
+ pinfo);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ smb_time_audit_log("create_file", 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) {
+ smb_time_audit_log("close", 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) {
+ smb_time_audit_log("read", 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) {
+ smb_time_audit_log("pread", 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) {
+ smb_time_audit_log("write", 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) {
+ smb_time_audit_log("pwrite", 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) {
+ smb_time_audit_log("lseek", 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) {
+ smb_time_audit_log("sendfile", 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) {
+ smb_time_audit_log("recvfile", timediff);
+ }
+
+ return result;
+}
+
+static int smb_time_audit_rename(vfs_handle_struct *handle,
+ const struct smb_filename *oldname,
+ const struct smb_filename *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) {
+ smb_time_audit_log("rename", 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) {
+ smb_time_audit_log("fsync", timediff);
+ }
+
+ return result;
+}
+
+static int smb_time_audit_stat(vfs_handle_struct *handle,
+ struct smb_filename *fname)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_STAT(handle, fname);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ smb_time_audit_log("stat", 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) {
+ smb_time_audit_log("fstat", timediff);
+ }
+
+ return result;
+}
+
+static int smb_time_audit_lstat(vfs_handle_struct *handle,
+ struct smb_filename *path)
+{
+ int result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_LSTAT(handle, path);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ smb_time_audit_log("lstat", timediff);
+ }
+
+ return result;
+}
+
+static uint64_t 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) {
+ smb_time_audit_log("get_alloc_size", timediff);
+ }
+
+ return result;
+}
+
+static int smb_time_audit_unlink(vfs_handle_struct *handle,
+ const struct smb_filename *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) {
+ smb_time_audit_log("unlink", 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) {
+ smb_time_audit_log("chmod", 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) {
+ smb_time_audit_log("fchmod", 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) {
+ smb_time_audit_log("chown", 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) {
+ smb_time_audit_log("fchown", 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) {
+ smb_time_audit_log("lchown", 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) {
+ smb_time_audit_log("chdir", 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) {
+ smb_time_audit_log("getwd", timediff);
+ }
+
+ return result;
+}
+
+static int smb_time_audit_ntimes(vfs_handle_struct *handle,
+ const struct smb_filename *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) {
+ smb_time_audit_log("ntimes", 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) {
+ smb_time_audit_log("ftruncate", 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) {
+ smb_time_audit_log("lock", 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) {
+ smb_time_audit_log("kernel_flock", 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) {
+ smb_time_audit_log("linux_setlease", 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) {
+ smb_time_audit_log("getlock", 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) {
+ smb_time_audit_log("symlink", 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) {
+ smb_time_audit_log("readlink", 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) {
+ smb_time_audit_log("link", 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) {
+ smb_time_audit_log("mknod", 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) {
+ smb_time_audit_log("realpath", 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) {
+ smb_time_audit_log("notify_watch", 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) {
+ smb_time_audit_log("chflags", 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) {
+ smb_time_audit_log("file_id_create", 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) {
+ smb_time_audit_log("streaminfo", 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) {
+ smb_time_audit_log("get_real_filename", 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) {
+ smb_time_audit_log("connectpath", 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) {
+ smb_time_audit_log("brl_lock_windows", 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) {
+ smb_time_audit_log("brl_unlock_windows", 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) {
+ smb_time_audit_log("brl_cancel_windows", 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) {
+ smb_time_audit_log("strict_lock", 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) {
+ smb_time_audit_log("strict_unlock", timediff);
+ }
+
+ return;
+}
+
+static NTSTATUS smb_time_audit_translate_name(struct vfs_handle_struct *handle,
+ const char *name,
+ enum vfs_translate_direction direction,
+ TALLOC_CTX *mem_ctx,
+ char **mapped_name)
+{
+ NTSTATUS result;
+ struct timeval tv;
+ double timediff;
+
+ GetTimeOfDay(&tv);
+ result = SMB_VFS_NEXT_TRANSLATE_NAME(handle, name, direction, mem_ctx,
+ mapped_name);
+ timediff = timeval_elapsed(&tv);
+
+ if (timediff > audit_timeout) {
+ smb_time_audit_log("translate_name", timediff);
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_fget_nt_acl(vfs_handle_struct *handle,
+ files_struct *fsp,
+ uint32 security_info,
+ struct security_descriptor **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) {
+ smb_time_audit_log("fget_nt_acl", timediff);
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_get_nt_acl(vfs_handle_struct *handle,
+ const char *name,
+ uint32 security_info,
+ struct security_descriptor **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) {
+ smb_time_audit_log("get_nt_acl", timediff);
+ }
+
+ return result;
+}
+
+static NTSTATUS smb_time_audit_fset_nt_acl(vfs_handle_struct *handle,
+ files_struct *fsp,
+ uint32 security_info_sent,
+ const struct security_descriptor *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) {
+ smb_time_audit_log("fset_nt_acl", 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) {
+ smb_time_audit_log("chmod_acl", 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) {
+ smb_time_audit_log("fchmod_acl", 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) {
+ smb_time_audit_log("sys_acl_get_entry", 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) {
+ smb_time_audit_log("sys_acl_get_tag_type", 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) {
+ smb_time_audit_log("sys_acl_get_permset", 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) {
+ smb_time_audit_log("sys_acl_get_qualifier", 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) {
+ smb_time_audit_log("sys_acl_get_file", 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) {
+ smb_time_audit_log("sys_acl_get_fd", 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) {
+ smb_time_audit_log("sys_acl_clear_perms", 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) {
+ smb_time_audit_log("sys_acl_add_perm", 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) {
+ smb_time_audit_log("sys_acl_to_text", 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) {
+ smb_time_audit_log("sys_acl_init", 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) {
+ smb_time_audit_log("sys_acl_create_entry", 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) {
+ smb_time_audit_log("sys_acl_set_tag_type", 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) {
+ smb_time_audit_log("sys_acl_set_qualifier", 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) {
+ smb_time_audit_log("sys_acl_set_permset", 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) {
+ smb_time_audit_log("sys_acl_valid", 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) {
+ smb_time_audit_log("sys_acl_set_file", 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) {
+ smb_time_audit_log("sys_acl_set_fd", 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) {
+ smb_time_audit_log("sys_acl_delete_def_file", 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) {
+ smb_time_audit_log("sys_acl_get_perm", 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) {
+ smb_time_audit_log("sys_acl_free_text", 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) {
+ smb_time_audit_log("sys_acl_free_acl", 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) {
+ smb_time_audit_log("sys_acl_free_qualifier", 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) {
+ smb_time_audit_log("getxattr", 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) {
+ smb_time_audit_log("lgetxattr", 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) {
+ smb_time_audit_log("fgetxattr", 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) {
+ smb_time_audit_log("listxattr", 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) {
+ smb_time_audit_log("llistxattr", 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) {
+ smb_time_audit_log("flistxattr", 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) {
+ smb_time_audit_log("removexattr", 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) {
+ smb_time_audit_log("lremovexattr", 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) {
+ smb_time_audit_log("fremovexattr", 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) {
+ smb_time_audit_log("setxattr", 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) {
+ smb_time_audit_log("lsetxattr", 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) {
+ smb_time_audit_log("fsetxattr", 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) {
+ smb_time_audit_log("aio_read", 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) {
+ smb_time_audit_log("aio_write", 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) {
+ smb_time_audit_log("aio_return", 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) {
+ smb_time_audit_log("aio_cancel", 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) {
+ smb_time_audit_log("aio_error", 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) {
+ smb_time_audit_log("aio_fsync", 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) {
+ smb_time_audit_log("aio_suspend", 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) {
+ smb_time_audit_log("aio_force", timediff);
+ }
+
+ return result;
+}
+
+
+
+/* VFS operations */
+
+static struct vfs_fn_pointers vfs_time_audit_fns = {
+ .connect_fn = smb_time_audit_connect,
+ .disconnect = smb_time_audit_disconnect,
+ .disk_free = smb_time_audit_disk_free,
+ .get_quota = smb_time_audit_get_quota,
+ .set_quota = smb_time_audit_set_quota,
+ .get_shadow_copy_data = smb_time_audit_get_shadow_copy_data,
+ .statvfs = smb_time_audit_statvfs,
+ .fs_capabilities = smb_time_audit_fs_capabilities,
+ .opendir = smb_time_audit_opendir,
+ .readdir = smb_time_audit_readdir,
+ .seekdir = smb_time_audit_seekdir,
+ .telldir = smb_time_audit_telldir,
+ .rewind_dir = smb_time_audit_rewinddir,
+ .mkdir = smb_time_audit_mkdir,
+ .rmdir = smb_time_audit_rmdir,
+ .closedir = smb_time_audit_closedir,
+ .init_search_op = smb_time_audit_init_search_op,
+ .open = smb_time_audit_open,
+ .create_file = smb_time_audit_create_file,
+ .close_fn = smb_time_audit_close,
+ .vfs_read = smb_time_audit_read,
+ .pread = smb_time_audit_pread,
+ .write = smb_time_audit_write,
+ .pwrite = smb_time_audit_pwrite,
+ .lseek = smb_time_audit_lseek,
+ .sendfile = smb_time_audit_sendfile,
+ .recvfile = smb_time_audit_recvfile,
+ .rename = smb_time_audit_rename,
+ .fsync = smb_time_audit_fsync,
+ .stat = smb_time_audit_stat,
+ .fstat = smb_time_audit_fstat,
+ .lstat = smb_time_audit_lstat,
+ .get_alloc_size = smb_time_audit_get_alloc_size,
+ .unlink = smb_time_audit_unlink,
+ .chmod = smb_time_audit_chmod,
+ .fchmod = smb_time_audit_fchmod,
+ .chown = smb_time_audit_chown,
+ .fchown = smb_time_audit_fchown,
+ .lchown = smb_time_audit_lchown,
+ .chdir = smb_time_audit_chdir,
+ .getwd = smb_time_audit_getwd,
+ .ntimes = smb_time_audit_ntimes,
+ .ftruncate = smb_time_audit_ftruncate,
+ .lock = smb_time_audit_lock,
+ .kernel_flock = smb_time_audit_kernel_flock,
+ .linux_setlease = smb_time_audit_linux_setlease,
+ .getlock = smb_time_audit_getlock,
+ .symlink = smb_time_audit_symlink,
+ .vfs_readlink = smb_time_audit_readlink,
+ .link = smb_time_audit_link,
+ .mknod = smb_time_audit_mknod,
+ .realpath = smb_time_audit_realpath,
+ .notify_watch = smb_time_audit_notify_watch,
+ .chflags = smb_time_audit_chflags,
+ .file_id_create = smb_time_audit_file_id_create,
+ .streaminfo = smb_time_audit_streaminfo,
+ .get_real_filename = smb_time_audit_get_real_filename,
+ .connectpath = smb_time_audit_connectpath,
+ .brl_lock_windows = smb_time_audit_brl_lock_windows,
+ .brl_unlock_windows = smb_time_audit_brl_unlock_windows,
+ .brl_cancel_windows = smb_time_audit_brl_cancel_windows,
+ .strict_lock = smb_time_audit_strict_lock,
+ .strict_unlock = smb_time_audit_strict_unlock,
+ .translate_name = smb_time_audit_translate_name,
+ .fget_nt_acl = smb_time_audit_fget_nt_acl,
+ .get_nt_acl = smb_time_audit_get_nt_acl,
+ .fset_nt_acl = smb_time_audit_fset_nt_acl,
+ .chmod_acl = smb_time_audit_chmod_acl,
+ .fchmod_acl = smb_time_audit_fchmod_acl,
+ .sys_acl_get_entry = smb_time_audit_sys_acl_get_entry,
+ .sys_acl_get_tag_type = smb_time_audit_sys_acl_get_tag_type,
+ .sys_acl_get_permset = smb_time_audit_sys_acl_get_permset,
+ .sys_acl_get_qualifier = smb_time_audit_sys_acl_get_qualifier,
+ .sys_acl_get_file = smb_time_audit_sys_acl_get_file,
+ .sys_acl_get_fd = smb_time_audit_sys_acl_get_fd,
+ .sys_acl_clear_perms = smb_time_audit_sys_acl_clear_perms,
+ .sys_acl_add_perm = smb_time_audit_sys_acl_add_perm,
+ .sys_acl_to_text = smb_time_audit_sys_acl_to_text,
+ .sys_acl_init = smb_time_audit_sys_acl_init,
+ .sys_acl_create_entry = smb_time_audit_sys_acl_create_entry,
+ .sys_acl_set_tag_type = smb_time_audit_sys_acl_set_tag_type,
+ .sys_acl_set_qualifier = smb_time_audit_sys_acl_set_qualifier,
+ .sys_acl_set_permset = smb_time_audit_sys_acl_set_permset,
+ .sys_acl_valid = smb_time_audit_sys_acl_valid,
+ .sys_acl_set_file = smb_time_audit_sys_acl_set_file,
+ .sys_acl_set_fd = smb_time_audit_sys_acl_set_fd,
+ .sys_acl_delete_def_file = smb_time_audit_sys_acl_delete_def_file,
+ .sys_acl_get_perm = smb_time_audit_sys_acl_get_perm,
+ .sys_acl_free_text = smb_time_audit_sys_acl_free_text,
+ .sys_acl_free_acl = smb_time_audit_sys_acl_free_acl,
+ .sys_acl_free_qualifier = smb_time_audit_sys_acl_free_qualifier,
+ .getxattr = smb_time_audit_getxattr,
+ .lgetxattr = smb_time_audit_lgetxattr,
+ .fgetxattr = smb_time_audit_fgetxattr,
+ .listxattr = smb_time_audit_listxattr,
+ .llistxattr = smb_time_audit_llistxattr,
+ .flistxattr = smb_time_audit_flistxattr,
+ .removexattr = smb_time_audit_removexattr,
+ .lremovexattr = smb_time_audit_lremovexattr,
+ .fremovexattr = smb_time_audit_fremovexattr,
+ .setxattr = smb_time_audit_setxattr,
+ .lsetxattr = smb_time_audit_lsetxattr,
+ .fsetxattr = smb_time_audit_fsetxattr,
+ .aio_read = smb_time_audit_aio_read,
+ .aio_write = smb_time_audit_aio_write,
+ .aio_return_fn = smb_time_audit_aio_return,
+ .aio_cancel = smb_time_audit_aio_cancel,
+ .aio_error_fn = smb_time_audit_aio_error,
+ .aio_fsync = smb_time_audit_aio_fsync,
+ .aio_suspend = smb_time_audit_aio_suspend,
+ .aio_force = smb_time_audit_aio_force,
+};
+
+
+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",
+ &vfs_time_audit_fns);
+}
git.samba.org / metze / samba-autobuild / .git / commitdiff