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
);
82 static uint64_t smb_time_audit_disk_free(vfs_handle_struct
*handle
,
84 bool small_query
, uint64_t *bsize
,
85 uint64_t *dfree
, uint64_t *dsize
)
88 struct timespec ts1
,ts2
;
91 clock_gettime_mono(&ts1
);
92 result
= SMB_VFS_NEXT_DISK_FREE(handle
, path
, small_query
, bsize
,
94 clock_gettime_mono(&ts2
);
95 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
97 /* Don't have a reasonable notion of failure here */
98 if (timediff
> audit_timeout
) {
99 smb_time_audit_log("disk_free", timediff
);
105 static int smb_time_audit_get_quota(struct vfs_handle_struct
*handle
,
106 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
110 struct timespec ts1
,ts2
;
113 clock_gettime_mono(&ts1
);
114 result
= SMB_VFS_NEXT_GET_QUOTA(handle
, qtype
, id
, qt
);
115 clock_gettime_mono(&ts2
);
116 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
118 if (timediff
> audit_timeout
) {
119 smb_time_audit_log("get_quota", timediff
);
124 static int smb_time_audit_set_quota(struct vfs_handle_struct
*handle
,
125 enum SMB_QUOTA_TYPE qtype
, unid_t id
,
129 struct timespec ts1
,ts2
;
132 clock_gettime_mono(&ts1
);
133 result
= SMB_VFS_NEXT_SET_QUOTA(handle
, qtype
, id
, qt
);
134 clock_gettime_mono(&ts2
);
135 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
137 if (timediff
> audit_timeout
) {
138 smb_time_audit_log("set_quota", timediff
);
144 static int smb_time_audit_get_shadow_copy_data(struct vfs_handle_struct
*handle
,
145 struct files_struct
*fsp
,
146 struct shadow_copy_data
*shadow_copy_data
,
150 struct timespec ts1
,ts2
;
153 clock_gettime_mono(&ts1
);
154 result
= SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle
, fsp
,
155 shadow_copy_data
, labels
);
156 clock_gettime_mono(&ts2
);
157 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
159 if (timediff
> audit_timeout
) {
160 smb_time_audit_log("get_shadow_copy_data", timediff
);
166 static int smb_time_audit_statvfs(struct vfs_handle_struct
*handle
,
168 struct vfs_statvfs_struct
*statbuf
)
171 struct timespec ts1
,ts2
;
174 clock_gettime_mono(&ts1
);
175 result
= SMB_VFS_NEXT_STATVFS(handle
, path
, statbuf
);
176 clock_gettime_mono(&ts2
);
177 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
179 if (timediff
> audit_timeout
) {
180 smb_time_audit_log("statvfs", timediff
);
186 static uint32_t smb_time_audit_fs_capabilities(struct vfs_handle_struct
*handle
,
187 enum timestamp_set_resolution
*p_ts_res
)
190 struct timespec ts1
,ts2
;
193 clock_gettime_mono(&ts1
);
194 result
= SMB_VFS_NEXT_FS_CAPABILITIES(handle
, p_ts_res
);
195 clock_gettime_mono(&ts2
);
196 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
198 if (timediff
> audit_timeout
) {
199 smb_time_audit_log("fs_capabilities", timediff
);
205 static DIR *smb_time_audit_opendir(vfs_handle_struct
*handle
,
207 const char *mask
, uint32 attr
)
210 struct timespec ts1
,ts2
;
213 clock_gettime_mono(&ts1
);
214 result
= SMB_VFS_NEXT_OPENDIR(handle
, fname
, mask
, attr
);
215 clock_gettime_mono(&ts2
);
216 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
218 if (timediff
> audit_timeout
) {
219 smb_time_audit_log("opendir", timediff
);
225 static DIR *smb_time_audit_fdopendir(vfs_handle_struct
*handle
,
227 const char *mask
, uint32 attr
)
230 struct timespec ts1
,ts2
;
233 clock_gettime_mono(&ts1
);
234 result
= SMB_VFS_NEXT_FDOPENDIR(handle
, fsp
, mask
, attr
);
235 clock_gettime_mono(&ts2
);
236 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
238 if (timediff
> audit_timeout
) {
239 smb_time_audit_log("fdopendir", timediff
);
245 static struct dirent
*smb_time_audit_readdir(vfs_handle_struct
*handle
,
247 SMB_STRUCT_STAT
*sbuf
)
249 struct dirent
*result
;
250 struct timespec ts1
,ts2
;
253 clock_gettime_mono(&ts1
);
254 result
= SMB_VFS_NEXT_READDIR(handle
, dirp
, sbuf
);
255 clock_gettime_mono(&ts2
);
256 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
258 if (timediff
> audit_timeout
) {
259 smb_time_audit_log("readdir", timediff
);
265 static void smb_time_audit_seekdir(vfs_handle_struct
*handle
,
266 DIR *dirp
, long offset
)
268 struct timespec ts1
,ts2
;
271 clock_gettime_mono(&ts1
);
272 SMB_VFS_NEXT_SEEKDIR(handle
, dirp
, offset
);
273 clock_gettime_mono(&ts2
);
274 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
276 if (timediff
> audit_timeout
) {
277 smb_time_audit_log("seekdir", timediff
);
282 static long smb_time_audit_telldir(vfs_handle_struct
*handle
,
286 struct timespec ts1
,ts2
;
289 clock_gettime_mono(&ts1
);
290 result
= SMB_VFS_NEXT_TELLDIR(handle
, dirp
);
291 clock_gettime_mono(&ts2
);
292 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
294 if (timediff
> audit_timeout
) {
295 smb_time_audit_log("telldir", timediff
);
301 static void smb_time_audit_rewinddir(vfs_handle_struct
*handle
,
304 struct timespec ts1
,ts2
;
307 clock_gettime_mono(&ts1
);
308 SMB_VFS_NEXT_REWINDDIR(handle
, dirp
);
309 clock_gettime_mono(&ts2
);
310 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
312 if (timediff
> audit_timeout
) {
313 smb_time_audit_log("rewinddir", timediff
);
318 static int smb_time_audit_mkdir(vfs_handle_struct
*handle
,
319 const char *path
, mode_t mode
)
322 struct timespec ts1
,ts2
;
325 clock_gettime_mono(&ts1
);
326 result
= SMB_VFS_NEXT_MKDIR(handle
, path
, mode
);
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("mkdir", timediff
);
337 static int smb_time_audit_rmdir(vfs_handle_struct
*handle
,
341 struct timespec ts1
,ts2
;
344 clock_gettime_mono(&ts1
);
345 result
= SMB_VFS_NEXT_RMDIR(handle
, path
);
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("rmdir", timediff
);
356 static int smb_time_audit_closedir(vfs_handle_struct
*handle
,
360 struct timespec ts1
,ts2
;
363 clock_gettime_mono(&ts1
);
364 result
= SMB_VFS_NEXT_CLOSEDIR(handle
, dirp
);
365 clock_gettime_mono(&ts2
);
366 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
368 if (timediff
> audit_timeout
) {
369 smb_time_audit_log("closedir", timediff
);
375 static void smb_time_audit_init_search_op(vfs_handle_struct
*handle
,
378 struct timespec ts1
,ts2
;
381 clock_gettime_mono(&ts1
);
382 SMB_VFS_NEXT_INIT_SEARCH_OP(handle
, dirp
);
383 clock_gettime_mono(&ts2
);
384 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
386 if (timediff
> audit_timeout
) {
387 smb_time_audit_log("init_search_op", timediff
);
391 static int smb_time_audit_open(vfs_handle_struct
*handle
,
392 struct smb_filename
*fname
,
394 int flags
, mode_t mode
)
397 struct timespec ts1
,ts2
;
400 clock_gettime_mono(&ts1
);
401 result
= SMB_VFS_NEXT_OPEN(handle
, fname
, fsp
, flags
, mode
);
402 clock_gettime_mono(&ts2
);
403 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
405 if (timediff
> audit_timeout
) {
406 smb_time_audit_log("open", timediff
);
412 static NTSTATUS
smb_time_audit_create_file(vfs_handle_struct
*handle
,
413 struct smb_request
*req
,
414 uint16_t root_dir_fid
,
415 struct smb_filename
*fname
,
416 uint32_t access_mask
,
417 uint32_t share_access
,
418 uint32_t create_disposition
,
419 uint32_t create_options
,
420 uint32_t file_attributes
,
421 uint32_t oplock_request
,
422 uint64_t allocation_size
,
423 uint32_t private_flags
,
424 struct security_descriptor
*sd
,
425 struct ea_list
*ea_list
,
426 files_struct
**result_fsp
,
430 struct timespec ts1
,ts2
;
433 clock_gettime_mono(&ts1
);
434 result
= SMB_VFS_NEXT_CREATE_FILE(
437 root_dir_fid
, /* root_dir_fid */
439 access_mask
, /* access_mask */
440 share_access
, /* share_access */
441 create_disposition
, /* create_disposition*/
442 create_options
, /* create_options */
443 file_attributes
, /* file_attributes */
444 oplock_request
, /* oplock_request */
445 allocation_size
, /* allocation_size */
448 ea_list
, /* ea_list */
449 result_fsp
, /* result */
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("create_file", timediff
);
461 static int smb_time_audit_close(vfs_handle_struct
*handle
, files_struct
*fsp
)
464 struct timespec ts1
,ts2
;
467 clock_gettime_mono(&ts1
);
468 result
= SMB_VFS_NEXT_CLOSE(handle
, fsp
);
469 clock_gettime_mono(&ts2
);
470 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
472 if (timediff
> audit_timeout
) {
473 smb_time_audit_log("close", timediff
);
479 static ssize_t
smb_time_audit_read(vfs_handle_struct
*handle
,
480 files_struct
*fsp
, void *data
, size_t n
)
483 struct timespec ts1
,ts2
;
486 clock_gettime_mono(&ts1
);
487 result
= SMB_VFS_NEXT_READ(handle
, fsp
, data
, n
);
488 clock_gettime_mono(&ts2
);
489 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
491 if (timediff
> audit_timeout
) {
492 smb_time_audit_log("read", timediff
);
498 static ssize_t
smb_time_audit_pread(vfs_handle_struct
*handle
,
500 void *data
, size_t n
, off_t offset
)
503 struct timespec ts1
,ts2
;
506 clock_gettime_mono(&ts1
);
507 result
= SMB_VFS_NEXT_PREAD(handle
, fsp
, data
, n
, offset
);
508 clock_gettime_mono(&ts2
);
509 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
511 if (timediff
> audit_timeout
) {
512 smb_time_audit_log("pread", timediff
);
518 struct smb_time_audit_pread_state
{
524 static void smb_time_audit_pread_done(struct tevent_req
*subreq
);
526 static struct tevent_req
*smb_time_audit_pread_send(
527 struct vfs_handle_struct
*handle
, TALLOC_CTX
*mem_ctx
,
528 struct tevent_context
*ev
, struct files_struct
*fsp
,
529 void *data
, size_t n
, off_t offset
)
531 struct tevent_req
*req
, *subreq
;
532 struct smb_time_audit_pread_state
*state
;
534 req
= tevent_req_create(mem_ctx
, &state
,
535 struct smb_time_audit_pread_state
);
539 clock_gettime_mono(&state
->ts1
);
541 subreq
= SMB_VFS_NEXT_PREAD_SEND(state
, ev
, handle
, fsp
, data
,
543 if (tevent_req_nomem(subreq
, req
)) {
544 return tevent_req_post(req
, ev
);
546 tevent_req_set_callback(subreq
, smb_time_audit_pread_done
, req
);
550 static void smb_time_audit_pread_done(struct tevent_req
*subreq
)
552 struct tevent_req
*req
= tevent_req_callback_data(
553 subreq
, struct tevent_req
);
554 struct smb_time_audit_pread_state
*state
= tevent_req_data(
555 req
, struct smb_time_audit_pread_state
);
557 state
->ret
= SMB_VFS_PREAD_RECV(subreq
, &state
->err
);
559 tevent_req_done(req
);
562 static ssize_t
smb_time_audit_pread_recv(struct tevent_req
*req
, int *err
)
564 struct smb_time_audit_pread_state
*state
= tevent_req_data(
565 req
, struct smb_time_audit_pread_state
);
569 clock_gettime_mono(&ts2
);
570 timediff
= nsec_time_diff(&ts2
,&state
->ts1
)*1.0e-9;
572 if (timediff
> audit_timeout
) {
573 smb_time_audit_log("pread", timediff
);
576 if (tevent_req_is_unix_error(req
, err
)) {
583 static ssize_t
smb_time_audit_write(vfs_handle_struct
*handle
,
585 const void *data
, size_t n
)
588 struct timespec ts1
,ts2
;
591 clock_gettime_mono(&ts1
);
592 result
= SMB_VFS_NEXT_WRITE(handle
, fsp
, data
, 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("write", timediff
);
603 static ssize_t
smb_time_audit_pwrite(vfs_handle_struct
*handle
,
605 const void *data
, size_t n
,
609 struct timespec ts1
,ts2
;
612 clock_gettime_mono(&ts1
);
613 result
= SMB_VFS_NEXT_PWRITE(handle
, fsp
, data
, n
, offset
);
614 clock_gettime_mono(&ts2
);
615 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
617 if (timediff
> audit_timeout
) {
618 smb_time_audit_log("pwrite", timediff
);
624 struct smb_time_audit_pwrite_state
{
630 static void smb_time_audit_pwrite_done(struct tevent_req
*subreq
);
632 static struct tevent_req
*smb_time_audit_pwrite_send(
633 struct vfs_handle_struct
*handle
, TALLOC_CTX
*mem_ctx
,
634 struct tevent_context
*ev
, struct files_struct
*fsp
,
635 const void *data
, size_t n
, off_t offset
)
637 struct tevent_req
*req
, *subreq
;
638 struct smb_time_audit_pwrite_state
*state
;
640 req
= tevent_req_create(mem_ctx
, &state
,
641 struct smb_time_audit_pwrite_state
);
645 clock_gettime_mono(&state
->ts1
);
647 subreq
= SMB_VFS_NEXT_PWRITE_SEND(state
, ev
, handle
, fsp
, data
,
649 if (tevent_req_nomem(subreq
, req
)) {
650 return tevent_req_post(req
, ev
);
652 tevent_req_set_callback(subreq
, smb_time_audit_pwrite_done
, req
);
656 static void smb_time_audit_pwrite_done(struct tevent_req
*subreq
)
658 struct tevent_req
*req
= tevent_req_callback_data(
659 subreq
, struct tevent_req
);
660 struct smb_time_audit_pwrite_state
*state
= tevent_req_data(
661 req
, struct smb_time_audit_pwrite_state
);
663 state
->ret
= SMB_VFS_PWRITE_RECV(subreq
, &state
->err
);
665 tevent_req_done(req
);
668 static ssize_t
smb_time_audit_pwrite_recv(struct tevent_req
*req
, int *err
)
670 struct smb_time_audit_pwrite_state
*state
= tevent_req_data(
671 req
, struct smb_time_audit_pwrite_state
);
675 clock_gettime_mono(&ts2
);
676 timediff
= nsec_time_diff(&ts2
,&state
->ts1
)*1.0e-9;
678 if (timediff
> audit_timeout
) {
679 smb_time_audit_log("pwrite", timediff
);
682 if (tevent_req_is_unix_error(req
, err
)) {
689 static off_t
smb_time_audit_lseek(vfs_handle_struct
*handle
,
691 off_t offset
, int whence
)
694 struct timespec ts1
,ts2
;
697 clock_gettime_mono(&ts1
);
698 result
= SMB_VFS_NEXT_LSEEK(handle
, fsp
, offset
, whence
);
699 clock_gettime_mono(&ts2
);
700 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
702 if (timediff
> audit_timeout
) {
703 smb_time_audit_log("lseek", timediff
);
709 static ssize_t
smb_time_audit_sendfile(vfs_handle_struct
*handle
, int tofd
,
710 files_struct
*fromfsp
,
711 const DATA_BLOB
*hdr
, off_t offset
,
715 struct timespec ts1
,ts2
;
718 clock_gettime_mono(&ts1
);
719 result
= SMB_VFS_NEXT_SENDFILE(handle
, tofd
, fromfsp
, hdr
, offset
, n
);
720 clock_gettime_mono(&ts2
);
721 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
723 if (timediff
> audit_timeout
) {
724 smb_time_audit_log("sendfile", timediff
);
730 static ssize_t
smb_time_audit_recvfile(vfs_handle_struct
*handle
, int fromfd
,
736 struct timespec ts1
,ts2
;
739 clock_gettime_mono(&ts1
);
740 result
= SMB_VFS_NEXT_RECVFILE(handle
, fromfd
, tofsp
, offset
, n
);
741 clock_gettime_mono(&ts2
);
742 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
744 if (timediff
> audit_timeout
) {
745 smb_time_audit_log("recvfile", timediff
);
751 static int smb_time_audit_rename(vfs_handle_struct
*handle
,
752 const struct smb_filename
*oldname
,
753 const struct smb_filename
*newname
)
756 struct timespec ts1
,ts2
;
759 clock_gettime_mono(&ts1
);
760 result
= SMB_VFS_NEXT_RENAME(handle
, oldname
, newname
);
761 clock_gettime_mono(&ts2
);
762 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
764 if (timediff
> audit_timeout
) {
765 smb_time_audit_log("rename", timediff
);
771 static int smb_time_audit_fsync(vfs_handle_struct
*handle
, files_struct
*fsp
)
774 struct timespec ts1
,ts2
;
777 clock_gettime_mono(&ts1
);
778 result
= SMB_VFS_NEXT_FSYNC(handle
, fsp
);
779 clock_gettime_mono(&ts2
);
780 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
782 if (timediff
> audit_timeout
) {
783 smb_time_audit_log("fsync", timediff
);
789 struct smb_time_audit_fsync_state
{
795 static void smb_time_audit_fsync_done(struct tevent_req
*subreq
);
797 static struct tevent_req
*smb_time_audit_fsync_send(
798 struct vfs_handle_struct
*handle
, TALLOC_CTX
*mem_ctx
,
799 struct tevent_context
*ev
, struct files_struct
*fsp
)
801 struct tevent_req
*req
, *subreq
;
802 struct smb_time_audit_fsync_state
*state
;
804 req
= tevent_req_create(mem_ctx
, &state
,
805 struct smb_time_audit_fsync_state
);
809 clock_gettime_mono(&state
->ts1
);
811 subreq
= SMB_VFS_NEXT_FSYNC_SEND(state
, ev
, handle
, fsp
);
812 if (tevent_req_nomem(subreq
, req
)) {
813 return tevent_req_post(req
, ev
);
815 tevent_req_set_callback(subreq
, smb_time_audit_fsync_done
, req
);
819 static void smb_time_audit_fsync_done(struct tevent_req
*subreq
)
821 struct tevent_req
*req
= tevent_req_callback_data(
822 subreq
, struct tevent_req
);
823 struct smb_time_audit_fsync_state
*state
= tevent_req_data(
824 req
, struct smb_time_audit_fsync_state
);
826 state
->ret
= SMB_VFS_FSYNC_RECV(subreq
, &state
->err
);
828 tevent_req_done(req
);
831 static int smb_time_audit_fsync_recv(struct tevent_req
*req
, int *err
)
833 struct smb_time_audit_fsync_state
*state
= tevent_req_data(
834 req
, struct smb_time_audit_fsync_state
);
838 clock_gettime_mono(&ts2
);
839 timediff
= nsec_time_diff(&ts2
,&state
->ts1
)*1.0e-9;
841 if (timediff
> audit_timeout
) {
842 smb_time_audit_log("fsync", timediff
);
845 if (tevent_req_is_unix_error(req
, err
)) {
852 static int smb_time_audit_stat(vfs_handle_struct
*handle
,
853 struct smb_filename
*fname
)
856 struct timespec ts1
,ts2
;
859 clock_gettime_mono(&ts1
);
860 result
= SMB_VFS_NEXT_STAT(handle
, fname
);
861 clock_gettime_mono(&ts2
);
862 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
864 if (timediff
> audit_timeout
) {
865 smb_time_audit_log("stat", timediff
);
871 static int smb_time_audit_fstat(vfs_handle_struct
*handle
, files_struct
*fsp
,
872 SMB_STRUCT_STAT
*sbuf
)
875 struct timespec ts1
,ts2
;
878 clock_gettime_mono(&ts1
);
879 result
= SMB_VFS_NEXT_FSTAT(handle
, fsp
, sbuf
);
880 clock_gettime_mono(&ts2
);
881 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
883 if (timediff
> audit_timeout
) {
884 smb_time_audit_log("fstat", timediff
);
890 static int smb_time_audit_lstat(vfs_handle_struct
*handle
,
891 struct smb_filename
*path
)
894 struct timespec ts1
,ts2
;
897 clock_gettime_mono(&ts1
);
898 result
= SMB_VFS_NEXT_LSTAT(handle
, path
);
899 clock_gettime_mono(&ts2
);
900 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
902 if (timediff
> audit_timeout
) {
903 smb_time_audit_log("lstat", timediff
);
909 static uint64_t smb_time_audit_get_alloc_size(vfs_handle_struct
*handle
,
911 const SMB_STRUCT_STAT
*sbuf
)
914 struct timespec ts1
,ts2
;
917 clock_gettime_mono(&ts1
);
918 result
= SMB_VFS_NEXT_GET_ALLOC_SIZE(handle
, fsp
, sbuf
);
919 clock_gettime_mono(&ts2
);
920 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
922 if (timediff
> audit_timeout
) {
923 smb_time_audit_log("get_alloc_size", timediff
);
929 static int smb_time_audit_unlink(vfs_handle_struct
*handle
,
930 const struct smb_filename
*path
)
933 struct timespec ts1
,ts2
;
936 clock_gettime_mono(&ts1
);
937 result
= SMB_VFS_NEXT_UNLINK(handle
, path
);
938 clock_gettime_mono(&ts2
);
939 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
941 if (timediff
> audit_timeout
) {
942 smb_time_audit_log("unlink", timediff
);
948 static int smb_time_audit_chmod(vfs_handle_struct
*handle
,
949 const char *path
, mode_t mode
)
952 struct timespec ts1
,ts2
;
955 clock_gettime_mono(&ts1
);
956 result
= SMB_VFS_NEXT_CHMOD(handle
, path
, mode
);
957 clock_gettime_mono(&ts2
);
958 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
960 if (timediff
> audit_timeout
) {
961 smb_time_audit_log("chmod", timediff
);
967 static int smb_time_audit_fchmod(vfs_handle_struct
*handle
, files_struct
*fsp
,
971 struct timespec ts1
,ts2
;
974 clock_gettime_mono(&ts1
);
975 result
= SMB_VFS_NEXT_FCHMOD(handle
, fsp
, mode
);
976 clock_gettime_mono(&ts2
);
977 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
979 if (timediff
> audit_timeout
) {
980 smb_time_audit_log("fchmod", timediff
);
986 static int smb_time_audit_chown(vfs_handle_struct
*handle
,
987 const char *path
, uid_t uid
, gid_t gid
)
990 struct timespec ts1
,ts2
;
993 clock_gettime_mono(&ts1
);
994 result
= SMB_VFS_NEXT_CHOWN(handle
, path
, uid
, gid
);
995 clock_gettime_mono(&ts2
);
996 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
998 if (timediff
> audit_timeout
) {
999 smb_time_audit_log("chown", timediff
);
1005 static int smb_time_audit_fchown(vfs_handle_struct
*handle
, files_struct
*fsp
,
1006 uid_t uid
, gid_t gid
)
1009 struct timespec ts1
,ts2
;
1012 clock_gettime_mono(&ts1
);
1013 result
= SMB_VFS_NEXT_FCHOWN(handle
, fsp
, uid
, gid
);
1014 clock_gettime_mono(&ts2
);
1015 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1017 if (timediff
> audit_timeout
) {
1018 smb_time_audit_log("fchown", timediff
);
1024 static int smb_time_audit_lchown(vfs_handle_struct
*handle
,
1025 const char *path
, uid_t uid
, gid_t gid
)
1028 struct timespec ts1
,ts2
;
1031 clock_gettime_mono(&ts1
);
1032 result
= SMB_VFS_NEXT_LCHOWN(handle
, path
, uid
, gid
);
1033 clock_gettime_mono(&ts2
);
1034 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1036 if (timediff
> audit_timeout
) {
1037 smb_time_audit_log("lchown", timediff
);
1043 static int smb_time_audit_chdir(vfs_handle_struct
*handle
, const char *path
)
1046 struct timespec ts1
,ts2
;
1049 clock_gettime_mono(&ts1
);
1050 result
= SMB_VFS_NEXT_CHDIR(handle
, path
);
1051 clock_gettime_mono(&ts2
);
1052 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1054 if (timediff
> audit_timeout
) {
1055 smb_time_audit_log("chdir", timediff
);
1061 static char *smb_time_audit_getwd(vfs_handle_struct
*handle
)
1064 struct timespec ts1
,ts2
;
1067 clock_gettime_mono(&ts1
);
1068 result
= SMB_VFS_NEXT_GETWD(handle
);
1069 clock_gettime_mono(&ts2
);
1070 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1072 if (timediff
> audit_timeout
) {
1073 smb_time_audit_log("getwd", timediff
);
1079 static int smb_time_audit_ntimes(vfs_handle_struct
*handle
,
1080 const struct smb_filename
*path
,
1081 struct smb_file_time
*ft
)
1084 struct timespec ts1
,ts2
;
1087 clock_gettime_mono(&ts1
);
1088 result
= SMB_VFS_NEXT_NTIMES(handle
, path
, ft
);
1089 clock_gettime_mono(&ts2
);
1090 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1092 if (timediff
> audit_timeout
) {
1093 smb_time_audit_log("ntimes", timediff
);
1099 static int smb_time_audit_ftruncate(vfs_handle_struct
*handle
,
1104 struct timespec ts1
,ts2
;
1107 clock_gettime_mono(&ts1
);
1108 result
= SMB_VFS_NEXT_FTRUNCATE(handle
, fsp
, len
);
1109 clock_gettime_mono(&ts2
);
1110 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1112 if (timediff
> audit_timeout
) {
1113 smb_time_audit_log("ftruncate", timediff
);
1119 static int smb_time_audit_fallocate(vfs_handle_struct
*handle
,
1121 enum vfs_fallocate_mode mode
,
1126 struct timespec ts1
,ts2
;
1129 clock_gettime_mono(&ts1
);
1130 result
= SMB_VFS_NEXT_FALLOCATE(handle
, fsp
, mode
, offset
, len
);
1131 clock_gettime_mono(&ts2
);
1132 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1134 if (timediff
> audit_timeout
) {
1135 smb_time_audit_log("fallocate", timediff
);
1141 static bool smb_time_audit_lock(vfs_handle_struct
*handle
, files_struct
*fsp
,
1142 int op
, off_t offset
, off_t count
,
1146 struct timespec ts1
,ts2
;
1149 clock_gettime_mono(&ts1
);
1150 result
= SMB_VFS_NEXT_LOCK(handle
, fsp
, op
, offset
, count
, type
);
1151 clock_gettime_mono(&ts2
);
1152 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1154 if (timediff
> audit_timeout
) {
1155 smb_time_audit_log("lock", timediff
);
1161 static int smb_time_audit_kernel_flock(struct vfs_handle_struct
*handle
,
1162 struct files_struct
*fsp
,
1163 uint32 share_mode
, uint32 access_mask
)
1166 struct timespec ts1
,ts2
;
1169 clock_gettime_mono(&ts1
);
1170 result
= SMB_VFS_NEXT_KERNEL_FLOCK(handle
, fsp
, share_mode
,
1172 clock_gettime_mono(&ts2
);
1173 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1175 if (timediff
> audit_timeout
) {
1176 smb_time_audit_log("kernel_flock", timediff
);
1182 static int smb_time_audit_linux_setlease(vfs_handle_struct
*handle
,
1187 struct timespec ts1
,ts2
;
1190 clock_gettime_mono(&ts1
);
1191 result
= SMB_VFS_NEXT_LINUX_SETLEASE(handle
, fsp
, leasetype
);
1192 clock_gettime_mono(&ts2
);
1193 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1195 if (timediff
> audit_timeout
) {
1196 smb_time_audit_log("linux_setlease", timediff
);
1202 static bool smb_time_audit_getlock(vfs_handle_struct
*handle
,
1204 off_t
*poffset
, off_t
*pcount
,
1205 int *ptype
, pid_t
*ppid
)
1208 struct timespec ts1
,ts2
;
1211 clock_gettime_mono(&ts1
);
1212 result
= SMB_VFS_NEXT_GETLOCK(handle
, fsp
, poffset
, pcount
, ptype
,
1214 clock_gettime_mono(&ts2
);
1215 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1217 if (timediff
> audit_timeout
) {
1218 smb_time_audit_log("getlock", timediff
);
1224 static int smb_time_audit_symlink(vfs_handle_struct
*handle
,
1225 const char *oldpath
, const char *newpath
)
1228 struct timespec ts1
,ts2
;
1231 clock_gettime_mono(&ts1
);
1232 result
= SMB_VFS_NEXT_SYMLINK(handle
, oldpath
, newpath
);
1233 clock_gettime_mono(&ts2
);
1234 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1236 if (timediff
> audit_timeout
) {
1237 smb_time_audit_log("symlink", timediff
);
1243 static int smb_time_audit_readlink(vfs_handle_struct
*handle
,
1244 const char *path
, char *buf
, size_t bufsiz
)
1247 struct timespec ts1
,ts2
;
1250 clock_gettime_mono(&ts1
);
1251 result
= SMB_VFS_NEXT_READLINK(handle
, path
, buf
, bufsiz
);
1252 clock_gettime_mono(&ts2
);
1253 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1255 if (timediff
> audit_timeout
) {
1256 smb_time_audit_log("readlink", timediff
);
1262 static int smb_time_audit_link(vfs_handle_struct
*handle
,
1263 const char *oldpath
, const char *newpath
)
1266 struct timespec ts1
,ts2
;
1269 clock_gettime_mono(&ts1
);
1270 result
= SMB_VFS_NEXT_LINK(handle
, oldpath
, newpath
);
1271 clock_gettime_mono(&ts2
);
1272 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1274 if (timediff
> audit_timeout
) {
1275 smb_time_audit_log("link", timediff
);
1281 static int smb_time_audit_mknod(vfs_handle_struct
*handle
,
1282 const char *pathname
, mode_t mode
,
1286 struct timespec ts1
,ts2
;
1289 clock_gettime_mono(&ts1
);
1290 result
= SMB_VFS_NEXT_MKNOD(handle
, pathname
, mode
, dev
);
1291 clock_gettime_mono(&ts2
);
1292 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1294 if (timediff
> audit_timeout
) {
1295 smb_time_audit_log("mknod", timediff
);
1301 static char *smb_time_audit_realpath(vfs_handle_struct
*handle
,
1305 struct timespec ts1
,ts2
;
1308 clock_gettime_mono(&ts1
);
1309 result
= SMB_VFS_NEXT_REALPATH(handle
, path
);
1310 clock_gettime_mono(&ts2
);
1311 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1313 if (timediff
> audit_timeout
) {
1314 smb_time_audit_log("realpath", timediff
);
1320 static NTSTATUS
smb_time_audit_notify_watch(struct vfs_handle_struct
*handle
,
1321 struct sys_notify_context
*ctx
,
1324 uint32_t *subdir_filter
,
1325 void (*callback
)(struct sys_notify_context
*ctx
,
1327 struct notify_event
*ev
),
1328 void *private_data
, void *handle_p
)
1331 struct timespec ts1
,ts2
;
1334 clock_gettime_mono(&ts1
);
1335 result
= SMB_VFS_NEXT_NOTIFY_WATCH(handle
, ctx
, path
,
1336 filter
, subdir_filter
, callback
,
1337 private_data
, handle_p
);
1338 clock_gettime_mono(&ts2
);
1339 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1341 if (timediff
> audit_timeout
) {
1342 smb_time_audit_log("notify_watch", timediff
);
1348 static int smb_time_audit_chflags(vfs_handle_struct
*handle
,
1349 const char *path
, unsigned int flags
)
1352 struct timespec ts1
,ts2
;
1355 clock_gettime_mono(&ts1
);
1356 result
= SMB_VFS_NEXT_CHFLAGS(handle
, path
, flags
);
1357 clock_gettime_mono(&ts2
);
1358 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1360 if (timediff
> audit_timeout
) {
1361 smb_time_audit_log("chflags", timediff
);
1367 static struct file_id
smb_time_audit_file_id_create(struct vfs_handle_struct
*handle
,
1368 const SMB_STRUCT_STAT
*sbuf
)
1370 struct file_id id_zero
;
1371 struct file_id result
;
1372 struct timespec ts1
,ts2
;
1375 ZERO_STRUCT(id_zero
);
1377 clock_gettime_mono(&ts1
);
1378 result
= SMB_VFS_NEXT_FILE_ID_CREATE(handle
, sbuf
);
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("file_id_create", timediff
);
1389 static NTSTATUS
smb_time_audit_streaminfo(vfs_handle_struct
*handle
,
1390 struct files_struct
*fsp
,
1392 TALLOC_CTX
*mem_ctx
,
1393 unsigned int *pnum_streams
,
1394 struct stream_struct
**pstreams
)
1397 struct timespec ts1
,ts2
;
1400 clock_gettime_mono(&ts1
);
1401 result
= SMB_VFS_NEXT_STREAMINFO(handle
, fsp
, fname
, mem_ctx
,
1402 pnum_streams
, pstreams
);
1403 clock_gettime_mono(&ts2
);
1404 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1406 if (timediff
> audit_timeout
) {
1407 smb_time_audit_log("streaminfo", timediff
);
1413 static int smb_time_audit_get_real_filename(struct vfs_handle_struct
*handle
,
1416 TALLOC_CTX
*mem_ctx
,
1420 struct timespec ts1
,ts2
;
1423 clock_gettime_mono(&ts1
);
1424 result
= SMB_VFS_NEXT_GET_REAL_FILENAME(handle
, path
, name
, mem_ctx
,
1426 clock_gettime_mono(&ts2
);
1427 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1429 if (timediff
> audit_timeout
) {
1430 smb_time_audit_log("get_real_filename", timediff
);
1436 static const char *smb_time_audit_connectpath(vfs_handle_struct
*handle
,
1440 struct timespec ts1
,ts2
;
1443 clock_gettime_mono(&ts1
);
1444 result
= SMB_VFS_NEXT_CONNECTPATH(handle
, fname
);
1445 clock_gettime_mono(&ts2
);
1446 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1448 if (timediff
> audit_timeout
) {
1449 smb_time_audit_log("connectpath", timediff
);
1455 static NTSTATUS
smb_time_audit_brl_lock_windows(struct vfs_handle_struct
*handle
,
1456 struct byte_range_lock
*br_lck
,
1457 struct lock_struct
*plock
,
1459 struct blocking_lock_record
*blr
)
1462 struct timespec ts1
,ts2
;
1465 clock_gettime_mono(&ts1
);
1466 result
= SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle
, br_lck
, plock
,
1467 blocking_lock
, blr
);
1468 clock_gettime_mono(&ts2
);
1469 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1471 if (timediff
> audit_timeout
) {
1472 smb_time_audit_log("brl_lock_windows", timediff
);
1478 static bool smb_time_audit_brl_unlock_windows(struct vfs_handle_struct
*handle
,
1479 struct messaging_context
*msg_ctx
,
1480 struct byte_range_lock
*br_lck
,
1481 const struct lock_struct
*plock
)
1484 struct timespec ts1
,ts2
;
1487 clock_gettime_mono(&ts1
);
1488 result
= SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle
, msg_ctx
, br_lck
,
1490 clock_gettime_mono(&ts2
);
1491 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1493 if (timediff
> audit_timeout
) {
1494 smb_time_audit_log("brl_unlock_windows", timediff
);
1500 static bool smb_time_audit_brl_cancel_windows(struct vfs_handle_struct
*handle
,
1501 struct byte_range_lock
*br_lck
,
1502 struct lock_struct
*plock
,
1503 struct blocking_lock_record
*blr
)
1506 struct timespec ts1
,ts2
;
1509 clock_gettime_mono(&ts1
);
1510 result
= SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle
, br_lck
, plock
, blr
);
1511 clock_gettime_mono(&ts2
);
1512 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1514 if (timediff
> audit_timeout
) {
1515 smb_time_audit_log("brl_cancel_windows", timediff
);
1521 static bool smb_time_audit_strict_lock(struct vfs_handle_struct
*handle
,
1522 struct files_struct
*fsp
,
1523 struct lock_struct
*plock
)
1526 struct timespec ts1
,ts2
;
1529 clock_gettime_mono(&ts1
);
1530 result
= SMB_VFS_NEXT_STRICT_LOCK(handle
, fsp
, plock
);
1531 clock_gettime_mono(&ts2
);
1532 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1534 if (timediff
> audit_timeout
) {
1535 smb_time_audit_log("strict_lock", timediff
);
1541 static void smb_time_audit_strict_unlock(struct vfs_handle_struct
*handle
,
1542 struct files_struct
*fsp
,
1543 struct lock_struct
*plock
)
1545 struct timespec ts1
,ts2
;
1548 clock_gettime_mono(&ts1
);
1549 SMB_VFS_NEXT_STRICT_UNLOCK(handle
, fsp
, plock
);
1550 clock_gettime_mono(&ts2
);
1551 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1553 if (timediff
> audit_timeout
) {
1554 smb_time_audit_log("strict_unlock", timediff
);
1558 static NTSTATUS
smb_time_audit_translate_name(struct vfs_handle_struct
*handle
,
1560 enum vfs_translate_direction direction
,
1561 TALLOC_CTX
*mem_ctx
,
1565 struct timespec ts1
,ts2
;
1568 clock_gettime_mono(&ts1
);
1569 result
= SMB_VFS_NEXT_TRANSLATE_NAME(handle
, name
, direction
, mem_ctx
,
1571 clock_gettime_mono(&ts2
);
1572 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1574 if (timediff
> audit_timeout
) {
1575 smb_time_audit_log("translate_name", timediff
);
1581 static NTSTATUS
smb_time_audit_fget_nt_acl(vfs_handle_struct
*handle
,
1583 uint32 security_info
,
1584 struct security_descriptor
**ppdesc
)
1587 struct timespec ts1
,ts2
;
1590 clock_gettime_mono(&ts1
);
1591 result
= SMB_VFS_NEXT_FGET_NT_ACL(handle
, fsp
, security_info
, ppdesc
);
1592 clock_gettime_mono(&ts2
);
1593 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1595 if (timediff
> audit_timeout
) {
1596 smb_time_audit_log("fget_nt_acl", timediff
);
1602 static NTSTATUS
smb_time_audit_get_nt_acl(vfs_handle_struct
*handle
,
1604 uint32 security_info
,
1605 struct security_descriptor
**ppdesc
)
1608 struct timespec ts1
,ts2
;
1611 clock_gettime_mono(&ts1
);
1612 result
= SMB_VFS_NEXT_GET_NT_ACL(handle
, name
, security_info
, ppdesc
);
1613 clock_gettime_mono(&ts2
);
1614 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1616 if (timediff
> audit_timeout
) {
1617 smb_time_audit_log("get_nt_acl", timediff
);
1623 static NTSTATUS
smb_time_audit_fset_nt_acl(vfs_handle_struct
*handle
,
1625 uint32 security_info_sent
,
1626 const struct security_descriptor
*psd
)
1629 struct timespec ts1
,ts2
;
1632 clock_gettime_mono(&ts1
);
1633 result
= SMB_VFS_NEXT_FSET_NT_ACL(handle
, fsp
, security_info_sent
,
1635 clock_gettime_mono(&ts2
);
1636 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1638 if (timediff
> audit_timeout
) {
1639 smb_time_audit_log("fset_nt_acl", timediff
);
1645 static int smb_time_audit_chmod_acl(vfs_handle_struct
*handle
,
1646 const char *path
, mode_t mode
)
1649 struct timespec ts1
,ts2
;
1652 clock_gettime_mono(&ts1
);
1653 result
= SMB_VFS_NEXT_CHMOD_ACL(handle
, path
, mode
);
1654 clock_gettime_mono(&ts2
);
1655 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1657 if (timediff
> audit_timeout
) {
1658 smb_time_audit_log("chmod_acl", timediff
);
1664 static int smb_time_audit_fchmod_acl(vfs_handle_struct
*handle
,
1665 files_struct
*fsp
, mode_t mode
)
1668 struct timespec ts1
,ts2
;
1671 clock_gettime_mono(&ts1
);
1672 result
= SMB_VFS_NEXT_FCHMOD_ACL(handle
, fsp
, mode
);
1673 clock_gettime_mono(&ts2
);
1674 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1676 if (timediff
> audit_timeout
) {
1677 smb_time_audit_log("fchmod_acl", timediff
);
1683 static SMB_ACL_T
smb_time_audit_sys_acl_get_file(vfs_handle_struct
*handle
,
1685 SMB_ACL_TYPE_T type
)
1688 struct timespec ts1
,ts2
;
1691 clock_gettime_mono(&ts1
);
1692 result
= SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle
, path_p
, type
);
1693 clock_gettime_mono(&ts2
);
1694 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1696 if (timediff
> audit_timeout
) {
1697 smb_time_audit_log("sys_acl_get_file", timediff
);
1703 static SMB_ACL_T
smb_time_audit_sys_acl_get_fd(vfs_handle_struct
*handle
,
1707 struct timespec ts1
,ts2
;
1710 clock_gettime_mono(&ts1
);
1711 result
= SMB_VFS_NEXT_SYS_ACL_GET_FD(handle
, fsp
);
1712 clock_gettime_mono(&ts2
);
1713 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1715 if (timediff
> audit_timeout
) {
1716 smb_time_audit_log("sys_acl_get_fd", timediff
);
1722 static int smb_time_audit_sys_acl_set_file(vfs_handle_struct
*handle
,
1724 SMB_ACL_TYPE_T acltype
,
1728 struct timespec ts1
,ts2
;
1731 clock_gettime_mono(&ts1
);
1732 result
= SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle
, name
, acltype
,
1734 clock_gettime_mono(&ts2
);
1735 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1737 if (timediff
> audit_timeout
) {
1738 smb_time_audit_log("sys_acl_set_file", timediff
);
1744 static int smb_time_audit_sys_acl_set_fd(vfs_handle_struct
*handle
,
1749 struct timespec ts1
,ts2
;
1752 clock_gettime_mono(&ts1
);
1753 result
= SMB_VFS_NEXT_SYS_ACL_SET_FD(handle
, fsp
, theacl
);
1754 clock_gettime_mono(&ts2
);
1755 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1757 if (timediff
> audit_timeout
) {
1758 smb_time_audit_log("sys_acl_set_fd", timediff
);
1764 static int smb_time_audit_sys_acl_delete_def_file(vfs_handle_struct
*handle
,
1768 struct timespec ts1
,ts2
;
1771 clock_gettime_mono(&ts1
);
1772 result
= SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle
, path
);
1773 clock_gettime_mono(&ts2
);
1774 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1776 if (timediff
> audit_timeout
) {
1777 smb_time_audit_log("sys_acl_delete_def_file", timediff
);
1783 static ssize_t
smb_time_audit_getxattr(struct vfs_handle_struct
*handle
,
1784 const char *path
, const char *name
,
1785 void *value
, size_t size
)
1788 struct timespec ts1
,ts2
;
1791 clock_gettime_mono(&ts1
);
1792 result
= SMB_VFS_NEXT_GETXATTR(handle
, path
, name
, value
, size
);
1793 clock_gettime_mono(&ts2
);
1794 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1796 if (timediff
> audit_timeout
) {
1797 smb_time_audit_log("getxattr", timediff
);
1803 static ssize_t
smb_time_audit_fgetxattr(struct vfs_handle_struct
*handle
,
1804 struct files_struct
*fsp
,
1805 const char *name
, void *value
,
1809 struct timespec ts1
,ts2
;
1812 clock_gettime_mono(&ts1
);
1813 result
= SMB_VFS_NEXT_FGETXATTR(handle
, fsp
, name
, value
, size
);
1814 clock_gettime_mono(&ts2
);
1815 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1817 if (timediff
> audit_timeout
) {
1818 smb_time_audit_log("fgetxattr", timediff
);
1824 static ssize_t
smb_time_audit_listxattr(struct vfs_handle_struct
*handle
,
1825 const char *path
, char *list
,
1829 struct timespec ts1
,ts2
;
1832 clock_gettime_mono(&ts1
);
1833 result
= SMB_VFS_NEXT_LISTXATTR(handle
, path
, list
, size
);
1834 clock_gettime_mono(&ts2
);
1835 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1837 if (timediff
> audit_timeout
) {
1838 smb_time_audit_log("listxattr", timediff
);
1844 static ssize_t
smb_time_audit_flistxattr(struct vfs_handle_struct
*handle
,
1845 struct files_struct
*fsp
, char *list
,
1849 struct timespec ts1
,ts2
;
1852 clock_gettime_mono(&ts1
);
1853 result
= SMB_VFS_NEXT_FLISTXATTR(handle
, fsp
, list
, size
);
1854 clock_gettime_mono(&ts2
);
1855 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1857 if (timediff
> audit_timeout
) {
1858 smb_time_audit_log("flistxattr", timediff
);
1864 static int smb_time_audit_removexattr(struct vfs_handle_struct
*handle
,
1865 const char *path
, const char *name
)
1868 struct timespec ts1
,ts2
;
1871 clock_gettime_mono(&ts1
);
1872 result
= SMB_VFS_NEXT_REMOVEXATTR(handle
, path
, name
);
1873 clock_gettime_mono(&ts2
);
1874 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1876 if (timediff
> audit_timeout
) {
1877 smb_time_audit_log("removexattr", timediff
);
1883 static int smb_time_audit_fremovexattr(struct vfs_handle_struct
*handle
,
1884 struct files_struct
*fsp
,
1888 struct timespec ts1
,ts2
;
1891 clock_gettime_mono(&ts1
);
1892 result
= SMB_VFS_NEXT_FREMOVEXATTR(handle
, fsp
, name
);
1893 clock_gettime_mono(&ts2
);
1894 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1896 if (timediff
> audit_timeout
) {
1897 smb_time_audit_log("fremovexattr", timediff
);
1903 static int smb_time_audit_setxattr(struct vfs_handle_struct
*handle
,
1904 const char *path
, const char *name
,
1905 const void *value
, size_t size
,
1909 struct timespec ts1
,ts2
;
1912 clock_gettime_mono(&ts1
);
1913 result
= SMB_VFS_NEXT_SETXATTR(handle
, path
, name
, value
, size
,
1915 clock_gettime_mono(&ts2
);
1916 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1918 if (timediff
> audit_timeout
) {
1919 smb_time_audit_log("setxattr", timediff
);
1925 static int smb_time_audit_fsetxattr(struct vfs_handle_struct
*handle
,
1926 struct files_struct
*fsp
, const char *name
,
1927 const void *value
, size_t size
, int flags
)
1930 struct timespec ts1
,ts2
;
1933 clock_gettime_mono(&ts1
);
1934 result
= SMB_VFS_NEXT_FSETXATTR(handle
, fsp
, name
, value
, size
, flags
);
1935 clock_gettime_mono(&ts2
);
1936 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1938 if (timediff
> audit_timeout
) {
1939 smb_time_audit_log("fsetxattr", timediff
);
1945 static bool smb_time_audit_aio_force(struct vfs_handle_struct
*handle
,
1946 struct files_struct
*fsp
)
1949 struct timespec ts1
,ts2
;
1952 clock_gettime_mono(&ts1
);
1953 result
= SMB_VFS_NEXT_AIO_FORCE(handle
, fsp
);
1954 clock_gettime_mono(&ts2
);
1955 timediff
= nsec_time_diff(&ts2
,&ts1
)*1.0e-9;
1957 if (timediff
> audit_timeout
) {
1958 smb_time_audit_log("aio_force", timediff
);
1966 /* VFS operations */
1968 static struct vfs_fn_pointers vfs_time_audit_fns
= {
1969 .connect_fn
= smb_time_audit_connect
,
1970 .disconnect_fn
= smb_time_audit_disconnect
,
1971 .disk_free_fn
= smb_time_audit_disk_free
,
1972 .get_quota_fn
= smb_time_audit_get_quota
,
1973 .set_quota_fn
= smb_time_audit_set_quota
,
1974 .get_shadow_copy_data_fn
= smb_time_audit_get_shadow_copy_data
,
1975 .statvfs_fn
= smb_time_audit_statvfs
,
1976 .fs_capabilities_fn
= smb_time_audit_fs_capabilities
,
1977 .opendir_fn
= smb_time_audit_opendir
,
1978 .fdopendir_fn
= smb_time_audit_fdopendir
,
1979 .readdir_fn
= smb_time_audit_readdir
,
1980 .seekdir_fn
= smb_time_audit_seekdir
,
1981 .telldir_fn
= smb_time_audit_telldir
,
1982 .rewind_dir_fn
= smb_time_audit_rewinddir
,
1983 .mkdir_fn
= smb_time_audit_mkdir
,
1984 .rmdir_fn
= smb_time_audit_rmdir
,
1985 .closedir_fn
= smb_time_audit_closedir
,
1986 .init_search_op_fn
= smb_time_audit_init_search_op
,
1987 .open_fn
= smb_time_audit_open
,
1988 .create_file_fn
= smb_time_audit_create_file
,
1989 .close_fn
= smb_time_audit_close
,
1990 .read_fn
= smb_time_audit_read
,
1991 .pread_fn
= smb_time_audit_pread
,
1992 .pread_send_fn
= smb_time_audit_pread_send
,
1993 .pread_recv_fn
= smb_time_audit_pread_recv
,
1994 .write_fn
= smb_time_audit_write
,
1995 .pwrite_fn
= smb_time_audit_pwrite
,
1996 .pwrite_send_fn
= smb_time_audit_pwrite_send
,
1997 .pwrite_recv_fn
= smb_time_audit_pwrite_recv
,
1998 .lseek_fn
= smb_time_audit_lseek
,
1999 .sendfile_fn
= smb_time_audit_sendfile
,
2000 .recvfile_fn
= smb_time_audit_recvfile
,
2001 .rename_fn
= smb_time_audit_rename
,
2002 .fsync_fn
= smb_time_audit_fsync
,
2003 .fsync_send_fn
= smb_time_audit_fsync_send
,
2004 .fsync_recv_fn
= smb_time_audit_fsync_recv
,
2005 .stat_fn
= smb_time_audit_stat
,
2006 .fstat_fn
= smb_time_audit_fstat
,
2007 .lstat_fn
= smb_time_audit_lstat
,
2008 .get_alloc_size_fn
= smb_time_audit_get_alloc_size
,
2009 .unlink_fn
= smb_time_audit_unlink
,
2010 .chmod_fn
= smb_time_audit_chmod
,
2011 .fchmod_fn
= smb_time_audit_fchmod
,
2012 .chown_fn
= smb_time_audit_chown
,
2013 .fchown_fn
= smb_time_audit_fchown
,
2014 .lchown_fn
= smb_time_audit_lchown
,
2015 .chdir_fn
= smb_time_audit_chdir
,
2016 .getwd_fn
= smb_time_audit_getwd
,
2017 .ntimes_fn
= smb_time_audit_ntimes
,
2018 .ftruncate_fn
= smb_time_audit_ftruncate
,
2019 .fallocate_fn
= smb_time_audit_fallocate
,
2020 .lock_fn
= smb_time_audit_lock
,
2021 .kernel_flock_fn
= smb_time_audit_kernel_flock
,
2022 .linux_setlease_fn
= smb_time_audit_linux_setlease
,
2023 .getlock_fn
= smb_time_audit_getlock
,
2024 .symlink_fn
= smb_time_audit_symlink
,
2025 .readlink_fn
= smb_time_audit_readlink
,
2026 .link_fn
= smb_time_audit_link
,
2027 .mknod_fn
= smb_time_audit_mknod
,
2028 .realpath_fn
= smb_time_audit_realpath
,
2029 .notify_watch_fn
= smb_time_audit_notify_watch
,
2030 .chflags_fn
= smb_time_audit_chflags
,
2031 .file_id_create_fn
= smb_time_audit_file_id_create
,
2032 .streaminfo_fn
= smb_time_audit_streaminfo
,
2033 .get_real_filename_fn
= smb_time_audit_get_real_filename
,
2034 .connectpath_fn
= smb_time_audit_connectpath
,
2035 .brl_lock_windows_fn
= smb_time_audit_brl_lock_windows
,
2036 .brl_unlock_windows_fn
= smb_time_audit_brl_unlock_windows
,
2037 .brl_cancel_windows_fn
= smb_time_audit_brl_cancel_windows
,
2038 .strict_lock_fn
= smb_time_audit_strict_lock
,
2039 .strict_unlock_fn
= smb_time_audit_strict_unlock
,
2040 .translate_name_fn
= smb_time_audit_translate_name
,
2041 .fget_nt_acl_fn
= smb_time_audit_fget_nt_acl
,
2042 .get_nt_acl_fn
= smb_time_audit_get_nt_acl
,
2043 .fset_nt_acl_fn
= smb_time_audit_fset_nt_acl
,
2044 .chmod_acl_fn
= smb_time_audit_chmod_acl
,
2045 .fchmod_acl_fn
= smb_time_audit_fchmod_acl
,
2046 .sys_acl_get_file_fn
= smb_time_audit_sys_acl_get_file
,
2047 .sys_acl_get_fd_fn
= smb_time_audit_sys_acl_get_fd
,
2048 .sys_acl_set_file_fn
= smb_time_audit_sys_acl_set_file
,
2049 .sys_acl_set_fd_fn
= smb_time_audit_sys_acl_set_fd
,
2050 .getxattr_fn
= smb_time_audit_getxattr
,
2051 .fgetxattr_fn
= smb_time_audit_fgetxattr
,
2052 .listxattr_fn
= smb_time_audit_listxattr
,
2053 .flistxattr_fn
= smb_time_audit_flistxattr
,
2054 .removexattr_fn
= smb_time_audit_removexattr
,
2055 .fremovexattr_fn
= smb_time_audit_fremovexattr
,
2056 .setxattr_fn
= smb_time_audit_setxattr
,
2057 .fsetxattr_fn
= smb_time_audit_fsetxattr
,
2058 .aio_force_fn
= smb_time_audit_aio_force
,
2062 NTSTATUS
vfs_time_audit_init(void);
2063 NTSTATUS
vfs_time_audit_init(void)
2065 audit_timeout
= (double)lp_parm_int(-1, "time_audit", "timeout",
2067 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION
, "time_audit",
2068 &vfs_time_audit_fns
);