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