source3/modules/vfs_time_audit.c

   1 /*
   2  * Time auditing VFS module for samba.  Log time taken for VFS call to syslog
   3  * facility.
   4  *
   5  * Copyright (C) Abhidnya Chirmule <achirmul@in.ibm.com> 2009
   6  *
   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.
  11  *
  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.
  16  *
  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/>.
  19  */
  20
  21 /*
  22  * This module implements logging for time taken for all Samba VFS operations.
  23  *
  24  * vfs objects = time_audit
  25  */
  26
  27
  28 #include "includes.h"
  29 #include "smbd/smbd.h"
  30 #include "ntioctl.h"
  31
  32 #undef DBGC_CLASS
  33 #define DBGC_CLASS DBGC_VFS
  34
  35 static double audit_timeout;
  36
  37 static void smb_time_audit_log(const char *syscallname, double elapsed)
  38 {
  39         DEBUG(0, ("WARNING: System call \"%s\" took unexpectedly long "
  40                   "(%.2f seconds) -- Validate that file and storage "
  41                   "subsystems are operating normally\n", syscallname,
  42                   elapsed));
  43 }
  44
  45 static int smb_time_audit_connect(vfs_handle_struct *handle,
  46                                   const char *svc, const char *user)
  47 {
  48         int result;
  49         struct timespec ts1,ts2;
  50         double timediff;
  51
  52         if (!handle) {
  53                 return -1;
  54         }
  55
  56         clock_gettime_mono(&ts1);
  57         result = SMB_VFS_NEXT_CONNECT(handle, svc, user);
  58         clock_gettime_mono(&ts2);
  59         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
  60         if (timediff > audit_timeout) {
  61                 smb_time_audit_log("connect", timediff);
  62         }
  63         return result;
  64 }
  65
  66 static void smb_time_audit_disconnect(vfs_handle_struct *handle)
  67 {
  68         struct timespec ts1,ts2;
  69         double timediff;
  70
  71         clock_gettime_mono(&ts1);
  72         SMB_VFS_NEXT_DISCONNECT(handle);
  73         clock_gettime_mono(&ts2);
  74         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
  75
  76         if (timediff > audit_timeout) {
  77                 smb_time_audit_log("disconnect", timediff);
  78         }
  79
  80         return;
  81 }
  82
  83 static uint64_t smb_time_audit_disk_free(vfs_handle_struct *handle,
  84                                          const char *path,
  85                                          bool small_query, uint64_t *bsize,
  86                                          uint64_t *dfree, uint64_t *dsize)
  87 {
  88         uint64_t result;
  89         struct timespec ts1,ts2;
  90         double timediff;
  91
  92         clock_gettime_mono(&ts1);
  93         result = SMB_VFS_NEXT_DISK_FREE(handle, path, small_query, bsize,
  94                                         dfree, dsize);
  95         clock_gettime_mono(&ts2);
  96         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
  97
  98         /* Don't have a reasonable notion of failure here */
  99         if (timediff > audit_timeout) {
 100                 smb_time_audit_log("disk_free", timediff);
 101         }
 102
 103         return result;
 104 }
 105
 106 static int smb_time_audit_get_quota(struct vfs_handle_struct *handle,
 107                                     enum SMB_QUOTA_TYPE qtype, unid_t id,
 108                                     SMB_DISK_QUOTA *qt)
 109 {
 110         int result;
 111         struct timespec ts1,ts2;
 112         double timediff;
 113
 114         clock_gettime_mono(&ts1);
 115         result = SMB_VFS_NEXT_GET_QUOTA(handle, qtype, id, qt);
 116         clock_gettime_mono(&ts2);
 117         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 118
 119         if (timediff > audit_timeout) {
 120                 smb_time_audit_log("get_quota", timediff);
 121         }
 122         return result;
 123 }
 124
 125 static int smb_time_audit_set_quota(struct vfs_handle_struct *handle,
 126                                     enum SMB_QUOTA_TYPE qtype, unid_t id,
 127                                     SMB_DISK_QUOTA *qt)
 128 {
 129         int result;
 130         struct timespec ts1,ts2;
 131         double timediff;
 132
 133         clock_gettime_mono(&ts1);
 134         result = SMB_VFS_NEXT_SET_QUOTA(handle, qtype, id, qt);
 135         clock_gettime_mono(&ts2);
 136         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 137
 138         if (timediff > audit_timeout) {
 139                 smb_time_audit_log("set_quota", timediff);
 140         }
 141
 142         return result;
 143 }
 144
 145 static int smb_time_audit_get_shadow_copy_data(struct vfs_handle_struct *handle,
 146                                                struct files_struct *fsp,
 147                                                struct shadow_copy_data *shadow_copy_data,
 148                                                bool labels)
 149 {
 150         int result;
 151         struct timespec ts1,ts2;
 152         double timediff;
 153
 154         clock_gettime_mono(&ts1);
 155         result = SMB_VFS_NEXT_GET_SHADOW_COPY_DATA(handle, fsp,
 156                                                    shadow_copy_data, labels);
 157         clock_gettime_mono(&ts2);
 158         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 159
 160         if (timediff > audit_timeout) {
 161                 smb_time_audit_log("get_shadow_copy_data", timediff);
 162         }
 163
 164         return result;
 165 }
 166
 167 static int smb_time_audit_statvfs(struct vfs_handle_struct *handle,
 168                                   const char *path,
 169                                   struct vfs_statvfs_struct *statbuf)
 170 {
 171         int result;
 172         struct timespec ts1,ts2;
 173         double timediff;
 174
 175         clock_gettime_mono(&ts1);
 176         result = SMB_VFS_NEXT_STATVFS(handle, path, statbuf);
 177         clock_gettime_mono(&ts2);
 178         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 179
 180         if (timediff > audit_timeout) {
 181                 smb_time_audit_log("statvfs", timediff);
 182         }
 183
 184         return result;
 185 }
 186
 187 static uint32_t smb_time_audit_fs_capabilities(struct vfs_handle_struct *handle,
 188                                                enum timestamp_set_resolution *p_ts_res)
 189 {
 190         uint32_t result;
 191         struct timespec ts1,ts2;
 192         double timediff;
 193
 194         clock_gettime_mono(&ts1);
 195         result = SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res);
 196         clock_gettime_mono(&ts2);
 197         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 198
 199         if (timediff > audit_timeout) {
 200                 smb_time_audit_log("fs_capabilities", timediff);
 201         }
 202
 203         return result;
 204 }
 205
 206 static SMB_STRUCT_DIR *smb_time_audit_opendir(vfs_handle_struct *handle,
 207                                               const char *fname,
 208                                               const char *mask, uint32 attr)
 209 {
 210         SMB_STRUCT_DIR *result;
 211         struct timespec ts1,ts2;
 212         double timediff;
 213
 214         clock_gettime_mono(&ts1);
 215         result = SMB_VFS_NEXT_OPENDIR(handle, fname, mask, attr);
 216         clock_gettime_mono(&ts2);
 217         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 218
 219         if (timediff > audit_timeout) {
 220                 smb_time_audit_log("opendir", timediff);
 221         }
 222
 223         return result;
 224 }
 225
 226 static SMB_STRUCT_DIR *smb_time_audit_fdopendir(vfs_handle_struct *handle,
 227                                               files_struct *fsp,
 228                                               const char *mask, uint32 attr)
 229 {
 230         SMB_STRUCT_DIR *result;
 231         struct timespec ts1,ts2;
 232         double timediff;
 233
 234         clock_gettime_mono(&ts1);
 235         result = SMB_VFS_NEXT_FDOPENDIR(handle, fsp, mask, attr);
 236         clock_gettime_mono(&ts2);
 237         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 238
 239         if (timediff > audit_timeout) {
 240                 smb_time_audit_log("fdopendir", timediff);
 241         }
 242
 243         return result;
 244 }
 245
 246 static SMB_STRUCT_DIRENT *smb_time_audit_readdir(vfs_handle_struct *handle,
 247                                                  SMB_STRUCT_DIR *dirp,
 248                                                  SMB_STRUCT_STAT *sbuf)
 249 {
 250         SMB_STRUCT_DIRENT *result;
 251         struct timespec ts1,ts2;
 252         double timediff;
 253
 254         clock_gettime_mono(&ts1);
 255         result = SMB_VFS_NEXT_READDIR(handle, dirp, sbuf);
 256         clock_gettime_mono(&ts2);
 257         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 258
 259         if (timediff > audit_timeout) {
 260                 smb_time_audit_log("readdir", timediff);
 261         }
 262
 263         return result;
 264 }
 265
 266 static void smb_time_audit_seekdir(vfs_handle_struct *handle,
 267                                    SMB_STRUCT_DIR *dirp, long offset)
 268 {
 269         struct timespec ts1,ts2;
 270         double timediff;
 271
 272         clock_gettime_mono(&ts1);
 273         SMB_VFS_NEXT_SEEKDIR(handle, dirp, offset);
 274         clock_gettime_mono(&ts2);
 275         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 276
 277         if (timediff > audit_timeout) {
 278                 smb_time_audit_log("seekdir", timediff);
 279         }
 280
 281         return;
 282 }
 283
 284 static long smb_time_audit_telldir(vfs_handle_struct *handle,
 285                                    SMB_STRUCT_DIR *dirp)
 286 {
 287         long result;
 288         struct timespec ts1,ts2;
 289         double timediff;
 290
 291         clock_gettime_mono(&ts1);
 292         result = SMB_VFS_NEXT_TELLDIR(handle, dirp);
 293         clock_gettime_mono(&ts2);
 294         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 295
 296         if (timediff > audit_timeout) {
 297                 smb_time_audit_log("telldir", timediff);
 298         }
 299
 300         return result;
 301 }
 302
 303 static void smb_time_audit_rewinddir(vfs_handle_struct *handle,
 304                                      SMB_STRUCT_DIR *dirp)
 305 {
 306         struct timespec ts1,ts2;
 307         double timediff;
 308
 309         clock_gettime_mono(&ts1);
 310         SMB_VFS_NEXT_REWINDDIR(handle, dirp);
 311         clock_gettime_mono(&ts2);
 312         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 313
 314         if (timediff > audit_timeout) {
 315                 smb_time_audit_log("rewinddir", timediff);
 316         }
 317
 318         return;
 319 }
 320
 321 static int smb_time_audit_mkdir(vfs_handle_struct *handle,
 322                                 const char *path, mode_t mode)
 323 {
 324         int result;
 325         struct timespec ts1,ts2;
 326         double timediff;
 327
 328         clock_gettime_mono(&ts1);
 329         result = SMB_VFS_NEXT_MKDIR(handle, path, mode);
 330         clock_gettime_mono(&ts2);
 331         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 332
 333         if (timediff > audit_timeout) {
 334                 smb_time_audit_log("mkdir", timediff);
 335         }
 336
 337         return result;
 338 }
 339
 340 static int smb_time_audit_rmdir(vfs_handle_struct *handle,
 341                                 const char *path)
 342 {
 343         int result;
 344         struct timespec ts1,ts2;
 345         double timediff;
 346
 347         clock_gettime_mono(&ts1);
 348         result = SMB_VFS_NEXT_RMDIR(handle, path);
 349         clock_gettime_mono(&ts2);
 350         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 351
 352         if (timediff > audit_timeout) {
 353                 smb_time_audit_log("rmdir", timediff);
 354         }
 355
 356         return result;
 357 }
 358
 359 static int smb_time_audit_closedir(vfs_handle_struct *handle,
 360                                    SMB_STRUCT_DIR *dirp)
 361 {
 362         int result;
 363         struct timespec ts1,ts2;
 364         double timediff;
 365
 366         clock_gettime_mono(&ts1);
 367         result = SMB_VFS_NEXT_CLOSEDIR(handle, dirp);
 368         clock_gettime_mono(&ts2);
 369         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 370
 371         if (timediff > audit_timeout) {
 372                 smb_time_audit_log("closedir", timediff);
 373         }
 374
 375         return result;
 376 }
 377
 378 static void smb_time_audit_init_search_op(vfs_handle_struct *handle,
 379                                           SMB_STRUCT_DIR *dirp)
 380 {
 381         struct timespec ts1,ts2;
 382         double timediff;
 383
 384         clock_gettime_mono(&ts1);
 385         SMB_VFS_NEXT_INIT_SEARCH_OP(handle, dirp);
 386         clock_gettime_mono(&ts2);
 387         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 388
 389         if (timediff > audit_timeout) {
 390                 smb_time_audit_log("init_search_op", timediff);
 391         }
 392         return;
 393 }
 394
 395 static int smb_time_audit_open(vfs_handle_struct *handle,
 396                                struct smb_filename *fname,
 397                                files_struct *fsp,
 398                                int flags, mode_t mode)
 399 {
 400         int result;
 401         struct timespec ts1,ts2;
 402         double timediff;
 403
 404         clock_gettime_mono(&ts1);
 405         result = SMB_VFS_NEXT_OPEN(handle, fname, fsp, flags, mode);
 406         clock_gettime_mono(&ts2);
 407         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 408
 409         if (timediff > audit_timeout) {
 410                 smb_time_audit_log("open", timediff);
 411         }
 412
 413         return result;
 414 }
 415
 416 static NTSTATUS smb_time_audit_create_file(vfs_handle_struct *handle,
 417                                            struct smb_request *req,
 418                                            uint16_t root_dir_fid,
 419                                            struct smb_filename *fname,
 420                                            uint32_t access_mask,
 421                                            uint32_t share_access,
 422                                            uint32_t create_disposition,
 423                                            uint32_t create_options,
 424                                            uint32_t file_attributes,
 425                                            uint32_t oplock_request,
 426                                            uint64_t allocation_size,
 427                                            uint32_t private_flags,
 428                                            struct security_descriptor *sd,
 429                                            struct ea_list *ea_list,
 430                                            files_struct **result_fsp,
 431                                            int *pinfo)
 432 {
 433         NTSTATUS result;
 434         struct timespec ts1,ts2;
 435         double timediff;
 436
 437         clock_gettime_mono(&ts1);
 438         result = SMB_VFS_NEXT_CREATE_FILE(
 439                 handle,                                 /* handle */
 440                 req,                                    /* req */
 441                 root_dir_fid,                           /* root_dir_fid */
 442                 fname,                                  /* fname */
 443                 access_mask,                            /* access_mask */
 444                 share_access,                           /* share_access */
 445                 create_disposition,                     /* create_disposition*/
 446                 create_options,                         /* create_options */
 447                 file_attributes,                        /* file_attributes */
 448                 oplock_request,                         /* oplock_request */
 449                 allocation_size,                        /* allocation_size */
 450                 private_flags,
 451                 sd,                                     /* sd */
 452                 ea_list,                                /* ea_list */
 453                 result_fsp,                             /* result */
 454                 pinfo);
 455         clock_gettime_mono(&ts2);
 456         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 457
 458         if (timediff > audit_timeout) {
 459                 smb_time_audit_log("create_file", timediff);
 460         }
 461
 462         return result;
 463 }
 464
 465 static int smb_time_audit_close(vfs_handle_struct *handle, files_struct *fsp)
 466 {
 467         int result;
 468         struct timespec ts1,ts2;
 469         double timediff;
 470
 471         clock_gettime_mono(&ts1);
 472         result = SMB_VFS_NEXT_CLOSE(handle, fsp);
 473         clock_gettime_mono(&ts2);
 474         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 475
 476         if (timediff > audit_timeout) {
 477                 smb_time_audit_log("close", timediff);
 478         }
 479
 480         return result;
 481 }
 482
 483 static ssize_t smb_time_audit_read(vfs_handle_struct *handle,
 484                                    files_struct *fsp, void *data, size_t n)
 485 {
 486         ssize_t result;
 487         struct timespec ts1,ts2;
 488         double timediff;
 489
 490         clock_gettime_mono(&ts1);
 491         result = SMB_VFS_NEXT_READ(handle, fsp, data, n);
 492         clock_gettime_mono(&ts2);
 493         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 494
 495         if (timediff > audit_timeout) {
 496                 smb_time_audit_log("read", timediff);
 497         }
 498
 499         return result;
 500 }
 501
 502 static ssize_t smb_time_audit_pread(vfs_handle_struct *handle,
 503                                     files_struct *fsp,
 504                                     void *data, size_t n, SMB_OFF_T offset)
 505 {
 506         ssize_t result;
 507         struct timespec ts1,ts2;
 508         double timediff;
 509
 510         clock_gettime_mono(&ts1);
 511         result = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
 512         clock_gettime_mono(&ts2);
 513         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 514
 515         if (timediff > audit_timeout) {
 516                 smb_time_audit_log("pread", timediff);
 517         }
 518
 519         return result;
 520 }
 521
 522 static ssize_t smb_time_audit_write(vfs_handle_struct *handle,
 523                                     files_struct *fsp,
 524                                     const void *data, size_t n)
 525 {
 526         ssize_t result;
 527         struct timespec ts1,ts2;
 528         double timediff;
 529
 530         clock_gettime_mono(&ts1);
 531         result = SMB_VFS_NEXT_WRITE(handle, fsp, data, n);
 532         clock_gettime_mono(&ts2);
 533         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 534
 535         if (timediff > audit_timeout) {
 536                 smb_time_audit_log("write", timediff);
 537         }
 538
 539         return result;
 540 }
 541
 542 static ssize_t smb_time_audit_pwrite(vfs_handle_struct *handle,
 543                                      files_struct *fsp,
 544                                      const void *data, size_t n,
 545                                      SMB_OFF_T offset)
 546 {
 547         ssize_t result;
 548         struct timespec ts1,ts2;
 549         double timediff;
 550
 551         clock_gettime_mono(&ts1);
 552         result = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
 553         clock_gettime_mono(&ts2);
 554         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 555
 556         if (timediff > audit_timeout) {
 557                 smb_time_audit_log("pwrite", timediff);
 558         }
 559
 560         return result;
 561 }
 562
 563 static SMB_OFF_T smb_time_audit_lseek(vfs_handle_struct *handle,
 564                                       files_struct *fsp,
 565                                       SMB_OFF_T offset, int whence)
 566 {
 567         SMB_OFF_T result;
 568         struct timespec ts1,ts2;
 569         double timediff;
 570
 571         clock_gettime_mono(&ts1);
 572         result = SMB_VFS_NEXT_LSEEK(handle, fsp, offset, whence);
 573         clock_gettime_mono(&ts2);
 574         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 575
 576         if (timediff > audit_timeout) {
 577                 smb_time_audit_log("lseek", timediff);
 578         }
 579
 580         return result;
 581 }
 582
 583 static ssize_t smb_time_audit_sendfile(vfs_handle_struct *handle, int tofd,
 584                                        files_struct *fromfsp,
 585                                        const DATA_BLOB *hdr, SMB_OFF_T offset,
 586                                        size_t n)
 587 {
 588         ssize_t result;
 589         struct timespec ts1,ts2;
 590         double timediff;
 591
 592         clock_gettime_mono(&ts1);
 593         result = SMB_VFS_NEXT_SENDFILE(handle, tofd, fromfsp, hdr, offset, n);
 594         clock_gettime_mono(&ts2);
 595         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 596
 597         if (timediff > audit_timeout) {
 598                 smb_time_audit_log("sendfile", timediff);
 599         }
 600
 601         return result;
 602 }
 603
 604 static ssize_t smb_time_audit_recvfile(vfs_handle_struct *handle, int fromfd,
 605                                        files_struct *tofsp,
 606                                        SMB_OFF_T offset,
 607                                        size_t n)
 608 {
 609         ssize_t result;
 610         struct timespec ts1,ts2;
 611         double timediff;
 612
 613         clock_gettime_mono(&ts1);
 614         result = SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, n);
 615         clock_gettime_mono(&ts2);
 616         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 617
 618         if (timediff > audit_timeout) {
 619                 smb_time_audit_log("recvfile", timediff);
 620         }
 621
 622         return result;
 623 }
 624
 625 static int smb_time_audit_rename(vfs_handle_struct *handle,
 626                                  const struct smb_filename *oldname,
 627                                  const struct smb_filename *newname)
 628 {
 629         int result;
 630         struct timespec ts1,ts2;
 631         double timediff;
 632
 633         clock_gettime_mono(&ts1);
 634         result = SMB_VFS_NEXT_RENAME(handle, oldname, newname);
 635         clock_gettime_mono(&ts2);
 636         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 637
 638         if (timediff > audit_timeout) {
 639                 smb_time_audit_log("rename", timediff);
 640         }
 641
 642         return result;
 643 }
 644
 645 static int smb_time_audit_fsync(vfs_handle_struct *handle, files_struct *fsp)
 646 {
 647         int result;
 648         struct timespec ts1,ts2;
 649         double timediff;
 650
 651         clock_gettime_mono(&ts1);
 652         result = SMB_VFS_NEXT_FSYNC(handle, fsp);
 653         clock_gettime_mono(&ts2);
 654         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 655
 656         if (timediff > audit_timeout) {
 657                 smb_time_audit_log("fsync", timediff);
 658         }
 659
 660         return result;
 661 }
 662
 663 static int smb_time_audit_stat(vfs_handle_struct *handle,
 664                                struct smb_filename *fname)
 665 {
 666         int result;
 667         struct timespec ts1,ts2;
 668         double timediff;
 669
 670         clock_gettime_mono(&ts1);
 671         result = SMB_VFS_NEXT_STAT(handle, fname);
 672         clock_gettime_mono(&ts2);
 673         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 674
 675         if (timediff > audit_timeout) {
 676                 smb_time_audit_log("stat", timediff);
 677         }
 678
 679         return result;
 680 }
 681
 682 static int smb_time_audit_fstat(vfs_handle_struct *handle, files_struct *fsp,
 683                                 SMB_STRUCT_STAT *sbuf)
 684 {
 685         int result;
 686         struct timespec ts1,ts2;
 687         double timediff;
 688
 689         clock_gettime_mono(&ts1);
 690         result = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
 691         clock_gettime_mono(&ts2);
 692         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 693
 694         if (timediff > audit_timeout) {
 695                 smb_time_audit_log("fstat", timediff);
 696         }
 697
 698         return result;
 699 }
 700
 701 static int smb_time_audit_lstat(vfs_handle_struct *handle,
 702                                 struct smb_filename *path)
 703 {
 704         int result;
 705         struct timespec ts1,ts2;
 706         double timediff;
 707
 708         clock_gettime_mono(&ts1);
 709         result = SMB_VFS_NEXT_LSTAT(handle, path);
 710         clock_gettime_mono(&ts2);
 711         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 712
 713         if (timediff > audit_timeout) {
 714                 smb_time_audit_log("lstat", timediff);
 715         }
 716
 717         return result;
 718 }
 719
 720 static uint64_t smb_time_audit_get_alloc_size(vfs_handle_struct *handle,
 721                                               files_struct *fsp,
 722                                               const SMB_STRUCT_STAT *sbuf)
 723 {
 724         uint64_t result;
 725         struct timespec ts1,ts2;
 726         double timediff;
 727
 728         clock_gettime_mono(&ts1);
 729         result = SMB_VFS_NEXT_GET_ALLOC_SIZE(handle, fsp, sbuf);
 730         clock_gettime_mono(&ts2);
 731         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 732
 733         if (timediff > audit_timeout) {
 734                 smb_time_audit_log("get_alloc_size", timediff);
 735         }
 736
 737         return result;
 738 }
 739
 740 static int smb_time_audit_unlink(vfs_handle_struct *handle,
 741                                  const struct smb_filename *path)
 742 {
 743         int result;
 744         struct timespec ts1,ts2;
 745         double timediff;
 746
 747         clock_gettime_mono(&ts1);
 748         result = SMB_VFS_NEXT_UNLINK(handle, path);
 749         clock_gettime_mono(&ts2);
 750         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 751
 752         if (timediff > audit_timeout) {
 753                 smb_time_audit_log("unlink", timediff);
 754         }
 755
 756         return result;
 757 }
 758
 759 static int smb_time_audit_chmod(vfs_handle_struct *handle,
 760                                 const char *path, mode_t mode)
 761 {
 762         int result;
 763         struct timespec ts1,ts2;
 764         double timediff;
 765
 766         clock_gettime_mono(&ts1);
 767         result = SMB_VFS_NEXT_CHMOD(handle, path, mode);
 768         clock_gettime_mono(&ts2);
 769         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 770
 771         if (timediff > audit_timeout) {
 772                 smb_time_audit_log("chmod", timediff);
 773         }
 774
 775         return result;
 776 }
 777
 778 static int smb_time_audit_fchmod(vfs_handle_struct *handle, files_struct *fsp,
 779                                  mode_t mode)
 780 {
 781         int result;
 782         struct timespec ts1,ts2;
 783         double timediff;
 784
 785         clock_gettime_mono(&ts1);
 786         result = SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
 787         clock_gettime_mono(&ts2);
 788         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 789
 790         if (timediff > audit_timeout) {
 791                 smb_time_audit_log("fchmod", timediff);
 792         }
 793
 794         return result;
 795 }
 796
 797 static int smb_time_audit_chown(vfs_handle_struct *handle,
 798                                 const char *path, uid_t uid, gid_t gid)
 799 {
 800         int result;
 801         struct timespec ts1,ts2;
 802         double timediff;
 803
 804         clock_gettime_mono(&ts1);
 805         result = SMB_VFS_NEXT_CHOWN(handle, path, uid, gid);
 806         clock_gettime_mono(&ts2);
 807         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 808
 809         if (timediff > audit_timeout) {
 810                 smb_time_audit_log("chown", timediff);
 811         }
 812
 813         return result;
 814 }
 815
 816 static int smb_time_audit_fchown(vfs_handle_struct *handle, files_struct *fsp,
 817                                  uid_t uid, gid_t gid)
 818 {
 819         int result;
 820         struct timespec ts1,ts2;
 821         double timediff;
 822
 823         clock_gettime_mono(&ts1);
 824         result = SMB_VFS_NEXT_FCHOWN(handle, fsp, uid, gid);
 825         clock_gettime_mono(&ts2);
 826         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 827
 828         if (timediff > audit_timeout) {
 829                 smb_time_audit_log("fchown", timediff);
 830         }
 831
 832         return result;
 833 }
 834
 835 static int smb_time_audit_lchown(vfs_handle_struct *handle,
 836                                  const char *path, uid_t uid, gid_t gid)
 837 {
 838         int result;
 839         struct timespec ts1,ts2;
 840         double timediff;
 841
 842         clock_gettime_mono(&ts1);
 843         result = SMB_VFS_NEXT_LCHOWN(handle, path, uid, gid);
 844         clock_gettime_mono(&ts2);
 845         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 846
 847         if (timediff > audit_timeout) {
 848                 smb_time_audit_log("lchown", timediff);
 849         }
 850
 851         return result;
 852 }
 853
 854 static int smb_time_audit_chdir(vfs_handle_struct *handle, const char *path)
 855 {
 856         int result;
 857         struct timespec ts1,ts2;
 858         double timediff;
 859
 860         clock_gettime_mono(&ts1);
 861         result = SMB_VFS_NEXT_CHDIR(handle, path);
 862         clock_gettime_mono(&ts2);
 863         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 864
 865         if (timediff > audit_timeout) {
 866                 smb_time_audit_log("chdir", timediff);
 867         }
 868
 869         return result;
 870 }
 871
 872 static char *smb_time_audit_getwd(vfs_handle_struct *handle)
 873 {
 874         char *result;
 875         struct timespec ts1,ts2;
 876         double timediff;
 877
 878         clock_gettime_mono(&ts1);
 879         result = SMB_VFS_NEXT_GETWD(handle);
 880         clock_gettime_mono(&ts2);
 881         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 882
 883         if (timediff > audit_timeout) {
 884                 smb_time_audit_log("getwd", timediff);
 885         }
 886
 887         return result;
 888 }
 889
 890 static int smb_time_audit_ntimes(vfs_handle_struct *handle,
 891                                  const struct smb_filename *path,
 892                                  struct smb_file_time *ft)
 893 {
 894         int result;
 895         struct timespec ts1,ts2;
 896         double timediff;
 897
 898         clock_gettime_mono(&ts1);
 899         result = SMB_VFS_NEXT_NTIMES(handle, path, ft);
 900         clock_gettime_mono(&ts2);
 901         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 902
 903         if (timediff > audit_timeout) {
 904                 smb_time_audit_log("ntimes", timediff);
 905         }
 906
 907         return result;
 908 }
 909
 910 static int smb_time_audit_ftruncate(vfs_handle_struct *handle,
 911                                     files_struct *fsp,
 912                                     SMB_OFF_T len)
 913 {
 914         int result;
 915         struct timespec ts1,ts2;
 916         double timediff;
 917
 918         clock_gettime_mono(&ts1);
 919         result = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
 920         clock_gettime_mono(&ts2);
 921         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 922
 923         if (timediff > audit_timeout) {
 924                 smb_time_audit_log("ftruncate", timediff);
 925         }
 926
 927         return result;
 928 }
 929
 930 static int smb_time_audit_fallocate(vfs_handle_struct *handle,
 931                                     files_struct *fsp,
 932                                     enum vfs_fallocate_mode mode,
 933                                     SMB_OFF_T offset,
 934                                     SMB_OFF_T len)
 935 {
 936         int result;
 937         struct timespec ts1,ts2;
 938         double timediff;
 939
 940         clock_gettime_mono(&ts1);
 941         result = SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
 942         clock_gettime_mono(&ts2);
 943         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 944
 945         if (timediff > audit_timeout) {
 946                 smb_time_audit_log("fallocate", timediff);
 947         }
 948
 949         return result;
 950 }
 951
 952 static bool smb_time_audit_lock(vfs_handle_struct *handle, files_struct *fsp,
 953                                 int op, SMB_OFF_T offset, SMB_OFF_T count,
 954                                 int type)
 955 {
 956         bool result;
 957         struct timespec ts1,ts2;
 958         double timediff;
 959
 960         clock_gettime_mono(&ts1);
 961         result = SMB_VFS_NEXT_LOCK(handle, fsp, op, offset, count, type);
 962         clock_gettime_mono(&ts2);
 963         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 964
 965         if (timediff > audit_timeout) {
 966                 smb_time_audit_log("lock", timediff);
 967         }
 968
 969         return result;
 970 }
 971
 972 static int smb_time_audit_kernel_flock(struct vfs_handle_struct *handle,
 973                                        struct files_struct *fsp,
 974                                        uint32 share_mode, uint32 access_mask)
 975 {
 976         int result;
 977         struct timespec ts1,ts2;
 978         double timediff;
 979
 980         clock_gettime_mono(&ts1);
 981         result = SMB_VFS_NEXT_KERNEL_FLOCK(handle, fsp, share_mode,
 982                                            access_mask);
 983         clock_gettime_mono(&ts2);
 984         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
 985
 986         if (timediff > audit_timeout) {
 987                 smb_time_audit_log("kernel_flock", timediff);
 988         }
 989
 990         return result;
 991 }
 992
 993 static int smb_time_audit_linux_setlease(vfs_handle_struct *handle,
 994                                          files_struct *fsp,
 995                                          int leasetype)
 996 {
 997         int result;
 998         struct timespec ts1,ts2;
 999         double timediff;
1000
1001         clock_gettime_mono(&ts1);
1002         result = SMB_VFS_NEXT_LINUX_SETLEASE(handle, fsp, leasetype);
1003         clock_gettime_mono(&ts2);
1004         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1005
1006         if (timediff > audit_timeout) {
1007                 smb_time_audit_log("linux_setlease", timediff);
1008         }
1009
1010         return result;
1011 }
1012
1013 static bool smb_time_audit_getlock(vfs_handle_struct *handle,
1014                                    files_struct *fsp,
1015                                    SMB_OFF_T *poffset, SMB_OFF_T *pcount,
1016                                    int *ptype, pid_t *ppid)
1017 {
1018         bool result;
1019         struct timespec ts1,ts2;
1020         double timediff;
1021
1022         clock_gettime_mono(&ts1);
1023         result = SMB_VFS_NEXT_GETLOCK(handle, fsp, poffset, pcount, ptype,
1024                                       ppid);
1025         clock_gettime_mono(&ts2);
1026         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1027
1028         if (timediff > audit_timeout) {
1029                 smb_time_audit_log("getlock", timediff);
1030         }
1031
1032         return result;
1033 }
1034
1035 static int smb_time_audit_symlink(vfs_handle_struct *handle,
1036                                   const char *oldpath, const char *newpath)
1037 {
1038         int result;
1039         struct timespec ts1,ts2;
1040         double timediff;
1041
1042         clock_gettime_mono(&ts1);
1043         result = SMB_VFS_NEXT_SYMLINK(handle, oldpath, newpath);
1044         clock_gettime_mono(&ts2);
1045         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1046
1047         if (timediff > audit_timeout) {
1048                 smb_time_audit_log("symlink", timediff);
1049         }
1050
1051         return result;
1052 }
1053
1054 static int smb_time_audit_readlink(vfs_handle_struct *handle,
1055                           const char *path, char *buf, size_t bufsiz)
1056 {
1057         int result;
1058         struct timespec ts1,ts2;
1059         double timediff;
1060
1061         clock_gettime_mono(&ts1);
1062         result = SMB_VFS_NEXT_READLINK(handle, path, buf, bufsiz);
1063         clock_gettime_mono(&ts2);
1064         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1065
1066         if (timediff > audit_timeout) {
1067                 smb_time_audit_log("readlink", timediff);
1068         }
1069
1070         return result;
1071 }
1072
1073 static int smb_time_audit_link(vfs_handle_struct *handle,
1074                                const char *oldpath, const char *newpath)
1075 {
1076         int result;
1077         struct timespec ts1,ts2;
1078         double timediff;
1079
1080         clock_gettime_mono(&ts1);
1081         result = SMB_VFS_NEXT_LINK(handle, oldpath, newpath);
1082         clock_gettime_mono(&ts2);
1083         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1084
1085         if (timediff > audit_timeout) {
1086                 smb_time_audit_log("link", timediff);
1087         }
1088
1089         return result;
1090 }
1091
1092 static int smb_time_audit_mknod(vfs_handle_struct *handle,
1093                                 const char *pathname, mode_t mode,
1094                                 SMB_DEV_T dev)
1095 {
1096         int result;
1097         struct timespec ts1,ts2;
1098         double timediff;
1099
1100         clock_gettime_mono(&ts1);
1101         result = SMB_VFS_NEXT_MKNOD(handle, pathname, mode, dev);
1102         clock_gettime_mono(&ts2);
1103         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1104
1105         if (timediff > audit_timeout) {
1106                 smb_time_audit_log("mknod", timediff);
1107         }
1108
1109         return result;
1110 }
1111
1112 static char *smb_time_audit_realpath(vfs_handle_struct *handle,
1113                                      const char *path)
1114 {
1115         char *result;
1116         struct timespec ts1,ts2;
1117         double timediff;
1118
1119         clock_gettime_mono(&ts1);
1120         result = SMB_VFS_NEXT_REALPATH(handle, path);
1121         clock_gettime_mono(&ts2);
1122         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1123
1124         if (timediff > audit_timeout) {
1125                 smb_time_audit_log("realpath", timediff);
1126         }
1127
1128         return result;
1129 }
1130
1131 static NTSTATUS smb_time_audit_notify_watch(struct vfs_handle_struct *handle,
1132                         struct sys_notify_context *ctx,
1133                         struct notify_entry *e,
1134                         const char *path,
1135                         void (*callback)(struct sys_notify_context *ctx,
1136                                         void *private_data,
1137                                         struct notify_event *ev),
1138                         void *private_data, void *handle_p)
1139 {
1140         NTSTATUS result;
1141         struct timespec ts1,ts2;
1142         double timediff;
1143
1144         clock_gettime_mono(&ts1);
1145         result = SMB_VFS_NEXT_NOTIFY_WATCH(handle, ctx, e, path, callback,
1146                                            private_data, handle_p);
1147         clock_gettime_mono(&ts2);
1148         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1149
1150         if (timediff > audit_timeout) {
1151                 smb_time_audit_log("notify_watch", timediff);
1152         }
1153
1154         return result;
1155 }
1156
1157 static int smb_time_audit_chflags(vfs_handle_struct *handle,
1158                                   const char *path, unsigned int flags)
1159 {
1160         int result;
1161         struct timespec ts1,ts2;
1162         double timediff;
1163
1164         clock_gettime_mono(&ts1);
1165         result = SMB_VFS_NEXT_CHFLAGS(handle, path, flags);
1166         clock_gettime_mono(&ts2);
1167         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1168
1169         if (timediff > audit_timeout) {
1170                 smb_time_audit_log("chflags", timediff);
1171         }
1172
1173         return result;
1174 }
1175
1176 static struct file_id smb_time_audit_file_id_create(struct vfs_handle_struct *handle,
1177                                                     const SMB_STRUCT_STAT *sbuf)
1178 {
1179         struct file_id id_zero;
1180         struct file_id result;
1181         struct timespec ts1,ts2;
1182         double timediff;
1183
1184         ZERO_STRUCT(id_zero);
1185
1186         clock_gettime_mono(&ts1);
1187         result = SMB_VFS_NEXT_FILE_ID_CREATE(handle, sbuf);
1188         clock_gettime_mono(&ts2);
1189         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1190
1191         if (timediff > audit_timeout) {
1192                 smb_time_audit_log("file_id_create", timediff);
1193         }
1194
1195         return result;
1196 }
1197
1198 static NTSTATUS smb_time_audit_streaminfo(vfs_handle_struct *handle,
1199                                           struct files_struct *fsp,
1200                                           const char *fname,
1201                                           TALLOC_CTX *mem_ctx,
1202                                           unsigned int *pnum_streams,
1203                                           struct stream_struct **pstreams)
1204 {
1205         NTSTATUS result;
1206         struct timespec ts1,ts2;
1207         double timediff;
1208
1209         clock_gettime_mono(&ts1);
1210         result = SMB_VFS_NEXT_STREAMINFO(handle, fsp, fname, mem_ctx,
1211                                          pnum_streams, pstreams);
1212         clock_gettime_mono(&ts2);
1213         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1214
1215         if (timediff > audit_timeout) {
1216                 smb_time_audit_log("streaminfo", timediff);
1217         }
1218
1219         return result;
1220 }
1221
1222 static int smb_time_audit_get_real_filename(struct vfs_handle_struct *handle,
1223                                             const char *path,
1224                                             const char *name,
1225                                             TALLOC_CTX *mem_ctx,
1226                                             char **found_name)
1227 {
1228         int result;
1229         struct timespec ts1,ts2;
1230         double timediff;
1231
1232         clock_gettime_mono(&ts1);
1233         result = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name, mem_ctx,
1234                                                 found_name);
1235         clock_gettime_mono(&ts2);
1236         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1237
1238         if (timediff > audit_timeout) {
1239                 smb_time_audit_log("get_real_filename", timediff);
1240         }
1241
1242         return result;
1243 }
1244
1245 static const char *smb_time_audit_connectpath(vfs_handle_struct *handle,
1246                                               const char *fname)
1247 {
1248         const char *result;
1249         struct timespec ts1,ts2;
1250         double timediff;
1251
1252         clock_gettime_mono(&ts1);
1253         result = SMB_VFS_NEXT_CONNECTPATH(handle, fname);
1254         clock_gettime_mono(&ts2);
1255         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1256
1257         if (timediff > audit_timeout) {
1258                 smb_time_audit_log("connectpath", timediff);
1259         }
1260
1261         return result;
1262 }
1263
1264 static NTSTATUS smb_time_audit_brl_lock_windows(struct vfs_handle_struct *handle,
1265                                                 struct byte_range_lock *br_lck,
1266                                                 struct lock_struct *plock,
1267                                                 bool blocking_lock,
1268                                                 struct blocking_lock_record *blr)
1269 {
1270         NTSTATUS result;
1271         struct timespec ts1,ts2;
1272         double timediff;
1273
1274         clock_gettime_mono(&ts1);
1275         result = SMB_VFS_NEXT_BRL_LOCK_WINDOWS(handle, br_lck, plock,
1276                                                blocking_lock, blr);
1277         clock_gettime_mono(&ts2);
1278         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1279
1280         if (timediff > audit_timeout) {
1281                 smb_time_audit_log("brl_lock_windows", timediff);
1282         }
1283
1284         return result;
1285 }
1286
1287 static bool smb_time_audit_brl_unlock_windows(struct vfs_handle_struct *handle,
1288                                               struct messaging_context *msg_ctx,
1289                                               struct byte_range_lock *br_lck,
1290                                               const struct lock_struct *plock)
1291 {
1292         bool result;
1293         struct timespec ts1,ts2;
1294         double timediff;
1295
1296         clock_gettime_mono(&ts1);
1297         result = SMB_VFS_NEXT_BRL_UNLOCK_WINDOWS(handle, msg_ctx, br_lck,
1298                                                  plock);
1299         clock_gettime_mono(&ts2);
1300         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1301
1302         if (timediff > audit_timeout) {
1303                 smb_time_audit_log("brl_unlock_windows", timediff);
1304         }
1305
1306         return result;
1307 }
1308
1309 static bool smb_time_audit_brl_cancel_windows(struct vfs_handle_struct *handle,
1310                                               struct byte_range_lock *br_lck,
1311                                               struct lock_struct *plock,
1312                                               struct blocking_lock_record *blr)
1313 {
1314         bool result;
1315         struct timespec ts1,ts2;
1316         double timediff;
1317
1318         clock_gettime_mono(&ts1);
1319         result = SMB_VFS_NEXT_BRL_CANCEL_WINDOWS(handle, br_lck, plock, blr);
1320         clock_gettime_mono(&ts2);
1321         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1322
1323         if (timediff > audit_timeout) {
1324                 smb_time_audit_log("brl_cancel_windows", timediff);
1325         }
1326
1327         return result;
1328 }
1329
1330 static bool smb_time_audit_strict_lock(struct vfs_handle_struct *handle,
1331                                        struct files_struct *fsp,
1332                                        struct lock_struct *plock)
1333 {
1334         bool result;
1335         struct timespec ts1,ts2;
1336         double timediff;
1337
1338         clock_gettime_mono(&ts1);
1339         result = SMB_VFS_NEXT_STRICT_LOCK(handle, fsp, plock);
1340         clock_gettime_mono(&ts2);
1341         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1342
1343         if (timediff > audit_timeout) {
1344                 smb_time_audit_log("strict_lock", timediff);
1345         }
1346
1347         return result;
1348 }
1349
1350 static void smb_time_audit_strict_unlock(struct vfs_handle_struct *handle,
1351                                          struct files_struct *fsp,
1352                                          struct lock_struct *plock)
1353 {
1354         struct timespec ts1,ts2;
1355         double timediff;
1356
1357         clock_gettime_mono(&ts1);
1358         SMB_VFS_NEXT_STRICT_UNLOCK(handle, fsp, plock);
1359         clock_gettime_mono(&ts2);
1360         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1361
1362         if (timediff > audit_timeout) {
1363                 smb_time_audit_log("strict_unlock", timediff);
1364         }
1365
1366         return;
1367 }
1368
1369 static NTSTATUS smb_time_audit_translate_name(struct vfs_handle_struct *handle,
1370                                               const char *name,
1371                                               enum vfs_translate_direction direction,
1372                                               TALLOC_CTX *mem_ctx,
1373                                               char **mapped_name)
1374 {
1375         NTSTATUS result;
1376         struct timespec ts1,ts2;
1377         double timediff;
1378
1379         clock_gettime_mono(&ts1);
1380         result = SMB_VFS_NEXT_TRANSLATE_NAME(handle, name, direction, mem_ctx,
1381                                              mapped_name);
1382         clock_gettime_mono(&ts2);
1383         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1384
1385         if (timediff > audit_timeout) {
1386                 smb_time_audit_log("translate_name", timediff);
1387         }
1388
1389         return result;
1390 }
1391
1392 static NTSTATUS smb_time_audit_fget_nt_acl(vfs_handle_struct *handle,
1393                                            files_struct *fsp,
1394                                            uint32 security_info,
1395                                            struct security_descriptor **ppdesc)
1396 {
1397         NTSTATUS result;
1398         struct timespec ts1,ts2;
1399         double timediff;
1400
1401         clock_gettime_mono(&ts1);
1402         result = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info, ppdesc);
1403         clock_gettime_mono(&ts2);
1404         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1405
1406         if (timediff > audit_timeout) {
1407                 smb_time_audit_log("fget_nt_acl", timediff);
1408         }
1409
1410         return result;
1411 }
1412
1413 static NTSTATUS smb_time_audit_get_nt_acl(vfs_handle_struct *handle,
1414                                           const char *name,
1415                                           uint32 security_info,
1416                                           struct security_descriptor **ppdesc)
1417 {
1418         NTSTATUS result;
1419         struct timespec ts1,ts2;
1420         double timediff;
1421
1422         clock_gettime_mono(&ts1);
1423         result = SMB_VFS_NEXT_GET_NT_ACL(handle, name, security_info, ppdesc);
1424         clock_gettime_mono(&ts2);
1425         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1426
1427         if (timediff > audit_timeout) {
1428                 smb_time_audit_log("get_nt_acl", timediff);
1429         }
1430
1431         return result;
1432 }
1433
1434 static NTSTATUS smb_time_audit_fset_nt_acl(vfs_handle_struct *handle,
1435                                            files_struct *fsp,
1436                                            uint32 security_info_sent,
1437                                            const struct security_descriptor *psd)
1438 {
1439         NTSTATUS result;
1440         struct timespec ts1,ts2;
1441         double timediff;
1442
1443         clock_gettime_mono(&ts1);
1444         result = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent,
1445                                           psd);
1446         clock_gettime_mono(&ts2);
1447         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1448
1449         if (timediff > audit_timeout) {
1450                 smb_time_audit_log("fset_nt_acl", timediff);
1451         }
1452
1453         return result;
1454 }
1455
1456 static int smb_time_audit_chmod_acl(vfs_handle_struct *handle,
1457                                     const char *path, mode_t mode)
1458 {
1459         int result;
1460         struct timespec ts1,ts2;
1461         double timediff;
1462
1463         clock_gettime_mono(&ts1);
1464         result = SMB_VFS_NEXT_CHMOD_ACL(handle, path, mode);
1465         clock_gettime_mono(&ts2);
1466         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1467
1468         if (timediff > audit_timeout) {
1469                 smb_time_audit_log("chmod_acl", timediff);
1470         }
1471
1472         return result;
1473 }
1474
1475 static int smb_time_audit_fchmod_acl(vfs_handle_struct *handle,
1476                                      files_struct *fsp, mode_t mode)
1477 {
1478         int result;
1479         struct timespec ts1,ts2;
1480         double timediff;
1481
1482         clock_gettime_mono(&ts1);
1483         result = SMB_VFS_NEXT_FCHMOD_ACL(handle, fsp, mode);
1484         clock_gettime_mono(&ts2);
1485         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1486
1487         if (timediff > audit_timeout) {
1488                 smb_time_audit_log("fchmod_acl", timediff);
1489         }
1490
1491         return result;
1492 }
1493
1494 static int smb_time_audit_sys_acl_get_entry(vfs_handle_struct *handle,
1495                                             SMB_ACL_T theacl, int entry_id,
1496                                             SMB_ACL_ENTRY_T *entry_p)
1497 {
1498         int result;
1499         struct timespec ts1,ts2;
1500         double timediff;
1501
1502         clock_gettime_mono(&ts1);
1503         result = SMB_VFS_NEXT_SYS_ACL_GET_ENTRY(handle, theacl, entry_id,
1504                                                 entry_p);
1505         clock_gettime_mono(&ts2);
1506         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1507
1508         if (timediff > audit_timeout) {
1509                 smb_time_audit_log("sys_acl_get_entry", timediff);
1510         }
1511
1512         return result;
1513 }
1514
1515 static int smb_time_audit_sys_acl_get_tag_type(vfs_handle_struct *handle,
1516                                                SMB_ACL_ENTRY_T entry_d,
1517                                                SMB_ACL_TAG_T *tag_type_p)
1518 {
1519         int result;
1520         struct timespec ts1,ts2;
1521         double timediff;
1522
1523         clock_gettime_mono(&ts1);
1524         result = SMB_VFS_NEXT_SYS_ACL_GET_TAG_TYPE(handle, entry_d,
1525                                                    tag_type_p);
1526         clock_gettime_mono(&ts2);
1527         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1528
1529         if (timediff > audit_timeout) {
1530                 smb_time_audit_log("sys_acl_get_tag_type", timediff);
1531         }
1532
1533         return result;
1534 }
1535
1536 static int smb_time_audit_sys_acl_get_permset(vfs_handle_struct *handle,
1537                                               SMB_ACL_ENTRY_T entry_d,
1538                                               SMB_ACL_PERMSET_T *permset_p)
1539 {
1540         int result;
1541         struct timespec ts1,ts2;
1542         double timediff;
1543
1544         clock_gettime_mono(&ts1);
1545         result = SMB_VFS_NEXT_SYS_ACL_GET_PERMSET(handle, entry_d,
1546                                                   permset_p);
1547         clock_gettime_mono(&ts2);
1548         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1549
1550         if (timediff > audit_timeout) {
1551                 smb_time_audit_log("sys_acl_get_permset", timediff);
1552         }
1553
1554         return result;
1555 }
1556
1557 static void * smb_time_audit_sys_acl_get_qualifier(vfs_handle_struct *handle,
1558                                                    SMB_ACL_ENTRY_T entry_d)
1559 {
1560         void *result;
1561         struct timespec ts1,ts2;
1562         double timediff;
1563
1564         clock_gettime_mono(&ts1);
1565         result = SMB_VFS_NEXT_SYS_ACL_GET_QUALIFIER(handle, entry_d);
1566         clock_gettime_mono(&ts2);
1567         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1568
1569         if (timediff > audit_timeout) {
1570                 smb_time_audit_log("sys_acl_get_qualifier", timediff);
1571         }
1572
1573         return result;
1574 }
1575
1576 static SMB_ACL_T smb_time_audit_sys_acl_get_file(vfs_handle_struct *handle,
1577                                                  const char *path_p,
1578                                                  SMB_ACL_TYPE_T type)
1579 {
1580         SMB_ACL_T result;
1581         struct timespec ts1,ts2;
1582         double timediff;
1583
1584         clock_gettime_mono(&ts1);
1585         result = SMB_VFS_NEXT_SYS_ACL_GET_FILE(handle, path_p, type);
1586         clock_gettime_mono(&ts2);
1587         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1588
1589         if (timediff > audit_timeout) {
1590                 smb_time_audit_log("sys_acl_get_file", timediff);
1591         }
1592
1593         return result;
1594 }
1595
1596 static SMB_ACL_T smb_time_audit_sys_acl_get_fd(vfs_handle_struct *handle,
1597                                                files_struct *fsp)
1598 {
1599         SMB_ACL_T result;
1600         struct timespec ts1,ts2;
1601         double timediff;
1602
1603         clock_gettime_mono(&ts1);
1604         result = SMB_VFS_NEXT_SYS_ACL_GET_FD(handle, fsp);
1605         clock_gettime_mono(&ts2);
1606         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1607
1608         if (timediff > audit_timeout) {
1609                 smb_time_audit_log("sys_acl_get_fd", timediff);
1610         }
1611
1612         return result;
1613 }
1614
1615 static int smb_time_audit_sys_acl_clear_perms(vfs_handle_struct *handle,
1616                                               SMB_ACL_PERMSET_T permset)
1617 {
1618         int result;
1619         struct timespec ts1,ts2;
1620         double timediff;
1621
1622         clock_gettime_mono(&ts1);
1623         result = SMB_VFS_NEXT_SYS_ACL_CLEAR_PERMS(handle, permset);
1624         clock_gettime_mono(&ts2);
1625         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1626
1627         if (timediff > audit_timeout) {
1628                 smb_time_audit_log("sys_acl_clear_perms", timediff);
1629         }
1630
1631         return result;
1632 }
1633
1634 static int smb_time_audit_sys_acl_add_perm(vfs_handle_struct *handle,
1635                                            SMB_ACL_PERMSET_T permset,
1636                                            SMB_ACL_PERM_T perm)
1637 {
1638         int result;
1639         struct timespec ts1,ts2;
1640         double timediff;
1641
1642         clock_gettime_mono(&ts1);
1643         result = SMB_VFS_NEXT_SYS_ACL_ADD_PERM(handle, permset, perm);
1644         clock_gettime_mono(&ts2);
1645         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1646
1647         if (timediff > audit_timeout) {
1648                 smb_time_audit_log("sys_acl_add_perm", timediff);
1649         }
1650
1651         return result;
1652 }
1653
1654 static char * smb_time_audit_sys_acl_to_text(vfs_handle_struct *handle,
1655                                              SMB_ACL_T theacl,
1656                                              ssize_t *plen)
1657 {
1658         char * result;
1659         struct timespec ts1,ts2;
1660         double timediff;
1661
1662         clock_gettime_mono(&ts1);
1663         result = SMB_VFS_NEXT_SYS_ACL_TO_TEXT(handle, theacl, plen);
1664         clock_gettime_mono(&ts2);
1665         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1666
1667         if (timediff > audit_timeout) {
1668                 smb_time_audit_log("sys_acl_to_text", timediff);
1669         }
1670
1671         return result;
1672 }
1673
1674 static SMB_ACL_T smb_time_audit_sys_acl_init(vfs_handle_struct *handle,
1675                                              int count)
1676 {
1677         SMB_ACL_T result;
1678         struct timespec ts1,ts2;
1679         double timediff;
1680
1681         clock_gettime_mono(&ts1);
1682         result = SMB_VFS_NEXT_SYS_ACL_INIT(handle, count);
1683         clock_gettime_mono(&ts2);
1684         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1685
1686         if (timediff > audit_timeout) {
1687                 smb_time_audit_log("sys_acl_init", timediff);
1688         }
1689
1690         return result;
1691 }
1692
1693 static int smb_time_audit_sys_acl_create_entry(vfs_handle_struct *handle,
1694                                                SMB_ACL_T *pacl,
1695                                                SMB_ACL_ENTRY_T *pentry)
1696 {
1697         int result;
1698         struct timespec ts1,ts2;
1699         double timediff;
1700
1701         clock_gettime_mono(&ts1);
1702         result = SMB_VFS_NEXT_SYS_ACL_CREATE_ENTRY(handle, pacl, pentry);
1703         clock_gettime_mono(&ts2);
1704         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1705
1706         if (timediff > audit_timeout) {
1707                 smb_time_audit_log("sys_acl_create_entry", timediff);
1708         }
1709
1710         return result;
1711 }
1712
1713 static int smb_time_audit_sys_acl_set_tag_type(vfs_handle_struct *handle,
1714                                                SMB_ACL_ENTRY_T entry,
1715                                                SMB_ACL_TAG_T tagtype)
1716 {
1717         int result;
1718         struct timespec ts1,ts2;
1719         double timediff;
1720
1721         clock_gettime_mono(&ts1);
1722         result = SMB_VFS_NEXT_SYS_ACL_SET_TAG_TYPE(handle, entry,
1723                                                    tagtype);
1724         clock_gettime_mono(&ts2);
1725         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1726
1727         if (timediff > audit_timeout) {
1728                 smb_time_audit_log("sys_acl_set_tag_type", timediff);
1729         }
1730
1731         return result;
1732 }
1733
1734 static int smb_time_audit_sys_acl_set_qualifier(vfs_handle_struct *handle,
1735                                                 SMB_ACL_ENTRY_T entry,
1736                                                 void *qual)
1737 {
1738         int result;
1739         struct timespec ts1,ts2;
1740         double timediff;
1741
1742         clock_gettime_mono(&ts1);
1743         result = SMB_VFS_NEXT_SYS_ACL_SET_QUALIFIER(handle, entry, qual);
1744         clock_gettime_mono(&ts2);
1745         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1746
1747         if (timediff > audit_timeout) {
1748                 smb_time_audit_log("sys_acl_set_qualifier", timediff);
1749         }
1750
1751         return result;
1752 }
1753
1754 static int smb_time_audit_sys_acl_set_permset(vfs_handle_struct *handle,
1755                                               SMB_ACL_ENTRY_T entry,
1756                                               SMB_ACL_PERMSET_T permset)
1757 {
1758         int result;
1759         struct timespec ts1,ts2;
1760         double timediff;
1761
1762         clock_gettime_mono(&ts1);
1763         result = SMB_VFS_NEXT_SYS_ACL_SET_PERMSET(handle, entry, permset);
1764         clock_gettime_mono(&ts2);
1765         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1766
1767         if (timediff > audit_timeout) {
1768                 smb_time_audit_log("sys_acl_set_permset", timediff);
1769         }
1770
1771         return result;
1772 }
1773
1774 static int smb_time_audit_sys_acl_valid(vfs_handle_struct *handle,
1775                                         SMB_ACL_T theacl)
1776 {
1777         int result;
1778         struct timespec ts1,ts2;
1779         double timediff;
1780
1781         clock_gettime_mono(&ts1);
1782         result = SMB_VFS_NEXT_SYS_ACL_VALID(handle, theacl);
1783         clock_gettime_mono(&ts2);
1784         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1785
1786         if (timediff > audit_timeout) {
1787                 smb_time_audit_log("sys_acl_valid", timediff);
1788         }
1789
1790         return result;
1791 }
1792
1793 static int smb_time_audit_sys_acl_set_file(vfs_handle_struct *handle,
1794                                            const char *name,
1795                                            SMB_ACL_TYPE_T acltype,
1796                                            SMB_ACL_T theacl)
1797 {
1798         int result;
1799         struct timespec ts1,ts2;
1800         double timediff;
1801
1802         clock_gettime_mono(&ts1);
1803         result = SMB_VFS_NEXT_SYS_ACL_SET_FILE(handle, name, acltype,
1804                                                theacl);
1805         clock_gettime_mono(&ts2);
1806         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1807
1808         if (timediff > audit_timeout) {
1809                 smb_time_audit_log("sys_acl_set_file", timediff);
1810         }
1811
1812         return result;
1813 }
1814
1815 static int smb_time_audit_sys_acl_set_fd(vfs_handle_struct *handle,
1816                                          files_struct *fsp,
1817                                          SMB_ACL_T theacl)
1818 {
1819         int result;
1820         struct timespec ts1,ts2;
1821         double timediff;
1822
1823         clock_gettime_mono(&ts1);
1824         result = SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl);
1825         clock_gettime_mono(&ts2);
1826         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1827
1828         if (timediff > audit_timeout) {
1829                 smb_time_audit_log("sys_acl_set_fd", timediff);
1830         }
1831
1832         return result;
1833 }
1834
1835 static int smb_time_audit_sys_acl_delete_def_file(vfs_handle_struct *handle,
1836                                                   const char *path)
1837 {
1838         int result;
1839         struct timespec ts1,ts2;
1840         double timediff;
1841
1842         clock_gettime_mono(&ts1);
1843         result = SMB_VFS_NEXT_SYS_ACL_DELETE_DEF_FILE(handle, path);
1844         clock_gettime_mono(&ts2);
1845         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1846
1847         if (timediff > audit_timeout) {
1848                 smb_time_audit_log("sys_acl_delete_def_file", timediff);
1849         }
1850
1851         return result;
1852 }
1853
1854 static int smb_time_audit_sys_acl_get_perm(vfs_handle_struct *handle,
1855                                            SMB_ACL_PERMSET_T permset,
1856                                            SMB_ACL_PERM_T perm)
1857 {
1858         int result;
1859         struct timespec ts1,ts2;
1860         double timediff;
1861
1862         clock_gettime_mono(&ts1);
1863         result = SMB_VFS_NEXT_SYS_ACL_GET_PERM(handle, permset, perm);
1864         clock_gettime_mono(&ts2);
1865         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1866
1867         if (timediff > audit_timeout) {
1868                 smb_time_audit_log("sys_acl_get_perm", timediff);
1869         }
1870
1871         return result;
1872 }
1873
1874 static int smb_time_audit_sys_acl_free_text(vfs_handle_struct *handle,
1875                                             char *text)
1876 {
1877         int result;
1878         struct timespec ts1,ts2;
1879         double timediff;
1880
1881         clock_gettime_mono(&ts1);
1882         result = SMB_VFS_NEXT_SYS_ACL_FREE_TEXT(handle, text);
1883         clock_gettime_mono(&ts2);
1884         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1885
1886         if (timediff > audit_timeout) {
1887                 smb_time_audit_log("sys_acl_free_text", timediff);
1888         }
1889
1890         return result;
1891 }
1892
1893 static int smb_time_audit_sys_acl_free_acl(vfs_handle_struct *handle,
1894                                            SMB_ACL_T posix_acl)
1895 {
1896         int result;
1897         struct timespec ts1,ts2;
1898         double timediff;
1899
1900         clock_gettime_mono(&ts1);
1901         result = SMB_VFS_NEXT_SYS_ACL_FREE_ACL(handle, posix_acl);
1902         clock_gettime_mono(&ts2);
1903         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1904
1905         if (timediff > audit_timeout) {
1906                 smb_time_audit_log("sys_acl_free_acl", timediff);
1907         }
1908
1909         return result;
1910 }
1911
1912 static int smb_time_audit_sys_acl_free_qualifier(vfs_handle_struct *handle,
1913                                                  void *qualifier,
1914                                                  SMB_ACL_TAG_T tagtype)
1915 {
1916         int result;
1917         struct timespec ts1,ts2;
1918         double timediff;
1919
1920         clock_gettime_mono(&ts1);
1921         result = SMB_VFS_NEXT_SYS_ACL_FREE_QUALIFIER(handle, qualifier,
1922                                                      tagtype);
1923         clock_gettime_mono(&ts2);
1924         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1925
1926         if (timediff > audit_timeout) {
1927                 smb_time_audit_log("sys_acl_free_qualifier", timediff);
1928         }
1929
1930         return result;
1931 }
1932
1933 static ssize_t smb_time_audit_getxattr(struct vfs_handle_struct *handle,
1934                                        const char *path, const char *name,
1935                                        void *value, size_t size)
1936 {
1937         ssize_t result;
1938         struct timespec ts1,ts2;
1939         double timediff;
1940
1941         clock_gettime_mono(&ts1);
1942         result = SMB_VFS_NEXT_GETXATTR(handle, path, name, value, size);
1943         clock_gettime_mono(&ts2);
1944         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1945
1946         if (timediff > audit_timeout) {
1947                 smb_time_audit_log("getxattr", timediff);
1948         }
1949
1950         return result;
1951 }
1952
1953 static ssize_t smb_time_audit_lgetxattr(struct vfs_handle_struct *handle,
1954                                         const char *path, const char *name,
1955                                         void *value, size_t size)
1956 {
1957         ssize_t result;
1958         struct timespec ts1,ts2;
1959         double timediff;
1960
1961         clock_gettime_mono(&ts1);
1962         result = SMB_VFS_NEXT_LGETXATTR(handle, path, name, value, size);
1963         clock_gettime_mono(&ts2);
1964         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1965
1966         if (timediff > audit_timeout) {
1967                 smb_time_audit_log("lgetxattr", timediff);
1968         }
1969
1970         return result;
1971 }
1972
1973 static ssize_t smb_time_audit_fgetxattr(struct vfs_handle_struct *handle,
1974                                         struct files_struct *fsp,
1975                                         const char *name, void *value,
1976                                         size_t size)
1977 {
1978         ssize_t result;
1979         struct timespec ts1,ts2;
1980         double timediff;
1981
1982         clock_gettime_mono(&ts1);
1983         result = SMB_VFS_NEXT_FGETXATTR(handle, fsp, name, value, size);
1984         clock_gettime_mono(&ts2);
1985         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
1986
1987         if (timediff > audit_timeout) {
1988                 smb_time_audit_log("fgetxattr", timediff);
1989         }
1990
1991         return result;
1992 }
1993
1994 static ssize_t smb_time_audit_listxattr(struct vfs_handle_struct *handle,
1995                                         const char *path, char *list,
1996                                         size_t size)
1997 {
1998         ssize_t result;
1999         struct timespec ts1,ts2;
2000         double timediff;
2001
2002         clock_gettime_mono(&ts1);
2003         result = SMB_VFS_NEXT_LISTXATTR(handle, path, list, size);
2004         clock_gettime_mono(&ts2);
2005         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2006
2007         if (timediff > audit_timeout) {
2008                 smb_time_audit_log("listxattr", timediff);
2009         }
2010
2011         return result;
2012 }
2013
2014 static ssize_t smb_time_audit_llistxattr(struct vfs_handle_struct *handle,
2015                                          const char *path, char *list,
2016                                          size_t size)
2017 {
2018         ssize_t result;
2019         struct timespec ts1,ts2;
2020         double timediff;
2021
2022         clock_gettime_mono(&ts1);
2023         result = SMB_VFS_NEXT_LLISTXATTR(handle, path, list, size);
2024         clock_gettime_mono(&ts2);
2025         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2026
2027         if (timediff > audit_timeout) {
2028                 smb_time_audit_log("llistxattr", timediff);
2029         }
2030
2031         return result;
2032 }
2033
2034 static ssize_t smb_time_audit_flistxattr(struct vfs_handle_struct *handle,
2035                                          struct files_struct *fsp, char *list,
2036                                          size_t size)
2037 {
2038         ssize_t result;
2039         struct timespec ts1,ts2;
2040         double timediff;
2041
2042         clock_gettime_mono(&ts1);
2043         result = SMB_VFS_NEXT_FLISTXATTR(handle, fsp, list, size);
2044         clock_gettime_mono(&ts2);
2045         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2046
2047         if (timediff > audit_timeout) {
2048                 smb_time_audit_log("flistxattr", timediff);
2049         }
2050
2051         return result;
2052 }
2053
2054 static int smb_time_audit_removexattr(struct vfs_handle_struct *handle,
2055                                       const char *path, const char *name)
2056 {
2057         int result;
2058         struct timespec ts1,ts2;
2059         double timediff;
2060
2061         clock_gettime_mono(&ts1);
2062         result = SMB_VFS_NEXT_REMOVEXATTR(handle, path, name);
2063         clock_gettime_mono(&ts2);
2064         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2065
2066         if (timediff > audit_timeout) {
2067                 smb_time_audit_log("removexattr", timediff);
2068         }
2069
2070         return result;
2071 }
2072
2073 static int smb_time_audit_lremovexattr(struct vfs_handle_struct *handle,
2074                                        const char *path, const char *name)
2075 {
2076         int result;
2077         struct timespec ts1,ts2;
2078         double timediff;
2079
2080         clock_gettime_mono(&ts1);
2081         result = SMB_VFS_NEXT_LREMOVEXATTR(handle, path, name);
2082         clock_gettime_mono(&ts2);
2083         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2084
2085         if (timediff > audit_timeout) {
2086                 smb_time_audit_log("lremovexattr", timediff);
2087         }
2088
2089         return result;
2090 }
2091
2092 static int smb_time_audit_fremovexattr(struct vfs_handle_struct *handle,
2093                                        struct files_struct *fsp,
2094                                        const char *name)
2095 {
2096         int result;
2097         struct timespec ts1,ts2;
2098         double timediff;
2099
2100         clock_gettime_mono(&ts1);
2101         result = SMB_VFS_NEXT_FREMOVEXATTR(handle, fsp, name);
2102         clock_gettime_mono(&ts2);
2103         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2104
2105         if (timediff > audit_timeout) {
2106                 smb_time_audit_log("fremovexattr", timediff);
2107         }
2108
2109         return result;
2110 }
2111
2112 static int smb_time_audit_setxattr(struct vfs_handle_struct *handle,
2113                                    const char *path, const char *name,
2114                                    const void *value, size_t size,
2115                                    int flags)
2116 {
2117         int result;
2118         struct timespec ts1,ts2;
2119         double timediff;
2120
2121         clock_gettime_mono(&ts1);
2122         result = SMB_VFS_NEXT_SETXATTR(handle, path, name, value, size,
2123                                        flags);
2124         clock_gettime_mono(&ts2);
2125         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2126
2127         if (timediff > audit_timeout) {
2128                 smb_time_audit_log("setxattr", timediff);
2129         }
2130
2131         return result;
2132 }
2133
2134 static int smb_time_audit_lsetxattr(struct vfs_handle_struct *handle,
2135                                     const char *path, const char *name,
2136                                     const void *value, size_t size,
2137                                     int flags)
2138 {
2139         int result;
2140         struct timespec ts1,ts2;
2141         double timediff;
2142
2143         clock_gettime_mono(&ts1);
2144         result = SMB_VFS_NEXT_LSETXATTR(handle, path, name, value, size,
2145                                         flags);
2146         clock_gettime_mono(&ts2);
2147         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2148
2149         if (timediff > audit_timeout) {
2150                 smb_time_audit_log("lsetxattr", timediff);
2151         }
2152
2153         return result;
2154 }
2155
2156 static int smb_time_audit_fsetxattr(struct vfs_handle_struct *handle,
2157                                     struct files_struct *fsp, const char *name,
2158                                     const void *value, size_t size, int flags)
2159 {
2160         int result;
2161         struct timespec ts1,ts2;
2162         double timediff;
2163
2164         clock_gettime_mono(&ts1);
2165         result = SMB_VFS_NEXT_FSETXATTR(handle, fsp, name, value, size, flags);
2166         clock_gettime_mono(&ts2);
2167         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2168
2169         if (timediff > audit_timeout) {
2170                 smb_time_audit_log("fsetxattr", timediff);
2171         }
2172
2173         return result;
2174 }
2175
2176 static int smb_time_audit_aio_read(struct vfs_handle_struct *handle,
2177                                    struct files_struct *fsp,
2178                                    SMB_STRUCT_AIOCB *aiocb)
2179 {
2180         int result;
2181         struct timespec ts1,ts2;
2182         double timediff;
2183
2184         clock_gettime_mono(&ts1);
2185         result = SMB_VFS_NEXT_AIO_READ(handle, fsp, aiocb);
2186         clock_gettime_mono(&ts2);
2187         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2188
2189         if (timediff > audit_timeout) {
2190                 smb_time_audit_log("aio_read", timediff);
2191         }
2192
2193         return result;
2194 }
2195
2196 static int smb_time_audit_aio_write(struct vfs_handle_struct *handle,
2197                                     struct files_struct *fsp,
2198                                     SMB_STRUCT_AIOCB *aiocb)
2199 {
2200         int result;
2201         struct timespec ts1,ts2;
2202         double timediff;
2203
2204         clock_gettime_mono(&ts1);
2205         result = SMB_VFS_NEXT_AIO_WRITE(handle, fsp, aiocb);
2206         clock_gettime_mono(&ts2);
2207         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2208
2209         if (timediff > audit_timeout) {
2210                 smb_time_audit_log("aio_write", timediff);
2211         }
2212
2213         return result;
2214 }
2215
2216 static ssize_t smb_time_audit_aio_return(struct vfs_handle_struct *handle,
2217                                          struct files_struct *fsp,
2218                                          SMB_STRUCT_AIOCB *aiocb)
2219 {
2220         ssize_t result;
2221         struct timespec ts1,ts2;
2222         double timediff;
2223
2224         clock_gettime_mono(&ts1);
2225         result = SMB_VFS_NEXT_AIO_RETURN(handle, fsp, aiocb);
2226         clock_gettime_mono(&ts2);
2227         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2228
2229         if (timediff > audit_timeout) {
2230                 smb_time_audit_log("aio_return", timediff);
2231         }
2232
2233         return result;
2234 }
2235
2236 static int smb_time_audit_aio_cancel(struct vfs_handle_struct *handle,
2237                                      struct files_struct *fsp,
2238                                      SMB_STRUCT_AIOCB *aiocb)
2239 {
2240         int result;
2241         struct timespec ts1,ts2;
2242         double timediff;
2243
2244         clock_gettime_mono(&ts1);
2245         result = SMB_VFS_NEXT_AIO_CANCEL(handle, fsp, aiocb);
2246         clock_gettime_mono(&ts2);
2247         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2248
2249         if (timediff > audit_timeout) {
2250                 smb_time_audit_log("aio_cancel", timediff);
2251         }
2252
2253         return result;
2254 }
2255
2256 static int smb_time_audit_aio_error(struct vfs_handle_struct *handle,
2257                                     struct files_struct *fsp,
2258                                     SMB_STRUCT_AIOCB *aiocb)
2259 {
2260         int result;
2261         struct timespec ts1,ts2;
2262         double timediff;
2263
2264         clock_gettime_mono(&ts1);
2265         result = SMB_VFS_NEXT_AIO_ERROR(handle, fsp, aiocb);
2266         clock_gettime_mono(&ts2);
2267         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2268
2269         if (timediff > audit_timeout) {
2270                 smb_time_audit_log("aio_error", timediff);
2271         }
2272
2273         return result;
2274 }
2275
2276 static int smb_time_audit_aio_fsync(struct vfs_handle_struct *handle,
2277                                     struct files_struct *fsp, int op,
2278                                     SMB_STRUCT_AIOCB *aiocb)
2279 {
2280         int result;
2281         struct timespec ts1,ts2;
2282         double timediff;
2283
2284         clock_gettime_mono(&ts1);
2285         result = SMB_VFS_NEXT_AIO_FSYNC(handle, fsp, op, aiocb);
2286         clock_gettime_mono(&ts2);
2287         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2288
2289         if (timediff > audit_timeout) {
2290                 smb_time_audit_log("aio_fsync", timediff);
2291         }
2292
2293         return result;
2294 }
2295
2296 static int smb_time_audit_aio_suspend(struct vfs_handle_struct *handle,
2297                                       struct files_struct *fsp,
2298                                       const SMB_STRUCT_AIOCB * const aiocb[],
2299                                       int n, const struct timespec *ts)
2300 {
2301         int result;
2302         struct timespec ts1,ts2;
2303         double timediff;
2304
2305         clock_gettime_mono(&ts1);
2306         result = SMB_VFS_NEXT_AIO_SUSPEND(handle, fsp, aiocb, n, ts);
2307         clock_gettime_mono(&ts2);
2308         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2309
2310         if (timediff > audit_timeout) {
2311                 smb_time_audit_log("aio_suspend", timediff);
2312         }
2313
2314         return result;
2315 }
2316
2317 static bool smb_time_audit_aio_force(struct vfs_handle_struct *handle,
2318                                      struct files_struct *fsp)
2319 {
2320         bool result;
2321         struct timespec ts1,ts2;
2322         double timediff;
2323
2324         clock_gettime_mono(&ts1);
2325         result = SMB_VFS_NEXT_AIO_FORCE(handle, fsp);
2326         clock_gettime_mono(&ts2);
2327         timediff = nsec_time_diff(&ts2,&ts1)*1.0e-9;
2328
2329         if (timediff > audit_timeout) {
2330                 smb_time_audit_log("aio_force", timediff);
2331         }
2332
2333         return result;
2334 }
2335
2336
2337
2338 /* VFS operations */
2339
2340 static struct vfs_fn_pointers vfs_time_audit_fns = {
2341         .connect_fn = smb_time_audit_connect,
2342         .disconnect_fn = smb_time_audit_disconnect,
2343         .disk_free_fn = smb_time_audit_disk_free,
2344         .get_quota_fn = smb_time_audit_get_quota,
2345         .set_quota_fn = smb_time_audit_set_quota,
2346         .get_shadow_copy_data_fn = smb_time_audit_get_shadow_copy_data,
2347         .statvfs_fn = smb_time_audit_statvfs,
2348         .fs_capabilities_fn = smb_time_audit_fs_capabilities,
2349         .opendir_fn = smb_time_audit_opendir,
2350         .fdopendir_fn = smb_time_audit_fdopendir,
2351         .readdir_fn = smb_time_audit_readdir,
2352         .seekdir_fn = smb_time_audit_seekdir,
2353         .telldir_fn = smb_time_audit_telldir,
2354         .rewind_dir_fn = smb_time_audit_rewinddir,
2355         .mkdir_fn = smb_time_audit_mkdir,
2356         .rmdir_fn = smb_time_audit_rmdir,
2357         .closedir_fn = smb_time_audit_closedir,
2358         .init_search_op_fn = smb_time_audit_init_search_op,
2359         .open_fn = smb_time_audit_open,
2360         .create_file_fn = smb_time_audit_create_file,
2361         .close_fn = smb_time_audit_close,
2362         .read_fn = smb_time_audit_read,
2363         .pread_fn = smb_time_audit_pread,
2364         .write_fn = smb_time_audit_write,
2365         .pwrite_fn = smb_time_audit_pwrite,
2366         .lseek_fn = smb_time_audit_lseek,
2367         .sendfile_fn = smb_time_audit_sendfile,
2368         .recvfile_fn = smb_time_audit_recvfile,
2369         .rename_fn = smb_time_audit_rename,
2370         .fsync_fn = smb_time_audit_fsync,
2371         .stat_fn = smb_time_audit_stat,
2372         .fstat_fn = smb_time_audit_fstat,
2373         .lstat_fn = smb_time_audit_lstat,
2374         .get_alloc_size_fn = smb_time_audit_get_alloc_size,
2375         .unlink_fn = smb_time_audit_unlink,
2376         .chmod_fn = smb_time_audit_chmod,
2377         .fchmod_fn = smb_time_audit_fchmod,
2378         .chown_fn = smb_time_audit_chown,
2379         .fchown_fn = smb_time_audit_fchown,
2380         .lchown_fn = smb_time_audit_lchown,
2381         .chdir_fn = smb_time_audit_chdir,
2382         .getwd_fn = smb_time_audit_getwd,
2383         .ntimes_fn = smb_time_audit_ntimes,
2384         .ftruncate_fn = smb_time_audit_ftruncate,
2385         .fallocate_fn = smb_time_audit_fallocate,
2386         .lock_fn = smb_time_audit_lock,
2387         .kernel_flock_fn = smb_time_audit_kernel_flock,
2388         .linux_setlease_fn = smb_time_audit_linux_setlease,
2389         .getlock_fn = smb_time_audit_getlock,
2390         .symlink_fn = smb_time_audit_symlink,
2391         .readlink_fn = smb_time_audit_readlink,
2392         .link_fn = smb_time_audit_link,
2393         .mknod_fn = smb_time_audit_mknod,
2394         .realpath_fn = smb_time_audit_realpath,
2395         .notify_watch_fn = smb_time_audit_notify_watch,
2396         .chflags_fn = smb_time_audit_chflags,
2397         .file_id_create_fn = smb_time_audit_file_id_create,
2398         .streaminfo_fn = smb_time_audit_streaminfo,
2399         .get_real_filename_fn = smb_time_audit_get_real_filename,
2400         .connectpath_fn = smb_time_audit_connectpath,
2401         .brl_lock_windows_fn = smb_time_audit_brl_lock_windows,
2402         .brl_unlock_windows_fn = smb_time_audit_brl_unlock_windows,
2403         .brl_cancel_windows_fn = smb_time_audit_brl_cancel_windows,
2404         .strict_lock_fn = smb_time_audit_strict_lock,
2405         .strict_unlock_fn = smb_time_audit_strict_unlock,
2406         .translate_name_fn = smb_time_audit_translate_name,
2407         .fget_nt_acl_fn = smb_time_audit_fget_nt_acl,
2408         .get_nt_acl_fn = smb_time_audit_get_nt_acl,
2409         .fset_nt_acl_fn = smb_time_audit_fset_nt_acl,
2410         .chmod_acl_fn = smb_time_audit_chmod_acl,
2411         .fchmod_acl_fn = smb_time_audit_fchmod_acl,
2412         .sys_acl_get_entry_fn = smb_time_audit_sys_acl_get_entry,
2413         .sys_acl_get_tag_type_fn = smb_time_audit_sys_acl_get_tag_type,
2414         .sys_acl_get_permset_fn = smb_time_audit_sys_acl_get_permset,
2415         .sys_acl_get_qualifier_fn = smb_time_audit_sys_acl_get_qualifier,
2416         .sys_acl_get_file_fn = smb_time_audit_sys_acl_get_file,
2417         .sys_acl_get_fd_fn = smb_time_audit_sys_acl_get_fd,
2418         .sys_acl_clear_perms_fn = smb_time_audit_sys_acl_clear_perms,
2419         .sys_acl_add_perm_fn = smb_time_audit_sys_acl_add_perm,
2420         .sys_acl_to_text_fn = smb_time_audit_sys_acl_to_text,
2421         .sys_acl_init_fn = smb_time_audit_sys_acl_init,
2422         .sys_acl_create_entry_fn = smb_time_audit_sys_acl_create_entry,
2423         .sys_acl_set_tag_type_fn = smb_time_audit_sys_acl_set_tag_type,
2424         .sys_acl_set_qualifier_fn = smb_time_audit_sys_acl_set_qualifier,
2425         .sys_acl_set_permset_fn = smb_time_audit_sys_acl_set_permset,
2426         .sys_acl_valid_fn = smb_time_audit_sys_acl_valid,
2427         .sys_acl_set_file_fn = smb_time_audit_sys_acl_set_file,
2428         .sys_acl_set_fd_fn = smb_time_audit_sys_acl_set_fd,
2429         .sys_acl_delete_def_file_fn = smb_time_audit_sys_acl_delete_def_file,
2430         .sys_acl_get_perm_fn = smb_time_audit_sys_acl_get_perm,
2431         .sys_acl_free_text_fn = smb_time_audit_sys_acl_free_text,
2432         .sys_acl_free_acl_fn = smb_time_audit_sys_acl_free_acl,
2433         .sys_acl_free_qualifier_fn = smb_time_audit_sys_acl_free_qualifier,
2434         .getxattr_fn = smb_time_audit_getxattr,
2435         .lgetxattr_fn = smb_time_audit_lgetxattr,
2436         .fgetxattr_fn = smb_time_audit_fgetxattr,
2437         .listxattr_fn = smb_time_audit_listxattr,
2438         .llistxattr_fn = smb_time_audit_llistxattr,
2439         .flistxattr_fn = smb_time_audit_flistxattr,
2440         .removexattr_fn = smb_time_audit_removexattr,
2441         .lremovexattr_fn = smb_time_audit_lremovexattr,
2442         .fremovexattr_fn = smb_time_audit_fremovexattr,
2443         .setxattr_fn = smb_time_audit_setxattr,
2444         .lsetxattr_fn = smb_time_audit_lsetxattr,
2445         .fsetxattr_fn = smb_time_audit_fsetxattr,
2446         .aio_read_fn = smb_time_audit_aio_read,
2447         .aio_write_fn = smb_time_audit_aio_write,
2448         .aio_return_fn = smb_time_audit_aio_return,
2449         .aio_cancel_fn = smb_time_audit_aio_cancel,
2450         .aio_error_fn = smb_time_audit_aio_error,
2451         .aio_fsync_fn = smb_time_audit_aio_fsync,
2452         .aio_suspend_fn = smb_time_audit_aio_suspend,
2453         .aio_force_fn = smb_time_audit_aio_force,
2454 };
2455
2456
2457 NTSTATUS vfs_time_audit_init(void);
2458 NTSTATUS vfs_time_audit_init(void)
2459 {
2460         audit_timeout = (double)lp_parm_int(-1, "time_audit", "timeout",
2461                                             10000) / 1000.0;
2462         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "time_audit",
2463                                 &vfs_time_audit_fns);
2464 }