2 * Time auditing VFS module for samba. Log time taken for VFS call to syslog
5 * Copyright (C) Abhidnya Chirmule <achirmul@in.ibm.com> 2009
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
22 * This module implements logging for time taken for all Samba VFS operations.
24 * vfs objects = time_audit
31 #define DBGC_CLASS DBGC_VFS
33 static double audit_timeout
;
35 static void smb_time_audit_log(const char *syscallname
, double elapsed
)
37 DEBUG(0, ("WARNING: System call \"%s\" took unexpectedly long "
38 "(%.2f seconds) -- Validate that file and storage "
39 "subsystems are operating normally\n", syscallname
,
43 static int smb_time_audit_connect(vfs_handle_struct
*handle
,
44 const char *svc
, const char *user
)
47 struct timespec ts1
,ts2
;
54 clock_gettime_mono(&ts1
);
55 result
= SMB_VFS_NEXT_CONNECT(handle
, svc
, user
);
56 clock_gettime_mono(&ts2
);
57 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
58 if (timediff
> audit_timeout
) {
59 smb_time_audit_log("connect", timediff
);
64 static void smb_time_audit_disconnect(vfs_handle_struct
*handle
)
66 struct timespec ts1
,ts2
;
69 clock_gettime_mono(&ts1
);
70 SMB_VFS_NEXT_DISCONNECT(handle
);
71 clock_gettime_mono(&ts2
);
72 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
74 if (timediff
> audit_timeout
) {
75 smb_time_audit_log("disconnect", timediff
);
81 static uint64_t smb_time_audit_disk_free(vfs_handle_struct
*handle
,
83 bool small_query
, uint64_t *bsize
,
84 uint64_t *dfree
, uint64_t *dsize
)
87 struct timespec ts1
,ts2
;
90 clock_gettime_mono(&ts1
);
91 result
= SMB_VFS_NEXT_DISK_FREE(handle
, path
, small_query
, bsize
,
93 clock_gettime_mono(&ts2
);
94 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
96 /* Don't have a reasonable notion of failure here */
97 if (timediff
> audit_timeout
) {
98 smb_time_audit_log("disk_free", timediff
);
104 static int smb_time_audit_get_quota(struct vfs_handle_struct
*handle
,
105 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
109 struct timespec ts1
,ts2
;
112 clock_gettime_mono(&ts1
);
113 result
= SMB_VFS_NEXT_GET_QUOTA(handle
, qtype
, id
, qt
);
114 clock_gettime_mono(&ts2
);
115 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
117 if (timediff
> audit_timeout
) {
118 smb_time_audit_log("get_quota", timediff
);
123 static int smb_time_audit_set_quota(struct vfs_handle_struct
*handle
,
124 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
128 struct timespec ts1
,ts2
;
131 clock_gettime_mono(&ts1
);
132 result
= SMB_VFS_NEXT_SET_QUOTA(handle
, qtype
, id
, qt
);
133 clock_gettime_mono(&ts2
);
134 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
136 if (timediff
> audit_timeout
) {
137 smb_time_audit_log("set_quota", timediff
);
143 static int smb_time_audit_get_shadow_copy_data(struct vfs_handle_struct
*handle
,
144 struct files_struct
*fsp
,
145 SHADOW_COPY_DATA
*shadow_copy_data
,
149 struct timespec ts1
,ts2
;
152 clock_gettime_mono(&ts1
);
153 result
= SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle
, fsp
,
154 shadow_copy_data
, labels
);
155 clock_gettime_mono(&ts2
);
156 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
158 if (timediff
> audit_timeout
) {
159 smb_time_audit_log("get_shadow_copy_data", timediff
);
165 static int smb_time_audit_statvfs(struct vfs_handle_struct
*handle
,
167 struct vfs_statvfs_struct
*statbuf
)
170 struct timespec ts1
,ts2
;
173 clock_gettime_mono(&ts1
);
174 result
= SMB_VFS_NEXT_STATVFS(handle
, path
, statbuf
);
175 clock_gettime_mono(&ts2
);
176 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
178 if (timediff
> audit_timeout
) {
179 smb_time_audit_log("statvfs", timediff
);
185 static uint32_t smb_time_audit_fs_capabilities(struct vfs_handle_struct
*handle
,
186 enum timestamp_set_resolution
*p_ts_res
)
189 struct timespec ts1
,ts2
;
192 clock_gettime_mono(&ts1
);
193 result
= SMB_VFS_NEXT_FS_CAPABILITIES(handle
, p_ts_res
);
194 clock_gettime_mono(&ts2
);
195 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
197 if (timediff
> audit_timeout
) {
198 smb_time_audit_log("fs_capabilities", timediff
);
204 static SMB_STRUCT_DIR
*smb_time_audit_opendir(vfs_handle_struct
*handle
,
206 const char *mask
, uint32 attr
)
208 SMB_STRUCT_DIR
*result
;
209 struct timespec ts1
,ts2
;
212 clock_gettime_mono(&ts1
);
213 result
= SMB_VFS_NEXT_OPENDIR(handle
, fname
, mask
, attr
);
214 clock_gettime_mono(&ts2
);
215 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
217 if (timediff
> audit_timeout
) {
218 smb_time_audit_log("opendir", timediff
);
224 static SMB_STRUCT_DIRENT
*smb_time_audit_readdir(vfs_handle_struct
*handle
,
225 SMB_STRUCT_DIR
*dirp
,
226 SMB_STRUCT_STAT
*sbuf
)
228 SMB_STRUCT_DIRENT
*result
;
229 struct timespec ts1
,ts2
;
232 clock_gettime_mono(&ts1
);
233 result
= SMB_VFS_NEXT_READDIR(handle
, dirp
, sbuf
);
234 clock_gettime_mono(&ts2
);
235 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
237 if (timediff
> audit_timeout
) {
238 smb_time_audit_log("readdir", timediff
);
244 static void smb_time_audit_seekdir(vfs_handle_struct
*handle
,
245 SMB_STRUCT_DIR
*dirp
, long offset
)
247 struct timespec ts1
,ts2
;
250 clock_gettime_mono(&ts1
);
251 SMB_VFS_NEXT_SEEKDIR(handle
, dirp
, offset
);
252 clock_gettime_mono(&ts2
);
253 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
255 if (timediff
> audit_timeout
) {
256 smb_time_audit_log("seekdir", timediff
);
262 static long smb_time_audit_telldir(vfs_handle_struct
*handle
,
263 SMB_STRUCT_DIR
*dirp
)
266 struct timespec ts1
,ts2
;
269 clock_gettime_mono(&ts1
);
270 result
= SMB_VFS_NEXT_TELLDIR(handle
, dirp
);
271 clock_gettime_mono(&ts2
);
272 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
274 if (timediff
> audit_timeout
) {
275 smb_time_audit_log("telldir", timediff
);
281 static void smb_time_audit_rewinddir(vfs_handle_struct
*handle
,
282 SMB_STRUCT_DIR
*dirp
)
284 struct timespec ts1
,ts2
;
287 clock_gettime_mono(&ts1
);
288 SMB_VFS_NEXT_REWINDDIR(handle
, dirp
);
289 clock_gettime_mono(&ts2
);
290 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
292 if (timediff
> audit_timeout
) {
293 smb_time_audit_log("rewinddir", timediff
);
299 static int smb_time_audit_mkdir(vfs_handle_struct
*handle
,
300 const char *path
, mode_t mode
)
303 struct timespec ts1
,ts2
;
306 clock_gettime_mono(&ts1
);
307 result
= SMB_VFS_NEXT_MKDIR(handle
, path
, mode
);
308 clock_gettime_mono(&ts2
);
309 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
311 if (timediff
> audit_timeout
) {
312 smb_time_audit_log("mkdir", timediff
);
318 static int smb_time_audit_rmdir(vfs_handle_struct
*handle
,
322 struct timespec ts1
,ts2
;
325 clock_gettime_mono(&ts1
);
326 result
= SMB_VFS_NEXT_RMDIR(handle
, path
);
327 clock_gettime_mono(&ts2
);
328 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
330 if (timediff
> audit_timeout
) {
331 smb_time_audit_log("rmdir", timediff
);
337 static int smb_time_audit_closedir(vfs_handle_struct
*handle
,
338 SMB_STRUCT_DIR
*dirp
)
341 struct timespec ts1
,ts2
;
344 clock_gettime_mono(&ts1
);
345 result
= SMB_VFS_NEXT_CLOSEDIR(handle
, dirp
);
346 clock_gettime_mono(&ts2
);
347 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
349 if (timediff
> audit_timeout
) {
350 smb_time_audit_log("closedir", timediff
);
356 static void smb_time_audit_init_search_op(vfs_handle_struct
*handle
,
357 SMB_STRUCT_DIR
*dirp
)
359 struct timespec ts1
,ts2
;
362 clock_gettime_mono(&ts1
);
363 SMB_VFS_NEXT_INIT_SEARCH_OP(handle
, dirp
);
364 clock_gettime_mono(&ts2
);
365 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
367 if (timediff
> audit_timeout
) {
368 smb_time_audit_log("init_search_op", timediff
);
373 static int smb_time_audit_open(vfs_handle_struct
*handle
,
374 struct smb_filename
*fname
,
376 int flags
, mode_t mode
)
379 struct timespec ts1
,ts2
;
382 clock_gettime_mono(&ts1
);
383 result
= SMB_VFS_NEXT_OPEN(handle
, fname
, fsp
, flags
, mode
);
384 clock_gettime_mono(&ts2
);
385 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
387 if (timediff
> audit_timeout
) {
388 smb_time_audit_log("open", timediff
);
394 static NTSTATUS
smb_time_audit_create_file(vfs_handle_struct
*handle
,
395 struct smb_request
*req
,
396 uint16_t root_dir_fid
,
397 struct smb_filename
*fname
,
398 uint32_t access_mask
,
399 uint32_t share_access
,
400 uint32_t create_disposition
,
401 uint32_t create_options
,
402 uint32_t file_attributes
,
403 uint32_t oplock_request
,
404 uint64_t allocation_size
,
405 uint32_t private_flags
,
406 struct security_descriptor
*sd
,
407 struct ea_list
*ea_list
,
408 files_struct
**result_fsp
,
412 struct timespec ts1
,ts2
;
415 clock_gettime_mono(&ts1
);
416 result
= SMB_VFS_NEXT_CREATE_FILE(
419 root_dir_fid
, /* root_dir_fid */
421 access_mask
, /* access_mask */
422 share_access
, /* share_access */
423 create_disposition
, /* create_disposition*/
424 create_options
, /* create_options */
425 file_attributes
, /* file_attributes */
426 oplock_request
, /* oplock_request */
427 allocation_size
, /* allocation_size */
430 ea_list
, /* ea_list */
431 result_fsp
, /* result */
433 clock_gettime_mono(&ts2
);
434 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
436 if (timediff
> audit_timeout
) {
437 smb_time_audit_log("create_file", timediff
);
443 static int smb_time_audit_close(vfs_handle_struct
*handle
, files_struct
*fsp
)
446 struct timespec ts1
,ts2
;
449 clock_gettime_mono(&ts1
);
450 result
= SMB_VFS_NEXT_CLOSE(handle
, fsp
);
451 clock_gettime_mono(&ts2
);
452 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
454 if (timediff
> audit_timeout
) {
455 smb_time_audit_log("close", timediff
);
461 static ssize_t
smb_time_audit_read(vfs_handle_struct
*handle
,
462 files_struct
*fsp
, void *data
, size_t n
)
465 struct timespec ts1
,ts2
;
468 clock_gettime_mono(&ts1
);
469 result
= SMB_VFS_NEXT_READ(handle
, fsp
, data
, n
);
470 clock_gettime_mono(&ts2
);
471 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
473 if (timediff
> audit_timeout
) {
474 smb_time_audit_log("read", timediff
);
480 static ssize_t
smb_time_audit_pread(vfs_handle_struct
*handle
,
482 void *data
, size_t n
, SMB_OFF_T offset
)
485 struct timespec ts1
,ts2
;
488 clock_gettime_mono(&ts1
);
489 result
= SMB_VFS_NEXT_PREAD(handle
, fsp
, data
, n
, offset
);
490 clock_gettime_mono(&ts2
);
491 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
493 if (timediff
> audit_timeout
) {
494 smb_time_audit_log("pread", timediff
);
500 static ssize_t
smb_time_audit_write(vfs_handle_struct
*handle
,
502 const void *data
, size_t n
)
505 struct timespec ts1
,ts2
;
508 clock_gettime_mono(&ts1
);
509 result
= SMB_VFS_NEXT_WRITE(handle
, fsp
, data
, n
);
510 clock_gettime_mono(&ts2
);
511 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
513 if (timediff
> audit_timeout
) {
514 smb_time_audit_log("write", timediff
);
520 static ssize_t
smb_time_audit_pwrite(vfs_handle_struct
*handle
,
522 const void *data
, size_t n
,
526 struct timespec ts1
,ts2
;
529 clock_gettime_mono(&ts1
);
530 result
= SMB_VFS_NEXT_PWRITE(handle
, fsp
, data
, n
, offset
);
531 clock_gettime_mono(&ts2
);
532 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
534 if (timediff
> audit_timeout
) {
535 smb_time_audit_log("pwrite", timediff
);
541 static SMB_OFF_T
smb_time_audit_lseek(vfs_handle_struct
*handle
,
543 SMB_OFF_T offset
, int whence
)
546 struct timespec ts1
,ts2
;
549 clock_gettime_mono(&ts1
);
550 result
= SMB_VFS_NEXT_LSEEK(handle
, fsp
, offset
, whence
);
551 clock_gettime_mono(&ts2
);
552 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
554 if (timediff
> audit_timeout
) {
555 smb_time_audit_log("lseek", timediff
);
561 static ssize_t
smb_time_audit_sendfile(vfs_handle_struct
*handle
, int tofd
,
562 files_struct
*fromfsp
,
563 const DATA_BLOB
*hdr
, SMB_OFF_T offset
,
567 struct timespec ts1
,ts2
;
570 clock_gettime_mono(&ts1
);
571 result
= SMB_VFS_NEXT_SENDFILE(handle
, tofd
, fromfsp
, hdr
, offset
, n
);
572 clock_gettime_mono(&ts2
);
573 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
575 if (timediff
> audit_timeout
) {
576 smb_time_audit_log("sendfile", timediff
);
582 static ssize_t
smb_time_audit_recvfile(vfs_handle_struct
*handle
, int fromfd
,
588 struct timespec ts1
,ts2
;
591 clock_gettime_mono(&ts1
);
592 result
= SMB_VFS_NEXT_RECVFILE(handle
, fromfd
, tofsp
, offset
, n
);
593 clock_gettime_mono(&ts2
);
594 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
596 if (timediff
> audit_timeout
) {
597 smb_time_audit_log("recvfile", timediff
);
603 static int smb_time_audit_rename(vfs_handle_struct
*handle
,
604 const struct smb_filename
*oldname
,
605 const struct smb_filename
*newname
)
608 struct timespec ts1
,ts2
;
611 clock_gettime_mono(&ts1
);
612 result
= SMB_VFS_NEXT_RENAME(handle
, oldname
, newname
);
613 clock_gettime_mono(&ts2
);
614 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
616 if (timediff
> audit_timeout
) {
617 smb_time_audit_log("rename", timediff
);
623 static int smb_time_audit_fsync(vfs_handle_struct
*handle
, files_struct
*fsp
)
626 struct timespec ts1
,ts2
;
629 clock_gettime_mono(&ts1
);
630 result
= SMB_VFS_NEXT_FSYNC(handle
, fsp
);
631 clock_gettime_mono(&ts2
);
632 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
634 if (timediff
> audit_timeout
) {
635 smb_time_audit_log("fsync", timediff
);
641 static int smb_time_audit_stat(vfs_handle_struct
*handle
,
642 struct smb_filename
*fname
)
645 struct timespec ts1
,ts2
;
648 clock_gettime_mono(&ts1
);
649 result
= SMB_VFS_NEXT_STAT(handle
, fname
);
650 clock_gettime_mono(&ts2
);
651 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
653 if (timediff
> audit_timeout
) {
654 smb_time_audit_log("stat", timediff
);
660 static int smb_time_audit_fstat(vfs_handle_struct
*handle
, files_struct
*fsp
,
661 SMB_STRUCT_STAT
*sbuf
)
664 struct timespec ts1
,ts2
;
667 clock_gettime_mono(&ts1
);
668 result
= SMB_VFS_NEXT_FSTAT(handle
, fsp
, sbuf
);
669 clock_gettime_mono(&ts2
);
670 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
672 if (timediff
> audit_timeout
) {
673 smb_time_audit_log("fstat", timediff
);
679 static int smb_time_audit_lstat(vfs_handle_struct
*handle
,
680 struct smb_filename
*path
)
683 struct timespec ts1
,ts2
;
686 clock_gettime_mono(&ts1
);
687 result
= SMB_VFS_NEXT_LSTAT(handle
, path
);
688 clock_gettime_mono(&ts2
);
689 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
691 if (timediff
> audit_timeout
) {
692 smb_time_audit_log("lstat", timediff
);
698 static uint64_t smb_time_audit_get_alloc_size(vfs_handle_struct
*handle
,
700 const SMB_STRUCT_STAT
*sbuf
)
703 struct timespec ts1
,ts2
;
706 clock_gettime_mono(&ts1
);
707 result
= SMB_VFS_NEXT_GET_ALLOC_SIZE(handle
, fsp
, sbuf
);
708 clock_gettime_mono(&ts2
);
709 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
711 if (timediff
> audit_timeout
) {
712 smb_time_audit_log("get_alloc_size", timediff
);
718 static int smb_time_audit_unlink(vfs_handle_struct
*handle
,
719 const struct smb_filename
*path
)
722 struct timespec ts1
,ts2
;
725 clock_gettime_mono(&ts1
);
726 result
= SMB_VFS_NEXT_UNLINK(handle
, path
);
727 clock_gettime_mono(&ts2
);
728 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
730 if (timediff
> audit_timeout
) {
731 smb_time_audit_log("unlink", timediff
);
737 static int smb_time_audit_chmod(vfs_handle_struct
*handle
,
738 const char *path
, mode_t mode
)
741 struct timespec ts1
,ts2
;
744 clock_gettime_mono(&ts1
);
745 result
= SMB_VFS_NEXT_CHMOD(handle
, path
, mode
);
746 clock_gettime_mono(&ts2
);
747 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
749 if (timediff
> audit_timeout
) {
750 smb_time_audit_log("chmod", timediff
);
756 static int smb_time_audit_fchmod(vfs_handle_struct
*handle
, files_struct
*fsp
,
760 struct timespec ts1
,ts2
;
763 clock_gettime_mono(&ts1
);
764 result
= SMB_VFS_NEXT_FCHMOD(handle
, fsp
, mode
);
765 clock_gettime_mono(&ts2
);
766 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
768 if (timediff
> audit_timeout
) {
769 smb_time_audit_log("fchmod", timediff
);
775 static int smb_time_audit_chown(vfs_handle_struct
*handle
,
776 const char *path
, uid_t uid
, gid_t gid
)
779 struct timespec ts1
,ts2
;
782 clock_gettime_mono(&ts1
);
783 result
= SMB_VFS_NEXT_CHOWN(handle
, path
, uid
, gid
);
784 clock_gettime_mono(&ts2
);
785 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
787 if (timediff
> audit_timeout
) {
788 smb_time_audit_log("chown", timediff
);
794 static int smb_time_audit_fchown(vfs_handle_struct
*handle
, files_struct
*fsp
,
795 uid_t uid
, gid_t gid
)
798 struct timespec ts1
,ts2
;
801 clock_gettime_mono(&ts1
);
802 result
= SMB_VFS_NEXT_FCHOWN(handle
, fsp
, uid
, gid
);
803 clock_gettime_mono(&ts2
);
804 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
806 if (timediff
> audit_timeout
) {
807 smb_time_audit_log("fchown", timediff
);
813 static int smb_time_audit_lchown(vfs_handle_struct
*handle
,
814 const char *path
, uid_t uid
, gid_t gid
)
817 struct timespec ts1
,ts2
;
820 clock_gettime_mono(&ts1
);
821 result
= SMB_VFS_NEXT_LCHOWN(handle
, path
, uid
, gid
);
822 clock_gettime_mono(&ts2
);
823 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
825 if (timediff
> audit_timeout
) {
826 smb_time_audit_log("lchown", timediff
);
832 static int smb_time_audit_chdir(vfs_handle_struct
*handle
, const char *path
)
835 struct timespec ts1
,ts2
;
838 clock_gettime_mono(&ts1
);
839 result
= SMB_VFS_NEXT_CHDIR(handle
, path
);
840 clock_gettime_mono(&ts2
);
841 timediff
= nsec_time_diff(&ts2
,&ts1
);
843 if (timediff
> audit_timeout
) {
844 smb_time_audit_log("chdir", timediff
*1.0e-9);
850 static char *smb_time_audit_getwd(vfs_handle_struct
*handle
, char *path
)
853 struct timespec ts1
,ts2
;
856 clock_gettime_mono(&ts1
);
857 result
= SMB_VFS_NEXT_GETWD(handle
, path
);
858 clock_gettime_mono(&ts2
);
859 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
861 if (timediff
> audit_timeout
) {
862 smb_time_audit_log("getwd", timediff
);
868 static int smb_time_audit_ntimes(vfs_handle_struct
*handle
,
869 const struct smb_filename
*path
,
870 struct smb_file_time
*ft
)
873 struct timespec ts1
,ts2
;
876 clock_gettime_mono(&ts1
);
877 result
= SMB_VFS_NEXT_NTIMES(handle
, path
, ft
);
878 clock_gettime_mono(&ts2
);
879 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
881 if (timediff
> audit_timeout
) {
882 smb_time_audit_log("ntimes", timediff
);
888 static int smb_time_audit_ftruncate(vfs_handle_struct
*handle
,
893 struct timespec ts1
,ts2
;
896 clock_gettime_mono(&ts1
);
897 result
= SMB_VFS_NEXT_FTRUNCATE(handle
, fsp
, len
);
898 clock_gettime_mono(&ts2
);
899 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
901 if (timediff
> audit_timeout
) {
902 smb_time_audit_log("ftruncate", timediff
);
908 static bool smb_time_audit_lock(vfs_handle_struct
*handle
, files_struct
*fsp
,
909 int op
, SMB_OFF_T offset
, SMB_OFF_T count
,
913 struct timespec ts1
,ts2
;
916 clock_gettime_mono(&ts1
);
917 result
= SMB_VFS_NEXT_LOCK(handle
, fsp
, op
, offset
, count
, type
);
918 clock_gettime_mono(&ts2
);
919 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
921 if (timediff
> audit_timeout
) {
922 smb_time_audit_log("lock", timediff
);
928 static int smb_time_audit_kernel_flock(struct vfs_handle_struct
*handle
,
929 struct files_struct
*fsp
,
930 uint32 share_mode
, uint32 access_mask
)
933 struct timespec ts1
,ts2
;
936 clock_gettime_mono(&ts1
);
937 result
= SMB_VFS_NEXT_KERNEL_FLOCK(handle
, fsp
, share_mode
,
939 clock_gettime_mono(&ts2
);
940 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
942 if (timediff
> audit_timeout
) {
943 smb_time_audit_log("kernel_flock", timediff
);
949 static int smb_time_audit_linux_setlease(vfs_handle_struct
*handle
,
954 struct timespec ts1
,ts2
;
957 clock_gettime_mono(&ts1
);
958 result
= SMB_VFS_NEXT_LINUX_SETLEASE(handle
, fsp
, leasetype
);
959 clock_gettime_mono(&ts2
);
960 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
962 if (timediff
> audit_timeout
) {
963 smb_time_audit_log("linux_setlease", timediff
);
969 static bool smb_time_audit_getlock(vfs_handle_struct
*handle
,
971 SMB_OFF_T
*poffset
, SMB_OFF_T
*pcount
,
972 int *ptype
, pid_t
*ppid
)
975 struct timespec ts1
,ts2
;
978 clock_gettime_mono(&ts1
);
979 result
= SMB_VFS_NEXT_GETLOCK(handle
, fsp
, poffset
, pcount
, ptype
,
981 clock_gettime_mono(&ts2
);
982 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
984 if (timediff
> audit_timeout
) {
985 smb_time_audit_log("getlock", timediff
);
991 static int smb_time_audit_symlink(vfs_handle_struct
*handle
,
992 const char *oldpath
, const char *newpath
)
995 struct timespec ts1
,ts2
;
998 clock_gettime_mono(&ts1
);
999 result
= SMB_VFS_NEXT_SYMLINK(handle
, oldpath
, newpath
);
1000 clock_gettime_mono(&ts2
);
1001 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1003 if (timediff
> audit_timeout
) {
1004 smb_time_audit_log("symlink", timediff
);
1010 static int smb_time_audit_readlink(vfs_handle_struct
*handle
,
1011 const char *path
, char *buf
, size_t bufsiz
)
1014 struct timespec ts1
,ts2
;
1017 clock_gettime_mono(&ts1
);
1018 result
= SMB_VFS_NEXT_READLINK(handle
, path
, buf
, bufsiz
);
1019 clock_gettime_mono(&ts2
);
1020 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1022 if (timediff
> audit_timeout
) {
1023 smb_time_audit_log("readlink", timediff
);
1029 static int smb_time_audit_link(vfs_handle_struct
*handle
,
1030 const char *oldpath
, const char *newpath
)
1033 struct timespec ts1
,ts2
;
1036 clock_gettime_mono(&ts1
);
1037 result
= SMB_VFS_NEXT_LINK(handle
, oldpath
, newpath
);
1038 clock_gettime_mono(&ts2
);
1039 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1041 if (timediff
> audit_timeout
) {
1042 smb_time_audit_log("link", timediff
);
1048 static int smb_time_audit_mknod(vfs_handle_struct
*handle
,
1049 const char *pathname
, mode_t mode
,
1053 struct timespec ts1
,ts2
;
1056 clock_gettime_mono(&ts1
);
1057 result
= SMB_VFS_NEXT_MKNOD(handle
, pathname
, mode
, dev
);
1058 clock_gettime_mono(&ts2
);
1059 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1061 if (timediff
> audit_timeout
) {
1062 smb_time_audit_log("mknod", timediff
);
1068 static char *smb_time_audit_realpath(vfs_handle_struct
*handle
,
1069 const char *path
, char *resolved_path
)
1072 struct timespec ts1
,ts2
;
1075 clock_gettime_mono(&ts1
);
1076 result
= SMB_VFS_NEXT_REALPATH(handle
, path
, resolved_path
);
1077 clock_gettime_mono(&ts2
);
1078 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1080 if (timediff
> audit_timeout
) {
1081 smb_time_audit_log("realpath", timediff
);
1087 static NTSTATUS
smb_time_audit_notify_watch(struct vfs_handle_struct
*handle
,
1088 struct sys_notify_context
*ctx
,
1089 struct notify_entry
*e
,
1090 void (*callback
)(struct sys_notify_context
*ctx
,
1092 struct notify_event
*ev
),
1093 void *private_data
, void *handle_p
)
1096 struct timespec ts1
,ts2
;
1099 clock_gettime_mono(&ts1
);
1100 result
= SMB_VFS_NEXT_NOTIFY_WATCH(handle
, ctx
, e
, callback
,
1101 private_data
, handle_p
);
1102 clock_gettime_mono(&ts2
);
1103 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1105 if (timediff
> audit_timeout
) {
1106 smb_time_audit_log("notify_watch", timediff
);
1112 static int smb_time_audit_chflags(vfs_handle_struct
*handle
,
1113 const char *path
, unsigned int flags
)
1116 struct timespec ts1
,ts2
;
1119 clock_gettime_mono(&ts1
);
1120 result
= SMB_VFS_NEXT_CHFLAGS(handle
, path
, flags
);
1121 clock_gettime_mono(&ts2
);
1122 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1124 if (timediff
> audit_timeout
) {
1125 smb_time_audit_log("chflags", timediff
);
1131 static struct file_id
smb_time_audit_file_id_create(struct vfs_handle_struct
*handle
,
1132 const SMB_STRUCT_STAT
*sbuf
)
1134 struct file_id id_zero
;
1135 struct file_id result
;
1136 struct timespec ts1
,ts2
;
1139 ZERO_STRUCT(id_zero
);
1141 clock_gettime_mono(&ts1
);
1142 result
= SMB_VFS_NEXT_FILE_ID_CREATE(handle
, sbuf
);
1143 clock_gettime_mono(&ts2
);
1144 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1146 if (timediff
> audit_timeout
) {
1147 smb_time_audit_log("file_id_create", timediff
);
1153 static NTSTATUS
smb_time_audit_streaminfo(vfs_handle_struct
*handle
,
1154 struct files_struct
*fsp
,
1156 TALLOC_CTX
*mem_ctx
,
1157 unsigned int *pnum_streams
,
1158 struct stream_struct
**pstreams
)
1161 struct timespec ts1
,ts2
;
1164 clock_gettime_mono(&ts1
);
1165 result
= SMB_VFS_NEXT_STREAMINFO(handle
, fsp
, fname
, mem_ctx
,
1166 pnum_streams
, pstreams
);
1167 clock_gettime_mono(&ts2
);
1168 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1170 if (timediff
> audit_timeout
) {
1171 smb_time_audit_log("streaminfo", timediff
);
1177 static int smb_time_audit_get_real_filename(struct vfs_handle_struct
*handle
,
1180 TALLOC_CTX
*mem_ctx
,
1184 struct timespec ts1
,ts2
;
1187 clock_gettime_mono(&ts1
);
1188 result
= SMB_VFS_NEXT_GET_REAL_FILENAME(handle
, path
, name
, mem_ctx
,
1190 clock_gettime_mono(&ts2
);
1191 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1193 if (timediff
> audit_timeout
) {
1194 smb_time_audit_log("get_real_filename", timediff
);
1200 static const char *smb_time_audit_connectpath(vfs_handle_struct
*handle
,
1204 struct timespec ts1
,ts2
;
1207 clock_gettime_mono(&ts1
);
1208 result
= SMB_VFS_NEXT_CONNECTPATH(handle
, fname
);
1209 clock_gettime_mono(&ts2
);
1210 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1212 if (timediff
> audit_timeout
) {
1213 smb_time_audit_log("connectpath", timediff
);
1219 static NTSTATUS
smb_time_audit_brl_lock_windows(struct vfs_handle_struct
*handle
,
1220 struct byte_range_lock
*br_lck
,
1221 struct lock_struct
*plock
,
1223 struct blocking_lock_record
*blr
)
1226 struct timespec ts1
,ts2
;
1229 clock_gettime_mono(&ts1
);
1230 result
= SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle
, br_lck
, plock
,
1231 blocking_lock
, blr
);
1232 clock_gettime_mono(&ts2
);
1233 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1235 if (timediff
> audit_timeout
) {
1236 smb_time_audit_log("brl_lock_windows", timediff
);
1242 static bool smb_time_audit_brl_unlock_windows(struct vfs_handle_struct
*handle
,
1243 struct messaging_context
*msg_ctx
,
1244 struct byte_range_lock
*br_lck
,
1245 const struct lock_struct
*plock
)
1248 struct timespec ts1
,ts2
;
1251 clock_gettime_mono(&ts1
);
1252 result
= SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle
, msg_ctx
, br_lck
,
1254 clock_gettime_mono(&ts2
);
1255 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1257 if (timediff
> audit_timeout
) {
1258 smb_time_audit_log("brl_unlock_windows", timediff
);
1264 static bool smb_time_audit_brl_cancel_windows(struct vfs_handle_struct
*handle
,
1265 struct byte_range_lock
*br_lck
,
1266 struct lock_struct
*plock
,
1267 struct blocking_lock_record
*blr
)
1270 struct timespec ts1
,ts2
;
1273 clock_gettime_mono(&ts1
);
1274 result
= SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle
, br_lck
, plock
, blr
);
1275 clock_gettime_mono(&ts2
);
1276 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1278 if (timediff
> audit_timeout
) {
1279 smb_time_audit_log("brl_cancel_windows", timediff
);
1285 static bool smb_time_audit_strict_lock(struct vfs_handle_struct
*handle
,
1286 struct files_struct
*fsp
,
1287 struct lock_struct
*plock
)
1290 struct timespec ts1
,ts2
;
1293 clock_gettime_mono(&ts1
);
1294 result
= SMB_VFS_NEXT_STRICT_LOCK(handle
, fsp
, plock
);
1295 clock_gettime_mono(&ts2
);
1296 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1298 if (timediff
> audit_timeout
) {
1299 smb_time_audit_log("strict_lock", timediff
);
1305 static void smb_time_audit_strict_unlock(struct vfs_handle_struct
*handle
,
1306 struct files_struct
*fsp
,
1307 struct lock_struct
*plock
)
1309 struct timespec ts1
,ts2
;
1312 clock_gettime_mono(&ts1
);
1313 SMB_VFS_NEXT_STRICT_UNLOCK(handle
, fsp
, plock
);
1314 clock_gettime_mono(&ts2
);
1315 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1317 if (timediff
> audit_timeout
) {
1318 smb_time_audit_log("strict_unlock", timediff
);
1324 static NTSTATUS
smb_time_audit_translate_name(struct vfs_handle_struct
*handle
,
1326 enum vfs_translate_direction direction
,
1327 TALLOC_CTX
*mem_ctx
,
1331 struct timespec ts1
,ts2
;
1334 clock_gettime_mono(&ts1
);
1335 result
= SMB_VFS_NEXT_TRANSLATE_NAME(handle
, name
, direction
, mem_ctx
,
1337 clock_gettime_mono(&ts2
);
1338 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1340 if (timediff
> audit_timeout
) {
1341 smb_time_audit_log("translate_name", timediff
);
1347 static NTSTATUS
smb_time_audit_fget_nt_acl(vfs_handle_struct
*handle
,
1349 uint32 security_info
,
1350 struct security_descriptor
**ppdesc
)
1353 struct timespec ts1
,ts2
;
1356 clock_gettime_mono(&ts1
);
1357 result
= SMB_VFS_NEXT_FGET_NT_ACL(handle
, fsp
, security_info
, ppdesc
);
1358 clock_gettime_mono(&ts2
);
1359 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1361 if (timediff
> audit_timeout
) {
1362 smb_time_audit_log("fget_nt_acl", timediff
);
1368 static NTSTATUS
smb_time_audit_get_nt_acl(vfs_handle_struct
*handle
,
1370 uint32 security_info
,
1371 struct security_descriptor
**ppdesc
)
1374 struct timespec ts1
,ts2
;
1377 clock_gettime_mono(&ts1
);
1378 result
= SMB_VFS_NEXT_GET_NT_ACL(handle
, name
, security_info
, ppdesc
);
1379 clock_gettime_mono(&ts2
);
1380 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1382 if (timediff
> audit_timeout
) {
1383 smb_time_audit_log("get_nt_acl", timediff
);
1389 static NTSTATUS
smb_time_audit_fset_nt_acl(vfs_handle_struct
*handle
,
1391 uint32 security_info_sent
,
1392 const struct security_descriptor
*psd
)
1395 struct timespec ts1
,ts2
;
1398 clock_gettime_mono(&ts1
);
1399 result
= SMB_VFS_NEXT_FSET_NT_ACL(handle
, fsp
, security_info_sent
,
1401 clock_gettime_mono(&ts2
);
1402 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1404 if (timediff
> audit_timeout
) {
1405 smb_time_audit_log("fset_nt_acl", timediff
);
1411 static int smb_time_audit_chmod_acl(vfs_handle_struct
*handle
,
1412 const char *path
, mode_t mode
)
1415 struct timespec ts1
,ts2
;
1418 clock_gettime_mono(&ts1
);
1419 result
= SMB_VFS_NEXT_CHMOD_ACL(handle
, path
, mode
);
1420 clock_gettime_mono(&ts2
);
1421 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1423 if (timediff
> audit_timeout
) {
1424 smb_time_audit_log("chmod_acl", timediff
);
1430 static int smb_time_audit_fchmod_acl(vfs_handle_struct
*handle
,
1431 files_struct
*fsp
, mode_t mode
)
1434 struct timespec ts1
,ts2
;
1437 clock_gettime_mono(&ts1
);
1438 result
= SMB_VFS_NEXT_FCHMOD_ACL(handle
, fsp
, mode
);
1439 clock_gettime_mono(&ts2
);
1440 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1442 if (timediff
> audit_timeout
) {
1443 smb_time_audit_log("fchmod_acl", timediff
);
1449 static int smb_time_audit_sys_acl_get_entry(vfs_handle_struct
*handle
,
1450 SMB_ACL_T theacl
, int entry_id
,
1451 SMB_ACL_ENTRY_T
*entry_p
)
1454 struct timespec ts1
,ts2
;
1457 clock_gettime_mono(&ts1
);
1458 result
= SMB_VFS_NEXT_SYS_ACL_GET_ENTRY(handle
, theacl
, entry_id
,
1460 clock_gettime_mono(&ts2
);
1461 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1463 if (timediff
> audit_timeout
) {
1464 smb_time_audit_log("sys_acl_get_entry", timediff
);
1470 static int smb_time_audit_sys_acl_get_tag_type(vfs_handle_struct
*handle
,
1471 SMB_ACL_ENTRY_T entry_d
,
1472 SMB_ACL_TAG_T
*tag_type_p
)
1475 struct timespec ts1
,ts2
;
1478 clock_gettime_mono(&ts1
);
1479 result
= SMB_VFS_NEXT_SYS_ACL_GET_TAG_TYPE(handle
, entry_d
,
1481 clock_gettime_mono(&ts2
);
1482 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1484 if (timediff
> audit_timeout
) {
1485 smb_time_audit_log("sys_acl_get_tag_type", timediff
);
1491 static int smb_time_audit_sys_acl_get_permset(vfs_handle_struct
*handle
,
1492 SMB_ACL_ENTRY_T entry_d
,
1493 SMB_ACL_PERMSET_T
*permset_p
)
1496 struct timespec ts1
,ts2
;
1499 clock_gettime_mono(&ts1
);
1500 result
= SMB_VFS_NEXT_SYS_ACL_GET_PERMSET(handle
, entry_d
,
1502 clock_gettime_mono(&ts2
);
1503 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1505 if (timediff
> audit_timeout
) {
1506 smb_time_audit_log("sys_acl_get_permset", timediff
);
1512 static void * smb_time_audit_sys_acl_get_qualifier(vfs_handle_struct
*handle
,
1513 SMB_ACL_ENTRY_T entry_d
)
1516 struct timespec ts1
,ts2
;
1519 clock_gettime_mono(&ts1
);
1520 result
= SMB_VFS_NEXT_SYS_ACL_GET_QUALIFIER(handle
, entry_d
);
1521 clock_gettime_mono(&ts2
);
1522 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1524 if (timediff
> audit_timeout
) {
1525 smb_time_audit_log("sys_acl_get_qualifier", timediff
);
1531 static SMB_ACL_T
smb_time_audit_sys_acl_get_file(vfs_handle_struct
*handle
,
1533 SMB_ACL_TYPE_T type
)
1536 struct timespec ts1
,ts2
;
1539 clock_gettime_mono(&ts1
);
1540 result
= SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle
, path_p
, type
);
1541 clock_gettime_mono(&ts2
);
1542 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1544 if (timediff
> audit_timeout
) {
1545 smb_time_audit_log("sys_acl_get_file", timediff
);
1551 static SMB_ACL_T
smb_time_audit_sys_acl_get_fd(vfs_handle_struct
*handle
,
1555 struct timespec ts1
,ts2
;
1558 clock_gettime_mono(&ts1
);
1559 result
= SMB_VFS_NEXT_SYS_ACL_GET_FD(handle
, fsp
);
1560 clock_gettime_mono(&ts2
);
1561 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1563 if (timediff
> audit_timeout
) {
1564 smb_time_audit_log("sys_acl_get_fd", timediff
);
1570 static int smb_time_audit_sys_acl_clear_perms(vfs_handle_struct
*handle
,
1571 SMB_ACL_PERMSET_T permset
)
1574 struct timespec ts1
,ts2
;
1577 clock_gettime_mono(&ts1
);
1578 result
= SMB_VFS_NEXT_SYS_ACL_CLEAR_PERMS(handle
, permset
);
1579 clock_gettime_mono(&ts2
);
1580 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1582 if (timediff
> audit_timeout
) {
1583 smb_time_audit_log("sys_acl_clear_perms", timediff
);
1589 static int smb_time_audit_sys_acl_add_perm(vfs_handle_struct
*handle
,
1590 SMB_ACL_PERMSET_T permset
,
1591 SMB_ACL_PERM_T perm
)
1594 struct timespec ts1
,ts2
;
1597 clock_gettime_mono(&ts1
);
1598 result
= SMB_VFS_NEXT_SYS_ACL_ADD_PERM(handle
, permset
, perm
);
1599 clock_gettime_mono(&ts2
);
1600 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1602 if (timediff
> audit_timeout
) {
1603 smb_time_audit_log("sys_acl_add_perm", timediff
);
1609 static char * smb_time_audit_sys_acl_to_text(vfs_handle_struct
*handle
,
1614 struct timespec ts1
,ts2
;
1617 clock_gettime_mono(&ts1
);
1618 result
= SMB_VFS_NEXT_SYS_ACL_TO_TEXT(handle
, theacl
, plen
);
1619 clock_gettime_mono(&ts2
);
1620 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1622 if (timediff
> audit_timeout
) {
1623 smb_time_audit_log("sys_acl_to_text", timediff
);
1629 static SMB_ACL_T
smb_time_audit_sys_acl_init(vfs_handle_struct
*handle
,
1633 struct timespec ts1
,ts2
;
1636 clock_gettime_mono(&ts1
);
1637 result
= SMB_VFS_NEXT_SYS_ACL_INIT(handle
, count
);
1638 clock_gettime_mono(&ts2
);
1639 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1641 if (timediff
> audit_timeout
) {
1642 smb_time_audit_log("sys_acl_init", timediff
);
1648 static int smb_time_audit_sys_acl_create_entry(vfs_handle_struct
*handle
,
1650 SMB_ACL_ENTRY_T
*pentry
)
1653 struct timespec ts1
,ts2
;
1656 clock_gettime_mono(&ts1
);
1657 result
= SMB_VFS_NEXT_SYS_ACL_CREATE_ENTRY(handle
, pacl
, pentry
);
1658 clock_gettime_mono(&ts2
);
1659 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1661 if (timediff
> audit_timeout
) {
1662 smb_time_audit_log("sys_acl_create_entry", timediff
);
1668 static int smb_time_audit_sys_acl_set_tag_type(vfs_handle_struct
*handle
,
1669 SMB_ACL_ENTRY_T entry
,
1670 SMB_ACL_TAG_T tagtype
)
1673 struct timespec ts1
,ts2
;
1676 clock_gettime_mono(&ts1
);
1677 result
= SMB_VFS_NEXT_SYS_ACL_SET_TAG_TYPE(handle
, entry
,
1679 clock_gettime_mono(&ts2
);
1680 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1682 if (timediff
> audit_timeout
) {
1683 smb_time_audit_log("sys_acl_set_tag_type", timediff
);
1689 static int smb_time_audit_sys_acl_set_qualifier(vfs_handle_struct
*handle
,
1690 SMB_ACL_ENTRY_T entry
,
1694 struct timespec ts1
,ts2
;
1697 clock_gettime_mono(&ts1
);
1698 result
= SMB_VFS_NEXT_SYS_ACL_SET_QUALIFIER(handle
, entry
, qual
);
1699 clock_gettime_mono(&ts2
);
1700 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1702 if (timediff
> audit_timeout
) {
1703 smb_time_audit_log("sys_acl_set_qualifier", timediff
);
1709 static int smb_time_audit_sys_acl_set_permset(vfs_handle_struct
*handle
,
1710 SMB_ACL_ENTRY_T entry
,
1711 SMB_ACL_PERMSET_T permset
)
1714 struct timespec ts1
,ts2
;
1717 clock_gettime_mono(&ts1
);
1718 result
= SMB_VFS_NEXT_SYS_ACL_SET_PERMSET(handle
, entry
, permset
);
1719 clock_gettime_mono(&ts2
);
1720 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1722 if (timediff
> audit_timeout
) {
1723 smb_time_audit_log("sys_acl_set_permset", timediff
);
1729 static int smb_time_audit_sys_acl_valid(vfs_handle_struct
*handle
,
1733 struct timespec ts1
,ts2
;
1736 clock_gettime_mono(&ts1
);
1737 result
= SMB_VFS_NEXT_SYS_ACL_VALID(handle
, theacl
);
1738 clock_gettime_mono(&ts2
);
1739 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1741 if (timediff
> audit_timeout
) {
1742 smb_time_audit_log("sys_acl_valid", timediff
);
1748 static int smb_time_audit_sys_acl_set_file(vfs_handle_struct
*handle
,
1750 SMB_ACL_TYPE_T acltype
,
1754 struct timespec ts1
,ts2
;
1757 clock_gettime_mono(&ts1
);
1758 result
= SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle
, name
, acltype
,
1760 clock_gettime_mono(&ts2
);
1761 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1763 if (timediff
> audit_timeout
) {
1764 smb_time_audit_log("sys_acl_set_file", timediff
);
1770 static int smb_time_audit_sys_acl_set_fd(vfs_handle_struct
*handle
,
1775 struct timespec ts1
,ts2
;
1778 clock_gettime_mono(&ts1
);
1779 result
= SMB_VFS_NEXT_SYS_ACL_SET_FD(handle
, fsp
, theacl
);
1780 clock_gettime_mono(&ts2
);
1781 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1783 if (timediff
> audit_timeout
) {
1784 smb_time_audit_log("sys_acl_set_fd", timediff
);
1790 static int smb_time_audit_sys_acl_delete_def_file(vfs_handle_struct
*handle
,
1794 struct timespec ts1
,ts2
;
1797 clock_gettime_mono(&ts1
);
1798 result
= SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle
, path
);
1799 clock_gettime_mono(&ts2
);
1800 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1802 if (timediff
> audit_timeout
) {
1803 smb_time_audit_log("sys_acl_delete_def_file", timediff
);
1809 static int smb_time_audit_sys_acl_get_perm(vfs_handle_struct
*handle
,
1810 SMB_ACL_PERMSET_T permset
,
1811 SMB_ACL_PERM_T perm
)
1814 struct timespec ts1
,ts2
;
1817 clock_gettime_mono(&ts1
);
1818 result
= SMB_VFS_NEXT_SYS_ACL_GET_PERM(handle
, permset
, perm
);
1819 clock_gettime_mono(&ts2
);
1820 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1822 if (timediff
> audit_timeout
) {
1823 smb_time_audit_log("sys_acl_get_perm", timediff
);
1829 static int smb_time_audit_sys_acl_free_text(vfs_handle_struct
*handle
,
1833 struct timespec ts1
,ts2
;
1836 clock_gettime_mono(&ts1
);
1837 result
= SMB_VFS_NEXT_SYS_ACL_FREE_TEXT(handle
, text
);
1838 clock_gettime_mono(&ts2
);
1839 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1841 if (timediff
> audit_timeout
) {
1842 smb_time_audit_log("sys_acl_free_text", timediff
);
1848 static int smb_time_audit_sys_acl_free_acl(vfs_handle_struct
*handle
,
1849 SMB_ACL_T posix_acl
)
1852 struct timespec ts1
,ts2
;
1855 clock_gettime_mono(&ts1
);
1856 result
= SMB_VFS_NEXT_SYS_ACL_FREE_ACL(handle
, posix_acl
);
1857 clock_gettime_mono(&ts2
);
1858 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1860 if (timediff
> audit_timeout
) {
1861 smb_time_audit_log("sys_acl_free_acl", timediff
);
1867 static int smb_time_audit_sys_acl_free_qualifier(vfs_handle_struct
*handle
,
1869 SMB_ACL_TAG_T tagtype
)
1872 struct timespec ts1
,ts2
;
1875 clock_gettime_mono(&ts1
);
1876 result
= SMB_VFS_NEXT_SYS_ACL_FREE_QUALIFIER(handle
, qualifier
,
1878 clock_gettime_mono(&ts2
);
1879 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1881 if (timediff
> audit_timeout
) {
1882 smb_time_audit_log("sys_acl_free_qualifier", timediff
);
1888 static ssize_t
smb_time_audit_getxattr(struct vfs_handle_struct
*handle
,
1889 const char *path
, const char *name
,
1890 void *value
, size_t size
)
1893 struct timespec ts1
,ts2
;
1896 clock_gettime_mono(&ts1
);
1897 result
= SMB_VFS_NEXT_GETXATTR(handle
, path
, name
, value
, size
);
1898 clock_gettime_mono(&ts2
);
1899 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1901 if (timediff
> audit_timeout
) {
1902 smb_time_audit_log("getxattr", timediff
);
1908 static ssize_t
smb_time_audit_lgetxattr(struct vfs_handle_struct
*handle
,
1909 const char *path
, const char *name
,
1910 void *value
, size_t size
)
1913 struct timespec ts1
,ts2
;
1916 clock_gettime_mono(&ts1
);
1917 result
= SMB_VFS_NEXT_LGETXATTR(handle
, path
, name
, value
, size
);
1918 clock_gettime_mono(&ts2
);
1919 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1921 if (timediff
> audit_timeout
) {
1922 smb_time_audit_log("lgetxattr", timediff
);
1928 static ssize_t
smb_time_audit_fgetxattr(struct vfs_handle_struct
*handle
,
1929 struct files_struct
*fsp
,
1930 const char *name
, void *value
,
1934 struct timespec ts1
,ts2
;
1937 clock_gettime_mono(&ts1
);
1938 result
= SMB_VFS_NEXT_FGETXATTR(handle
, fsp
, name
, value
, size
);
1939 clock_gettime_mono(&ts2
);
1940 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1942 if (timediff
> audit_timeout
) {
1943 smb_time_audit_log("fgetxattr", timediff
);
1949 static ssize_t
smb_time_audit_listxattr(struct vfs_handle_struct
*handle
,
1950 const char *path
, char *list
,
1954 struct timespec ts1
,ts2
;
1957 clock_gettime_mono(&ts1
);
1958 result
= SMB_VFS_NEXT_LISTXATTR(handle
, path
, list
, size
);
1959 clock_gettime_mono(&ts2
);
1960 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1962 if (timediff
> audit_timeout
) {
1963 smb_time_audit_log("listxattr", timediff
);
1969 static ssize_t
smb_time_audit_llistxattr(struct vfs_handle_struct
*handle
,
1970 const char *path
, char *list
,
1974 struct timespec ts1
,ts2
;
1977 clock_gettime_mono(&ts1
);
1978 result
= SMB_VFS_NEXT_LLISTXATTR(handle
, path
, list
, size
);
1979 clock_gettime_mono(&ts2
);
1980 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1982 if (timediff
> audit_timeout
) {
1983 smb_time_audit_log("llistxattr", timediff
);
1989 static ssize_t
smb_time_audit_flistxattr(struct vfs_handle_struct
*handle
,
1990 struct files_struct
*fsp
, char *list
,
1994 struct timespec ts1
,ts2
;
1997 clock_gettime_mono(&ts1
);
1998 result
= SMB_VFS_NEXT_FLISTXATTR(handle
, fsp
, list
, size
);
1999 clock_gettime_mono(&ts2
);
2000 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2002 if (timediff
> audit_timeout
) {
2003 smb_time_audit_log("flistxattr", timediff
);
2009 static int smb_time_audit_removexattr(struct vfs_handle_struct
*handle
,
2010 const char *path
, const char *name
)
2013 struct timespec ts1
,ts2
;
2016 clock_gettime_mono(&ts1
);
2017 result
= SMB_VFS_NEXT_REMOVEXATTR(handle
, path
, name
);
2018 clock_gettime_mono(&ts2
);
2019 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2021 if (timediff
> audit_timeout
) {
2022 smb_time_audit_log("removexattr", timediff
);
2028 static int smb_time_audit_lremovexattr(struct vfs_handle_struct
*handle
,
2029 const char *path
, const char *name
)
2032 struct timespec ts1
,ts2
;
2035 clock_gettime_mono(&ts1
);
2036 result
= SMB_VFS_NEXT_LREMOVEXATTR(handle
, path
, name
);
2037 clock_gettime_mono(&ts2
);
2038 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2040 if (timediff
> audit_timeout
) {
2041 smb_time_audit_log("lremovexattr", timediff
);
2047 static int smb_time_audit_fremovexattr(struct vfs_handle_struct
*handle
,
2048 struct files_struct
*fsp
,
2052 struct timespec ts1
,ts2
;
2055 clock_gettime_mono(&ts1
);
2056 result
= SMB_VFS_NEXT_FREMOVEXATTR(handle
, fsp
, name
);
2057 clock_gettime_mono(&ts2
);
2058 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2060 if (timediff
> audit_timeout
) {
2061 smb_time_audit_log("fremovexattr", timediff
);
2067 static int smb_time_audit_setxattr(struct vfs_handle_struct
*handle
,
2068 const char *path
, const char *name
,
2069 const void *value
, size_t size
,
2073 struct timespec ts1
,ts2
;
2076 clock_gettime_mono(&ts1
);
2077 result
= SMB_VFS_NEXT_SETXATTR(handle
, path
, name
, value
, size
,
2079 clock_gettime_mono(&ts2
);
2080 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2082 if (timediff
> audit_timeout
) {
2083 smb_time_audit_log("setxattr", timediff
);
2089 static int smb_time_audit_lsetxattr(struct vfs_handle_struct
*handle
,
2090 const char *path
, const char *name
,
2091 const void *value
, size_t size
,
2095 struct timespec ts1
,ts2
;
2098 clock_gettime_mono(&ts1
);
2099 result
= SMB_VFS_NEXT_LSETXATTR(handle
, path
, name
, value
, size
,
2101 clock_gettime_mono(&ts2
);
2102 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2104 if (timediff
> audit_timeout
) {
2105 smb_time_audit_log("lsetxattr", timediff
);
2111 static int smb_time_audit_fsetxattr(struct vfs_handle_struct
*handle
,
2112 struct files_struct
*fsp
, const char *name
,
2113 const void *value
, size_t size
, int flags
)
2116 struct timespec ts1
,ts2
;
2119 clock_gettime_mono(&ts1
);
2120 result
= SMB_VFS_NEXT_FSETXATTR(handle
, fsp
, name
, value
, size
, flags
);
2121 clock_gettime_mono(&ts2
);
2122 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2124 if (timediff
> audit_timeout
) {
2125 smb_time_audit_log("fsetxattr", timediff
);
2131 static int smb_time_audit_aio_read(struct vfs_handle_struct
*handle
,
2132 struct files_struct
*fsp
,
2133 SMB_STRUCT_AIOCB
*aiocb
)
2136 struct timespec ts1
,ts2
;
2139 clock_gettime_mono(&ts1
);
2140 result
= SMB_VFS_NEXT_AIO_READ(handle
, fsp
, aiocb
);
2141 clock_gettime_mono(&ts2
);
2142 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2144 if (timediff
> audit_timeout
) {
2145 smb_time_audit_log("aio_read", timediff
);
2151 static int smb_time_audit_aio_write(struct vfs_handle_struct
*handle
,
2152 struct files_struct
*fsp
,
2153 SMB_STRUCT_AIOCB
*aiocb
)
2156 struct timespec ts1
,ts2
;
2159 clock_gettime_mono(&ts1
);
2160 result
= SMB_VFS_NEXT_AIO_WRITE(handle
, fsp
, aiocb
);
2161 clock_gettime_mono(&ts2
);
2162 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2164 if (timediff
> audit_timeout
) {
2165 smb_time_audit_log("aio_write", timediff
);
2171 static ssize_t
smb_time_audit_aio_return(struct vfs_handle_struct
*handle
,
2172 struct files_struct
*fsp
,
2173 SMB_STRUCT_AIOCB
*aiocb
)
2176 struct timespec ts1
,ts2
;
2179 clock_gettime_mono(&ts1
);
2180 result
= SMB_VFS_NEXT_AIO_RETURN(handle
, fsp
, aiocb
);
2181 clock_gettime_mono(&ts2
);
2182 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2184 if (timediff
> audit_timeout
) {
2185 smb_time_audit_log("aio_return", timediff
);
2191 static int smb_time_audit_aio_cancel(struct vfs_handle_struct
*handle
,
2192 struct files_struct
*fsp
,
2193 SMB_STRUCT_AIOCB
*aiocb
)
2196 struct timespec ts1
,ts2
;
2199 clock_gettime_mono(&ts1
);
2200 result
= SMB_VFS_NEXT_AIO_CANCEL(handle
, fsp
, aiocb
);
2201 clock_gettime_mono(&ts2
);
2202 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2204 if (timediff
> audit_timeout
) {
2205 smb_time_audit_log("aio_cancel", timediff
);
2211 static int smb_time_audit_aio_error(struct vfs_handle_struct
*handle
,
2212 struct files_struct
*fsp
,
2213 SMB_STRUCT_AIOCB
*aiocb
)
2216 struct timespec ts1
,ts2
;
2219 clock_gettime_mono(&ts1
);
2220 result
= SMB_VFS_NEXT_AIO_ERROR(handle
, fsp
, aiocb
);
2221 clock_gettime_mono(&ts2
);
2222 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2224 if (timediff
> audit_timeout
) {
2225 smb_time_audit_log("aio_error", timediff
);
2231 static int smb_time_audit_aio_fsync(struct vfs_handle_struct
*handle
,
2232 struct files_struct
*fsp
, int op
,
2233 SMB_STRUCT_AIOCB
*aiocb
)
2236 struct timespec ts1
,ts2
;
2239 clock_gettime_mono(&ts1
);
2240 result
= SMB_VFS_NEXT_AIO_FSYNC(handle
, fsp
, op
, aiocb
);
2241 clock_gettime_mono(&ts2
);
2242 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2244 if (timediff
> audit_timeout
) {
2245 smb_time_audit_log("aio_fsync", timediff
);
2251 static int smb_time_audit_aio_suspend(struct vfs_handle_struct
*handle
,
2252 struct files_struct
*fsp
,
2253 const SMB_STRUCT_AIOCB
* const aiocb
[],
2254 int n
, const struct timespec
*ts
)
2257 struct timespec ts1
,ts2
;
2260 clock_gettime_mono(&ts1
);
2261 result
= SMB_VFS_NEXT_AIO_SUSPEND(handle
, fsp
, aiocb
, n
, ts
);
2262 clock_gettime_mono(&ts2
);
2263 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2265 if (timediff
> audit_timeout
) {
2266 smb_time_audit_log("aio_suspend", timediff
);
2272 static bool smb_time_audit_aio_force(struct vfs_handle_struct
*handle
,
2273 struct files_struct
*fsp
)
2276 struct timespec ts1
,ts2
;
2279 clock_gettime_mono(&ts1
);
2280 result
= SMB_VFS_NEXT_AIO_FORCE(handle
, fsp
);
2281 clock_gettime_mono(&ts2
);
2282 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2284 if (timediff
> audit_timeout
) {
2285 smb_time_audit_log("aio_force", timediff
);
2293 /* VFS operations */
2295 static struct vfs_fn_pointers vfs_time_audit_fns
= {
2296 .connect_fn
= smb_time_audit_connect
,
2297 .disconnect
= smb_time_audit_disconnect
,
2298 .disk_free
= smb_time_audit_disk_free
,
2299 .get_quota
= smb_time_audit_get_quota
,
2300 .set_quota
= smb_time_audit_set_quota
,
2301 .get_shadow_copy_data
= smb_time_audit_get_shadow_copy_data
,
2302 .statvfs
= smb_time_audit_statvfs
,
2303 .fs_capabilities
= smb_time_audit_fs_capabilities
,
2304 .opendir
= smb_time_audit_opendir
,
2305 .readdir
= smb_time_audit_readdir
,
2306 .seekdir
= smb_time_audit_seekdir
,
2307 .telldir
= smb_time_audit_telldir
,
2308 .rewind_dir
= smb_time_audit_rewinddir
,
2309 .mkdir
= smb_time_audit_mkdir
,
2310 .rmdir
= smb_time_audit_rmdir
,
2311 .closedir
= smb_time_audit_closedir
,
2312 .init_search_op
= smb_time_audit_init_search_op
,
2313 .open
= smb_time_audit_open
,
2314 .create_file
= smb_time_audit_create_file
,
2315 .close_fn
= smb_time_audit_close
,
2316 .vfs_read
= smb_time_audit_read
,
2317 .pread
= smb_time_audit_pread
,
2318 .write
= smb_time_audit_write
,
2319 .pwrite
= smb_time_audit_pwrite
,
2320 .lseek
= smb_time_audit_lseek
,
2321 .sendfile
= smb_time_audit_sendfile
,
2322 .recvfile
= smb_time_audit_recvfile
,
2323 .rename
= smb_time_audit_rename
,
2324 .fsync
= smb_time_audit_fsync
,
2325 .stat
= smb_time_audit_stat
,
2326 .fstat
= smb_time_audit_fstat
,
2327 .lstat
= smb_time_audit_lstat
,
2328 .get_alloc_size
= smb_time_audit_get_alloc_size
,
2329 .unlink
= smb_time_audit_unlink
,
2330 .chmod
= smb_time_audit_chmod
,
2331 .fchmod
= smb_time_audit_fchmod
,
2332 .chown
= smb_time_audit_chown
,
2333 .fchown
= smb_time_audit_fchown
,
2334 .lchown
= smb_time_audit_lchown
,
2335 .chdir
= smb_time_audit_chdir
,
2336 .getwd
= smb_time_audit_getwd
,
2337 .ntimes
= smb_time_audit_ntimes
,
2338 .ftruncate
= smb_time_audit_ftruncate
,
2339 .lock
= smb_time_audit_lock
,
2340 .kernel_flock
= smb_time_audit_kernel_flock
,
2341 .linux_setlease
= smb_time_audit_linux_setlease
,
2342 .getlock
= smb_time_audit_getlock
,
2343 .symlink
= smb_time_audit_symlink
,
2344 .vfs_readlink
= smb_time_audit_readlink
,
2345 .link
= smb_time_audit_link
,
2346 .mknod
= smb_time_audit_mknod
,
2347 .realpath
= smb_time_audit_realpath
,
2348 .notify_watch
= smb_time_audit_notify_watch
,
2349 .chflags
= smb_time_audit_chflags
,
2350 .file_id_create
= smb_time_audit_file_id_create
,
2351 .streaminfo
= smb_time_audit_streaminfo
,
2352 .get_real_filename
= smb_time_audit_get_real_filename
,
2353 .connectpath
= smb_time_audit_connectpath
,
2354 .brl_lock_windows
= smb_time_audit_brl_lock_windows
,
2355 .brl_unlock_windows
= smb_time_audit_brl_unlock_windows
,
2356 .brl_cancel_windows
= smb_time_audit_brl_cancel_windows
,
2357 .strict_lock
= smb_time_audit_strict_lock
,
2358 .strict_unlock
= smb_time_audit_strict_unlock
,
2359 .translate_name
= smb_time_audit_translate_name
,
2360 .fget_nt_acl
= smb_time_audit_fget_nt_acl
,
2361 .get_nt_acl
= smb_time_audit_get_nt_acl
,
2362 .fset_nt_acl
= smb_time_audit_fset_nt_acl
,
2363 .chmod_acl
= smb_time_audit_chmod_acl
,
2364 .fchmod_acl
= smb_time_audit_fchmod_acl
,
2365 .sys_acl_get_entry
= smb_time_audit_sys_acl_get_entry
,
2366 .sys_acl_get_tag_type
= smb_time_audit_sys_acl_get_tag_type
,
2367 .sys_acl_get_permset
= smb_time_audit_sys_acl_get_permset
,
2368 .sys_acl_get_qualifier
= smb_time_audit_sys_acl_get_qualifier
,
2369 .sys_acl_get_file
= smb_time_audit_sys_acl_get_file
,
2370 .sys_acl_get_fd
= smb_time_audit_sys_acl_get_fd
,
2371 .sys_acl_clear_perms
= smb_time_audit_sys_acl_clear_perms
,
2372 .sys_acl_add_perm
= smb_time_audit_sys_acl_add_perm
,
2373 .sys_acl_to_text
= smb_time_audit_sys_acl_to_text
,
2374 .sys_acl_init
= smb_time_audit_sys_acl_init
,
2375 .sys_acl_create_entry
= smb_time_audit_sys_acl_create_entry
,
2376 .sys_acl_set_tag_type
= smb_time_audit_sys_acl_set_tag_type
,
2377 .sys_acl_set_qualifier
= smb_time_audit_sys_acl_set_qualifier
,
2378 .sys_acl_set_permset
= smb_time_audit_sys_acl_set_permset
,
2379 .sys_acl_valid
= smb_time_audit_sys_acl_valid
,
2380 .sys_acl_set_file
= smb_time_audit_sys_acl_set_file
,
2381 .sys_acl_set_fd
= smb_time_audit_sys_acl_set_fd
,
2382 .sys_acl_delete_def_file
= smb_time_audit_sys_acl_delete_def_file
,
2383 .sys_acl_get_perm
= smb_time_audit_sys_acl_get_perm
,
2384 .sys_acl_free_text
= smb_time_audit_sys_acl_free_text
,
2385 .sys_acl_free_acl
= smb_time_audit_sys_acl_free_acl
,
2386 .sys_acl_free_qualifier
= smb_time_audit_sys_acl_free_qualifier
,
2387 .getxattr
= smb_time_audit_getxattr
,
2388 .lgetxattr
= smb_time_audit_lgetxattr
,
2389 .fgetxattr
= smb_time_audit_fgetxattr
,
2390 .listxattr
= smb_time_audit_listxattr
,
2391 .llistxattr
= smb_time_audit_llistxattr
,
2392 .flistxattr
= smb_time_audit_flistxattr
,
2393 .removexattr
= smb_time_audit_removexattr
,
2394 .lremovexattr
= smb_time_audit_lremovexattr
,
2395 .fremovexattr
= smb_time_audit_fremovexattr
,
2396 .setxattr
= smb_time_audit_setxattr
,
2397 .lsetxattr
= smb_time_audit_lsetxattr
,
2398 .fsetxattr
= smb_time_audit_fsetxattr
,
2399 .aio_read
= smb_time_audit_aio_read
,
2400 .aio_write
= smb_time_audit_aio_write
,
2401 .aio_return_fn
= smb_time_audit_aio_return
,
2402 .aio_cancel
= smb_time_audit_aio_cancel
,
2403 .aio_error_fn
= smb_time_audit_aio_error
,
2404 .aio_fsync
= smb_time_audit_aio_fsync
,
2405 .aio_suspend
= smb_time_audit_aio_suspend
,
2406 .aio_force
= smb_time_audit_aio_force
,
2410 NTSTATUS
vfs_time_audit_init(void);
2411 NTSTATUS
vfs_time_audit_init(void)
2413 audit_timeout
= (double)lp_parm_int(-1, "time_audit", "timeout",
2415 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION
, "time_audit",
2416 &vfs_time_audit_fns
);