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