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
29 #include "smbd/smbd.h"
31 #include "lib/util/tevent_unix.h"
34 #define DBGC_CLASS DBGC_VFS
36 static double audit_timeout
;
38 static void smb_time_audit_log(const char *syscallname
, double elapsed
)
40 DEBUG(0, ("WARNING: System call \"%s\" took unexpectedly long "
41 "(%.2f seconds) -- Validate that file and storage "
42 "subsystems are operating normally\n", syscallname
,
46 static int smb_time_audit_connect(vfs_handle_struct
*handle
,
47 const char *svc
, const char *user
)
50 struct timespec ts1
,ts2
;
57 clock_gettime_mono(&ts1
);
58 result
= SMB_VFS_NEXT_CONNECT(handle
, svc
, user
);
59 clock_gettime_mono(&ts2
);
60 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
61 if (timediff
> audit_timeout
) {
62 smb_time_audit_log("connect", timediff
);
67 static void smb_time_audit_disconnect(vfs_handle_struct
*handle
)
69 struct timespec ts1
,ts2
;
72 clock_gettime_mono(&ts1
);
73 SMB_VFS_NEXT_DISCONNECT(handle
);
74 clock_gettime_mono(&ts2
);
75 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
77 if (timediff
> audit_timeout
) {
78 smb_time_audit_log("disconnect", timediff
);
84 static uint64_t smb_time_audit_disk_free(vfs_handle_struct
*handle
,
86 bool small_query
, uint64_t *bsize
,
87 uint64_t *dfree
, uint64_t *dsize
)
90 struct timespec ts1
,ts2
;
93 clock_gettime_mono(&ts1
);
94 result
= SMB_VFS_NEXT_DISK_FREE(handle
, path
, small_query
, bsize
,
96 clock_gettime_mono(&ts2
);
97 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
99 /* Don't have a reasonable notion of failure here */
100 if (timediff
> audit_timeout
) {
101 smb_time_audit_log("disk_free", timediff
);
107 static int smb_time_audit_get_quota(struct vfs_handle_struct
*handle
,
108 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
112 struct timespec ts1
,ts2
;
115 clock_gettime_mono(&ts1
);
116 result
= SMB_VFS_NEXT_GET_QUOTA(handle
, qtype
, id
, qt
);
117 clock_gettime_mono(&ts2
);
118 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
120 if (timediff
> audit_timeout
) {
121 smb_time_audit_log("get_quota", timediff
);
126 static int smb_time_audit_set_quota(struct vfs_handle_struct
*handle
,
127 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
131 struct timespec ts1
,ts2
;
134 clock_gettime_mono(&ts1
);
135 result
= SMB_VFS_NEXT_SET_QUOTA(handle
, qtype
, id
, qt
);
136 clock_gettime_mono(&ts2
);
137 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
139 if (timediff
> audit_timeout
) {
140 smb_time_audit_log("set_quota", timediff
);
146 static int smb_time_audit_get_shadow_copy_data(struct vfs_handle_struct
*handle
,
147 struct files_struct
*fsp
,
148 struct shadow_copy_data
*shadow_copy_data
,
152 struct timespec ts1
,ts2
;
155 clock_gettime_mono(&ts1
);
156 result
= SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle
, fsp
,
157 shadow_copy_data
, labels
);
158 clock_gettime_mono(&ts2
);
159 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
161 if (timediff
> audit_timeout
) {
162 smb_time_audit_log("get_shadow_copy_data", timediff
);
168 static int smb_time_audit_statvfs(struct vfs_handle_struct
*handle
,
170 struct vfs_statvfs_struct
*statbuf
)
173 struct timespec ts1
,ts2
;
176 clock_gettime_mono(&ts1
);
177 result
= SMB_VFS_NEXT_STATVFS(handle
, path
, statbuf
);
178 clock_gettime_mono(&ts2
);
179 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
181 if (timediff
> audit_timeout
) {
182 smb_time_audit_log("statvfs", timediff
);
188 static uint32_t smb_time_audit_fs_capabilities(struct vfs_handle_struct
*handle
,
189 enum timestamp_set_resolution
*p_ts_res
)
192 struct timespec ts1
,ts2
;
195 clock_gettime_mono(&ts1
);
196 result
= SMB_VFS_NEXT_FS_CAPABILITIES(handle
, p_ts_res
);
197 clock_gettime_mono(&ts2
);
198 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
200 if (timediff
> audit_timeout
) {
201 smb_time_audit_log("fs_capabilities", timediff
);
207 static DIR *smb_time_audit_opendir(vfs_handle_struct
*handle
,
209 const char *mask
, uint32 attr
)
212 struct timespec ts1
,ts2
;
215 clock_gettime_mono(&ts1
);
216 result
= SMB_VFS_NEXT_OPENDIR(handle
, fname
, mask
, attr
);
217 clock_gettime_mono(&ts2
);
218 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
220 if (timediff
> audit_timeout
) {
221 smb_time_audit_log("opendir", timediff
);
227 static DIR *smb_time_audit_fdopendir(vfs_handle_struct
*handle
,
229 const char *mask
, uint32 attr
)
232 struct timespec ts1
,ts2
;
235 clock_gettime_mono(&ts1
);
236 result
= SMB_VFS_NEXT_FDOPENDIR(handle
, fsp
, mask
, attr
);
237 clock_gettime_mono(&ts2
);
238 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
240 if (timediff
> audit_timeout
) {
241 smb_time_audit_log("fdopendir", timediff
);
247 static struct dirent
*smb_time_audit_readdir(vfs_handle_struct
*handle
,
249 SMB_STRUCT_STAT
*sbuf
)
251 struct dirent
*result
;
252 struct timespec ts1
,ts2
;
255 clock_gettime_mono(&ts1
);
256 result
= SMB_VFS_NEXT_READDIR(handle
, dirp
, sbuf
);
257 clock_gettime_mono(&ts2
);
258 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
260 if (timediff
> audit_timeout
) {
261 smb_time_audit_log("readdir", timediff
);
267 static void smb_time_audit_seekdir(vfs_handle_struct
*handle
,
268 DIR *dirp
, long offset
)
270 struct timespec ts1
,ts2
;
273 clock_gettime_mono(&ts1
);
274 SMB_VFS_NEXT_SEEKDIR(handle
, dirp
, offset
);
275 clock_gettime_mono(&ts2
);
276 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
278 if (timediff
> audit_timeout
) {
279 smb_time_audit_log("seekdir", timediff
);
285 static long smb_time_audit_telldir(vfs_handle_struct
*handle
,
289 struct timespec ts1
,ts2
;
292 clock_gettime_mono(&ts1
);
293 result
= SMB_VFS_NEXT_TELLDIR(handle
, dirp
);
294 clock_gettime_mono(&ts2
);
295 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
297 if (timediff
> audit_timeout
) {
298 smb_time_audit_log("telldir", timediff
);
304 static void smb_time_audit_rewinddir(vfs_handle_struct
*handle
,
307 struct timespec ts1
,ts2
;
310 clock_gettime_mono(&ts1
);
311 SMB_VFS_NEXT_REWINDDIR(handle
, dirp
);
312 clock_gettime_mono(&ts2
);
313 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
315 if (timediff
> audit_timeout
) {
316 smb_time_audit_log("rewinddir", timediff
);
322 static int smb_time_audit_mkdir(vfs_handle_struct
*handle
,
323 const char *path
, mode_t mode
)
326 struct timespec ts1
,ts2
;
329 clock_gettime_mono(&ts1
);
330 result
= SMB_VFS_NEXT_MKDIR(handle
, path
, mode
);
331 clock_gettime_mono(&ts2
);
332 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
334 if (timediff
> audit_timeout
) {
335 smb_time_audit_log("mkdir", timediff
);
341 static int smb_time_audit_rmdir(vfs_handle_struct
*handle
,
345 struct timespec ts1
,ts2
;
348 clock_gettime_mono(&ts1
);
349 result
= SMB_VFS_NEXT_RMDIR(handle
, path
);
350 clock_gettime_mono(&ts2
);
351 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
353 if (timediff
> audit_timeout
) {
354 smb_time_audit_log("rmdir", timediff
);
360 static int smb_time_audit_closedir(vfs_handle_struct
*handle
,
364 struct timespec ts1
,ts2
;
367 clock_gettime_mono(&ts1
);
368 result
= SMB_VFS_NEXT_CLOSEDIR(handle
, dirp
);
369 clock_gettime_mono(&ts2
);
370 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
372 if (timediff
> audit_timeout
) {
373 smb_time_audit_log("closedir", timediff
);
379 static void smb_time_audit_init_search_op(vfs_handle_struct
*handle
,
382 struct timespec ts1
,ts2
;
385 clock_gettime_mono(&ts1
);
386 SMB_VFS_NEXT_INIT_SEARCH_OP(handle
, dirp
);
387 clock_gettime_mono(&ts2
);
388 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
390 if (timediff
> audit_timeout
) {
391 smb_time_audit_log("init_search_op", timediff
);
396 static int smb_time_audit_open(vfs_handle_struct
*handle
,
397 struct smb_filename
*fname
,
399 int flags
, mode_t mode
)
402 struct timespec ts1
,ts2
;
405 clock_gettime_mono(&ts1
);
406 result
= SMB_VFS_NEXT_OPEN(handle
, fname
, fsp
, flags
, mode
);
407 clock_gettime_mono(&ts2
);
408 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
410 if (timediff
> audit_timeout
) {
411 smb_time_audit_log("open", timediff
);
417 static NTSTATUS
smb_time_audit_create_file(vfs_handle_struct
*handle
,
418 struct smb_request
*req
,
419 uint16_t root_dir_fid
,
420 struct smb_filename
*fname
,
421 uint32_t access_mask
,
422 uint32_t share_access
,
423 uint32_t create_disposition
,
424 uint32_t create_options
,
425 uint32_t file_attributes
,
426 uint32_t oplock_request
,
427 uint64_t allocation_size
,
428 uint32_t private_flags
,
429 struct security_descriptor
*sd
,
430 struct ea_list
*ea_list
,
431 files_struct
**result_fsp
,
435 struct timespec ts1
,ts2
;
438 clock_gettime_mono(&ts1
);
439 result
= SMB_VFS_NEXT_CREATE_FILE(
442 root_dir_fid
, /* root_dir_fid */
444 access_mask
, /* access_mask */
445 share_access
, /* share_access */
446 create_disposition
, /* create_disposition*/
447 create_options
, /* create_options */
448 file_attributes
, /* file_attributes */
449 oplock_request
, /* oplock_request */
450 allocation_size
, /* allocation_size */
453 ea_list
, /* ea_list */
454 result_fsp
, /* result */
456 clock_gettime_mono(&ts2
);
457 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
459 if (timediff
> audit_timeout
) {
460 smb_time_audit_log("create_file", timediff
);
466 static int smb_time_audit_close(vfs_handle_struct
*handle
, files_struct
*fsp
)
469 struct timespec ts1
,ts2
;
472 clock_gettime_mono(&ts1
);
473 result
= SMB_VFS_NEXT_CLOSE(handle
, fsp
);
474 clock_gettime_mono(&ts2
);
475 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
477 if (timediff
> audit_timeout
) {
478 smb_time_audit_log("close", timediff
);
484 static ssize_t
smb_time_audit_read(vfs_handle_struct
*handle
,
485 files_struct
*fsp
, void *data
, size_t n
)
488 struct timespec ts1
,ts2
;
491 clock_gettime_mono(&ts1
);
492 result
= SMB_VFS_NEXT_READ(handle
, fsp
, data
, n
);
493 clock_gettime_mono(&ts2
);
494 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
496 if (timediff
> audit_timeout
) {
497 smb_time_audit_log("read", timediff
);
503 static ssize_t
smb_time_audit_pread(vfs_handle_struct
*handle
,
505 void *data
, size_t n
, off_t offset
)
508 struct timespec ts1
,ts2
;
511 clock_gettime_mono(&ts1
);
512 result
= SMB_VFS_NEXT_PREAD(handle
, fsp
, data
, n
, offset
);
513 clock_gettime_mono(&ts2
);
514 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
516 if (timediff
> audit_timeout
) {
517 smb_time_audit_log("pread", timediff
);
523 struct smb_time_audit_pread_state
{
529 static void smb_time_audit_pread_done(struct tevent_req
*subreq
);
531 static struct tevent_req
*smb_time_audit_pread_send(
532 struct vfs_handle_struct
*handle
, TALLOC_CTX
*mem_ctx
,
533 struct tevent_context
*ev
, struct files_struct
*fsp
,
534 void *data
, size_t n
, off_t offset
)
536 struct tevent_req
*req
, *subreq
;
537 struct smb_time_audit_pread_state
*state
;
539 req
= tevent_req_create(mem_ctx
, &state
,
540 struct smb_time_audit_pread_state
);
544 clock_gettime_mono(&state
->ts1
);
546 subreq
= SMB_VFS_NEXT_PREAD_SEND(state
, ev
, handle
, fsp
, data
,
548 if (tevent_req_nomem(subreq
, req
)) {
549 return tevent_req_post(req
, ev
);
551 tevent_req_set_callback(subreq
, smb_time_audit_pread_done
, req
);
555 static void smb_time_audit_pread_done(struct tevent_req
*subreq
)
557 struct tevent_req
*req
= tevent_req_callback_data(
558 subreq
, struct tevent_req
);
559 struct smb_time_audit_pread_state
*state
= tevent_req_data(
560 req
, struct smb_time_audit_pread_state
);
562 state
->ret
= SMB_VFS_PREAD_RECV(subreq
, &state
->err
);
564 tevent_req_done(req
);
567 static ssize_t
smb_time_audit_pread_recv(struct tevent_req
*req
, int *err
)
569 struct smb_time_audit_pread_state
*state
= tevent_req_data(
570 req
, struct smb_time_audit_pread_state
);
574 clock_gettime_mono(&ts2
);
575 timediff
= nsec_time_diff(&ts2
,&state
->ts1
)*1.0e-9;
577 if (timediff
> audit_timeout
) {
578 smb_time_audit_log("pread", timediff
);
581 if (tevent_req_is_unix_error(req
, err
)) {
588 static ssize_t
smb_time_audit_write(vfs_handle_struct
*handle
,
590 const void *data
, size_t n
)
593 struct timespec ts1
,ts2
;
596 clock_gettime_mono(&ts1
);
597 result
= SMB_VFS_NEXT_WRITE(handle
, fsp
, data
, n
);
598 clock_gettime_mono(&ts2
);
599 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
601 if (timediff
> audit_timeout
) {
602 smb_time_audit_log("write", timediff
);
608 static ssize_t
smb_time_audit_pwrite(vfs_handle_struct
*handle
,
610 const void *data
, size_t n
,
614 struct timespec ts1
,ts2
;
617 clock_gettime_mono(&ts1
);
618 result
= SMB_VFS_NEXT_PWRITE(handle
, fsp
, data
, n
, offset
);
619 clock_gettime_mono(&ts2
);
620 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
622 if (timediff
> audit_timeout
) {
623 smb_time_audit_log("pwrite", timediff
);
629 struct smb_time_audit_pwrite_state
{
635 static void smb_time_audit_pwrite_done(struct tevent_req
*subreq
);
637 static struct tevent_req
*smb_time_audit_pwrite_send(
638 struct vfs_handle_struct
*handle
, TALLOC_CTX
*mem_ctx
,
639 struct tevent_context
*ev
, struct files_struct
*fsp
,
640 const void *data
, size_t n
, off_t offset
)
642 struct tevent_req
*req
, *subreq
;
643 struct smb_time_audit_pwrite_state
*state
;
645 req
= tevent_req_create(mem_ctx
, &state
,
646 struct smb_time_audit_pwrite_state
);
650 clock_gettime_mono(&state
->ts1
);
652 subreq
= SMB_VFS_NEXT_PWRITE_SEND(state
, ev
, handle
, fsp
, data
,
654 if (tevent_req_nomem(subreq
, req
)) {
655 return tevent_req_post(req
, ev
);
657 tevent_req_set_callback(subreq
, smb_time_audit_pwrite_done
, req
);
661 static void smb_time_audit_pwrite_done(struct tevent_req
*subreq
)
663 struct tevent_req
*req
= tevent_req_callback_data(
664 subreq
, struct tevent_req
);
665 struct smb_time_audit_pwrite_state
*state
= tevent_req_data(
666 req
, struct smb_time_audit_pwrite_state
);
668 state
->ret
= SMB_VFS_PWRITE_RECV(subreq
, &state
->err
);
670 tevent_req_done(req
);
673 static ssize_t
smb_time_audit_pwrite_recv(struct tevent_req
*req
, int *err
)
675 struct smb_time_audit_pwrite_state
*state
= tevent_req_data(
676 req
, struct smb_time_audit_pwrite_state
);
680 clock_gettime_mono(&ts2
);
681 timediff
= nsec_time_diff(&ts2
,&state
->ts1
)*1.0e-9;
683 if (timediff
> audit_timeout
) {
684 smb_time_audit_log("pwrite", timediff
);
687 if (tevent_req_is_unix_error(req
, err
)) {
694 static off_t
smb_time_audit_lseek(vfs_handle_struct
*handle
,
696 off_t offset
, int whence
)
699 struct timespec ts1
,ts2
;
702 clock_gettime_mono(&ts1
);
703 result
= SMB_VFS_NEXT_LSEEK(handle
, fsp
, offset
, whence
);
704 clock_gettime_mono(&ts2
);
705 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
707 if (timediff
> audit_timeout
) {
708 smb_time_audit_log("lseek", timediff
);
714 static ssize_t
smb_time_audit_sendfile(vfs_handle_struct
*handle
, int tofd
,
715 files_struct
*fromfsp
,
716 const DATA_BLOB
*hdr
, off_t offset
,
720 struct timespec ts1
,ts2
;
723 clock_gettime_mono(&ts1
);
724 result
= SMB_VFS_NEXT_SENDFILE(handle
, tofd
, fromfsp
, hdr
, offset
, n
);
725 clock_gettime_mono(&ts2
);
726 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
728 if (timediff
> audit_timeout
) {
729 smb_time_audit_log("sendfile", timediff
);
735 static ssize_t
smb_time_audit_recvfile(vfs_handle_struct
*handle
, int fromfd
,
741 struct timespec ts1
,ts2
;
744 clock_gettime_mono(&ts1
);
745 result
= SMB_VFS_NEXT_RECVFILE(handle
, fromfd
, tofsp
, offset
, n
);
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("recvfile", timediff
);
756 static int smb_time_audit_rename(vfs_handle_struct
*handle
,
757 const struct smb_filename
*oldname
,
758 const struct smb_filename
*newname
)
761 struct timespec ts1
,ts2
;
764 clock_gettime_mono(&ts1
);
765 result
= SMB_VFS_NEXT_RENAME(handle
, oldname
, newname
);
766 clock_gettime_mono(&ts2
);
767 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
769 if (timediff
> audit_timeout
) {
770 smb_time_audit_log("rename", timediff
);
776 static int smb_time_audit_fsync(vfs_handle_struct
*handle
, files_struct
*fsp
)
779 struct timespec ts1
,ts2
;
782 clock_gettime_mono(&ts1
);
783 result
= SMB_VFS_NEXT_FSYNC(handle
, fsp
);
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("fsync", timediff
);
794 struct smb_time_audit_fsync_state
{
800 static void smb_time_audit_fsync_done(struct tevent_req
*subreq
);
802 static struct tevent_req
*smb_time_audit_fsync_send(
803 struct vfs_handle_struct
*handle
, TALLOC_CTX
*mem_ctx
,
804 struct tevent_context
*ev
, struct files_struct
*fsp
)
806 struct tevent_req
*req
, *subreq
;
807 struct smb_time_audit_fsync_state
*state
;
809 req
= tevent_req_create(mem_ctx
, &state
,
810 struct smb_time_audit_fsync_state
);
814 clock_gettime_mono(&state
->ts1
);
816 subreq
= SMB_VFS_NEXT_FSYNC_SEND(state
, ev
, handle
, fsp
);
817 if (tevent_req_nomem(subreq
, req
)) {
818 return tevent_req_post(req
, ev
);
820 tevent_req_set_callback(subreq
, smb_time_audit_fsync_done
, req
);
824 static void smb_time_audit_fsync_done(struct tevent_req
*subreq
)
826 struct tevent_req
*req
= tevent_req_callback_data(
827 subreq
, struct tevent_req
);
828 struct smb_time_audit_fsync_state
*state
= tevent_req_data(
829 req
, struct smb_time_audit_fsync_state
);
831 state
->ret
= SMB_VFS_FSYNC_RECV(subreq
, &state
->err
);
833 tevent_req_done(req
);
836 static int smb_time_audit_fsync_recv(struct tevent_req
*req
, int *err
)
838 struct smb_time_audit_fsync_state
*state
= tevent_req_data(
839 req
, struct smb_time_audit_fsync_state
);
843 clock_gettime_mono(&ts2
);
844 timediff
= nsec_time_diff(&ts2
,&state
->ts1
)*1.0e-9;
846 if (timediff
> audit_timeout
) {
847 smb_time_audit_log("fsync", timediff
);
850 if (tevent_req_is_unix_error(req
, err
)) {
857 static int smb_time_audit_stat(vfs_handle_struct
*handle
,
858 struct smb_filename
*fname
)
861 struct timespec ts1
,ts2
;
864 clock_gettime_mono(&ts1
);
865 result
= SMB_VFS_NEXT_STAT(handle
, fname
);
866 clock_gettime_mono(&ts2
);
867 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
869 if (timediff
> audit_timeout
) {
870 smb_time_audit_log("stat", timediff
);
876 static int smb_time_audit_fstat(vfs_handle_struct
*handle
, files_struct
*fsp
,
877 SMB_STRUCT_STAT
*sbuf
)
880 struct timespec ts1
,ts2
;
883 clock_gettime_mono(&ts1
);
884 result
= SMB_VFS_NEXT_FSTAT(handle
, fsp
, sbuf
);
885 clock_gettime_mono(&ts2
);
886 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
888 if (timediff
> audit_timeout
) {
889 smb_time_audit_log("fstat", timediff
);
895 static int smb_time_audit_lstat(vfs_handle_struct
*handle
,
896 struct smb_filename
*path
)
899 struct timespec ts1
,ts2
;
902 clock_gettime_mono(&ts1
);
903 result
= SMB_VFS_NEXT_LSTAT(handle
, path
);
904 clock_gettime_mono(&ts2
);
905 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
907 if (timediff
> audit_timeout
) {
908 smb_time_audit_log("lstat", timediff
);
914 static uint64_t smb_time_audit_get_alloc_size(vfs_handle_struct
*handle
,
916 const SMB_STRUCT_STAT
*sbuf
)
919 struct timespec ts1
,ts2
;
922 clock_gettime_mono(&ts1
);
923 result
= SMB_VFS_NEXT_GET_ALLOC_SIZE(handle
, fsp
, sbuf
);
924 clock_gettime_mono(&ts2
);
925 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
927 if (timediff
> audit_timeout
) {
928 smb_time_audit_log("get_alloc_size", timediff
);
934 static int smb_time_audit_unlink(vfs_handle_struct
*handle
,
935 const struct smb_filename
*path
)
938 struct timespec ts1
,ts2
;
941 clock_gettime_mono(&ts1
);
942 result
= SMB_VFS_NEXT_UNLINK(handle
, path
);
943 clock_gettime_mono(&ts2
);
944 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
946 if (timediff
> audit_timeout
) {
947 smb_time_audit_log("unlink", timediff
);
953 static int smb_time_audit_chmod(vfs_handle_struct
*handle
,
954 const char *path
, mode_t mode
)
957 struct timespec ts1
,ts2
;
960 clock_gettime_mono(&ts1
);
961 result
= SMB_VFS_NEXT_CHMOD(handle
, path
, mode
);
962 clock_gettime_mono(&ts2
);
963 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
965 if (timediff
> audit_timeout
) {
966 smb_time_audit_log("chmod", timediff
);
972 static int smb_time_audit_fchmod(vfs_handle_struct
*handle
, files_struct
*fsp
,
976 struct timespec ts1
,ts2
;
979 clock_gettime_mono(&ts1
);
980 result
= SMB_VFS_NEXT_FCHMOD(handle
, fsp
, mode
);
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("fchmod", timediff
);
991 static int smb_time_audit_chown(vfs_handle_struct
*handle
,
992 const char *path
, uid_t uid
, gid_t gid
)
995 struct timespec ts1
,ts2
;
998 clock_gettime_mono(&ts1
);
999 result
= SMB_VFS_NEXT_CHOWN(handle
, path
, uid
, gid
);
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("chown", timediff
);
1010 static int smb_time_audit_fchown(vfs_handle_struct
*handle
, files_struct
*fsp
,
1011 uid_t uid
, gid_t gid
)
1014 struct timespec ts1
,ts2
;
1017 clock_gettime_mono(&ts1
);
1018 result
= SMB_VFS_NEXT_FCHOWN(handle
, fsp
, uid
, gid
);
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("fchown", timediff
);
1029 static int smb_time_audit_lchown(vfs_handle_struct
*handle
,
1030 const char *path
, uid_t uid
, gid_t gid
)
1033 struct timespec ts1
,ts2
;
1036 clock_gettime_mono(&ts1
);
1037 result
= SMB_VFS_NEXT_LCHOWN(handle
, path
, uid
, gid
);
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("lchown", timediff
);
1048 static int smb_time_audit_chdir(vfs_handle_struct
*handle
, const char *path
)
1051 struct timespec ts1
,ts2
;
1054 clock_gettime_mono(&ts1
);
1055 result
= SMB_VFS_NEXT_CHDIR(handle
, path
);
1056 clock_gettime_mono(&ts2
);
1057 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1059 if (timediff
> audit_timeout
) {
1060 smb_time_audit_log("chdir", timediff
);
1066 static char *smb_time_audit_getwd(vfs_handle_struct
*handle
)
1069 struct timespec ts1
,ts2
;
1072 clock_gettime_mono(&ts1
);
1073 result
= SMB_VFS_NEXT_GETWD(handle
);
1074 clock_gettime_mono(&ts2
);
1075 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1077 if (timediff
> audit_timeout
) {
1078 smb_time_audit_log("getwd", timediff
);
1084 static int smb_time_audit_ntimes(vfs_handle_struct
*handle
,
1085 const struct smb_filename
*path
,
1086 struct smb_file_time
*ft
)
1089 struct timespec ts1
,ts2
;
1092 clock_gettime_mono(&ts1
);
1093 result
= SMB_VFS_NEXT_NTIMES(handle
, path
, ft
);
1094 clock_gettime_mono(&ts2
);
1095 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1097 if (timediff
> audit_timeout
) {
1098 smb_time_audit_log("ntimes", timediff
);
1104 static int smb_time_audit_ftruncate(vfs_handle_struct
*handle
,
1109 struct timespec ts1
,ts2
;
1112 clock_gettime_mono(&ts1
);
1113 result
= SMB_VFS_NEXT_FTRUNCATE(handle
, fsp
, len
);
1114 clock_gettime_mono(&ts2
);
1115 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1117 if (timediff
> audit_timeout
) {
1118 smb_time_audit_log("ftruncate", timediff
);
1124 static int smb_time_audit_fallocate(vfs_handle_struct
*handle
,
1126 enum vfs_fallocate_mode mode
,
1131 struct timespec ts1
,ts2
;
1134 clock_gettime_mono(&ts1
);
1135 result
= SMB_VFS_NEXT_FALLOCATE(handle
, fsp
, mode
, offset
, len
);
1136 clock_gettime_mono(&ts2
);
1137 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1139 if (timediff
> audit_timeout
) {
1140 smb_time_audit_log("fallocate", timediff
);
1146 static bool smb_time_audit_lock(vfs_handle_struct
*handle
, files_struct
*fsp
,
1147 int op
, off_t offset
, off_t count
,
1151 struct timespec ts1
,ts2
;
1154 clock_gettime_mono(&ts1
);
1155 result
= SMB_VFS_NEXT_LOCK(handle
, fsp
, op
, offset
, count
, type
);
1156 clock_gettime_mono(&ts2
);
1157 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1159 if (timediff
> audit_timeout
) {
1160 smb_time_audit_log("lock", timediff
);
1166 static int smb_time_audit_kernel_flock(struct vfs_handle_struct
*handle
,
1167 struct files_struct
*fsp
,
1168 uint32 share_mode
, uint32 access_mask
)
1171 struct timespec ts1
,ts2
;
1174 clock_gettime_mono(&ts1
);
1175 result
= SMB_VFS_NEXT_KERNEL_FLOCK(handle
, fsp
, share_mode
,
1177 clock_gettime_mono(&ts2
);
1178 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1180 if (timediff
> audit_timeout
) {
1181 smb_time_audit_log("kernel_flock", timediff
);
1187 static int smb_time_audit_linux_setlease(vfs_handle_struct
*handle
,
1192 struct timespec ts1
,ts2
;
1195 clock_gettime_mono(&ts1
);
1196 result
= SMB_VFS_NEXT_LINUX_SETLEASE(handle
, fsp
, leasetype
);
1197 clock_gettime_mono(&ts2
);
1198 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1200 if (timediff
> audit_timeout
) {
1201 smb_time_audit_log("linux_setlease", timediff
);
1207 static bool smb_time_audit_getlock(vfs_handle_struct
*handle
,
1209 off_t
*poffset
, off_t
*pcount
,
1210 int *ptype
, pid_t
*ppid
)
1213 struct timespec ts1
,ts2
;
1216 clock_gettime_mono(&ts1
);
1217 result
= SMB_VFS_NEXT_GETLOCK(handle
, fsp
, poffset
, pcount
, ptype
,
1219 clock_gettime_mono(&ts2
);
1220 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1222 if (timediff
> audit_timeout
) {
1223 smb_time_audit_log("getlock", timediff
);
1229 static int smb_time_audit_symlink(vfs_handle_struct
*handle
,
1230 const char *oldpath
, const char *newpath
)
1233 struct timespec ts1
,ts2
;
1236 clock_gettime_mono(&ts1
);
1237 result
= SMB_VFS_NEXT_SYMLINK(handle
, oldpath
, newpath
);
1238 clock_gettime_mono(&ts2
);
1239 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1241 if (timediff
> audit_timeout
) {
1242 smb_time_audit_log("symlink", timediff
);
1248 static int smb_time_audit_readlink(vfs_handle_struct
*handle
,
1249 const char *path
, char *buf
, size_t bufsiz
)
1252 struct timespec ts1
,ts2
;
1255 clock_gettime_mono(&ts1
);
1256 result
= SMB_VFS_NEXT_READLINK(handle
, path
, buf
, bufsiz
);
1257 clock_gettime_mono(&ts2
);
1258 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1260 if (timediff
> audit_timeout
) {
1261 smb_time_audit_log("readlink", timediff
);
1267 static int smb_time_audit_link(vfs_handle_struct
*handle
,
1268 const char *oldpath
, const char *newpath
)
1271 struct timespec ts1
,ts2
;
1274 clock_gettime_mono(&ts1
);
1275 result
= SMB_VFS_NEXT_LINK(handle
, oldpath
, newpath
);
1276 clock_gettime_mono(&ts2
);
1277 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1279 if (timediff
> audit_timeout
) {
1280 smb_time_audit_log("link", timediff
);
1286 static int smb_time_audit_mknod(vfs_handle_struct
*handle
,
1287 const char *pathname
, mode_t mode
,
1291 struct timespec ts1
,ts2
;
1294 clock_gettime_mono(&ts1
);
1295 result
= SMB_VFS_NEXT_MKNOD(handle
, pathname
, mode
, dev
);
1296 clock_gettime_mono(&ts2
);
1297 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1299 if (timediff
> audit_timeout
) {
1300 smb_time_audit_log("mknod", timediff
);
1306 static char *smb_time_audit_realpath(vfs_handle_struct
*handle
,
1310 struct timespec ts1
,ts2
;
1313 clock_gettime_mono(&ts1
);
1314 result
= SMB_VFS_NEXT_REALPATH(handle
, path
);
1315 clock_gettime_mono(&ts2
);
1316 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1318 if (timediff
> audit_timeout
) {
1319 smb_time_audit_log("realpath", timediff
);
1325 static NTSTATUS
smb_time_audit_notify_watch(struct vfs_handle_struct
*handle
,
1326 struct sys_notify_context
*ctx
,
1329 uint32_t *subdir_filter
,
1330 void (*callback
)(struct sys_notify_context
*ctx
,
1332 struct notify_event
*ev
),
1333 void *private_data
, void *handle_p
)
1336 struct timespec ts1
,ts2
;
1339 clock_gettime_mono(&ts1
);
1340 result
= SMB_VFS_NEXT_NOTIFY_WATCH(handle
, ctx
, path
,
1341 filter
, subdir_filter
, callback
,
1342 private_data
, handle_p
);
1343 clock_gettime_mono(&ts2
);
1344 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1346 if (timediff
> audit_timeout
) {
1347 smb_time_audit_log("notify_watch", timediff
);
1353 static int smb_time_audit_chflags(vfs_handle_struct
*handle
,
1354 const char *path
, unsigned int flags
)
1357 struct timespec ts1
,ts2
;
1360 clock_gettime_mono(&ts1
);
1361 result
= SMB_VFS_NEXT_CHFLAGS(handle
, path
, flags
);
1362 clock_gettime_mono(&ts2
);
1363 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1365 if (timediff
> audit_timeout
) {
1366 smb_time_audit_log("chflags", timediff
);
1372 static struct file_id
smb_time_audit_file_id_create(struct vfs_handle_struct
*handle
,
1373 const SMB_STRUCT_STAT
*sbuf
)
1375 struct file_id id_zero
;
1376 struct file_id result
;
1377 struct timespec ts1
,ts2
;
1380 ZERO_STRUCT(id_zero
);
1382 clock_gettime_mono(&ts1
);
1383 result
= SMB_VFS_NEXT_FILE_ID_CREATE(handle
, sbuf
);
1384 clock_gettime_mono(&ts2
);
1385 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1387 if (timediff
> audit_timeout
) {
1388 smb_time_audit_log("file_id_create", timediff
);
1394 static NTSTATUS
smb_time_audit_streaminfo(vfs_handle_struct
*handle
,
1395 struct files_struct
*fsp
,
1397 TALLOC_CTX
*mem_ctx
,
1398 unsigned int *pnum_streams
,
1399 struct stream_struct
**pstreams
)
1402 struct timespec ts1
,ts2
;
1405 clock_gettime_mono(&ts1
);
1406 result
= SMB_VFS_NEXT_STREAMINFO(handle
, fsp
, fname
, mem_ctx
,
1407 pnum_streams
, pstreams
);
1408 clock_gettime_mono(&ts2
);
1409 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1411 if (timediff
> audit_timeout
) {
1412 smb_time_audit_log("streaminfo", timediff
);
1418 static int smb_time_audit_get_real_filename(struct vfs_handle_struct
*handle
,
1421 TALLOC_CTX
*mem_ctx
,
1425 struct timespec ts1
,ts2
;
1428 clock_gettime_mono(&ts1
);
1429 result
= SMB_VFS_NEXT_GET_REAL_FILENAME(handle
, path
, name
, mem_ctx
,
1431 clock_gettime_mono(&ts2
);
1432 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1434 if (timediff
> audit_timeout
) {
1435 smb_time_audit_log("get_real_filename", timediff
);
1441 static const char *smb_time_audit_connectpath(vfs_handle_struct
*handle
,
1445 struct timespec ts1
,ts2
;
1448 clock_gettime_mono(&ts1
);
1449 result
= SMB_VFS_NEXT_CONNECTPATH(handle
, fname
);
1450 clock_gettime_mono(&ts2
);
1451 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1453 if (timediff
> audit_timeout
) {
1454 smb_time_audit_log("connectpath", timediff
);
1460 static NTSTATUS
smb_time_audit_brl_lock_windows(struct vfs_handle_struct
*handle
,
1461 struct byte_range_lock
*br_lck
,
1462 struct lock_struct
*plock
,
1464 struct blocking_lock_record
*blr
)
1467 struct timespec ts1
,ts2
;
1470 clock_gettime_mono(&ts1
);
1471 result
= SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle
, br_lck
, plock
,
1472 blocking_lock
, blr
);
1473 clock_gettime_mono(&ts2
);
1474 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1476 if (timediff
> audit_timeout
) {
1477 smb_time_audit_log("brl_lock_windows", timediff
);
1483 static bool smb_time_audit_brl_unlock_windows(struct vfs_handle_struct
*handle
,
1484 struct messaging_context
*msg_ctx
,
1485 struct byte_range_lock
*br_lck
,
1486 const struct lock_struct
*plock
)
1489 struct timespec ts1
,ts2
;
1492 clock_gettime_mono(&ts1
);
1493 result
= SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle
, msg_ctx
, br_lck
,
1495 clock_gettime_mono(&ts2
);
1496 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1498 if (timediff
> audit_timeout
) {
1499 smb_time_audit_log("brl_unlock_windows", timediff
);
1505 static bool smb_time_audit_brl_cancel_windows(struct vfs_handle_struct
*handle
,
1506 struct byte_range_lock
*br_lck
,
1507 struct lock_struct
*plock
,
1508 struct blocking_lock_record
*blr
)
1511 struct timespec ts1
,ts2
;
1514 clock_gettime_mono(&ts1
);
1515 result
= SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle
, br_lck
, plock
, blr
);
1516 clock_gettime_mono(&ts2
);
1517 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1519 if (timediff
> audit_timeout
) {
1520 smb_time_audit_log("brl_cancel_windows", timediff
);
1526 static bool smb_time_audit_strict_lock(struct vfs_handle_struct
*handle
,
1527 struct files_struct
*fsp
,
1528 struct lock_struct
*plock
)
1531 struct timespec ts1
,ts2
;
1534 clock_gettime_mono(&ts1
);
1535 result
= SMB_VFS_NEXT_STRICT_LOCK(handle
, fsp
, plock
);
1536 clock_gettime_mono(&ts2
);
1537 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1539 if (timediff
> audit_timeout
) {
1540 smb_time_audit_log("strict_lock", timediff
);
1546 static void smb_time_audit_strict_unlock(struct vfs_handle_struct
*handle
,
1547 struct files_struct
*fsp
,
1548 struct lock_struct
*plock
)
1550 struct timespec ts1
,ts2
;
1553 clock_gettime_mono(&ts1
);
1554 SMB_VFS_NEXT_STRICT_UNLOCK(handle
, fsp
, plock
);
1555 clock_gettime_mono(&ts2
);
1556 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1558 if (timediff
> audit_timeout
) {
1559 smb_time_audit_log("strict_unlock", timediff
);
1565 static NTSTATUS
smb_time_audit_translate_name(struct vfs_handle_struct
*handle
,
1567 enum vfs_translate_direction direction
,
1568 TALLOC_CTX
*mem_ctx
,
1572 struct timespec ts1
,ts2
;
1575 clock_gettime_mono(&ts1
);
1576 result
= SMB_VFS_NEXT_TRANSLATE_NAME(handle
, name
, direction
, mem_ctx
,
1578 clock_gettime_mono(&ts2
);
1579 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1581 if (timediff
> audit_timeout
) {
1582 smb_time_audit_log("translate_name", timediff
);
1588 static NTSTATUS
smb_time_audit_fget_nt_acl(vfs_handle_struct
*handle
,
1590 uint32 security_info
,
1591 struct security_descriptor
**ppdesc
)
1594 struct timespec ts1
,ts2
;
1597 clock_gettime_mono(&ts1
);
1598 result
= SMB_VFS_NEXT_FGET_NT_ACL(handle
, fsp
, security_info
, ppdesc
);
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("fget_nt_acl", timediff
);
1609 static NTSTATUS
smb_time_audit_get_nt_acl(vfs_handle_struct
*handle
,
1611 uint32 security_info
,
1612 struct security_descriptor
**ppdesc
)
1615 struct timespec ts1
,ts2
;
1618 clock_gettime_mono(&ts1
);
1619 result
= SMB_VFS_NEXT_GET_NT_ACL(handle
, name
, security_info
, ppdesc
);
1620 clock_gettime_mono(&ts2
);
1621 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1623 if (timediff
> audit_timeout
) {
1624 smb_time_audit_log("get_nt_acl", timediff
);
1630 static NTSTATUS
smb_time_audit_fset_nt_acl(vfs_handle_struct
*handle
,
1632 uint32 security_info_sent
,
1633 const struct security_descriptor
*psd
)
1636 struct timespec ts1
,ts2
;
1639 clock_gettime_mono(&ts1
);
1640 result
= SMB_VFS_NEXT_FSET_NT_ACL(handle
, fsp
, security_info_sent
,
1642 clock_gettime_mono(&ts2
);
1643 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1645 if (timediff
> audit_timeout
) {
1646 smb_time_audit_log("fset_nt_acl", timediff
);
1652 static int smb_time_audit_chmod_acl(vfs_handle_struct
*handle
,
1653 const char *path
, mode_t mode
)
1656 struct timespec ts1
,ts2
;
1659 clock_gettime_mono(&ts1
);
1660 result
= SMB_VFS_NEXT_CHMOD_ACL(handle
, path
, mode
);
1661 clock_gettime_mono(&ts2
);
1662 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1664 if (timediff
> audit_timeout
) {
1665 smb_time_audit_log("chmod_acl", timediff
);
1671 static int smb_time_audit_fchmod_acl(vfs_handle_struct
*handle
,
1672 files_struct
*fsp
, mode_t mode
)
1675 struct timespec ts1
,ts2
;
1678 clock_gettime_mono(&ts1
);
1679 result
= SMB_VFS_NEXT_FCHMOD_ACL(handle
, fsp
, mode
);
1680 clock_gettime_mono(&ts2
);
1681 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1683 if (timediff
> audit_timeout
) {
1684 smb_time_audit_log("fchmod_acl", timediff
);
1690 static int smb_time_audit_sys_acl_get_entry(vfs_handle_struct
*handle
,
1691 SMB_ACL_T theacl
, int entry_id
,
1692 SMB_ACL_ENTRY_T
*entry_p
)
1695 struct timespec ts1
,ts2
;
1698 clock_gettime_mono(&ts1
);
1699 result
= SMB_VFS_NEXT_SYS_ACL_GET_ENTRY(handle
, theacl
, entry_id
,
1701 clock_gettime_mono(&ts2
);
1702 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1704 if (timediff
> audit_timeout
) {
1705 smb_time_audit_log("sys_acl_get_entry", timediff
);
1711 static int smb_time_audit_sys_acl_get_tag_type(vfs_handle_struct
*handle
,
1712 SMB_ACL_ENTRY_T entry_d
,
1713 SMB_ACL_TAG_T
*tag_type_p
)
1716 struct timespec ts1
,ts2
;
1719 clock_gettime_mono(&ts1
);
1720 result
= SMB_VFS_NEXT_SYS_ACL_GET_TAG_TYPE(handle
, entry_d
,
1722 clock_gettime_mono(&ts2
);
1723 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1725 if (timediff
> audit_timeout
) {
1726 smb_time_audit_log("sys_acl_get_tag_type", timediff
);
1732 static int smb_time_audit_sys_acl_get_permset(vfs_handle_struct
*handle
,
1733 SMB_ACL_ENTRY_T entry_d
,
1734 SMB_ACL_PERMSET_T
*permset_p
)
1737 struct timespec ts1
,ts2
;
1740 clock_gettime_mono(&ts1
);
1741 result
= SMB_VFS_NEXT_SYS_ACL_GET_PERMSET(handle
, entry_d
,
1743 clock_gettime_mono(&ts2
);
1744 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1746 if (timediff
> audit_timeout
) {
1747 smb_time_audit_log("sys_acl_get_permset", timediff
);
1753 static void * smb_time_audit_sys_acl_get_qualifier(vfs_handle_struct
*handle
,
1754 SMB_ACL_ENTRY_T entry_d
)
1757 struct timespec ts1
,ts2
;
1760 clock_gettime_mono(&ts1
);
1761 result
= SMB_VFS_NEXT_SYS_ACL_GET_QUALIFIER(handle
, entry_d
);
1762 clock_gettime_mono(&ts2
);
1763 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1765 if (timediff
> audit_timeout
) {
1766 smb_time_audit_log("sys_acl_get_qualifier", timediff
);
1772 static SMB_ACL_T
smb_time_audit_sys_acl_get_file(vfs_handle_struct
*handle
,
1774 SMB_ACL_TYPE_T type
)
1777 struct timespec ts1
,ts2
;
1780 clock_gettime_mono(&ts1
);
1781 result
= SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle
, path_p
, type
);
1782 clock_gettime_mono(&ts2
);
1783 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1785 if (timediff
> audit_timeout
) {
1786 smb_time_audit_log("sys_acl_get_file", timediff
);
1792 static SMB_ACL_T
smb_time_audit_sys_acl_get_fd(vfs_handle_struct
*handle
,
1796 struct timespec ts1
,ts2
;
1799 clock_gettime_mono(&ts1
);
1800 result
= SMB_VFS_NEXT_SYS_ACL_GET_FD(handle
, fsp
);
1801 clock_gettime_mono(&ts2
);
1802 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1804 if (timediff
> audit_timeout
) {
1805 smb_time_audit_log("sys_acl_get_fd", timediff
);
1811 static int smb_time_audit_sys_acl_clear_perms(vfs_handle_struct
*handle
,
1812 SMB_ACL_PERMSET_T permset
)
1815 struct timespec ts1
,ts2
;
1818 clock_gettime_mono(&ts1
);
1819 result
= SMB_VFS_NEXT_SYS_ACL_CLEAR_PERMS(handle
, permset
);
1820 clock_gettime_mono(&ts2
);
1821 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1823 if (timediff
> audit_timeout
) {
1824 smb_time_audit_log("sys_acl_clear_perms", timediff
);
1830 static int smb_time_audit_sys_acl_add_perm(vfs_handle_struct
*handle
,
1831 SMB_ACL_PERMSET_T permset
,
1832 SMB_ACL_PERM_T perm
)
1835 struct timespec ts1
,ts2
;
1838 clock_gettime_mono(&ts1
);
1839 result
= SMB_VFS_NEXT_SYS_ACL_ADD_PERM(handle
, permset
, perm
);
1840 clock_gettime_mono(&ts2
);
1841 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1843 if (timediff
> audit_timeout
) {
1844 smb_time_audit_log("sys_acl_add_perm", timediff
);
1850 static char * smb_time_audit_sys_acl_to_text(vfs_handle_struct
*handle
,
1855 struct timespec ts1
,ts2
;
1858 clock_gettime_mono(&ts1
);
1859 result
= SMB_VFS_NEXT_SYS_ACL_TO_TEXT(handle
, theacl
, plen
);
1860 clock_gettime_mono(&ts2
);
1861 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1863 if (timediff
> audit_timeout
) {
1864 smb_time_audit_log("sys_acl_to_text", timediff
);
1870 static SMB_ACL_T
smb_time_audit_sys_acl_init(vfs_handle_struct
*handle
,
1874 struct timespec ts1
,ts2
;
1877 clock_gettime_mono(&ts1
);
1878 result
= SMB_VFS_NEXT_SYS_ACL_INIT(handle
, count
);
1879 clock_gettime_mono(&ts2
);
1880 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1882 if (timediff
> audit_timeout
) {
1883 smb_time_audit_log("sys_acl_init", timediff
);
1889 static int smb_time_audit_sys_acl_create_entry(vfs_handle_struct
*handle
,
1891 SMB_ACL_ENTRY_T
*pentry
)
1894 struct timespec ts1
,ts2
;
1897 clock_gettime_mono(&ts1
);
1898 result
= SMB_VFS_NEXT_SYS_ACL_CREATE_ENTRY(handle
, pacl
, pentry
);
1899 clock_gettime_mono(&ts2
);
1900 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1902 if (timediff
> audit_timeout
) {
1903 smb_time_audit_log("sys_acl_create_entry", timediff
);
1909 static int smb_time_audit_sys_acl_set_tag_type(vfs_handle_struct
*handle
,
1910 SMB_ACL_ENTRY_T entry
,
1911 SMB_ACL_TAG_T tagtype
)
1914 struct timespec ts1
,ts2
;
1917 clock_gettime_mono(&ts1
);
1918 result
= SMB_VFS_NEXT_SYS_ACL_SET_TAG_TYPE(handle
, entry
,
1920 clock_gettime_mono(&ts2
);
1921 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1923 if (timediff
> audit_timeout
) {
1924 smb_time_audit_log("sys_acl_set_tag_type", timediff
);
1930 static int smb_time_audit_sys_acl_set_qualifier(vfs_handle_struct
*handle
,
1931 SMB_ACL_ENTRY_T entry
,
1935 struct timespec ts1
,ts2
;
1938 clock_gettime_mono(&ts1
);
1939 result
= SMB_VFS_NEXT_SYS_ACL_SET_QUALIFIER(handle
, entry
, qual
);
1940 clock_gettime_mono(&ts2
);
1941 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1943 if (timediff
> audit_timeout
) {
1944 smb_time_audit_log("sys_acl_set_qualifier", timediff
);
1950 static int smb_time_audit_sys_acl_set_permset(vfs_handle_struct
*handle
,
1951 SMB_ACL_ENTRY_T entry
,
1952 SMB_ACL_PERMSET_T permset
)
1955 struct timespec ts1
,ts2
;
1958 clock_gettime_mono(&ts1
);
1959 result
= SMB_VFS_NEXT_SYS_ACL_SET_PERMSET(handle
, entry
, permset
);
1960 clock_gettime_mono(&ts2
);
1961 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1963 if (timediff
> audit_timeout
) {
1964 smb_time_audit_log("sys_acl_set_permset", timediff
);
1970 static int smb_time_audit_sys_acl_valid(vfs_handle_struct
*handle
,
1974 struct timespec ts1
,ts2
;
1977 clock_gettime_mono(&ts1
);
1978 result
= SMB_VFS_NEXT_SYS_ACL_VALID(handle
, theacl
);
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("sys_acl_valid", timediff
);
1989 static int smb_time_audit_sys_acl_set_file(vfs_handle_struct
*handle
,
1991 SMB_ACL_TYPE_T acltype
,
1995 struct timespec ts1
,ts2
;
1998 clock_gettime_mono(&ts1
);
1999 result
= SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle
, name
, acltype
,
2001 clock_gettime_mono(&ts2
);
2002 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2004 if (timediff
> audit_timeout
) {
2005 smb_time_audit_log("sys_acl_set_file", timediff
);
2011 static int smb_time_audit_sys_acl_set_fd(vfs_handle_struct
*handle
,
2016 struct timespec ts1
,ts2
;
2019 clock_gettime_mono(&ts1
);
2020 result
= SMB_VFS_NEXT_SYS_ACL_SET_FD(handle
, fsp
, theacl
);
2021 clock_gettime_mono(&ts2
);
2022 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2024 if (timediff
> audit_timeout
) {
2025 smb_time_audit_log("sys_acl_set_fd", timediff
);
2031 static int smb_time_audit_sys_acl_delete_def_file(vfs_handle_struct
*handle
,
2035 struct timespec ts1
,ts2
;
2038 clock_gettime_mono(&ts1
);
2039 result
= SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle
, path
);
2040 clock_gettime_mono(&ts2
);
2041 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2043 if (timediff
> audit_timeout
) {
2044 smb_time_audit_log("sys_acl_delete_def_file", timediff
);
2050 static int smb_time_audit_sys_acl_get_perm(vfs_handle_struct
*handle
,
2051 SMB_ACL_PERMSET_T permset
,
2052 SMB_ACL_PERM_T perm
)
2055 struct timespec ts1
,ts2
;
2058 clock_gettime_mono(&ts1
);
2059 result
= SMB_VFS_NEXT_SYS_ACL_GET_PERM(handle
, permset
, perm
);
2060 clock_gettime_mono(&ts2
);
2061 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2063 if (timediff
> audit_timeout
) {
2064 smb_time_audit_log("sys_acl_get_perm", timediff
);
2070 static int smb_time_audit_sys_acl_free_text(vfs_handle_struct
*handle
,
2074 struct timespec ts1
,ts2
;
2077 clock_gettime_mono(&ts1
);
2078 result
= SMB_VFS_NEXT_SYS_ACL_FREE_TEXT(handle
, text
);
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("sys_acl_free_text", timediff
);
2089 static int smb_time_audit_sys_acl_free_acl(vfs_handle_struct
*handle
,
2090 SMB_ACL_T posix_acl
)
2093 struct timespec ts1
,ts2
;
2096 clock_gettime_mono(&ts1
);
2097 result
= SMB_VFS_NEXT_SYS_ACL_FREE_ACL(handle
, posix_acl
);
2098 clock_gettime_mono(&ts2
);
2099 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2101 if (timediff
> audit_timeout
) {
2102 smb_time_audit_log("sys_acl_free_acl", timediff
);
2108 static int smb_time_audit_sys_acl_free_qualifier(vfs_handle_struct
*handle
,
2110 SMB_ACL_TAG_T tagtype
)
2113 struct timespec ts1
,ts2
;
2116 clock_gettime_mono(&ts1
);
2117 result
= SMB_VFS_NEXT_SYS_ACL_FREE_QUALIFIER(handle
, qualifier
,
2119 clock_gettime_mono(&ts2
);
2120 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2122 if (timediff
> audit_timeout
) {
2123 smb_time_audit_log("sys_acl_free_qualifier", timediff
);
2129 static ssize_t
smb_time_audit_getxattr(struct vfs_handle_struct
*handle
,
2130 const char *path
, const char *name
,
2131 void *value
, size_t size
)
2134 struct timespec ts1
,ts2
;
2137 clock_gettime_mono(&ts1
);
2138 result
= SMB_VFS_NEXT_GETXATTR(handle
, path
, name
, value
, size
);
2139 clock_gettime_mono(&ts2
);
2140 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2142 if (timediff
> audit_timeout
) {
2143 smb_time_audit_log("getxattr", timediff
);
2149 static ssize_t
smb_time_audit_fgetxattr(struct vfs_handle_struct
*handle
,
2150 struct files_struct
*fsp
,
2151 const char *name
, void *value
,
2155 struct timespec ts1
,ts2
;
2158 clock_gettime_mono(&ts1
);
2159 result
= SMB_VFS_NEXT_FGETXATTR(handle
, fsp
, name
, value
, size
);
2160 clock_gettime_mono(&ts2
);
2161 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2163 if (timediff
> audit_timeout
) {
2164 smb_time_audit_log("fgetxattr", timediff
);
2170 static ssize_t
smb_time_audit_listxattr(struct vfs_handle_struct
*handle
,
2171 const char *path
, char *list
,
2175 struct timespec ts1
,ts2
;
2178 clock_gettime_mono(&ts1
);
2179 result
= SMB_VFS_NEXT_LISTXATTR(handle
, path
, list
, size
);
2180 clock_gettime_mono(&ts2
);
2181 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2183 if (timediff
> audit_timeout
) {
2184 smb_time_audit_log("listxattr", timediff
);
2190 static ssize_t
smb_time_audit_flistxattr(struct vfs_handle_struct
*handle
,
2191 struct files_struct
*fsp
, char *list
,
2195 struct timespec ts1
,ts2
;
2198 clock_gettime_mono(&ts1
);
2199 result
= SMB_VFS_NEXT_FLISTXATTR(handle
, fsp
, list
, size
);
2200 clock_gettime_mono(&ts2
);
2201 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2203 if (timediff
> audit_timeout
) {
2204 smb_time_audit_log("flistxattr", timediff
);
2210 static int smb_time_audit_removexattr(struct vfs_handle_struct
*handle
,
2211 const char *path
, const char *name
)
2214 struct timespec ts1
,ts2
;
2217 clock_gettime_mono(&ts1
);
2218 result
= SMB_VFS_NEXT_REMOVEXATTR(handle
, path
, name
);
2219 clock_gettime_mono(&ts2
);
2220 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2222 if (timediff
> audit_timeout
) {
2223 smb_time_audit_log("removexattr", timediff
);
2229 static int smb_time_audit_fremovexattr(struct vfs_handle_struct
*handle
,
2230 struct files_struct
*fsp
,
2234 struct timespec ts1
,ts2
;
2237 clock_gettime_mono(&ts1
);
2238 result
= SMB_VFS_NEXT_FREMOVEXATTR(handle
, fsp
, name
);
2239 clock_gettime_mono(&ts2
);
2240 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2242 if (timediff
> audit_timeout
) {
2243 smb_time_audit_log("fremovexattr", timediff
);
2249 static int smb_time_audit_setxattr(struct vfs_handle_struct
*handle
,
2250 const char *path
, const char *name
,
2251 const void *value
, size_t size
,
2255 struct timespec ts1
,ts2
;
2258 clock_gettime_mono(&ts1
);
2259 result
= SMB_VFS_NEXT_SETXATTR(handle
, path
, name
, value
, size
,
2261 clock_gettime_mono(&ts2
);
2262 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2264 if (timediff
> audit_timeout
) {
2265 smb_time_audit_log("setxattr", timediff
);
2271 static int smb_time_audit_fsetxattr(struct vfs_handle_struct
*handle
,
2272 struct files_struct
*fsp
, const char *name
,
2273 const void *value
, size_t size
, int flags
)
2276 struct timespec ts1
,ts2
;
2279 clock_gettime_mono(&ts1
);
2280 result
= SMB_VFS_NEXT_FSETXATTR(handle
, fsp
, name
, value
, size
, flags
);
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("fsetxattr", timediff
);
2291 static bool smb_time_audit_aio_force(struct vfs_handle_struct
*handle
,
2292 struct files_struct
*fsp
)
2295 struct timespec ts1
,ts2
;
2298 clock_gettime_mono(&ts1
);
2299 result
= SMB_VFS_NEXT_AIO_FORCE(handle
, fsp
);
2300 clock_gettime_mono(&ts2
);
2301 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
2303 if (timediff
> audit_timeout
) {
2304 smb_time_audit_log("aio_force", timediff
);
2312 /* VFS operations */
2314 static struct vfs_fn_pointers vfs_time_audit_fns
= {
2315 .connect_fn
= smb_time_audit_connect
,
2316 .disconnect_fn
= smb_time_audit_disconnect
,
2317 .disk_free_fn
= smb_time_audit_disk_free
,
2318 .get_quota_fn
= smb_time_audit_get_quota
,
2319 .set_quota_fn
= smb_time_audit_set_quota
,
2320 .get_shadow_copy_data_fn
= smb_time_audit_get_shadow_copy_data
,
2321 .statvfs_fn
= smb_time_audit_statvfs
,
2322 .fs_capabilities_fn
= smb_time_audit_fs_capabilities
,
2323 .opendir_fn
= smb_time_audit_opendir
,
2324 .fdopendir_fn
= smb_time_audit_fdopendir
,
2325 .readdir_fn
= smb_time_audit_readdir
,
2326 .seekdir_fn
= smb_time_audit_seekdir
,
2327 .telldir_fn
= smb_time_audit_telldir
,
2328 .rewind_dir_fn
= smb_time_audit_rewinddir
,
2329 .mkdir_fn
= smb_time_audit_mkdir
,
2330 .rmdir_fn
= smb_time_audit_rmdir
,
2331 .closedir_fn
= smb_time_audit_closedir
,
2332 .init_search_op_fn
= smb_time_audit_init_search_op
,
2333 .open_fn
= smb_time_audit_open
,
2334 .create_file_fn
= smb_time_audit_create_file
,
2335 .close_fn
= smb_time_audit_close
,
2336 .read_fn
= smb_time_audit_read
,
2337 .pread_fn
= smb_time_audit_pread
,
2338 .pread_send_fn
= smb_time_audit_pread_send
,
2339 .pread_recv_fn
= smb_time_audit_pread_recv
,
2340 .write_fn
= smb_time_audit_write
,
2341 .pwrite_fn
= smb_time_audit_pwrite
,
2342 .pwrite_send_fn
= smb_time_audit_pwrite_send
,
2343 .pwrite_recv_fn
= smb_time_audit_pwrite_recv
,
2344 .lseek_fn
= smb_time_audit_lseek
,
2345 .sendfile_fn
= smb_time_audit_sendfile
,
2346 .recvfile_fn
= smb_time_audit_recvfile
,
2347 .rename_fn
= smb_time_audit_rename
,
2348 .fsync_fn
= smb_time_audit_fsync
,
2349 .fsync_send_fn
= smb_time_audit_fsync_send
,
2350 .fsync_recv_fn
= smb_time_audit_fsync_recv
,
2351 .stat_fn
= smb_time_audit_stat
,
2352 .fstat_fn
= smb_time_audit_fstat
,
2353 .lstat_fn
= smb_time_audit_lstat
,
2354 .get_alloc_size_fn
= smb_time_audit_get_alloc_size
,
2355 .unlink_fn
= smb_time_audit_unlink
,
2356 .chmod_fn
= smb_time_audit_chmod
,
2357 .fchmod_fn
= smb_time_audit_fchmod
,
2358 .chown_fn
= smb_time_audit_chown
,
2359 .fchown_fn
= smb_time_audit_fchown
,
2360 .lchown_fn
= smb_time_audit_lchown
,
2361 .chdir_fn
= smb_time_audit_chdir
,
2362 .getwd_fn
= smb_time_audit_getwd
,
2363 .ntimes_fn
= smb_time_audit_ntimes
,
2364 .ftruncate_fn
= smb_time_audit_ftruncate
,
2365 .fallocate_fn
= smb_time_audit_fallocate
,
2366 .lock_fn
= smb_time_audit_lock
,
2367 .kernel_flock_fn
= smb_time_audit_kernel_flock
,
2368 .linux_setlease_fn
= smb_time_audit_linux_setlease
,
2369 .getlock_fn
= smb_time_audit_getlock
,
2370 .symlink_fn
= smb_time_audit_symlink
,
2371 .readlink_fn
= smb_time_audit_readlink
,
2372 .link_fn
= smb_time_audit_link
,
2373 .mknod_fn
= smb_time_audit_mknod
,
2374 .realpath_fn
= smb_time_audit_realpath
,
2375 .notify_watch_fn
= smb_time_audit_notify_watch
,
2376 .chflags_fn
= smb_time_audit_chflags
,
2377 .file_id_create_fn
= smb_time_audit_file_id_create
,
2378 .streaminfo_fn
= smb_time_audit_streaminfo
,
2379 .get_real_filename_fn
= smb_time_audit_get_real_filename
,
2380 .connectpath_fn
= smb_time_audit_connectpath
,
2381 .brl_lock_windows_fn
= smb_time_audit_brl_lock_windows
,
2382 .brl_unlock_windows_fn
= smb_time_audit_brl_unlock_windows
,
2383 .brl_cancel_windows_fn
= smb_time_audit_brl_cancel_windows
,
2384 .strict_lock_fn
= smb_time_audit_strict_lock
,
2385 .strict_unlock_fn
= smb_time_audit_strict_unlock
,
2386 .translate_name_fn
= smb_time_audit_translate_name
,
2387 .fget_nt_acl_fn
= smb_time_audit_fget_nt_acl
,
2388 .get_nt_acl_fn
= smb_time_audit_get_nt_acl
,
2389 .fset_nt_acl_fn
= smb_time_audit_fset_nt_acl
,
2390 .chmod_acl_fn
= smb_time_audit_chmod_acl
,
2391 .fchmod_acl_fn
= smb_time_audit_fchmod_acl
,
2392 .sys_acl_get_entry_fn
= smb_time_audit_sys_acl_get_entry
,
2393 .sys_acl_get_tag_type_fn
= smb_time_audit_sys_acl_get_tag_type
,
2394 .sys_acl_get_permset_fn
= smb_time_audit_sys_acl_get_permset
,
2395 .sys_acl_get_qualifier_fn
= smb_time_audit_sys_acl_get_qualifier
,
2396 .sys_acl_get_file_fn
= smb_time_audit_sys_acl_get_file
,
2397 .sys_acl_get_fd_fn
= smb_time_audit_sys_acl_get_fd
,
2398 .sys_acl_clear_perms_fn
= smb_time_audit_sys_acl_clear_perms
,
2399 .sys_acl_add_perm_fn
= smb_time_audit_sys_acl_add_perm
,
2400 .sys_acl_to_text_fn
= smb_time_audit_sys_acl_to_text
,
2401 .sys_acl_init_fn
= smb_time_audit_sys_acl_init
,
2402 .sys_acl_create_entry_fn
= smb_time_audit_sys_acl_create_entry
,
2403 .sys_acl_set_tag_type_fn
= smb_time_audit_sys_acl_set_tag_type
,
2404 .sys_acl_set_qualifier_fn
= smb_time_audit_sys_acl_set_qualifier
,
2405 .sys_acl_set_permset_fn
= smb_time_audit_sys_acl_set_permset
,
2406 .sys_acl_valid_fn
= smb_time_audit_sys_acl_valid
,
2407 .sys_acl_set_file_fn
= smb_time_audit_sys_acl_set_file
,
2408 .sys_acl_set_fd_fn
= smb_time_audit_sys_acl_set_fd
,
2409 .sys_acl_delete_def_file_fn
= smb_time_audit_sys_acl_delete_def_file
,
2410 .sys_acl_get_perm_fn
= smb_time_audit_sys_acl_get_perm
,
2411 .sys_acl_free_text_fn
= smb_time_audit_sys_acl_free_text
,
2412 .sys_acl_free_acl_fn
= smb_time_audit_sys_acl_free_acl
,
2413 .sys_acl_free_qualifier_fn
= smb_time_audit_sys_acl_free_qualifier
,
2414 .getxattr_fn
= smb_time_audit_getxattr
,
2415 .fgetxattr_fn
= smb_time_audit_fgetxattr
,
2416 .listxattr_fn
= smb_time_audit_listxattr
,
2417 .flistxattr_fn
= smb_time_audit_flistxattr
,
2418 .removexattr_fn
= smb_time_audit_removexattr
,
2419 .fremovexattr_fn
= smb_time_audit_fremovexattr
,
2420 .setxattr_fn
= smb_time_audit_setxattr
,
2421 .fsetxattr_fn
= smb_time_audit_fsetxattr
,
2422 .aio_force_fn
= smb_time_audit_aio_force
,
2426 NTSTATUS
vfs_time_audit_init(void);
2427 NTSTATUS
vfs_time_audit_init(void)
2429 audit_timeout
= (double)lp_parm_int(-1, "time_audit", "timeout",
2431 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION
, "time_audit",
2432 &vfs_time_audit_fns
);