source/smbd/fileio.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    read/write to a files_struct
   5    Copyright (C) Andrew Tridgell 1992-1998
   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 2 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, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 static BOOL setup_write_cache(files_struct *, SMB_OFF_T);
  25
  26 /****************************************************************************
  27 seek a file. Try to avoid the seek if possible
  28 ****************************************************************************/
  29
  30 SMB_OFF_T seek_file(files_struct *fsp,SMB_OFF_T pos)
  31 {
  32   SMB_OFF_T offset = 0;
  33   SMB_OFF_T seek_ret;
  34
  35   if (fsp->print_file && lp_postscript(fsp->conn->service))
  36     offset = 3;
  37
  38   seek_ret = fsp->conn->vfs_ops.lseek(fsp,fsp->fd,pos+offset,SEEK_SET);
  39
  40   /*
  41    * We want to maintain the fiction that we can seek
  42    * on a fifo for file system purposes. This allows
  43    * people to set up UNIX fifo's that feed data to Windows
  44    * applications. JRA.
  45    */
  46
  47   if((seek_ret == -1) && (errno == ESPIPE)) {
  48     seek_ret = pos+offset;
  49     errno = 0;
  50   }
  51
  52   if((seek_ret == -1) || (seek_ret != pos+offset)) {
  53     DEBUG(0,("seek_file: sys_lseek failed. Error was %s\n", strerror(errno) ));
  54     fsp->pos = -1;
  55     return -1;
  56   }
  57
  58   fsp->pos = seek_ret - offset;
  59
  60   DEBUG(10,("seek_file: requested pos = %.0f, new pos = %.0f\n",
  61         (double)(pos+offset), (double)fsp->pos ));
  62
  63   return(fsp->pos);
  64 }
  65
  66 /****************************************************************************
  67  Read from write cache if we can.
  68 ****************************************************************************/
  69
  70
  71 BOOL read_from_write_cache(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n)
  72 {
  73   write_cache *wcp = fsp->wcp;
  74
  75   if(!wcp)
  76     return False;
  77
  78   if(n > wcp->data_size || pos < wcp->offset || pos + n > wcp->offset + wcp->data_size)
  79     return False;
  80
  81   memcpy(data, wcp->data + (pos - wcp->offset), n);
  82
  83   DO_PROFILE_INC(writecache_read_hits);
  84
  85   return True;
  86 }
  87
  88 /****************************************************************************
  89 read from a file
  90 ****************************************************************************/
  91
  92 ssize_t read_file(files_struct *fsp,char *data,SMB_OFF_T pos,size_t n)
  93 {
  94         ssize_t ret=0,readret;
  95
  96         /* you can't read from print files */
  97         if (fsp->print_file)
  98                 return -1;
  99
 100         /*
 101          * Serve from write cache if we can.
 102          */
 103
 104         if(read_from_write_cache(fsp, data, pos, n))
 105                 return n;
 106
 107         flush_write_cache(fsp, READ_FLUSH);
 108
 109         if (seek_file(fsp,pos) == -1) {
 110                 DEBUG(3,("read_file: Failed to seek to %.0f\n",(double)pos));
 111                 return(ret);
 112         }
 113
 114         if (n > 0) {
 115 #ifdef DMF_FIX
 116                 int numretries = 3;
 117 tryagain:
 118                 readret = fsp->conn->vfs_ops.read(fsp,fsp->fd,data,n);
 119                 if (readret == -1) {
 120                         if ((errno == EAGAIN) && numretries) {
 121                                 DEBUG(3,("read_file EAGAIN retry in 10 seconds\n"));
 122                                 (void)sleep(10);
 123                                 --numretries;
 124                                 goto tryagain;
 125                         }
 126                         return -1;
 127                 }
 128 #else /* NO DMF fix. */
 129                 readret = fsp->conn->vfs_ops.read(fsp,fsp->fd,data,n);
 130                 if (readret == -1)
 131                         return -1;
 132 #endif
 133
 134                 if (readret > 0)
 135                         ret += readret;
 136         }
 137
 138         return(ret);
 139 }
 140
 141 /* how many write cache buffers have been allocated */
 142 static unsigned int allocated_write_caches;
 143
 144 /****************************************************************************
 145  *Really* write to a file.
 146 ****************************************************************************/
 147
 148 static ssize_t real_write_file(files_struct *fsp,char *data,SMB_OFF_T pos, size_t n)
 149 {
 150   if ((pos != -1) && (seek_file(fsp,pos) == -1))
 151     return -1;
 152
 153   return vfs_write_data(fsp,data,n);
 154 }
 155
 156 /****************************************************************************
 157 write to a file
 158 ****************************************************************************/
 159
 160 ssize_t write_file(files_struct *fsp, char *data, SMB_OFF_T pos, size_t n)
 161 {
 162   write_cache *wcp = fsp->wcp;
 163   ssize_t total_written = 0;
 164   int write_path = -1;
 165
 166   if (fsp->print_file) {
 167           return print_job_write(fsp->print_jobid, data, n);
 168   }
 169
 170   if (!fsp->can_write) {
 171     errno = EPERM;
 172     return(0);
 173   }
 174
 175   if (!fsp->modified) {
 176     SMB_STRUCT_STAT st;
 177     fsp->modified = True;
 178
 179     if (fsp->conn->vfs_ops.fstat(fsp,fsp->fd,&st) == 0) {
 180       int dosmode = dos_mode(fsp->conn,fsp->fsp_name,&st);
 181       if (MAP_ARCHIVE(fsp->conn) && !IS_DOS_ARCHIVE(dosmode)) {
 182         file_chmod(fsp->conn,fsp->fsp_name,dosmode | aARCH,&st);
 183       }
 184
 185       /*
 186        * If this is the first write and we have an exclusive oplock then setup
 187        * the write cache.
 188        */
 189
 190       if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && !wcp) {
 191         setup_write_cache(fsp, st.st_size);
 192         wcp = fsp->wcp;
 193       }
 194     }
 195   }
 196
 197 #ifdef WITH_PROFILE
 198   DO_PROFILE_INC(writecache_total_writes);
 199   if (!fsp->oplock_type) {
 200     DO_PROFILE_INC(writecache_non_oplock_writes);
 201   }
 202 #endif
 203
 204   /*
 205    * If this file is level II oplocked then we need
 206    * to grab the shared memory lock and inform all
 207    * other files with a level II lock that they need
 208    * to flush their read caches. We keep the lock over
 209    * the shared memory area whilst doing this.
 210    */
 211
 212   release_level_2_oplocks_on_change(fsp);
 213
 214 #ifdef WITH_PROFILE
 215   if (profile_p && profile_p->writecache_total_writes % 500 == 0) {
 216     DEBUG(3,("WRITECACHE: initwrites=%u abutted=%u total=%u \
 217 nonop=%u allocated=%u active=%u direct=%u perfect=%u readhits=%u\n",
 218         profile_p->writecache_init_writes,
 219         profile_p->writecache_abutted_writes,
 220         profile_p->writecache_total_writes,
 221         profile_p->writecache_non_oplock_writes,
 222         profile_p->writecache_allocated_write_caches,
 223         profile_p->writecache_num_write_caches,
 224         profile_p->writecache_direct_writes,
 225         profile_p->writecache_num_perfect_writes,
 226         profile_p->writecache_read_hits ));
 227
 228     DEBUG(3,("WRITECACHE: Flushes SEEK=%d, READ=%d, WRITE=%d, READRAW=%d, OPLOCK=%d, CLOSE=%d, SYNC=%d\n",
 229         profile_p->writecache_flushed_writes[SEEK_FLUSH],
 230         profile_p->writecache_flushed_writes[READ_FLUSH],
 231         profile_p->writecache_flushed_writes[WRITE_FLUSH],
 232         profile_p->writecache_flushed_writes[READRAW_FLUSH],
 233         profile_p->writecache_flushed_writes[OPLOCK_RELEASE_FLUSH],
 234         profile_p->writecache_flushed_writes[CLOSE_FLUSH],
 235         profile_p->writecache_flushed_writes[SYNC_FLUSH] ));
 236   }
 237 #endif
 238
 239   if(!wcp) {
 240     DO_PROFILE_INC(writecache_direct_writes);
 241     return real_write_file(fsp, data, pos, n);
 242   }
 243
 244   DEBUG(9,("write_file(fd=%d pos=%d size=%d) wofs=%d wsize=%d\n",
 245            fsp->fd, (int)pos, (int)n, (int)wcp->offset, (int)wcp->data_size));
 246
 247   /*
 248    * If we have active cache and it isn't contiguous then we flush.
 249    * NOTE: There is a small problem with running out of disk ....
 250    */
 251
 252   if (wcp->data_size) {
 253
 254     BOOL cache_flush_needed = False;
 255
 256     if ((pos >= wcp->offset) && (pos <= wcp->offset + wcp->data_size)) {
 257
 258       /*
 259        * Start of write overlaps or abutts the existing data.
 260        */
 261
 262       size_t data_used = MIN((wcp->alloc_size - (pos - wcp->offset)), n);
 263
 264       memcpy(wcp->data + (pos - wcp->offset), data, data_used);
 265
 266       /*
 267        * Update the current buffer size with the new data.
 268        */
 269
 270       if(pos + data_used > wcp->offset + wcp->data_size)
 271         wcp->data_size = pos + data_used - wcp->offset;
 272
 273       /*
 274        * Update the file size if changed.
 275        */
 276
 277       if (wcp->offset + wcp->data_size > wcp->file_size)
 278         wcp->file_size = wcp->offset + wcp->data_size;
 279
 280       /*
 281        * If we used all the data then
 282        * return here.
 283        */
 284
 285       if(n == data_used)
 286         return n;
 287       else
 288         cache_flush_needed = True;
 289
 290       /*
 291        * Move the start of data forward by the amount used,
 292        * cut down the amount left by the same amount.
 293        */
 294
 295       data += data_used;
 296       pos += data_used;
 297       n -= data_used;
 298
 299       DO_PROFILE_INC(writecache_abutted_writes);
 300       total_written = data_used;
 301
 302       write_path = 1;
 303
 304     } else if ((pos < wcp->offset) && (pos + n > wcp->offset) &&
 305                (pos + n <= wcp->offset + wcp->alloc_size)) {
 306
 307       /*
 308        * End of write overlaps the existing data.
 309        */
 310
 311       size_t data_used = pos + n - wcp->offset;
 312
 313       memcpy(wcp->data, data + n - data_used, data_used);
 314
 315       /*
 316        * Update the current buffer size with the new data.
 317        */
 318
 319       if(pos + n > wcp->offset + wcp->data_size)
 320         wcp->data_size = pos + n - wcp->offset;
 321
 322       /*
 323        * Update the file size if changed.
 324        */
 325
 326       if (wcp->offset + wcp->data_size > wcp->file_size)
 327         wcp->file_size = wcp->offset + wcp->data_size;
 328
 329       /*
 330        * We don't need to move the start of data, but we
 331        * cut down the amount left by the amount used.
 332        */
 333
 334       n -= data_used;
 335
 336       /*
 337        * We cannot have used all the data here.
 338        */
 339
 340       cache_flush_needed = True;
 341
 342       DO_PROFILE_INC(writecache_abutted_writes);
 343       total_written = data_used;
 344
 345       write_path = 2;
 346
 347     } else if ( (pos >= wcp->file_size) &&
 348                 (pos > wcp->offset + wcp->data_size) &&
 349                 (pos < wcp->offset + wcp->alloc_size) ) {
 350
 351       /*
 352        * Non-contiguous write part of which fits within
 353        * the cache buffer and is extending the file.
 354        */
 355
 356       size_t data_used;
 357
 358       if(pos + n <= wcp->offset + wcp->alloc_size)
 359         data_used = n;
 360       else
 361         data_used = wcp->offset + wcp->alloc_size - pos;
 362
 363       /*
 364        * Fill in the non-continuous area with zeros.
 365        */
 366
 367       memset(wcp->data + wcp->data_size, '\0',
 368              pos - (wcp->offset + wcp->data_size) );
 369
 370       memcpy(wcp->data + (pos - wcp->offset), data, data_used);
 371
 372       /*
 373        * Update the current buffer size with the new data.
 374        */
 375
 376       if(pos + data_used > wcp->offset + wcp->data_size)
 377         wcp->data_size = pos + data_used - wcp->offset;
 378
 379       /*
 380        * Update the file size if changed.
 381        */
 382
 383       if (wcp->offset + wcp->data_size > wcp->file_size)
 384         wcp->file_size = wcp->offset + wcp->data_size;
 385
 386       /*
 387        * If we used all the data then
 388        * return here.
 389        */
 390
 391       if(n == data_used)
 392         return n;
 393       else
 394         cache_flush_needed = True;
 395
 396       /*
 397        * Move the start of data forward by the amount used,
 398        * cut down the amount left by the same amount.
 399        */
 400
 401       data += data_used;
 402       pos += data_used;
 403       n -= data_used;
 404
 405       DO_PROFILE_INC(writecache_abutted_writes);
 406       total_written = data_used;
 407
 408       write_path = 3;
 409
 410     } else {
 411
 412       /*
 413        * Write is bigger than buffer, or there is no overlap on the
 414        * low or high ends.
 415        */
 416
 417       DEBUG(9,("write_file: non cacheable write : fd = %d, pos = %.0f, len = %u, current cache pos = %.0f \
 418 len = %u\n",fsp->fd, (double)pos, (unsigned int)n, (double)wcp->offset, (unsigned int)wcp->data_size ));
 419
 420       /*
 421        * Update the file size if needed.
 422        */
 423
 424       if(pos + n > wcp->file_size)
 425         wcp->file_size = pos + n;
 426
 427       /*
 428        * If write would fit in the cache, and is larger than
 429        * the data already in the cache, flush the cache and
 430        * preferentially copy the data new data into it. Otherwise
 431        * just write the data directly.
 432        */
 433
 434       if ( n <= wcp->alloc_size && n > wcp->data_size) {
 435         cache_flush_needed = True;
 436       } else {
 437         ssize_t ret = real_write_file(fsp, data, pos, n);
 438
 439         DO_PROFILE_INC(writecache_direct_writes);
 440         if (ret == -1)
 441           return ret;
 442
 443         if (pos + ret > wcp->file_size)
 444           wcp->file_size = pos + ret;
 445
 446         return ret;
 447       }
 448
 449       write_path = 4;
 450
 451     }
 452
 453     if(wcp->data_size > wcp->file_size)
 454       wcp->file_size = wcp->data_size;
 455
 456     if (cache_flush_needed) {
 457       DEBUG(3,("WRITE_FLUSH:%d: due to noncontinuous write: fd = %d, size = %.0f, pos = %.0f, \
 458 n = %u, wcp->offset=%.0f, wcp->data_size=%u\n",
 459              write_path, fsp->fd, (double)wcp->file_size, (double)pos, (unsigned int)n,
 460              (double)wcp->offset, (unsigned int)wcp->data_size ));
 461
 462       flush_write_cache(fsp, WRITE_FLUSH);
 463     }
 464   }
 465
 466   /*
 467    * If the write request is bigger than the cache
 468    * size, write it all out.
 469    */
 470
 471   if (n > wcp->alloc_size ) {
 472     ssize_t ret = real_write_file(fsp, data, pos, n);
 473     if (ret == -1)
 474       return -1;
 475
 476     if (pos + ret > wcp->file_size)
 477       wcp->file_size = pos + n;
 478
 479     DO_PROFILE_INC(writecache_direct_writes);
 480     return total_written + n;
 481   }
 482
 483   /*
 484    * If there's any data left, cache it.
 485    */
 486
 487   if (n) {
 488 #ifdef WITH_PROFILE
 489     if (wcp->data_size) {
 490       DO_PROFILE_INC(writecache_abutted_writes);
 491     } else {
 492       DO_PROFILE_INC(writecache_init_writes);
 493     }
 494 #endif
 495     memcpy(wcp->data+wcp->data_size, data, n);
 496     if (wcp->data_size == 0) {
 497       wcp->offset = pos;
 498       DO_PROFILE_INC(writecache_num_write_caches);
 499     }
 500     wcp->data_size += n;
 501
 502     /*
 503      * Update the file size if changed.
 504      */
 505
 506     if (wcp->offset + wcp->data_size > wcp->file_size)
 507       wcp->file_size = wcp->offset + wcp->data_size;
 508     DEBUG(9,("cache return %u\n", (unsigned int)n));
 509
 510     total_written += n;
 511     return total_written; /* .... that's a write :) */
 512   }
 513
 514   return total_written;
 515 }
 516
 517 /****************************************************************************
 518  Delete the write cache structure.
 519 ****************************************************************************/
 520
 521 void delete_write_cache(files_struct *fsp)
 522 {
 523   write_cache *wcp;
 524
 525   if(!fsp)
 526     return;
 527
 528   if(!(wcp = fsp->wcp))
 529     return;
 530
 531   DO_PROFILE_DEC(writecache_allocated_write_caches);
 532   allocated_write_caches--;
 533
 534   SMB_ASSERT(wcp->data_size == 0);
 535
 536   SAFE_FREE(wcp->data);
 537   SAFE_FREE(fsp->wcp);
 538
 539   DEBUG(10,("delete_write_cache: File %s deleted write cache\n", fsp->fsp_name ));
 540
 541 }
 542
 543 /****************************************************************************
 544  Setup the write cache structure.
 545 ****************************************************************************/
 546
 547 static BOOL setup_write_cache(files_struct *fsp, SMB_OFF_T file_size)
 548 {
 549   ssize_t alloc_size = lp_write_cache_size(SNUM(fsp->conn));
 550   write_cache *wcp;
 551
 552   if (allocated_write_caches >= MAX_WRITE_CACHES)
 553         return False;
 554
 555   if(alloc_size == 0 || fsp->wcp)
 556     return False;
 557
 558   if((wcp = (write_cache *)malloc(sizeof(write_cache))) == NULL) {
 559     DEBUG(0,("setup_write_cache: malloc fail.\n"));
 560     return False;
 561   }
 562
 563   wcp->file_size = file_size;
 564   wcp->offset = 0;
 565   wcp->alloc_size = alloc_size;
 566   wcp->data_size = 0;
 567   if((wcp->data = malloc(wcp->alloc_size)) == NULL) {
 568     DEBUG(0,("setup_write_cache: malloc fail for buffer size %u.\n",
 569           (unsigned int)wcp->alloc_size ));
 570     SAFE_FREE(wcp);
 571     return False;
 572   }
 573
 574   fsp->wcp = wcp;
 575   DO_PROFILE_INC(writecache_allocated_write_caches);
 576   allocated_write_caches++;
 577
 578   DEBUG(10,("setup_write_cache: File %s allocated write cache size %u\n",
 579                 fsp->fsp_name, wcp->alloc_size ));
 580
 581   return True;
 582 }
 583
 584 /****************************************************************************
 585  Cope with a size change.
 586 ****************************************************************************/
 587
 588 void set_filelen_write_cache(files_struct *fsp, SMB_OFF_T file_size)
 589 {
 590   if(fsp->wcp) {
 591     /* The cache *must* have been flushed before we do this. */
 592     if (fsp->wcp->data_size != 0) {
 593       pstring msg;
 594       slprintf(msg, sizeof(msg)-1, "set_filelen_write_cache: size change \
 595 on file %s with write cache size = %u\n", fsp->fsp_name, fsp->wcp->data_size );
 596       smb_panic(msg);
 597     }
 598     fsp->wcp->file_size = file_size;
 599   }
 600 }
 601
 602 /*******************************************************************
 603  Flush a write cache struct to disk.
 604 ********************************************************************/
 605
 606 ssize_t flush_write_cache(files_struct *fsp, enum flush_reason_enum reason)
 607 {
 608   write_cache *wcp = fsp->wcp;
 609   size_t data_size;
 610   ssize_t ret;
 611
 612   if(!wcp || !wcp->data_size)
 613     return 0;
 614
 615   data_size = wcp->data_size;
 616   wcp->data_size = 0;
 617
 618   DO_PROFILE_DEC_INC(writecache_num_write_caches,writecache_flushed_writes[reason]);
 619
 620   DEBUG(9,("flushing write cache: fd = %d, off=%.0f, size=%u\n",
 621            fsp->fd, (double)wcp->offset, (unsigned int)data_size));
 622
 623 #ifdef WITH_PROFILE
 624   if(data_size == wcp->alloc_size)
 625     DO_PROFILE_INC(writecache_num_perfect_writes);
 626 #endif
 627
 628   ret = real_write_file(fsp, wcp->data, wcp->offset, data_size);
 629
 630   /*
 631    * Ensure file size if kept up to date if write extends file.
 632    */
 633
 634   if ((ret != -1) && (wcp->offset + ret > wcp->file_size))
 635     wcp->file_size = wcp->offset + ret;
 636
 637   return ret;
 638 }
 639
 640 /*******************************************************************
 641 sync a file
 642 ********************************************************************/
 643
 644 void sync_file(connection_struct *conn, files_struct *fsp)
 645 {
 646     if(lp_strict_sync(SNUM(conn)) && fsp->fd != -1) {
 647       flush_write_cache(fsp, SYNC_FLUSH);
 648       conn->vfs_ops.fsync(fsp,fsp->fd);
 649     }
 650 }