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