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"
32 #include "lib/util/tevent_ntstatus.h"
35 #define DBGC_CLASS DBGC_VFS
37 static double audit_timeout;
39 static void smb_time_audit_log_msg(const char *syscallname, double elapsed,
42 DEBUG(0, ("WARNING: VFS call \"%s\" took unexpectedly long "
43 "(%.2f seconds) %s%s-- Validate that file and storage "
44 "subsystems are operating normally\n", syscallname,
45 elapsed, (msg != NULL) ? msg : "",
46 (msg != NULL) ? " " : ""));
49 static void smb_time_audit_log(const char *syscallname, double elapsed)
51 smb_time_audit_log_msg(syscallname, elapsed, NULL);
54 static void smb_time_audit_log_fsp(const char *syscallname, double elapsed,
55 const struct files_struct *fsp)
57 char *base_name = NULL;
58 char *connectpath = NULL;
62 smb_time_audit_log(syscallname, elapsed);
66 connectpath = fsp->conn->connectpath;
68 base_name = fsp->fsp_name->base_name;
70 if (connectpath != NULL && base_name != NULL) {
71 msg = talloc_asprintf(talloc_tos(), "filename = \"%s/%s\"",
72 connectpath, base_name);
73 } else if (connectpath != NULL && base_name == NULL) {
74 msg = talloc_asprintf(talloc_tos(), "connectpath = \"%s\", "
77 } else if (connectpath == NULL && base_name != NULL) {
78 msg = talloc_asprintf(talloc_tos(), "connectpath = <NULL>, "
81 } else { /* connectpath == NULL && base_name == NULL */
82 msg = talloc_asprintf(talloc_tos(), "connectpath = <NULL>, "
83 "base_name = <NULL>");
85 smb_time_audit_log_msg(syscallname, elapsed, msg);
89 static void smb_time_audit_log_fname(const char *syscallname, double elapsed,
95 if (getcwd(cwd, sizeof(cwd)) == NULL) {
96 snprintf(cwd, sizeof(cwd), "<getcwd() error %d>", errno);
99 msg = talloc_asprintf(talloc_tos(),
100 "cwd = \"%s\", filename = \"%s\"",
103 msg = talloc_asprintf(talloc_tos(),
104 "cwd = \"%s\", filename = <NULL>",
107 smb_time_audit_log_msg(syscallname, elapsed, msg);
111 static void smb_time_audit_log_smb_fname(const char *syscallname, double elapsed,
112 const struct smb_filename *smb_fname)
114 if (smb_fname != NULL) {
115 smb_time_audit_log_fname(syscallname, elapsed,
116 smb_fname->base_name);
118 smb_time_audit_log_fname(syscallname, elapsed,
119 "smb_fname = <NULL>");
123 static int smb_time_audit_connect(vfs_handle_struct *handle,
124 const char *svc, const char *user)
127 struct timespec ts1,ts2;
134 clock_gettime_mono(&ts1);
135 result = SMB_VFS_NEXT_CONNECT(handle, svc, user);
136 clock_gettime_mono(&ts2);
137 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
138 if (timediff > audit_timeout) {
139 smb_time_audit_log_msg("connect", timediff, user);
144 static void smb_time_audit_disconnect(vfs_handle_struct *handle)
146 struct timespec ts1,ts2;
149 clock_gettime_mono(&ts1);
150 SMB_VFS_NEXT_DISCONNECT(handle);
151 clock_gettime_mono(&ts2);
152 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
154 if (timediff > audit_timeout) {
155 smb_time_audit_log("disconnect", timediff);
159 static uint64_t smb_time_audit_disk_free(vfs_handle_struct *handle,
160 const struct smb_filename *smb_fname,
166 struct timespec ts1,ts2;
169 clock_gettime_mono(&ts1);
170 result = SMB_VFS_NEXT_DISK_FREE(handle, smb_fname, bsize, dfree, dsize);
171 clock_gettime_mono(&ts2);
172 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
174 /* Don't have a reasonable notion of failure here */
175 if (timediff > audit_timeout) {
176 smb_time_audit_log_fname("disk_free",
178 smb_fname->base_name);
184 static int smb_time_audit_get_quota(struct vfs_handle_struct *handle,
185 const struct smb_filename *smb_fname,
186 enum SMB_QUOTA_TYPE qtype,
191 struct timespec ts1,ts2;
194 clock_gettime_mono(&ts1);
195 result = SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, qt);
196 clock_gettime_mono(&ts2);
197 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
199 if (timediff > audit_timeout) {
200 smb_time_audit_log_fname("get_quota",
202 smb_fname->base_name);
207 static int smb_time_audit_set_quota(struct vfs_handle_struct *handle,
208 enum SMB_QUOTA_TYPE qtype, unid_t id,
212 struct timespec ts1,ts2;
215 clock_gettime_mono(&ts1);
216 result = SMB_VFS_NEXT_SET_QUOTA(handle, qtype, id, qt);
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("set_quota", timediff);
227 static int smb_time_audit_get_shadow_copy_data(struct vfs_handle_struct *handle,
228 struct files_struct *fsp,
229 struct shadow_copy_data *shadow_copy_data,
233 struct timespec ts1,ts2;
236 clock_gettime_mono(&ts1);
237 result = SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle, fsp,
238 shadow_copy_data, labels);
239 clock_gettime_mono(&ts2);
240 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
242 if (timediff > audit_timeout) {
243 smb_time_audit_log_fsp("get_shadow_copy_data", timediff, fsp);
249 static int smb_time_audit_statvfs(struct vfs_handle_struct *handle,
250 const struct smb_filename *smb_fname,
251 struct vfs_statvfs_struct *statbuf)
254 struct timespec ts1,ts2;
257 clock_gettime_mono(&ts1);
258 result = SMB_VFS_NEXT_STATVFS(handle, smb_fname, statbuf);
259 clock_gettime_mono(&ts2);
260 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
262 if (timediff > audit_timeout) {
263 smb_time_audit_log_fname("statvfs", timediff,
264 smb_fname->base_name);
270 static uint32_t smb_time_audit_fs_capabilities(struct vfs_handle_struct *handle,
271 enum timestamp_set_resolution *p_ts_res)
274 struct timespec ts1,ts2;
277 clock_gettime_mono(&ts1);
278 result = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
279 clock_gettime_mono(&ts2);
280 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
282 if (timediff > audit_timeout) {
283 smb_time_audit_log("fs_capabilities", timediff);
289 static NTSTATUS smb_time_audit_get_dfs_referrals(
290 struct vfs_handle_struct *handle,
291 struct dfs_GetDFSReferral *r)
294 struct timespec ts1,ts2;
297 clock_gettime_mono(&ts1);
298 result = SMB_VFS_NEXT_GET_DFS_REFERRALS(handle, r);
299 clock_gettime_mono(&ts2);
300 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
302 if (timediff > audit_timeout) {
303 smb_time_audit_log("get_dfs_referrals", timediff);
309 static NTSTATUS smb_time_audit_snap_check_path(struct vfs_handle_struct *handle,
311 const char *service_path,
315 struct timespec ts1,ts2;
318 clock_gettime_mono(&ts1);
319 status = SMB_VFS_NEXT_SNAP_CHECK_PATH(handle, mem_ctx, service_path,
321 clock_gettime_mono(&ts2);
322 timediff = nsec_time_diff(&ts2, &ts1) * 1.0e-9;
324 if (timediff > audit_timeout) {
325 smb_time_audit_log("snap_check_path", timediff);
331 static NTSTATUS smb_time_audit_snap_create(struct vfs_handle_struct *handle,
333 const char *base_volume,
340 struct timespec ts1,ts2;
343 clock_gettime_mono(&ts1);
344 status = SMB_VFS_NEXT_SNAP_CREATE(handle, mem_ctx, base_volume, tstamp,
345 rw, base_path, snap_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("snap_create", timediff);
356 static NTSTATUS smb_time_audit_snap_delete(struct vfs_handle_struct *handle,
362 struct timespec ts1,ts2;
365 clock_gettime_mono(&ts1);
366 status = SMB_VFS_NEXT_SNAP_DELETE(handle, mem_ctx, base_path,
368 clock_gettime_mono(&ts2);
369 timediff = nsec_time_diff(&ts2, &ts1) * 1.0e-9;
371 if (timediff > audit_timeout) {
372 smb_time_audit_log("snap_delete", timediff);
378 static DIR *smb_time_audit_opendir(vfs_handle_struct *handle,
379 const struct smb_filename *smb_fname,
380 const char *mask, uint32_t attr)
383 struct timespec ts1,ts2;
386 clock_gettime_mono(&ts1);
387 result = SMB_VFS_NEXT_OPENDIR(handle, smb_fname, mask, attr);
388 clock_gettime_mono(&ts2);
389 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
391 if (timediff > audit_timeout) {
392 smb_time_audit_log_smb_fname("opendir", timediff, smb_fname);
398 static DIR *smb_time_audit_fdopendir(vfs_handle_struct *handle,
400 const char *mask, uint32_t attr)
403 struct timespec ts1,ts2;
406 clock_gettime_mono(&ts1);
407 result = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
408 clock_gettime_mono(&ts2);
409 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
411 if (timediff > audit_timeout) {
412 smb_time_audit_log_fsp("fdopendir", timediff, fsp);
418 static struct dirent *smb_time_audit_readdir(vfs_handle_struct *handle,
420 SMB_STRUCT_STAT *sbuf)
422 struct dirent *result;
423 struct timespec ts1,ts2;
426 clock_gettime_mono(&ts1);
427 result = SMB_VFS_NEXT_READDIR(handle, dirp, sbuf);
428 clock_gettime_mono(&ts2);
429 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
431 if (timediff > audit_timeout) {
432 smb_time_audit_log("readdir", timediff);
438 static void smb_time_audit_seekdir(vfs_handle_struct *handle,
439 DIR *dirp, long offset)
441 struct timespec ts1,ts2;
444 clock_gettime_mono(&ts1);
445 SMB_VFS_NEXT_SEEKDIR(handle, dirp, offset);
446 clock_gettime_mono(&ts2);
447 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
449 if (timediff > audit_timeout) {
450 smb_time_audit_log("seekdir", timediff);
455 static long smb_time_audit_telldir(vfs_handle_struct *handle,
459 struct timespec ts1,ts2;
462 clock_gettime_mono(&ts1);
463 result = SMB_VFS_NEXT_TELLDIR(handle, dirp);
464 clock_gettime_mono(&ts2);
465 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
467 if (timediff > audit_timeout) {
468 smb_time_audit_log("telldir", timediff);
474 static void smb_time_audit_rewinddir(vfs_handle_struct *handle,
477 struct timespec ts1,ts2;
480 clock_gettime_mono(&ts1);
481 SMB_VFS_NEXT_REWINDDIR(handle, dirp);
482 clock_gettime_mono(&ts2);
483 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
485 if (timediff > audit_timeout) {
486 smb_time_audit_log("rewinddir", timediff);
491 static int smb_time_audit_mkdir(vfs_handle_struct *handle,
492 const struct smb_filename *smb_fname,
496 struct timespec ts1,ts2;
499 clock_gettime_mono(&ts1);
500 result = SMB_VFS_NEXT_MKDIR(handle, smb_fname, mode);
501 clock_gettime_mono(&ts2);
502 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
504 if (timediff > audit_timeout) {
505 smb_time_audit_log_smb_fname("mkdir",
513 static int smb_time_audit_rmdir(vfs_handle_struct *handle,
514 const struct smb_filename *smb_fname)
517 struct timespec ts1,ts2;
520 clock_gettime_mono(&ts1);
521 result = SMB_VFS_NEXT_RMDIR(handle, smb_fname);
522 clock_gettime_mono(&ts2);
523 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
525 if (timediff > audit_timeout) {
526 smb_time_audit_log_smb_fname("rmdir",
534 static int smb_time_audit_closedir(vfs_handle_struct *handle,
538 struct timespec ts1,ts2;
541 clock_gettime_mono(&ts1);
542 result = SMB_VFS_NEXT_CLOSEDIR(handle, dirp);
543 clock_gettime_mono(&ts2);
544 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
546 if (timediff > audit_timeout) {
547 smb_time_audit_log("closedir", timediff);
553 static int smb_time_audit_open(vfs_handle_struct *handle,
554 struct smb_filename *fname,
556 int flags, mode_t mode)
559 struct timespec ts1,ts2;
562 clock_gettime_mono(&ts1);
563 result = SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
564 clock_gettime_mono(&ts2);
565 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
567 if (timediff > audit_timeout) {
568 smb_time_audit_log_fsp("open", timediff, fsp);
574 static NTSTATUS smb_time_audit_create_file(vfs_handle_struct *handle,
575 struct smb_request *req,
576 uint16_t root_dir_fid,
577 struct smb_filename *fname,
578 uint32_t access_mask,
579 uint32_t share_access,
580 uint32_t create_disposition,
581 uint32_t create_options,
582 uint32_t file_attributes,
583 uint32_t oplock_request,
584 struct smb2_lease *lease,
585 uint64_t allocation_size,
586 uint32_t private_flags,
587 struct security_descriptor *sd,
588 struct ea_list *ea_list,
589 files_struct **result_fsp,
591 const struct smb2_create_blobs *in_context_blobs,
592 struct smb2_create_blobs *out_context_blobs)
595 struct timespec ts1,ts2;
598 clock_gettime_mono(&ts1);
599 result = SMB_VFS_NEXT_CREATE_FILE(
602 root_dir_fid, /* root_dir_fid */
604 access_mask, /* access_mask */
605 share_access, /* share_access */
606 create_disposition, /* create_disposition*/
607 create_options, /* create_options */
608 file_attributes, /* file_attributes */
609 oplock_request, /* oplock_request */
611 allocation_size, /* allocation_size */
614 ea_list, /* ea_list */
615 result_fsp, /* result */
617 in_context_blobs, out_context_blobs); /* create context */
618 clock_gettime_mono(&ts2);
619 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
621 if (timediff > audit_timeout) {
623 * can't use result_fsp this time, may have
624 * invalid content causing smbd crash
626 smb_time_audit_log_smb_fname("create_file", timediff,
633 static int smb_time_audit_close(vfs_handle_struct *handle, files_struct *fsp)
636 struct timespec ts1,ts2;
639 clock_gettime_mono(&ts1);
640 result = SMB_VFS_NEXT_CLOSE(handle, fsp);
641 clock_gettime_mono(&ts2);
642 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
644 if (timediff > audit_timeout) {
645 smb_time_audit_log_fsp("close", timediff, fsp);
651 static ssize_t smb_time_audit_pread(vfs_handle_struct *handle,
653 void *data, size_t n, off_t offset)
656 struct timespec ts1,ts2;
659 clock_gettime_mono(&ts1);
660 result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
661 clock_gettime_mono(&ts2);
662 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
664 if (timediff > audit_timeout) {
665 smb_time_audit_log_fsp("pread", timediff, fsp);
671 struct smb_time_audit_pread_state {
672 struct files_struct *fsp;
674 struct vfs_aio_state vfs_aio_state;
677 static void smb_time_audit_pread_done(struct tevent_req *subreq);
679 static struct tevent_req *smb_time_audit_pread_send(
680 struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
681 struct tevent_context *ev, struct files_struct *fsp,
682 void *data, size_t n, off_t offset)
684 struct tevent_req *req, *subreq;
685 struct smb_time_audit_pread_state *state;
687 req = tevent_req_create(mem_ctx, &state,
688 struct smb_time_audit_pread_state);
694 subreq = SMB_VFS_NEXT_PREAD_SEND(state, ev, handle, fsp, data,
696 if (tevent_req_nomem(subreq, req)) {
697 return tevent_req_post(req, ev);
699 tevent_req_set_callback(subreq, smb_time_audit_pread_done, req);
703 static void smb_time_audit_pread_done(struct tevent_req *subreq)
705 struct tevent_req *req = tevent_req_callback_data(
706 subreq, struct tevent_req);
707 struct smb_time_audit_pread_state *state = tevent_req_data(
708 req, struct smb_time_audit_pread_state);
710 state->ret = SMB_VFS_PREAD_RECV(subreq, &state->vfs_aio_state);
712 tevent_req_done(req);
715 static ssize_t smb_time_audit_pread_recv(struct tevent_req *req,
716 struct vfs_aio_state *vfs_aio_state)
718 struct smb_time_audit_pread_state *state = tevent_req_data(
719 req, struct smb_time_audit_pread_state);
722 timediff = state->vfs_aio_state.duration * 1.0e-9;
724 if (timediff > audit_timeout) {
725 smb_time_audit_log_fsp("async pread", timediff, state->fsp);
728 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
731 *vfs_aio_state = state->vfs_aio_state;
735 static ssize_t smb_time_audit_pwrite(vfs_handle_struct *handle,
737 const void *data, size_t n,
741 struct timespec ts1,ts2;
744 clock_gettime_mono(&ts1);
745 result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
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_fsp("pwrite", timediff, fsp);
756 struct smb_time_audit_pwrite_state {
757 struct files_struct *fsp;
759 struct vfs_aio_state vfs_aio_state;
762 static void smb_time_audit_pwrite_done(struct tevent_req *subreq);
764 static struct tevent_req *smb_time_audit_pwrite_send(
765 struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
766 struct tevent_context *ev, struct files_struct *fsp,
767 const void *data, size_t n, off_t offset)
769 struct tevent_req *req, *subreq;
770 struct smb_time_audit_pwrite_state *state;
772 req = tevent_req_create(mem_ctx, &state,
773 struct smb_time_audit_pwrite_state);
779 subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp, data,
781 if (tevent_req_nomem(subreq, req)) {
782 return tevent_req_post(req, ev);
784 tevent_req_set_callback(subreq, smb_time_audit_pwrite_done, req);
788 static void smb_time_audit_pwrite_done(struct tevent_req *subreq)
790 struct tevent_req *req = tevent_req_callback_data(
791 subreq, struct tevent_req);
792 struct smb_time_audit_pwrite_state *state = tevent_req_data(
793 req, struct smb_time_audit_pwrite_state);
795 state->ret = SMB_VFS_PWRITE_RECV(subreq, &state->vfs_aio_state);
797 tevent_req_done(req);
800 static ssize_t smb_time_audit_pwrite_recv(struct tevent_req *req,
801 struct vfs_aio_state *vfs_aio_state)
803 struct smb_time_audit_pwrite_state *state = tevent_req_data(
804 req, struct smb_time_audit_pwrite_state);
807 timediff = state->vfs_aio_state.duration * 1.0e-9;
809 if (timediff > audit_timeout) {
810 smb_time_audit_log_fsp("async pwrite", timediff, state->fsp);
813 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
816 *vfs_aio_state = state->vfs_aio_state;
820 static off_t smb_time_audit_lseek(vfs_handle_struct *handle,
822 off_t offset, int whence)
825 struct timespec ts1,ts2;
828 clock_gettime_mono(&ts1);
829 result = SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence);
830 clock_gettime_mono(&ts2);
831 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
833 if (timediff > audit_timeout) {
834 smb_time_audit_log_fsp("lseek", timediff, fsp);
840 static ssize_t smb_time_audit_sendfile(vfs_handle_struct *handle, int tofd,
841 files_struct *fromfsp,
842 const DATA_BLOB *hdr, off_t offset,
846 struct timespec ts1,ts2;
849 clock_gettime_mono(&ts1);
850 result = SMB_VFS_NEXT_SENDFILE(handle, tofd, fromfsp, hdr, offset, n);
851 clock_gettime_mono(&ts2);
852 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
854 if (timediff > audit_timeout) {
855 smb_time_audit_log_fsp("sendfile", timediff, fromfsp);
861 static ssize_t smb_time_audit_recvfile(vfs_handle_struct *handle, int fromfd,
867 struct timespec ts1,ts2;
870 clock_gettime_mono(&ts1);
871 result = SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, n);
872 clock_gettime_mono(&ts2);
873 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
875 if (timediff > audit_timeout) {
876 smb_time_audit_log_fsp("recvfile", timediff, tofsp);
882 static int smb_time_audit_rename(vfs_handle_struct *handle,
883 const struct smb_filename *oldname,
884 const struct smb_filename *newname)
887 struct timespec ts1,ts2;
890 clock_gettime_mono(&ts1);
891 result = SMB_VFS_NEXT_RENAME(handle, oldname, newname);
892 clock_gettime_mono(&ts2);
893 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
895 if (timediff > audit_timeout) {
896 smb_time_audit_log_smb_fname("rename", timediff, newname);
902 struct smb_time_audit_fsync_state {
903 struct files_struct *fsp;
905 struct vfs_aio_state vfs_aio_state;
908 static void smb_time_audit_fsync_done(struct tevent_req *subreq);
910 static struct tevent_req *smb_time_audit_fsync_send(
911 struct vfs_handle_struct *handle, TALLOC_CTX *mem_ctx,
912 struct tevent_context *ev, struct files_struct *fsp)
914 struct tevent_req *req, *subreq;
915 struct smb_time_audit_fsync_state *state;
917 req = tevent_req_create(mem_ctx, &state,
918 struct smb_time_audit_fsync_state);
924 subreq = SMB_VFS_NEXT_FSYNC_SEND(state, ev, handle, fsp);
925 if (tevent_req_nomem(subreq, req)) {
926 return tevent_req_post(req, ev);
928 tevent_req_set_callback(subreq, smb_time_audit_fsync_done, req);
932 static void smb_time_audit_fsync_done(struct tevent_req *subreq)
934 struct tevent_req *req = tevent_req_callback_data(
935 subreq, struct tevent_req);
936 struct smb_time_audit_fsync_state *state = tevent_req_data(
937 req, struct smb_time_audit_fsync_state);
939 state->ret = SMB_VFS_FSYNC_RECV(subreq, &state->vfs_aio_state);
941 tevent_req_done(req);
944 static int smb_time_audit_fsync_recv(struct tevent_req *req,
945 struct vfs_aio_state *vfs_aio_state)
947 struct smb_time_audit_fsync_state *state = tevent_req_data(
948 req, struct smb_time_audit_fsync_state);
951 timediff = state->vfs_aio_state.duration * 1.0e-9;
953 if (timediff > audit_timeout) {
954 smb_time_audit_log_fsp("async fsync", timediff, state->fsp);
957 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
960 *vfs_aio_state = state->vfs_aio_state;
964 static int smb_time_audit_stat(vfs_handle_struct *handle,
965 struct smb_filename *fname)
968 struct timespec ts1,ts2;
971 clock_gettime_mono(&ts1);
972 result = SMB_VFS_NEXT_STAT(handle, fname);
973 clock_gettime_mono(&ts2);
974 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
976 if (timediff > audit_timeout) {
977 smb_time_audit_log_smb_fname("stat", timediff, fname);
983 static int smb_time_audit_fstat(vfs_handle_struct *handle, files_struct *fsp,
984 SMB_STRUCT_STAT *sbuf)
987 struct timespec ts1,ts2;
990 clock_gettime_mono(&ts1);
991 result = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
992 clock_gettime_mono(&ts2);
993 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
995 if (timediff > audit_timeout) {
996 smb_time_audit_log_fsp("fstat", timediff, fsp);
1002 static int smb_time_audit_lstat(vfs_handle_struct *handle,
1003 struct smb_filename *path)
1006 struct timespec ts1,ts2;
1009 clock_gettime_mono(&ts1);
1010 result = SMB_VFS_NEXT_LSTAT(handle, path);
1011 clock_gettime_mono(&ts2);
1012 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1014 if (timediff > audit_timeout) {
1015 smb_time_audit_log_smb_fname("lstat", timediff, path);
1021 static uint64_t smb_time_audit_get_alloc_size(vfs_handle_struct *handle,
1023 const SMB_STRUCT_STAT *sbuf)
1026 struct timespec ts1,ts2;
1029 clock_gettime_mono(&ts1);
1030 result = SMB_VFS_NEXT_GET_ALLOC_SIZE(handle, fsp, sbuf);
1031 clock_gettime_mono(&ts2);
1032 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1034 if (timediff > audit_timeout) {
1035 smb_time_audit_log_fsp("get_alloc_size", timediff, fsp);
1041 static int smb_time_audit_unlink(vfs_handle_struct *handle,
1042 const struct smb_filename *path)
1045 struct timespec ts1,ts2;
1048 clock_gettime_mono(&ts1);
1049 result = SMB_VFS_NEXT_UNLINK(handle, path);
1050 clock_gettime_mono(&ts2);
1051 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1053 if (timediff > audit_timeout) {
1054 smb_time_audit_log_smb_fname("unlink", timediff, path);
1060 static int smb_time_audit_chmod(vfs_handle_struct *handle,
1061 const struct smb_filename *smb_fname,
1065 struct timespec ts1,ts2;
1068 clock_gettime_mono(&ts1);
1069 result = SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
1070 clock_gettime_mono(&ts2);
1071 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1073 if (timediff > audit_timeout) {
1074 smb_time_audit_log_fname("chmod",
1076 smb_fname->base_name);
1082 static int smb_time_audit_fchmod(vfs_handle_struct *handle, files_struct *fsp,
1086 struct timespec ts1,ts2;
1089 clock_gettime_mono(&ts1);
1090 result = SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
1091 clock_gettime_mono(&ts2);
1092 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1094 if (timediff > audit_timeout) {
1095 smb_time_audit_log_fsp("fchmod", timediff, fsp);
1101 static int smb_time_audit_chown(vfs_handle_struct *handle,
1102 const struct smb_filename *smb_fname,
1107 struct timespec ts1,ts2;
1110 clock_gettime_mono(&ts1);
1111 result = SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
1112 clock_gettime_mono(&ts2);
1113 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1115 if (timediff > audit_timeout) {
1116 smb_time_audit_log_fname("chown",
1118 smb_fname->base_name);
1124 static int smb_time_audit_fchown(vfs_handle_struct *handle, files_struct *fsp,
1125 uid_t uid, gid_t gid)
1128 struct timespec ts1,ts2;
1131 clock_gettime_mono(&ts1);
1132 result = SMB_VFS_NEXT_FCHOWN(handle, fsp, uid, gid);
1133 clock_gettime_mono(&ts2);
1134 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1136 if (timediff > audit_timeout) {
1137 smb_time_audit_log_fsp("fchown", timediff, fsp);
1143 static int smb_time_audit_lchown(vfs_handle_struct *handle,
1144 const struct smb_filename *smb_fname,
1149 struct timespec ts1,ts2;
1152 clock_gettime_mono(&ts1);
1153 result = SMB_VFS_NEXT_LCHOWN(handle, smb_fname, uid, gid);
1154 clock_gettime_mono(&ts2);
1155 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1157 if (timediff > audit_timeout) {
1158 smb_time_audit_log_fname("lchown",
1160 smb_fname->base_name);
1166 static int smb_time_audit_chdir(vfs_handle_struct *handle,
1167 const struct smb_filename *smb_fname)
1170 struct timespec ts1,ts2;
1173 clock_gettime_mono(&ts1);
1174 result = SMB_VFS_NEXT_CHDIR(handle, smb_fname);
1175 clock_gettime_mono(&ts2);
1176 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1178 if (timediff > audit_timeout) {
1179 smb_time_audit_log_fname("chdir",
1181 smb_fname->base_name);
1187 static struct smb_filename *smb_time_audit_getwd(vfs_handle_struct *handle,
1188 TALLOC_CTX *mem_ctx)
1190 struct smb_filename *result;
1191 struct timespec ts1,ts2;
1194 clock_gettime_mono(&ts1);
1195 result = SMB_VFS_NEXT_GETWD(handle, mem_ctx);
1196 clock_gettime_mono(&ts2);
1197 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1199 if (timediff > audit_timeout) {
1200 smb_time_audit_log("getwd", timediff);
1206 static int smb_time_audit_ntimes(vfs_handle_struct *handle,
1207 const struct smb_filename *path,
1208 struct smb_file_time *ft)
1211 struct timespec ts1,ts2;
1214 clock_gettime_mono(&ts1);
1215 result = SMB_VFS_NEXT_NTIMES(handle, path, ft);
1216 clock_gettime_mono(&ts2);
1217 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1219 if (timediff > audit_timeout) {
1220 smb_time_audit_log_smb_fname("ntimes", timediff, path);
1226 static int smb_time_audit_ftruncate(vfs_handle_struct *handle,
1231 struct timespec ts1,ts2;
1234 clock_gettime_mono(&ts1);
1235 result = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
1236 clock_gettime_mono(&ts2);
1237 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1239 if (timediff > audit_timeout) {
1240 smb_time_audit_log_fsp("ftruncate", timediff, fsp);
1246 static int smb_time_audit_fallocate(vfs_handle_struct *handle,
1253 int saved_errno = 0;
1254 struct timespec ts1,ts2;
1257 clock_gettime_mono(&ts1);
1258 result = SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
1260 saved_errno = errno;
1262 clock_gettime_mono(&ts2);
1263 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1265 if (timediff > audit_timeout) {
1266 smb_time_audit_log_fsp("fallocate", timediff, fsp);
1269 errno = saved_errno;
1274 static bool smb_time_audit_lock(vfs_handle_struct *handle, files_struct *fsp,
1275 int op, off_t offset, off_t count,
1279 struct timespec ts1,ts2;
1282 clock_gettime_mono(&ts1);
1283 result = SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type);
1284 clock_gettime_mono(&ts2);
1285 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1287 if (timediff > audit_timeout) {
1288 smb_time_audit_log_fsp("lock", timediff, fsp);
1294 static int smb_time_audit_kernel_flock(struct vfs_handle_struct *handle,
1295 struct files_struct *fsp,
1296 uint32_t share_mode, uint32_t access_mask)
1299 struct timespec ts1,ts2;
1302 clock_gettime_mono(&ts1);
1303 result = SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode,
1305 clock_gettime_mono(&ts2);
1306 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1308 if (timediff > audit_timeout) {
1309 smb_time_audit_log_fsp("kernel_flock", timediff, fsp);
1315 static int smb_time_audit_linux_setlease(vfs_handle_struct *handle,
1320 struct timespec ts1,ts2;
1323 clock_gettime_mono(&ts1);
1324 result = SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype);
1325 clock_gettime_mono(&ts2);
1326 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1328 if (timediff > audit_timeout) {
1329 smb_time_audit_log_fsp("linux_setlease", timediff, fsp);
1335 static bool smb_time_audit_getlock(vfs_handle_struct *handle,
1337 off_t *poffset, off_t *pcount,
1338 int *ptype, pid_t *ppid)
1341 struct timespec ts1,ts2;
1344 clock_gettime_mono(&ts1);
1345 result = SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype,
1347 clock_gettime_mono(&ts2);
1348 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1350 if (timediff > audit_timeout) {
1351 smb_time_audit_log_fsp("getlock", timediff, fsp);
1357 static int smb_time_audit_symlink(vfs_handle_struct *handle,
1358 const char *link_contents,
1359 const struct smb_filename *new_smb_fname)
1362 struct timespec ts1,ts2;
1365 clock_gettime_mono(&ts1);
1366 result = SMB_VFS_NEXT_SYMLINK(handle, link_contents, new_smb_fname);
1367 clock_gettime_mono(&ts2);
1368 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1370 if (timediff > audit_timeout) {
1371 smb_time_audit_log_fname("symlink", timediff,
1372 new_smb_fname->base_name);
1378 static int smb_time_audit_readlink(vfs_handle_struct *handle,
1379 const struct smb_filename *smb_fname,
1384 struct timespec ts1,ts2;
1387 clock_gettime_mono(&ts1);
1388 result = SMB_VFS_NEXT_READLINK(handle, smb_fname,
1390 clock_gettime_mono(&ts2);
1391 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1393 if (timediff > audit_timeout) {
1394 smb_time_audit_log_fname("readlink", timediff,
1395 smb_fname->base_name);
1401 static int smb_time_audit_link(vfs_handle_struct *handle,
1402 const struct smb_filename *old_smb_fname,
1403 const struct smb_filename *new_smb_fname)
1406 struct timespec ts1,ts2;
1409 clock_gettime_mono(&ts1);
1410 result = SMB_VFS_NEXT_LINK(handle, old_smb_fname, new_smb_fname);
1411 clock_gettime_mono(&ts2);
1412 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1414 if (timediff > audit_timeout) {
1415 smb_time_audit_log_fname("link", timediff,
1416 new_smb_fname->base_name);
1422 static int smb_time_audit_mknod(vfs_handle_struct *handle,
1423 const struct smb_filename *smb_fname,
1428 struct timespec ts1,ts2;
1431 clock_gettime_mono(&ts1);
1432 result = SMB_VFS_NEXT_MKNOD(handle, smb_fname, mode, dev);
1433 clock_gettime_mono(&ts2);
1434 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1436 if (timediff > audit_timeout) {
1437 smb_time_audit_log_smb_fname("mknod", timediff, smb_fname);
1443 static struct smb_filename *smb_time_audit_realpath(vfs_handle_struct *handle,
1445 const struct smb_filename *smb_fname)
1447 struct smb_filename *result_fname;
1448 struct timespec ts1,ts2;
1451 clock_gettime_mono(&ts1);
1452 result_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
1453 clock_gettime_mono(&ts2);
1454 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1456 if (timediff > audit_timeout) {
1457 smb_time_audit_log_fname("realpath", timediff,
1458 smb_fname->base_name);
1461 return result_fname;
1464 static int smb_time_audit_chflags(vfs_handle_struct *handle,
1465 const struct smb_filename *smb_fname,
1469 struct timespec ts1,ts2;
1472 clock_gettime_mono(&ts1);
1473 result = SMB_VFS_NEXT_CHFLAGS(handle, smb_fname, flags);
1474 clock_gettime_mono(&ts2);
1475 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1477 if (timediff > audit_timeout) {
1478 smb_time_audit_log_smb_fname("chflags", timediff, smb_fname);
1484 static struct file_id smb_time_audit_file_id_create(struct vfs_handle_struct *handle,
1485 const SMB_STRUCT_STAT *sbuf)
1487 struct file_id id_zero;
1488 struct file_id result;
1489 struct timespec ts1,ts2;
1492 ZERO_STRUCT(id_zero);
1494 clock_gettime_mono(&ts1);
1495 result = SMB_VFS_NEXT_FILE_ID_CREATE(handle, sbuf);
1496 clock_gettime_mono(&ts2);
1497 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1499 if (timediff > audit_timeout) {
1500 smb_time_audit_log("file_id_create", timediff);
1506 static NTSTATUS smb_time_audit_streaminfo(vfs_handle_struct *handle,
1507 struct files_struct *fsp,
1508 const struct smb_filename *smb_fname,
1509 TALLOC_CTX *mem_ctx,
1510 unsigned int *pnum_streams,
1511 struct stream_struct **pstreams)
1514 struct timespec ts1,ts2;
1517 clock_gettime_mono(&ts1);
1518 result = SMB_VFS_NEXT_STREAMINFO(handle, fsp, smb_fname, mem_ctx,
1519 pnum_streams, pstreams);
1520 clock_gettime_mono(&ts2);
1521 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1523 if (timediff > audit_timeout) {
1524 smb_time_audit_log_fsp("streaminfo", timediff, fsp);
1530 static int smb_time_audit_get_real_filename(struct vfs_handle_struct *handle,
1533 TALLOC_CTX *mem_ctx,
1537 struct timespec ts1,ts2;
1540 clock_gettime_mono(&ts1);
1541 result = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name, mem_ctx,
1543 clock_gettime_mono(&ts2);
1544 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1546 if (timediff > audit_timeout) {
1547 smb_time_audit_log_fname("get_real_filename", timediff, path);
1553 static const char *smb_time_audit_connectpath(vfs_handle_struct *handle,
1554 const struct smb_filename *smb_fname)
1557 struct timespec ts1,ts2;
1560 clock_gettime_mono(&ts1);
1561 result = SMB_VFS_NEXT_CONNECTPATH(handle, smb_fname);
1562 clock_gettime_mono(&ts2);
1563 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1565 if (timediff > audit_timeout) {
1566 smb_time_audit_log_fname("connectpath", timediff,
1567 smb_fname->base_name);
1573 static NTSTATUS smb_time_audit_brl_lock_windows(struct vfs_handle_struct *handle,
1574 struct byte_range_lock *br_lck,
1575 struct lock_struct *plock,
1579 struct timespec ts1,ts2;
1582 clock_gettime_mono(&ts1);
1583 result = SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle, br_lck, plock,
1585 clock_gettime_mono(&ts2);
1586 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1588 if (timediff > audit_timeout) {
1589 smb_time_audit_log_fsp("brl_lock_windows", timediff,
1596 static bool smb_time_audit_brl_unlock_windows(struct vfs_handle_struct *handle,
1597 struct messaging_context *msg_ctx,
1598 struct byte_range_lock *br_lck,
1599 const struct lock_struct *plock)
1602 struct timespec ts1,ts2;
1605 clock_gettime_mono(&ts1);
1606 result = SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle, msg_ctx, br_lck,
1608 clock_gettime_mono(&ts2);
1609 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1611 if (timediff > audit_timeout) {
1612 smb_time_audit_log_fsp("brl_unlock_windows", timediff,
1619 static bool smb_time_audit_brl_cancel_windows(struct vfs_handle_struct *handle,
1620 struct byte_range_lock *br_lck,
1621 struct lock_struct *plock)
1624 struct timespec ts1,ts2;
1627 clock_gettime_mono(&ts1);
1628 result = SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle, br_lck, plock);
1629 clock_gettime_mono(&ts2);
1630 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1632 if (timediff > audit_timeout) {
1633 smb_time_audit_log_fsp("brl_cancel_windows", timediff,
1640 static bool smb_time_audit_strict_lock_check(struct vfs_handle_struct *handle,
1641 struct files_struct *fsp,
1642 struct lock_struct *plock)
1645 struct timespec ts1,ts2;
1648 clock_gettime_mono(&ts1);
1649 result = SMB_VFS_NEXT_STRICT_LOCK_CHECK(handle, fsp, plock);
1650 clock_gettime_mono(&ts2);
1651 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1653 if (timediff > audit_timeout) {
1654 smb_time_audit_log_fsp("strict_lock_check", timediff, fsp);
1660 static NTSTATUS smb_time_audit_translate_name(struct vfs_handle_struct *handle,
1662 enum vfs_translate_direction direction,
1663 TALLOC_CTX *mem_ctx,
1667 struct timespec ts1,ts2;
1670 clock_gettime_mono(&ts1);
1671 result = SMB_VFS_NEXT_TRANSLATE_NAME(handle, name, direction, mem_ctx,
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_fname("translate_name", timediff, name);
1683 static NTSTATUS smb_time_audit_fsctl(struct vfs_handle_struct *handle,
1684 struct files_struct *fsp,
1688 const uint8_t *_in_data,
1690 uint8_t **_out_data,
1691 uint32_t max_out_len,
1695 struct timespec ts1,ts2;
1698 clock_gettime_mono(&ts1);
1699 result = SMB_VFS_NEXT_FSCTL(handle,
1709 clock_gettime_mono(&ts2);
1710 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1712 if (timediff > audit_timeout) {
1713 smb_time_audit_log_fsp("fsctl", timediff, fsp);
1719 static NTSTATUS smb_time_get_dos_attributes(struct vfs_handle_struct *handle,
1720 struct smb_filename *smb_fname,
1724 struct timespec ts1,ts2;
1727 clock_gettime_mono(&ts1);
1728 result = SMB_VFS_NEXT_GET_DOS_ATTRIBUTES(handle,
1731 clock_gettime_mono(&ts2);
1732 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1734 if (timediff > audit_timeout) {
1735 smb_time_audit_log_fname("get_dos_attributes",
1737 smb_fname->base_name);
1743 static NTSTATUS smb_time_fget_dos_attributes(struct vfs_handle_struct *handle,
1744 struct files_struct *fsp,
1748 struct timespec ts1,ts2;
1751 clock_gettime_mono(&ts1);
1752 result = SMB_VFS_NEXT_FGET_DOS_ATTRIBUTES(handle,
1755 clock_gettime_mono(&ts2);
1756 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1758 if (timediff > audit_timeout) {
1759 smb_time_audit_log_fsp("fget_dos_attributes", timediff, fsp);
1765 static NTSTATUS smb_time_set_dos_attributes(struct vfs_handle_struct *handle,
1766 const struct smb_filename *smb_fname,
1770 struct timespec ts1,ts2;
1773 clock_gettime_mono(&ts1);
1774 result = SMB_VFS_NEXT_SET_DOS_ATTRIBUTES(handle,
1777 clock_gettime_mono(&ts2);
1778 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1780 if (timediff > audit_timeout) {
1781 smb_time_audit_log_fname("set_dos_attributes",
1783 smb_fname->base_name);
1789 static NTSTATUS smb_time_fset_dos_attributes(struct vfs_handle_struct *handle,
1790 struct files_struct *fsp,
1794 struct timespec ts1,ts2;
1797 clock_gettime_mono(&ts1);
1798 result = SMB_VFS_NEXT_FSET_DOS_ATTRIBUTES(handle,
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_fsp("fset_dos_attributes", timediff, fsp);
1811 struct time_audit_offload_read_state {
1812 struct vfs_handle_struct *handle;
1813 struct timespec ts_send;
1814 DATA_BLOB token_blob;
1817 static void smb_time_audit_offload_read_done(struct tevent_req *subreq);
1819 static struct tevent_req *smb_time_audit_offload_read_send(
1820 TALLOC_CTX *mem_ctx,
1821 struct tevent_context *ev,
1822 struct vfs_handle_struct *handle,
1823 struct files_struct *fsp,
1829 struct tevent_req *req = NULL;
1830 struct tevent_req *subreq = NULL;
1831 struct time_audit_offload_read_state *state = NULL;
1833 req = tevent_req_create(mem_ctx, &state,
1834 struct time_audit_offload_read_state);
1838 state->handle = handle;
1839 clock_gettime_mono(&state->ts_send);
1841 subreq = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev,
1845 if (tevent_req_nomem(subreq, req)) {
1846 return tevent_req_post(req, ev);
1849 tevent_req_set_callback(subreq, smb_time_audit_offload_read_done, req);
1853 static void smb_time_audit_offload_read_done(struct tevent_req *subreq)
1855 struct tevent_req *req = tevent_req_callback_data(
1856 subreq, struct tevent_req);
1857 struct time_audit_offload_read_state *state = tevent_req_data(
1858 req, struct time_audit_offload_read_state);
1861 status = SMB_VFS_NEXT_OFFLOAD_READ_RECV(subreq,
1864 &state->token_blob);
1865 TALLOC_FREE(subreq);
1866 if (tevent_req_nterror(req, status)) {
1869 tevent_req_done(req);
1872 static NTSTATUS smb_time_audit_offload_read_recv(
1873 struct tevent_req *req,
1874 struct vfs_handle_struct *handle,
1875 TALLOC_CTX *mem_ctx,
1876 DATA_BLOB *_token_blob)
1878 struct time_audit_offload_read_state *state = tevent_req_data(
1879 req, struct time_audit_offload_read_state);
1880 struct timespec ts_recv;
1882 DATA_BLOB token_blob;
1885 clock_gettime_mono(&ts_recv);
1886 timediff = nsec_time_diff(&ts_recv, &state->ts_send) * 1.0e-9;
1887 if (timediff > audit_timeout) {
1888 smb_time_audit_log("offload_read", timediff);
1891 if (tevent_req_is_nterror(req, &status)) {
1892 tevent_req_received(req);
1896 token_blob = data_blob_talloc(mem_ctx,
1897 state->token_blob.data,
1898 state->token_blob.length);
1899 if (token_blob.data == NULL) {
1900 tevent_req_received(req);
1901 return NT_STATUS_NO_MEMORY;
1904 tevent_req_received(req);
1905 return NT_STATUS_OK;
1908 struct time_audit_offload_write_state {
1909 struct timespec ts_send;
1910 struct vfs_handle_struct *handle;
1913 static void smb_time_audit_offload_write_done(struct tevent_req *subreq);
1915 static struct tevent_req *smb_time_audit_offload_write_send(struct vfs_handle_struct *handle,
1916 TALLOC_CTX *mem_ctx,
1917 struct tevent_context *ev,
1920 off_t transfer_offset,
1921 struct files_struct *dest_fsp,
1925 struct tevent_req *req;
1926 struct tevent_req *subreq;
1927 struct time_audit_offload_write_state *state;
1929 req = tevent_req_create(mem_ctx, &state,
1930 struct time_audit_offload_write_state);
1935 state->handle = handle;
1936 clock_gettime_mono(&state->ts_send);
1937 subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle, state, ev,
1938 fsctl, token, transfer_offset,
1939 dest_fsp, dest_off, num);
1940 if (tevent_req_nomem(subreq, req)) {
1941 return tevent_req_post(req, ev);
1944 tevent_req_set_callback(subreq, smb_time_audit_offload_write_done, req);
1948 static void smb_time_audit_offload_write_done(struct tevent_req *subreq)
1950 struct tevent_req *req = tevent_req_callback_data(
1951 subreq, struct tevent_req);
1952 struct time_audit_offload_write_state *state = tevent_req_data(
1953 req, struct time_audit_offload_write_state);
1956 status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
1959 TALLOC_FREE(subreq);
1960 if (tevent_req_nterror(req, status)) {
1963 tevent_req_done(req);
1966 static NTSTATUS smb_time_audit_offload_write_recv(struct vfs_handle_struct *handle,
1967 struct tevent_req *req,
1970 struct time_audit_offload_write_state *state = tevent_req_data(
1971 req, struct time_audit_offload_write_state);
1972 struct timespec ts_recv;
1976 clock_gettime_mono(&ts_recv);
1977 timediff = nsec_time_diff(&ts_recv, &state->ts_send)*1.0e-9;
1978 if (timediff > audit_timeout) {
1979 smb_time_audit_log("offload_write", timediff);
1982 *copied = state->copied;
1983 if (tevent_req_is_nterror(req, &status)) {
1984 tevent_req_received(req);
1988 tevent_req_received(req);
1989 return NT_STATUS_OK;
1992 static NTSTATUS smb_time_audit_get_compression(vfs_handle_struct *handle,
1993 TALLOC_CTX *mem_ctx,
1994 struct files_struct *fsp,
1995 struct smb_filename *smb_fname,
1996 uint16_t *_compression_fmt)
1999 struct timespec ts1,ts2;
2002 clock_gettime_mono(&ts1);
2003 result = SMB_VFS_NEXT_GET_COMPRESSION(handle, mem_ctx, fsp, smb_fname,
2005 clock_gettime_mono(&ts2);
2006 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2008 if (timediff > audit_timeout) {
2010 smb_time_audit_log_fsp("get_compression",
2013 smb_time_audit_log_smb_fname("get_compression",
2014 timediff, smb_fname);
2021 static NTSTATUS smb_time_audit_set_compression(vfs_handle_struct *handle,
2022 TALLOC_CTX *mem_ctx,
2023 struct files_struct *fsp,
2024 uint16_t compression_fmt)
2027 struct timespec ts1,ts2;
2030 clock_gettime_mono(&ts1);
2031 result = SMB_VFS_NEXT_SET_COMPRESSION(handle, mem_ctx, fsp,
2033 clock_gettime_mono(&ts2);
2034 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2036 if (timediff > audit_timeout) {
2037 smb_time_audit_log_fsp("set_compression", timediff, fsp);
2043 static NTSTATUS smb_time_audit_readdir_attr(struct vfs_handle_struct *handle,
2044 const struct smb_filename *fname,
2045 TALLOC_CTX *mem_ctx,
2046 struct readdir_attr_data **pattr_data)
2049 struct timespec ts1,ts2;
2052 clock_gettime_mono(&ts1);
2053 status = SMB_VFS_NEXT_READDIR_ATTR(handle, fname, mem_ctx, pattr_data);
2054 clock_gettime_mono(&ts2);
2055 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2057 if (timediff > audit_timeout) {
2058 smb_time_audit_log_smb_fname("readdir_attr", timediff, fname);
2064 static NTSTATUS smb_time_audit_fget_nt_acl(vfs_handle_struct *handle,
2066 uint32_t security_info,
2067 TALLOC_CTX *mem_ctx,
2068 struct security_descriptor **ppdesc)
2071 struct timespec ts1,ts2;
2074 clock_gettime_mono(&ts1);
2075 result = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
2077 clock_gettime_mono(&ts2);
2078 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2080 if (timediff > audit_timeout) {
2081 smb_time_audit_log_fsp("fget_nt_acl", timediff, fsp);
2087 static NTSTATUS smb_time_audit_get_nt_acl(vfs_handle_struct *handle,
2088 const struct smb_filename *smb_fname,
2089 uint32_t security_info,
2090 TALLOC_CTX *mem_ctx,
2091 struct security_descriptor **ppdesc)
2094 struct timespec ts1,ts2;
2097 clock_gettime_mono(&ts1);
2098 result = SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info,
2100 clock_gettime_mono(&ts2);
2101 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2103 if (timediff > audit_timeout) {
2104 smb_time_audit_log_fname("get_nt_acl",
2106 smb_fname->base_name);
2112 static NTSTATUS smb_time_audit_fset_nt_acl(vfs_handle_struct *handle,
2114 uint32_t security_info_sent,
2115 const struct security_descriptor *psd)
2118 struct timespec ts1,ts2;
2121 clock_gettime_mono(&ts1);
2122 result = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent,
2124 clock_gettime_mono(&ts2);
2125 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2127 if (timediff > audit_timeout) {
2128 smb_time_audit_log_fsp("fset_nt_acl", timediff, fsp);
2134 static NTSTATUS smb_time_audit_audit_file(struct vfs_handle_struct *handle,
2135 struct smb_filename *smb_fname,
2136 struct security_acl *sacl,
2137 uint32_t access_requested,
2138 uint32_t access_denied)
2141 struct timespec ts1,ts2;
2144 clock_gettime_mono(&ts1);
2145 result = SMB_VFS_NEXT_AUDIT_FILE(handle,
2150 clock_gettime_mono(&ts2);
2151 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2153 if (timediff > audit_timeout) {
2154 smb_time_audit_log_fname("audit_file",
2156 smb_fname->base_name);
2164 static int smb_time_audit_chmod_acl(vfs_handle_struct *handle,
2165 const struct smb_filename *smb_fname,
2169 struct timespec ts1,ts2;
2172 clock_gettime_mono(&ts1);
2173 result = SMB_VFS_NEXT_CHMOD_ACL(handle, smb_fname, mode);
2174 clock_gettime_mono(&ts2);
2175 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2177 if (timediff > audit_timeout) {
2178 smb_time_audit_log_fname("chmod_acl",
2180 smb_fname->base_name);
2186 static int smb_time_audit_fchmod_acl(vfs_handle_struct *handle,
2187 files_struct *fsp, mode_t mode)
2190 struct timespec ts1,ts2;
2193 clock_gettime_mono(&ts1);
2194 result = SMB_VFS_NEXT_FCHMOD_ACL(handle, fsp, mode);
2195 clock_gettime_mono(&ts2);
2196 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2198 if (timediff > audit_timeout) {
2199 smb_time_audit_log_fsp("fchmod_acl", timediff, fsp);
2205 static SMB_ACL_T smb_time_audit_sys_acl_get_file(vfs_handle_struct *handle,
2206 const struct smb_filename *smb_fname,
2207 SMB_ACL_TYPE_T type,
2208 TALLOC_CTX *mem_ctx)
2211 struct timespec ts1,ts2;
2214 clock_gettime_mono(&ts1);
2215 result = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, smb_fname,
2217 clock_gettime_mono(&ts2);
2218 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2220 if (timediff > audit_timeout) {
2221 smb_time_audit_log_fname("sys_acl_get_file", timediff,
2222 smb_fname->base_name);
2228 static SMB_ACL_T smb_time_audit_sys_acl_get_fd(vfs_handle_struct *handle,
2230 TALLOC_CTX *mem_ctx)
2233 struct timespec ts1,ts2;
2236 clock_gettime_mono(&ts1);
2237 result = SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp, mem_ctx);
2238 clock_gettime_mono(&ts2);
2239 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2241 if (timediff > audit_timeout) {
2242 smb_time_audit_log_fsp("sys_acl_get_fd", timediff, fsp);
2249 static int smb_time_audit_sys_acl_blob_get_file(vfs_handle_struct *handle,
2250 const struct smb_filename *smb_fname,
2251 TALLOC_CTX *mem_ctx,
2252 char **blob_description,
2256 struct timespec ts1,ts2;
2259 clock_gettime_mono(&ts1);
2260 result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FILE(handle, smb_fname,
2261 mem_ctx, blob_description, blob);
2262 clock_gettime_mono(&ts2);
2263 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2265 if (timediff > audit_timeout) {
2266 smb_time_audit_log("sys_acl_blob_get_file", timediff);
2272 static int smb_time_audit_sys_acl_blob_get_fd(vfs_handle_struct *handle,
2274 TALLOC_CTX *mem_ctx,
2275 char **blob_description,
2279 struct timespec ts1,ts2;
2282 clock_gettime_mono(&ts1);
2283 result = SMB_VFS_NEXT_SYS_ACL_BLOB_GET_FD(handle, fsp, mem_ctx, blob_description, blob);
2284 clock_gettime_mono(&ts2);
2285 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2287 if (timediff > audit_timeout) {
2288 smb_time_audit_log("sys_acl_blob_get_fd", timediff);
2294 static int smb_time_audit_sys_acl_set_file(vfs_handle_struct *handle,
2295 const struct smb_filename *smb_fname,
2296 SMB_ACL_TYPE_T acltype,
2300 struct timespec ts1,ts2;
2303 clock_gettime_mono(&ts1);
2304 result = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, smb_fname, acltype,
2306 clock_gettime_mono(&ts2);
2307 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2309 if (timediff > audit_timeout) {
2310 smb_time_audit_log_fname("sys_acl_set_file", timediff,
2311 smb_fname->base_name);
2317 static int smb_time_audit_sys_acl_set_fd(vfs_handle_struct *handle,
2322 struct timespec ts1,ts2;
2325 clock_gettime_mono(&ts1);
2326 result = SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl);
2327 clock_gettime_mono(&ts2);
2328 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2330 if (timediff > audit_timeout) {
2331 smb_time_audit_log_fsp("sys_acl_set_fd", timediff, fsp);
2337 static int smb_time_audit_sys_acl_delete_def_file(vfs_handle_struct *handle,
2338 const struct smb_filename *smb_fname)
2341 struct timespec ts1,ts2;
2344 clock_gettime_mono(&ts1);
2345 result = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, smb_fname);
2346 clock_gettime_mono(&ts2);
2347 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2349 if (timediff > audit_timeout) {
2350 smb_time_audit_log_fname("sys_acl_delete_def_file", timediff,
2351 smb_fname->base_name);
2357 static ssize_t smb_time_audit_getxattr(struct vfs_handle_struct *handle,
2358 const struct smb_filename *smb_fname,
2364 struct timespec ts1,ts2;
2367 clock_gettime_mono(&ts1);
2368 result = SMB_VFS_NEXT_GETXATTR(handle, smb_fname, name, value, size);
2369 clock_gettime_mono(&ts2);
2370 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2372 if (timediff > audit_timeout) {
2373 smb_time_audit_log_fname("getxattr", timediff,
2374 smb_fname->base_name);
2380 static ssize_t smb_time_audit_fgetxattr(struct vfs_handle_struct *handle,
2381 struct files_struct *fsp,
2382 const char *name, void *value,
2386 struct timespec ts1,ts2;
2389 clock_gettime_mono(&ts1);
2390 result = SMB_VFS_NEXT_FGETXATTR(handle, fsp, name, value, size);
2391 clock_gettime_mono(&ts2);
2392 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2394 if (timediff > audit_timeout) {
2395 smb_time_audit_log_fsp("fgetxattr", timediff, fsp);
2401 static ssize_t smb_time_audit_listxattr(struct vfs_handle_struct *handle,
2402 const struct smb_filename *smb_fname,
2407 struct timespec ts1,ts2;
2410 clock_gettime_mono(&ts1);
2411 result = SMB_VFS_NEXT_LISTXATTR(handle, smb_fname, list, size);
2412 clock_gettime_mono(&ts2);
2413 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2415 if (timediff > audit_timeout) {
2416 smb_time_audit_log_fname("listxattr", timediff,
2417 smb_fname->base_name);
2423 static ssize_t smb_time_audit_flistxattr(struct vfs_handle_struct *handle,
2424 struct files_struct *fsp, char *list,
2428 struct timespec ts1,ts2;
2431 clock_gettime_mono(&ts1);
2432 result = SMB_VFS_NEXT_FLISTXATTR(handle, fsp, list, size);
2433 clock_gettime_mono(&ts2);
2434 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2436 if (timediff > audit_timeout) {
2437 smb_time_audit_log_fsp("flistxattr", timediff, fsp);
2443 static int smb_time_audit_removexattr(struct vfs_handle_struct *handle,
2444 const struct smb_filename *smb_fname,
2448 struct timespec ts1,ts2;
2451 clock_gettime_mono(&ts1);
2452 result = SMB_VFS_NEXT_REMOVEXATTR(handle, smb_fname, name);
2453 clock_gettime_mono(&ts2);
2454 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2456 if (timediff > audit_timeout) {
2457 smb_time_audit_log_fname("removexattr", timediff,
2458 smb_fname->base_name);
2464 static int smb_time_audit_fremovexattr(struct vfs_handle_struct *handle,
2465 struct files_struct *fsp,
2469 struct timespec ts1,ts2;
2472 clock_gettime_mono(&ts1);
2473 result = SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
2474 clock_gettime_mono(&ts2);
2475 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2477 if (timediff > audit_timeout) {
2478 smb_time_audit_log_fsp("fremovexattr", timediff, fsp);
2484 static int smb_time_audit_setxattr(struct vfs_handle_struct *handle,
2485 const struct smb_filename *smb_fname,
2492 struct timespec ts1,ts2;
2495 clock_gettime_mono(&ts1);
2496 result = SMB_VFS_NEXT_SETXATTR(handle, smb_fname, name, value, size,
2498 clock_gettime_mono(&ts2);
2499 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2501 if (timediff > audit_timeout) {
2502 smb_time_audit_log_fname("setxattr", timediff,
2503 smb_fname->base_name);
2509 static int smb_time_audit_fsetxattr(struct vfs_handle_struct *handle,
2510 struct files_struct *fsp, const char *name,
2511 const void *value, size_t size, int flags)
2514 struct timespec ts1,ts2;
2517 clock_gettime_mono(&ts1);
2518 result = SMB_VFS_NEXT_FSETXATTR(handle, fsp, name, value, size, flags);
2519 clock_gettime_mono(&ts2);
2520 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2522 if (timediff > audit_timeout) {
2523 smb_time_audit_log_fsp("fsetxattr", timediff, fsp);
2529 static bool smb_time_audit_aio_force(struct vfs_handle_struct *handle,
2530 struct files_struct *fsp)
2533 struct timespec ts1,ts2;
2536 clock_gettime_mono(&ts1);
2537 result = SMB_VFS_NEXT_AIO_FORCE(handle, fsp);
2538 clock_gettime_mono(&ts2);
2539 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2541 if (timediff > audit_timeout) {
2542 smb_time_audit_log_fsp("aio_force", timediff, fsp);
2548 static NTSTATUS smb_time_audit_durable_cookie(struct vfs_handle_struct *handle,
2549 struct files_struct *fsp,
2550 TALLOC_CTX *mem_ctx,
2554 struct timespec ts1,ts2;
2557 clock_gettime_mono(&ts1);
2558 result = SMB_VFS_NEXT_DURABLE_COOKIE(handle, fsp, mem_ctx, cookie);
2559 clock_gettime_mono(&ts2);
2560 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2562 if (timediff > audit_timeout) {
2563 smb_time_audit_log_fsp("durable_cookie", timediff, fsp);
2569 static NTSTATUS smb_time_audit_durable_disconnect(struct vfs_handle_struct *handle,
2570 struct files_struct *fsp,
2571 const DATA_BLOB old_cookie,
2572 TALLOC_CTX *mem_ctx,
2573 DATA_BLOB *new_cookie)
2576 struct timespec ts1,ts2;
2579 clock_gettime_mono(&ts1);
2580 result = SMB_VFS_NEXT_DURABLE_DISCONNECT(handle, fsp, old_cookie,
2581 mem_ctx, new_cookie);
2582 clock_gettime_mono(&ts2);
2583 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2585 if (timediff > audit_timeout) {
2586 smb_time_audit_log_fsp("durable_disconnect", timediff, fsp);
2592 static NTSTATUS smb_time_audit_durable_reconnect(struct vfs_handle_struct *handle,
2593 struct smb_request *smb1req,
2594 struct smbXsrv_open *op,
2595 const DATA_BLOB old_cookie,
2596 TALLOC_CTX *mem_ctx,
2597 struct files_struct **fsp,
2598 DATA_BLOB *new_cookie)
2601 struct timespec ts1,ts2;
2604 clock_gettime_mono(&ts1);
2605 result = SMB_VFS_NEXT_DURABLE_RECONNECT(handle, smb1req, op, old_cookie,
2606 mem_ctx, fsp, new_cookie);
2607 clock_gettime_mono(&ts2);
2608 timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2610 if (timediff > audit_timeout) {
2611 smb_time_audit_log("durable_reconnect", timediff);
2617 /* VFS operations */
2619 static struct vfs_fn_pointers vfs_time_audit_fns = {
2620 .connect_fn = smb_time_audit_connect,
2621 .disconnect_fn = smb_time_audit_disconnect,
2622 .disk_free_fn = smb_time_audit_disk_free,
2623 .get_quota_fn = smb_time_audit_get_quota,
2624 .set_quota_fn = smb_time_audit_set_quota,
2625 .get_shadow_copy_data_fn = smb_time_audit_get_shadow_copy_data,
2626 .statvfs_fn = smb_time_audit_statvfs,
2627 .fs_capabilities_fn = smb_time_audit_fs_capabilities,
2628 .get_dfs_referrals_fn = smb_time_audit_get_dfs_referrals,
2629 .opendir_fn = smb_time_audit_opendir,
2630 .fdopendir_fn = smb_time_audit_fdopendir,
2631 .readdir_fn = smb_time_audit_readdir,
2632 .seekdir_fn = smb_time_audit_seekdir,
2633 .telldir_fn = smb_time_audit_telldir,
2634 .rewind_dir_fn = smb_time_audit_rewinddir,
2635 .mkdir_fn = smb_time_audit_mkdir,
2636 .rmdir_fn = smb_time_audit_rmdir,
2637 .closedir_fn = smb_time_audit_closedir,
2638 .open_fn = smb_time_audit_open,
2639 .create_file_fn = smb_time_audit_create_file,
2640 .close_fn = smb_time_audit_close,
2641 .pread_fn = smb_time_audit_pread,
2642 .pread_send_fn = smb_time_audit_pread_send,
2643 .pread_recv_fn = smb_time_audit_pread_recv,
2644 .pwrite_fn = smb_time_audit_pwrite,
2645 .pwrite_send_fn = smb_time_audit_pwrite_send,
2646 .pwrite_recv_fn = smb_time_audit_pwrite_recv,
2647 .lseek_fn = smb_time_audit_lseek,
2648 .sendfile_fn = smb_time_audit_sendfile,
2649 .recvfile_fn = smb_time_audit_recvfile,
2650 .rename_fn = smb_time_audit_rename,
2651 .fsync_send_fn = smb_time_audit_fsync_send,
2652 .fsync_recv_fn = smb_time_audit_fsync_recv,
2653 .stat_fn = smb_time_audit_stat,
2654 .fstat_fn = smb_time_audit_fstat,
2655 .lstat_fn = smb_time_audit_lstat,
2656 .get_alloc_size_fn = smb_time_audit_get_alloc_size,
2657 .unlink_fn = smb_time_audit_unlink,
2658 .chmod_fn = smb_time_audit_chmod,
2659 .fchmod_fn = smb_time_audit_fchmod,
2660 .chown_fn = smb_time_audit_chown,
2661 .fchown_fn = smb_time_audit_fchown,
2662 .lchown_fn = smb_time_audit_lchown,
2663 .chdir_fn = smb_time_audit_chdir,
2664 .getwd_fn = smb_time_audit_getwd,
2665 .ntimes_fn = smb_time_audit_ntimes,
2666 .ftruncate_fn = smb_time_audit_ftruncate,
2667 .fallocate_fn = smb_time_audit_fallocate,
2668 .lock_fn = smb_time_audit_lock,
2669 .kernel_flock_fn = smb_time_audit_kernel_flock,
2670 .linux_setlease_fn = smb_time_audit_linux_setlease,
2671 .getlock_fn = smb_time_audit_getlock,
2672 .symlink_fn = smb_time_audit_symlink,
2673 .readlink_fn = smb_time_audit_readlink,
2674 .link_fn = smb_time_audit_link,
2675 .mknod_fn = smb_time_audit_mknod,
2676 .realpath_fn = smb_time_audit_realpath,
2677 .chflags_fn = smb_time_audit_chflags,
2678 .file_id_create_fn = smb_time_audit_file_id_create,
2679 .offload_read_send_fn = smb_time_audit_offload_read_send,
2680 .offload_read_recv_fn = smb_time_audit_offload_read_recv,
2681 .offload_write_send_fn = smb_time_audit_offload_write_send,
2682 .offload_write_recv_fn = smb_time_audit_offload_write_recv,
2683 .get_compression_fn = smb_time_audit_get_compression,
2684 .set_compression_fn = smb_time_audit_set_compression,
2685 .snap_check_path_fn = smb_time_audit_snap_check_path,
2686 .snap_create_fn = smb_time_audit_snap_create,
2687 .snap_delete_fn = smb_time_audit_snap_delete,
2688 .streaminfo_fn = smb_time_audit_streaminfo,
2689 .get_real_filename_fn = smb_time_audit_get_real_filename,
2690 .connectpath_fn = smb_time_audit_connectpath,
2691 .brl_lock_windows_fn = smb_time_audit_brl_lock_windows,
2692 .brl_unlock_windows_fn = smb_time_audit_brl_unlock_windows,
2693 .brl_cancel_windows_fn = smb_time_audit_brl_cancel_windows,
2694 .strict_lock_check_fn = smb_time_audit_strict_lock_check,
2695 .translate_name_fn = smb_time_audit_translate_name,
2696 .fsctl_fn = smb_time_audit_fsctl,
2697 .get_dos_attributes_fn = smb_time_get_dos_attributes,
2698 .fget_dos_attributes_fn = smb_time_fget_dos_attributes,
2699 .set_dos_attributes_fn = smb_time_set_dos_attributes,
2700 .fset_dos_attributes_fn = smb_time_fset_dos_attributes,
2701 .fget_nt_acl_fn = smb_time_audit_fget_nt_acl,
2702 .get_nt_acl_fn = smb_time_audit_get_nt_acl,
2703 .fset_nt_acl_fn = smb_time_audit_fset_nt_acl,
2704 .audit_file_fn = smb_time_audit_audit_file,
2705 .chmod_acl_fn = smb_time_audit_chmod_acl,
2706 .fchmod_acl_fn = smb_time_audit_fchmod_acl,
2707 .sys_acl_get_file_fn = smb_time_audit_sys_acl_get_file,
2708 .sys_acl_get_fd_fn = smb_time_audit_sys_acl_get_fd,
2709 .sys_acl_blob_get_file_fn = smb_time_audit_sys_acl_blob_get_file,
2710 .sys_acl_blob_get_fd_fn = smb_time_audit_sys_acl_blob_get_fd,
2711 .sys_acl_set_file_fn = smb_time_audit_sys_acl_set_file,
2712 .sys_acl_set_fd_fn = smb_time_audit_sys_acl_set_fd,
2713 .sys_acl_delete_def_file_fn = smb_time_audit_sys_acl_delete_def_file,
2714 .getxattr_fn = smb_time_audit_getxattr,
2715 .fgetxattr_fn = smb_time_audit_fgetxattr,
2716 .listxattr_fn = smb_time_audit_listxattr,
2717 .flistxattr_fn = smb_time_audit_flistxattr,
2718 .removexattr_fn = smb_time_audit_removexattr,
2719 .fremovexattr_fn = smb_time_audit_fremovexattr,
2720 .setxattr_fn = smb_time_audit_setxattr,
2721 .fsetxattr_fn = smb_time_audit_fsetxattr,
2722 .aio_force_fn = smb_time_audit_aio_force,
2723 .durable_cookie_fn = smb_time_audit_durable_cookie,
2724 .durable_disconnect_fn = smb_time_audit_durable_disconnect,
2725 .durable_reconnect_fn = smb_time_audit_durable_reconnect,
2726 .readdir_attr_fn = smb_time_audit_readdir_attr,
2731 NTSTATUS vfs_time_audit_init(TALLOC_CTX *ctx)
2733 smb_vfs_assert_all_fns(&vfs_time_audit_fns, "time_audit");
2735 audit_timeout = (double)lp_parm_int(-1, "time_audit", "timeout",
2737 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "time_audit",
2738 &vfs_time_audit_fns);