src/afs/VNOPS/afs_vnop_write.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * Implements:
  12  * afs_UFSWrite
  13  * afs_MemWrite
  14  * afs_StoreOnLastReference
  15  * afs_close
  16  * afs_closex
  17  * afs_fsync
  18  */
  19
  20 #include <afsconfig.h>
  21 #include "afs/param.h"
  22
  23 RCSID
  24     ("$Header$");
  25
  26 #include "afs/sysincludes.h"    /* Standard vendor system headers */
  27 #include "afsincludes.h"        /* Afs-based standard headers */
  28 #include "afs/afs_stats.h"      /* statistics */
  29 #include "afs/afs_cbqueue.h"
  30 #include "afs/nfsclient.h"
  31 #include "afs/afs_osidnlc.h"
  32
  33
  34 extern unsigned char *afs_indexFlags;
  35
  36 /* Called by all write-on-close routines: regular afs_close,
  37  * store via background daemon and store via the
  38  * afs_FlushActiveVCaches routine (when CCORE is on).
  39  * avc->lock must be write-locked.
  40  */
  41 int
  42 afs_StoreOnLastReference(register struct vcache *avc,
  43                          register struct vrequest *treq)
  44 {
  45     int code = 0;
  46
  47     AFS_STATCNT(afs_StoreOnLastReference);
  48     /* if CCore flag is set, we clear it and do the extra decrement
  49      * ourselves now. If we're called by the CCore clearer, the CCore
  50      * flag will already be clear, so we don't have to worry about
  51      * clearing it twice. */
  52     if (avc->states & CCore) {
  53         avc->states &= ~CCore;
  54 #if defined(AFS_SGI_ENV)
  55         osi_Assert(avc->opens > 0 && avc->execsOrWriters > 0);
  56 #endif
  57         /* WARNING: Our linux cm code treats the execsOrWriters counter differently
  58          * depending on the flags the file was opened with. So, if you make any
  59          * changes to the way the execsOrWriters flag is handled check with the
  60          * top level code.  */
  61         avc->opens--;
  62         avc->execsOrWriters--;
  63         AFS_RELE(AFSTOV(avc));  /* VN_HOLD at set CCore(afs_FakeClose) */
  64         crfree((struct AFS_UCRED *)avc->linkData);      /* "crheld" in afs_FakeClose */
  65         avc->linkData = NULL;
  66     }
  67
  68     if (!AFS_IS_DISCONNECTED) {
  69         /* Connected. */
  70
  71         /* Now, send the file back.  Used to require 0 writers left, but now do
  72          * it on every close for write, since two closes in a row are harmless
  73          * since first will clean all chunks, and second will be noop.  Note that
  74          * this will also save confusion when someone keeps a file open
  75          * inadvertently, since with old system, writes to the server would never
  76          * happen again.
  77          */
  78         code = afs_StoreAllSegments(avc, treq, AFS_LASTSTORE /*!sync-to-disk */ );
  79         /*
  80          * We have to do these after the above store in done: in some systems
  81          * like aix they'll need to flush all the vm dirty pages to the disk via
  82          * the strategy routine. During that all procedure (done under no avc
  83          * locks) opens, refcounts would be zero, since it didn't reach the
  84          * afs_{rd,wr} routines which means the vcache is a perfect candidate
  85          * for flushing!
  86          */
  87
  88 #ifdef AFS_DISCON_ENV
  89      } else if (AFS_IS_DISCON_RW) {
  90         /* Disconnected. */
  91
  92         if (!avc->ddirty_flags ||
  93                 (avc->ddirty_flags == VDisconShadowed)) {
  94             /* Add to disconnected dirty list. */
  95             AFS_DISCON_ADD_DIRTY(avc);
  96         }
  97
  98         /* Set disconnected write flag. */
  99         avc->ddirty_flags |= VDisconWriteClose;
 100 #endif
 101     }           /* if not disconnected */
 102
 103 #if defined(AFS_SGI_ENV)
 104     osi_Assert(avc->opens > 0 && avc->execsOrWriters > 0);
 105 #endif
 106
 107     avc->opens--;
 108     avc->execsOrWriters--;
 109     return code;
 110 }
 111
 112
 113
 114 int
 115 afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
 116              struct AFS_UCRED *acred, int noLock)
 117 {
 118     afs_size_t totalLength;
 119     afs_size_t transferLength;
 120     afs_size_t filePos;
 121     afs_size_t offset, len;
 122     afs_int32 tlen, trimlen;
 123     afs_int32 startDate;
 124     afs_int32 max;
 125     register struct dcache *tdc;
 126 #ifdef _HIGHC_
 127     volatile
 128 #endif
 129     afs_int32 error;
 130 #ifdef AFS_DARWIN80_ENV
 131     uio_t tuiop = NULL;
 132 #else
 133     struct uio tuio;
 134     struct uio *tuiop = &tuio;
 135     struct iovec *tvec;         /* again, should have define */
 136 #endif
 137     register afs_int32 code;
 138     struct vrequest treq;
 139
 140     AFS_STATCNT(afs_MemWrite);
 141     if (avc->vc_error)
 142         return avc->vc_error;
 143
 144     startDate = osi_Time();
 145     if ((code = afs_InitReq(&treq, acred)))
 146         return code;
 147     /* otherwise we read */
 148     totalLength = AFS_UIO_RESID(auio);
 149     filePos = AFS_UIO_OFFSET(auio);
 150     error = 0;
 151     transferLength = 0;
 152     afs_Trace4(afs_iclSetp, CM_TRACE_WRITE, ICL_TYPE_POINTER, avc,
 153                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(filePos), ICL_TYPE_OFFSET,
 154                ICL_HANDLE_OFFSET(totalLength), ICL_TYPE_OFFSET,
 155                ICL_HANDLE_OFFSET(avc->m.Length));
 156     if (!noLock) {
 157         afs_MaybeWakeupTruncateDaemon();
 158         ObtainWriteLock(&avc->lock, 126);
 159     }
 160 #if defined(AFS_SGI_ENV)
 161     {
 162         off_t diff;
 163         /*
 164          * afs_xwrite handles setting m.Length
 165          * and handles APPEND mode.
 166          * Since we are called via strategy, we need to trim the write to
 167          * the actual size of the file
 168          */
 169         osi_Assert(filePos <= avc->m.Length);
 170         diff = avc->m.Length - filePos;
 171         AFS_UIO_SETRESID(auio, MIN(totalLength, diff));
 172         totalLength = AFS_UIO_RESID(auio);
 173     }
 174 #else
 175     if (aio & IO_APPEND) {
 176         /* append mode, start it at the right spot */
 177 #if     defined(AFS_SUN56_ENV)
 178         auio->uio_loffset = 0;
 179 #endif
 180         filePos = avc->m.Length;
 181         AFS_UIO_SETOFFSET(auio, filePos);
 182     }
 183 #endif
 184     /*
 185      * Note that we use startDate rather than calling osi_Time() here.
 186      * This is to avoid counting lock-waiting time in file date (for ranlib).
 187      */
 188     avc->m.Date = startDate;
 189
 190 #if     defined(AFS_HPUX_ENV)
 191 #if     defined(AFS_HPUX101_ENV)
 192     if ((totalLength + filePos) >> 9 >
 193         (p_rlimit(u.u_procp))[RLIMIT_FSIZE].rlim_cur) {
 194 #else
 195     if ((totalLength + filePos) >> 9 > u.u_rlimit[RLIMIT_FSIZE].rlim_cur) {
 196 #endif
 197         if (!noLock)
 198             ReleaseWriteLock(&avc->lock);
 199         return (EFBIG);
 200     }
 201 #endif
 202 #ifdef AFS_VM_RDWR_ENV
 203     /*
 204      * If write is implemented via VM, afs_FakeOpen() is called from the
 205      * high-level write op.
 206      */
 207     if (avc->execsOrWriters <= 0) {
 208         printf("WARNING: afs_ufswr vp=%lx, exOrW=%d\n", (unsigned long)avc,
 209                avc->execsOrWriters);
 210     }
 211 #else
 212     afs_FakeOpen(avc);
 213 #endif
 214     avc->states |= CDirty;
 215 #ifndef AFS_DARWIN80_ENV
 216     tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
 217 #endif
 218     while (totalLength > 0) {
 219         /*
 220          *  The following line is necessary because afs_GetDCache with
 221          *  flag == 4 expects the length field to be filled. It decides
 222          *  from this whether it's necessary to fetch data into the chunk
 223          *  before writing or not (when the whole chunk is overwritten!).
 224          */
 225         len = totalLength;      /* write this amount by default */
 226         if (noLock) {
 227             tdc = afs_FindDCache(avc, filePos);
 228             if (tdc)
 229                 ObtainWriteLock(&tdc->lock, 653);
 230         } else if (afs_blocksUsed >
 231                    PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
 232             tdc = afs_FindDCache(avc, filePos);
 233             if (tdc) {
 234                 ObtainWriteLock(&tdc->lock, 654);
 235                 if (!hsame(tdc->f.versionNo, avc->m.DataVersion)
 236                     || (tdc->dflags & DFFetching)) {
 237                     ReleaseWriteLock(&tdc->lock);
 238                     afs_PutDCache(tdc);
 239                     tdc = NULL;
 240                 }
 241             }
 242             if (!tdc) {
 243                 afs_MaybeWakeupTruncateDaemon();
 244                 while (afs_blocksUsed >
 245                        PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
 246                     ReleaseWriteLock(&avc->lock);
 247                     if (afs_blocksUsed - afs_blocksDiscarded >
 248                         PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
 249                         afs_WaitForCacheDrain = 1;
 250                         afs_osi_Sleep(&afs_WaitForCacheDrain);
 251                     }
 252                     afs_MaybeFreeDiscardedDCache();
 253                     afs_MaybeWakeupTruncateDaemon();
 254                     ObtainWriteLock(&avc->lock, 506);
 255                 }
 256                 avc->states |= CDirty;
 257                 tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 4);
 258                 if (tdc)
 259                     ObtainWriteLock(&tdc->lock, 655);
 260             }
 261         } else {
 262             tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 4);
 263             if (tdc)
 264                 ObtainWriteLock(&tdc->lock, 656);
 265         }
 266         if (!tdc) {
 267             error = EIO;
 268             break;
 269         }
 270         if (!(afs_indexFlags[tdc->index] & IFDataMod)) {
 271             afs_stats_cmperf.cacheCurrDirtyChunks++;
 272             afs_indexFlags[tdc->index] |= IFDataMod;    /* so it doesn't disappear */
 273         }
 274         if (!(tdc->f.states & DWriting)) {
 275             /* don't mark entry as mod if we don't have to */
 276             tdc->f.states |= DWriting;
 277             tdc->dflags |= DFEntryMod;
 278         }
 279         len = totalLength;      /* write this amount by default */
 280         offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 281         max = AFS_CHUNKTOSIZE(tdc->f.chunk);    /* max size of this chunk */
 282         if (max <= len + offset) {      /*if we'd go past the end of this chunk */
 283             /* it won't all fit in this chunk, so write as much
 284              * as will fit */
 285             len = max - offset;
 286         }
 287
 288 #ifdef  AFS_DARWIN80_ENV
 289         if (tuiop)
 290             uio_free(tuiop);
 291         trimlen = len;
 292         tuiop = afsio_darwin_partialcopy(auio, trimlen);
 293 #else
 294         /* mung uio structure to be right for this transfer */
 295         afsio_copy(auio, &tuio, tvec);
 296         trimlen = len;
 297         afsio_trim(&tuio, trimlen);
 298 #endif
 299         AFS_UIO_SETOFFSET(tuiop, offset);
 300
 301         code = afs_MemWriteUIO(tdc->f.inode, tuiop);
 302         if (code) {
 303             void *mep;          /* XXX in prototype world is struct memCacheEntry * */
 304             error = code;
 305             ZapDCE(tdc);        /* bad data */
 306             mep = afs_MemCacheOpen(tdc->f.inode);
 307             afs_MemCacheTruncate(mep, 0);
 308             afs_MemCacheClose(mep);
 309             afs_stats_cmperf.cacheCurrDirtyChunks--;
 310             afs_indexFlags[tdc->index] &= ~IFDataMod;   /* so it does disappear */
 311             ReleaseWriteLock(&tdc->lock);
 312             afs_PutDCache(tdc);
 313             break;
 314         }
 315         /* otherwise we've written some, fixup length, etc and continue with next seg */
 316         len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
 317         tlen = len;
 318         afsio_skip(auio, tlen); /* advance auio over data written */
 319         /* compute new file size */
 320         if (offset + len > tdc->f.chunkBytes) {
 321             afs_int32 tlength = offset + len;
 322             afs_AdjustSize(tdc, tlength);
 323             if (tdc->validPos < filePos + len)
 324                 tdc->validPos = filePos + len;
 325         }
 326         totalLength -= len;
 327         transferLength += len;
 328         filePos += len;
 329 #if defined(AFS_SGI_ENV)
 330         /* afs_xwrite handles setting m.Length */
 331         osi_Assert(filePos <= avc->m.Length);
 332 #else
 333         if (filePos > avc->m.Length) {
 334             afs_Trace4(afs_iclSetp, CM_TRACE_SETLENGTH, ICL_TYPE_STRING,
 335                        __FILE__, ICL_TYPE_LONG, __LINE__, ICL_TYPE_OFFSET,
 336                        ICL_HANDLE_OFFSET(avc->m.Length), ICL_TYPE_OFFSET,
 337                        ICL_HANDLE_OFFSET(filePos));
 338             avc->m.Length = filePos;
 339         }
 340 #endif
 341         ReleaseWriteLock(&tdc->lock);
 342         afs_PutDCache(tdc);
 343 #if !defined(AFS_VM_RDWR_ENV)
 344         /*
 345          * If write is implemented via VM, afs_DoPartialWrite() is called from
 346          * the high-level write op.
 347          */
 348         if (!noLock) {
 349             code = afs_DoPartialWrite(avc, &treq);
 350             if (code) {
 351                 error = code;
 352                 break;
 353             }
 354         }
 355 #endif
 356     }
 357 #ifndef AFS_VM_RDWR_ENV
 358     afs_FakeClose(avc, acred);
 359 #endif
 360     if (error && !avc->vc_error)
 361         avc->vc_error = error;
 362     if (!noLock)
 363         ReleaseWriteLock(&avc->lock);
 364 #ifdef AFS_DARWIN80_ENV
 365     uio_free(tuiop);
 366 #else
 367     osi_FreeSmallSpace(tvec);
 368 #endif
 369     error = afs_CheckCode(error, &treq, 6);
 370     return error;
 371 }
 372
 373
 374 /* called on writes */
 375 int
 376 afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
 377              struct AFS_UCRED *acred, int noLock)
 378 {
 379     afs_size_t totalLength;
 380     afs_size_t transferLength;
 381     afs_size_t filePos;
 382     afs_size_t offset, len;
 383     afs_int32 tlen;
 384     afs_int32 trimlen;
 385     afs_int32 startDate;
 386     afs_int32 max;
 387     register struct dcache *tdc;
 388 #ifdef _HIGHC_
 389     volatile
 390 #endif
 391     afs_int32 error;
 392 #ifdef AFS_DARWIN80_ENV
 393     uio_t tuiop = NULL;
 394 #else
 395     struct uio tuio;
 396     struct uio *tuiop = &tuio;
 397     struct iovec *tvec;         /* again, should have define */
 398 #endif
 399     struct osi_file *tfile;
 400     register afs_int32 code;
 401     struct vrequest treq;
 402
 403     AFS_STATCNT(afs_UFSWrite);
 404     if (avc->vc_error)
 405         return avc->vc_error;
 406
 407     if (AFS_IS_DISCONNECTED && !AFS_IS_DISCON_RW)
 408         return ENETDOWN;
 409
 410     startDate = osi_Time();
 411     if ((code = afs_InitReq(&treq, acred)))
 412         return code;
 413     /* otherwise we read */
 414     totalLength = AFS_UIO_RESID(auio);
 415     filePos = AFS_UIO_OFFSET(auio);
 416     error = 0;
 417     transferLength = 0;
 418     afs_Trace4(afs_iclSetp, CM_TRACE_WRITE, ICL_TYPE_POINTER, avc,
 419                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(filePos), ICL_TYPE_OFFSET,
 420                ICL_HANDLE_OFFSET(totalLength), ICL_TYPE_OFFSET,
 421                ICL_HANDLE_OFFSET(avc->m.Length));
 422     if (!noLock) {
 423         afs_MaybeWakeupTruncateDaemon();
 424         ObtainWriteLock(&avc->lock, 556);
 425     }
 426 #if defined(AFS_SGI_ENV)
 427     {
 428         off_t diff;
 429         /*
 430          * afs_xwrite handles setting m.Length
 431          * and handles APPEND mode.
 432          * Since we are called via strategy, we need to trim the write to
 433          * the actual size of the file
 434          */
 435         osi_Assert(filePos <= avc->m.Length);
 436         diff = avc->m.Length - filePos;
 437         AFS_UIO_SETRESID(auio, MIN(totalLength, diff));
 438         totalLength = AFS_UIO_RESID(auio);
 439     }
 440 #else
 441     if (aio & IO_APPEND) {
 442         /* append mode, start it at the right spot */
 443 #if     defined(AFS_SUN56_ENV)
 444         auio->uio_loffset = 0;
 445 #endif
 446         filePos = avc->m.Length;
 447         AFS_UIO_SETOFFSET(auio, avc->m.Length);
 448     }
 449 #endif
 450     /*
 451      * Note that we use startDate rather than calling osi_Time() here.
 452      * This is to avoid counting lock-waiting time in file date (for ranlib).
 453      */
 454     avc->m.Date = startDate;
 455
 456 #if     defined(AFS_HPUX_ENV)
 457 #if     defined(AFS_HPUX101_ENV)
 458     if ((totalLength + filePos) >> 9 >
 459         p_rlimit(u.u_procp)[RLIMIT_FSIZE].rlim_cur) {
 460 #else
 461     if ((totalLength + filePos) >> 9 > u.u_rlimit[RLIMIT_FSIZE].rlim_cur) {
 462 #endif
 463         if (!noLock)
 464             ReleaseWriteLock(&avc->lock);
 465         return (EFBIG);
 466     }
 467 #endif
 468 #ifdef  AFS_VM_RDWR_ENV
 469     /*
 470      * If write is implemented via VM, afs_FakeOpen() is called from the
 471      * high-level write op.
 472      */
 473     if (avc->execsOrWriters <= 0) {
 474         printf("WARNING: afs_ufswr vcp=%lx, exOrW=%d\n", (unsigned long)avc,
 475                avc->execsOrWriters);
 476     }
 477 #else
 478     afs_FakeOpen(avc);
 479 #endif
 480     avc->states |= CDirty;
 481 #ifndef AFS_DARWIN80_ENV
 482     tvec = (struct iovec *)osi_AllocSmallSpace(sizeof(struct iovec));
 483 #endif
 484     while (totalLength > 0) {
 485         /*
 486          *  The following line is necessary because afs_GetDCache with
 487          *  flag == 4 expects the length field to be filled. It decides
 488          *  from this whether it's necessary to fetch data into the chunk
 489          *  before writing or not (when the whole chunk is overwritten!).
 490          */
 491         len = totalLength;      /* write this amount by default */
 492         /* read the cached info */
 493         if (noLock) {
 494             tdc = afs_FindDCache(avc, filePos);
 495             if (tdc)
 496                 ObtainWriteLock(&tdc->lock, 657);
 497         } else if (afs_blocksUsed >
 498                    PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
 499             tdc = afs_FindDCache(avc, filePos);
 500             if (tdc) {
 501                 ObtainWriteLock(&tdc->lock, 658);
 502                 if (!hsame(tdc->f.versionNo, avc->m.DataVersion)
 503                     || (tdc->dflags & DFFetching)) {
 504                     ReleaseWriteLock(&tdc->lock);
 505                     afs_PutDCache(tdc);
 506                     tdc = NULL;
 507                 }
 508             }
 509             if (!tdc) {
 510                 afs_MaybeWakeupTruncateDaemon();
 511                 while (afs_blocksUsed >
 512                        PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
 513                     ReleaseWriteLock(&avc->lock);
 514                     if (afs_blocksUsed - afs_blocksDiscarded >
 515                         PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
 516                         afs_WaitForCacheDrain = 1;
 517                         afs_osi_Sleep(&afs_WaitForCacheDrain);
 518                     }
 519                     afs_MaybeFreeDiscardedDCache();
 520                     afs_MaybeWakeupTruncateDaemon();
 521                     ObtainWriteLock(&avc->lock, 509);
 522                 }
 523                 avc->states |= CDirty;
 524                 tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 4);
 525                 if (tdc)
 526                     ObtainWriteLock(&tdc->lock, 659);
 527             }
 528         } else {
 529             tdc = afs_GetDCache(avc, filePos, &treq, &offset, &len, 4);
 530             if (tdc)
 531                 ObtainWriteLock(&tdc->lock, 660);
 532         }
 533         if (!tdc) {
 534             error = EIO;
 535             break;
 536         }
 537         if (!(afs_indexFlags[tdc->index] & IFDataMod)) {
 538             afs_stats_cmperf.cacheCurrDirtyChunks++;
 539             afs_indexFlags[tdc->index] |= IFDataMod;    /* so it doesn't disappear */
 540         }
 541         if (!(tdc->f.states & DWriting)) {
 542             /* don't mark entry as mod if we don't have to */
 543             tdc->f.states |= DWriting;
 544             tdc->dflags |= DFEntryMod;
 545         }
 546 #if defined(LINUX_USE_FH)
 547         tfile = (struct osi_file *)osi_UFSOpen_fh(&tdc->f.fh, tdc->f.fh_type);
 548 #else
 549         tfile = (struct osi_file *)osi_UFSOpen(tdc->f.inode);
 550 #endif
 551         len = totalLength;      /* write this amount by default */
 552         offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 553         max = AFS_CHUNKTOSIZE(tdc->f.chunk);    /* max size of this chunk */
 554         if (max <= len + offset) {      /*if we'd go past the end of this chunk */
 555             /* it won't all fit in this chunk, so write as much
 556              * as will fit */
 557             len = max - offset;
 558         }
 559
 560 #ifdef  AFS_DARWIN80_ENV
 561         if (tuiop)
 562             uio_free(tuiop);
 563         trimlen = len;
 564         tuiop = afsio_darwin_partialcopy(auio, trimlen);
 565 #else
 566         /* mung uio structure to be right for this transfer */
 567         afsio_copy(auio, &tuio, tvec);
 568         trimlen = len;
 569         afsio_trim(&tuio, trimlen);
 570 #endif
 571         AFS_UIO_SETOFFSET(tuiop, offset);
 572
 573 #if defined(AFS_AIX41_ENV)
 574         AFS_GUNLOCK();
 575         code =
 576             VNOP_RDWR(tfile->vnode, UIO_WRITE, FWRITE, &tuio, NULL, NULL,
 577                       NULL, afs_osi_credp);
 578         AFS_GLOCK();
 579 #elif defined(AFS_AIX32_ENV)
 580         code = VNOP_RDWR(tfile->vnode, UIO_WRITE, FWRITE, &tuio, NULL, NULL);
 581 #elif defined(AFS_AIX_ENV)
 582         code =
 583             VNOP_RDWR(tfile->vnode, UIO_WRITE, FWRITE, (off_t) & offset,
 584                       &tuio, NULL, NULL, -1);
 585 #elif defined(AFS_SUN5_ENV)
 586         AFS_GUNLOCK();
 587 #ifdef AFS_SUN510_ENV
 588         {
 589             caller_context_t ct;
 590
 591             VOP_RWLOCK(tfile->vnode, 1, &ct);
 592             code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp, &ct);
 593             VOP_RWUNLOCK(tfile->vnode, 1, &ct);
 594         }
 595 #else
 596         VOP_RWLOCK(tfile->vnode, 1);
 597         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 598         VOP_RWUNLOCK(tfile->vnode, 1);
 599 #endif
 600         AFS_GLOCK();
 601         if (code == ENOSPC)
 602             afs_warnuser
 603                 ("\n\n\n*** Cache partition is full - decrease cachesize!!! ***\n\n\n");
 604 #elif defined(AFS_SGI_ENV)
 605         AFS_GUNLOCK();
 606         avc->states |= CWritingUFS;
 607         AFS_VOP_RWLOCK(tfile->vnode, VRWLOCK_WRITE);
 608         AFS_VOP_WRITE(tfile->vnode, &tuio, IO_ISLOCKED, afs_osi_credp, code);
 609         AFS_VOP_RWUNLOCK(tfile->vnode, VRWLOCK_WRITE);
 610         avc->states &= ~CWritingUFS;
 611         AFS_GLOCK();
 612 #elif defined(AFS_OSF_ENV)
 613         {
 614             struct ucred *tmpcred = u.u_cred;
 615             u.u_cred = afs_osi_credp;
 616             tuio.uio_rw = UIO_WRITE;
 617             AFS_GUNLOCK();
 618             VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp, code);
 619             AFS_GLOCK();
 620             u.u_cred = tmpcred;
 621         }
 622 #elif defined(AFS_HPUX100_ENV)
 623         {
 624             AFS_GUNLOCK();
 625             code = VOP_RDWR(tfile->vnode, &tuio, UIO_WRITE, 0, afs_osi_credp);
 626             AFS_GLOCK();
 627         }
 628 #elif defined(AFS_LINUX20_ENV)
 629         AFS_GUNLOCK();
 630         code = osi_rdwr(tfile, &tuio, UIO_WRITE);
 631         AFS_GLOCK();
 632 #elif defined(AFS_DARWIN80_ENV)
 633         AFS_GUNLOCK();
 634         code = VNOP_WRITE(tfile->vnode, tuiop, 0, afs_osi_ctxtp);
 635         AFS_GLOCK();
 636 #elif defined(AFS_DARWIN_ENV)
 637         AFS_GUNLOCK();
 638         VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
 639         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 640         VOP_UNLOCK(tfile->vnode, 0, current_proc());
 641         AFS_GLOCK();
 642 #elif defined(AFS_FBSD80_ENV)
 643         AFS_GUNLOCK();
 644         VOP_LOCK(tfile->vnode, LK_EXCLUSIVE);
 645         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 646         VOP_UNLOCK(tfile->vnode, 0);
 647         AFS_GLOCK();
 648 #elif defined(AFS_FBSD50_ENV)
 649         AFS_GUNLOCK();
 650         VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curthread);
 651         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 652         VOP_UNLOCK(tfile->vnode, 0, curthread);
 653         AFS_GLOCK();
 654 #elif defined(AFS_XBSD_ENV)
 655         AFS_GUNLOCK();
 656         VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curproc);
 657         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 658         VOP_UNLOCK(tfile->vnode, 0, curproc);
 659         AFS_GLOCK();
 660 #else
 661 #ifdef  AFS_HPUX_ENV
 662         tuio.uio_fpflags &= ~FSYNCIO;   /* don't do sync io */
 663 #endif
 664         code = VOP_RDWR(tfile->vnode, &tuio, UIO_WRITE, 0, afs_osi_credp);
 665 #endif
 666         if (code) {
 667             error = code;
 668             ZapDCE(tdc);        /* bad data */
 669             osi_UFSTruncate(tfile, 0);  /* fake truncate the segment */
 670             afs_AdjustSize(tdc, 0);     /* sets f.chunkSize to 0 */
 671             afs_stats_cmperf.cacheCurrDirtyChunks--;
 672             afs_indexFlags[tdc->index] &= ~IFDataMod;   /* so it does disappear */
 673             afs_CFileClose(tfile);
 674             ReleaseWriteLock(&tdc->lock);
 675             afs_PutDCache(tdc);
 676             break;
 677         }
 678         /* otherwise we've written some, fixup length, etc and continue with next seg */
 679         len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
 680         tlen = len;
 681         afsio_skip(auio, tlen); /* advance auio over data written */
 682         /* compute new file size */
 683         if (offset + len > tdc->f.chunkBytes) {
 684             afs_int32 tlength = offset + len;
 685             afs_AdjustSize(tdc, tlength);
 686             if (tdc->validPos < filePos + len)
 687                 tdc->validPos = filePos + len;
 688         }
 689         totalLength -= len;
 690         transferLength += len;
 691         filePos += len;
 692 #if defined(AFS_SGI_ENV)
 693         /* afs_xwrite handles setting m.Length */
 694         osi_Assert(filePos <= avc->m.Length);
 695 #else
 696         if (filePos > avc->m.Length) {
 697             afs_Trace4(afs_iclSetp, CM_TRACE_SETLENGTH, ICL_TYPE_STRING,
 698                        __FILE__, ICL_TYPE_LONG, __LINE__, ICL_TYPE_OFFSET,
 699                        ICL_HANDLE_OFFSET(avc->m.Length), ICL_TYPE_OFFSET,
 700                        ICL_HANDLE_OFFSET(filePos));
 701             avc->m.Length = filePos;
 702         }
 703 #endif
 704         osi_UFSClose(tfile);
 705         ReleaseWriteLock(&tdc->lock);
 706         afs_PutDCache(tdc);
 707 #if !defined(AFS_VM_RDWR_ENV)
 708         /*
 709          * If write is implemented via VM, afs_DoPartialWrite() is called from
 710          * the high-level write op.
 711          */
 712         if (!noLock) {
 713             code = afs_DoPartialWrite(avc, &treq);
 714             if (code) {
 715                 error = code;
 716                 break;
 717             }
 718         }
 719 #endif
 720     }
 721 #ifndef AFS_VM_RDWR_ENV
 722     afs_FakeClose(avc, acred);
 723 #endif
 724     error = afs_CheckCode(error, &treq, 7);
 725     /* This set is here so we get the CheckCode. */
 726     if (error && !avc->vc_error)
 727         avc->vc_error = error;
 728     if (!noLock)
 729         ReleaseWriteLock(&avc->lock);
 730 #ifdef AFS_DARWIN80_ENV
 731     uio_free(tuiop);
 732 #else
 733     osi_FreeSmallSpace(tvec);
 734 #endif
 735 #ifndef AFS_VM_RDWR_ENV
 736     /*
 737      * If write is implemented via VM, afs_fsync() is called from the high-level
 738      * write op.
 739      */
 740 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 741     if (noLock && (aio & IO_SYNC)) {
 742 #else
 743 #ifdef  AFS_HPUX_ENV
 744     /* On hpux on synchronous writes syncio will be set to IO_SYNC. If
 745      * we're doing them because the file was opened with O_SYNCIO specified,
 746      * we have to look in the u area. No single mechanism here!!
 747      */
 748     if (noLock && ((aio & IO_SYNC) | (auio->uio_fpflags & FSYNCIO))) {
 749 #else
 750     if (noLock && (aio & FSYNC)) {
 751 #endif
 752 #endif
 753         if (!AFS_NFSXLATORREQ(acred))
 754             afs_fsync(avc, acred);
 755     }
 756 #endif
 757     return error;
 758 }
 759
 760 /* do partial write if we're low on unmodified chunks */
 761 int
 762 afs_DoPartialWrite(register struct vcache *avc, struct vrequest *areq)
 763 {
 764     register afs_int32 code;
 765
 766     if (afs_stats_cmperf.cacheCurrDirtyChunks <=
 767         afs_stats_cmperf.cacheMaxDirtyChunks)
 768         return 0;               /* nothing to do */
 769     /* otherwise, call afs_StoreDCache (later try to do this async, if possible) */
 770     afs_Trace2(afs_iclSetp, CM_TRACE_PARTIALWRITE, ICL_TYPE_POINTER, avc,
 771                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->m.Length));
 772
 773 #if     defined(AFS_SUN5_ENV)
 774     code = afs_StoreAllSegments(avc, areq, AFS_ASYNC | AFS_VMSYNC_INVAL);
 775 #else
 776     code = afs_StoreAllSegments(avc, areq, AFS_ASYNC);
 777 #endif
 778     return code;
 779 }
 780
 781 #ifdef AFS_OSF_ENV
 782 #ifdef AFS_DUX50_ENV
 783 #define vno_close(X) vn_close((X), 0, NOCRED)
 784 #elif defined(AFS_DUX40_ENV)
 785 #define      vno_close       vn_close
 786 #endif
 787 /* We don't need this for AIX since:
 788  * (1) aix doesn't use fileops and it call close directly intead
 789  * (where the unlocking should be done) and
 790  * (2) temporarily, the aix lockf isn't supported yet.
 791  *
 792  *  this stupid routine is used to release the flocks held on a
 793  *  particular file descriptor.  Sun doesn't pass file descr. info
 794  *  through to the vnode layer, and yet we must unlock flocked files
 795  *  on the *appropriate* (not first, as in System V) close call.  Thus
 796  *  this code.
 797  * How does this code get invoked? The afs AFS_FLOCK plugs in the new afs
 798  * file ops structure into any afs file when it gets flocked.
 799  * N.B: Intercepting close syscall doesn't trap aborts or exit system
 800  * calls.
 801 */
 802 int
 803 afs_closex(register struct file *afd)
 804 {
 805     struct vrequest treq;
 806     struct vcache *tvc;
 807     afs_int32 flags;
 808     int closeDone;
 809     afs_int32 code = 0;
 810     struct afs_fakestat_state fakestat;
 811
 812     AFS_STATCNT(afs_closex);
 813     /* setup the credentials */
 814     if ((code = afs_InitReq(&treq, u.u_cred)))
 815         return code;
 816     afs_InitFakeStat(&fakestat);
 817
 818     closeDone = 0;
 819     /* we're the last one.  If we're an AFS vnode, clear the flags,
 820      * close the file and release the lock when done.  Otherwise, just
 821      * let the regular close code work.      */
 822     if (afd->f_type == DTYPE_VNODE) {
 823         tvc = VTOAFS(afd->f_data);
 824         if (IsAfsVnode(AFSTOV(tvc))) {
 825             code = afs_EvalFakeStat(&tvc, &fakestat, &treq);
 826             if (code) {
 827                 afs_PutFakeStat(&fakestat);
 828                 return code;
 829             }
 830             VN_HOLD(AFSTOV(tvc));
 831             flags = afd->f_flag & (FSHLOCK | FEXLOCK);
 832             afd->f_flag &= ~(FSHLOCK | FEXLOCK);
 833             code = vno_close(afd);
 834             if (flags)
 835                 HandleFlock(tvc, LOCK_UN, &treq, u.u_procp->p_pid,
 836                             1 /*onlymine */ );
 837             AFS_RELE(AFSTOV(tvc));
 838             closeDone = 1;
 839         }
 840     }
 841     /* now, if close not done, do it */
 842     if (!closeDone) {
 843         code = vno_close(afd);
 844     }
 845     afs_PutFakeStat(&fakestat);
 846     return code;                /* return code from vnode layer */
 847 }
 848 #endif
 849
 850
 851 /* handle any closing cleanup stuff */
 852 int
 853 #ifdef  AFS_SGI_ENV
 854 afs_close(OSI_VC_ARG(avc), aflags, lastclose,
 855 #if !defined(AFS_SGI65_ENV)
 856           offset,
 857 #endif
 858           acred
 859 #if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
 860           , flp
 861 #endif
 862     )
 863      lastclose_t lastclose;
 864 #if !defined(AFS_SGI65_ENV)
 865      off_t offset;
 866 #if defined(AFS_SGI64_ENV)
 867      struct flid *flp;
 868 #endif
 869 #endif
 870 #elif defined(AFS_SUN5_ENV)
 871 afs_close(OSI_VC_ARG(avc), aflags, count, offset, acred)
 872      offset_t offset;
 873      int count;
 874 #else
 875 afs_close(OSI_VC_ARG(avc), aflags, acred)
 876 #endif
 877      OSI_VC_DECL(avc);
 878      afs_int32 aflags;
 879      struct AFS_UCRED *acred;
 880 {
 881     register afs_int32 code;
 882     register struct brequest *tb;
 883     struct vrequest treq;
 884 #ifdef AFS_SGI65_ENV
 885     struct flid flid;
 886 #endif
 887     struct afs_fakestat_state fakestat;
 888     OSI_VC_CONVERT(avc);
 889
 890     AFS_STATCNT(afs_close);
 891     afs_Trace2(afs_iclSetp, CM_TRACE_CLOSE, ICL_TYPE_POINTER, avc,
 892                ICL_TYPE_INT32, aflags);
 893     code = afs_InitReq(&treq, acred);
 894     if (code)
 895         return code;
 896     afs_InitFakeStat(&fakestat);
 897     code = afs_EvalFakeStat(&avc, &fakestat, &treq);
 898     if (code) {
 899         afs_PutFakeStat(&fakestat);
 900         return code;
 901     }
 902     AFS_DISCON_LOCK();
 903 #ifdef  AFS_SUN5_ENV
 904     if (avc->flockCount) {
 905         HandleFlock(avc, LOCK_UN, &treq, 0, 1 /*onlymine */ );
 906     }
 907 #endif
 908 #if defined(AFS_SGI_ENV)
 909     if (!lastclose) {
 910         afs_PutFakeStat(&fakestat);
 911         AFS_DISCON_UNLOCK();
 912         return 0;
 913     }
 914     /* unlock any locks for pid - could be wrong for child .. */
 915     AFS_RWLOCK((vnode_t *) avc, VRWLOCK_WRITE);
 916 #ifdef AFS_SGI65_ENV
 917     get_current_flid(&flid);
 918     cleanlocks((vnode_t *) avc, flid.fl_pid, flid.fl_sysid);
 919     HandleFlock(avc, LOCK_UN, &treq, flid.fl_pid, 1 /*onlymine */ );
 920 #else
 921 #ifdef AFS_SGI64_ENV
 922     cleanlocks((vnode_t *) avc, flp);
 923 #else /* AFS_SGI64_ENV */
 924     cleanlocks((vnode_t *) avc, u.u_procp->p_epid, u.u_procp->p_sysid);
 925 #endif /* AFS_SGI64_ENV */
 926     HandleFlock(avc, LOCK_UN, &treq, OSI_GET_CURRENT_PID(), 1 /*onlymine */ );
 927 #endif /* AFS_SGI65_ENV */
 928     /* afs_chkpgoob will drop and re-acquire the global lock. */
 929     afs_chkpgoob(&avc->v, btoc(avc->m.Length));
 930 #elif   defined(AFS_SUN5_ENV)
 931     if (count > 1) {
 932         /* The vfs layer may call this repeatedly with higher "count"; only on the last close (i.e. count = 1) we should actually proceed with the close. */
 933         afs_PutFakeStat(&fakestat);
 934         AFS_DISCON_UNLOCK();
 935         return 0;
 936     }
 937 #else /* AFS_SGI_ENV */
 938     if (avc->flockCount) {      /* Release Lock */
 939 #if     defined(AFS_OSF_ENV)
 940         HandleFlock(avc, LOCK_UN, &treq, u.u_procp->p_pid, 1 /*onlymine */ );
 941 #else
 942         HandleFlock(avc, LOCK_UN, &treq, 0, 1 /*onlymine */ );
 943 #endif
 944     }
 945 #endif /* AFS_SGI_ENV */
 946     if (aflags & (FWRITE | FTRUNC)) {
 947         if (afs_BBusy() || (AFS_NFSXLATORREQ(acred)) || AFS_IS_DISCONNECTED) {
 948             /* do it yourself if daemons are all busy */
 949             ObtainWriteLock(&avc->lock, 124);
 950             code = afs_StoreOnLastReference(avc, &treq);
 951             ReleaseWriteLock(&avc->lock);
 952 #if defined(AFS_SGI_ENV)
 953             AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
 954 #endif
 955         } else {
 956 #if defined(AFS_SGI_ENV)
 957             AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
 958 #endif
 959             /* at least one daemon is idle, so ask it to do the store.
 960              * Also, note that  we don't lock it any more... */
 961             tb = afs_BQueue(BOP_STORE, avc, 0, 1, acred,
 962                             (afs_size_t) acred->cr_uid, (afs_size_t) 0,
 963                             (void *)0);
 964             /* sleep waiting for the store to start, then retrieve error code */
 965             while ((tb->flags & BUVALID) == 0) {
 966                 tb->flags |= BUWAIT;
 967                 afs_osi_Sleep(tb);
 968             }
 969             code = tb->code;
 970             afs_BRelease(tb);
 971         }
 972
 973         /* VNOVNODE is "acceptable" error code from close, since
 974          * may happen when deleting a file on another machine while
 975          * it is open here. We do the same for ENOENT since in afs_CheckCode we map VNOVNODE -> ENOENT */
 976         if (code == VNOVNODE || code == ENOENT)
 977             code = 0;
 978
 979         /* Ensure last closer gets the error. If another thread caused
 980          * DoPartialWrite and this thread does not actually store the data,
 981          * it may not see the quota error.
 982          */
 983         ObtainWriteLock(&avc->lock, 406);
 984         if (avc->vc_error) {
 985 #ifdef AFS_AIX32_ENV
 986             osi_ReleaseVM(avc, acred);
 987 #endif
 988             printf("avc->vc_error=%d\n", avc->vc_error);
 989             code = avc->vc_error;
 990             avc->vc_error = 0;
 991         }
 992         ReleaseWriteLock(&avc->lock);
 993
 994         /* some codes merit specific complaint */
 995         if (code < 0) {
 996             afs_warnuser("afs: failed to store file (network problems)\n");
 997         }
 998 #ifdef  AFS_SUN5_ENV
 999         else if (code == ENOSPC) {
1000             afs_warnuser
1001                 ("afs: failed to store file (over quota or partition full)\n");
1002         }
1003 #else
1004         else if (code == ENOSPC) {
1005             afs_warnuser("afs: failed to store file (partition full)\n");
1006         } else if (code == EDQUOT) {
1007             afs_warnuser("afs: failed to store file (over quota)\n");
1008         }
1009 #endif
1010         else if (code != 0)
1011             afs_warnuser("afs: failed to store file (%d)\n", code);
1012
1013         /* finally, we flush any text pages lying around here */
1014         hzero(avc->flushDV);
1015         osi_FlushText(avc);
1016     } else {
1017 #if defined(AFS_SGI_ENV)
1018         AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
1019         osi_Assert(avc->opens > 0);
1020 #endif
1021         /* file open for read */
1022         ObtainWriteLock(&avc->lock, 411);
1023         if (avc->vc_error) {
1024 #ifdef AFS_AIX32_ENV
1025             osi_ReleaseVM(avc, acred);
1026 #endif
1027             code = avc->vc_error;
1028             avc->vc_error = 0;
1029         }
1030         avc->opens--;
1031         ReleaseWriteLock(&avc->lock);
1032     }
1033 #ifdef  AFS_OSF_ENV
1034     if ((VREFCOUNT(avc) <= 2) && (avc->states & CUnlinked)) {
1035         afs_remunlink(avc, 1);  /* ignore any return code */
1036     }
1037 #endif
1038     AFS_DISCON_UNLOCK();
1039     afs_PutFakeStat(&fakestat);
1040     code = afs_CheckCode(code, &treq, 5);
1041     return code;
1042 }
1043
1044
1045 int
1046 #ifdef  AFS_OSF_ENV
1047 afs_fsync(OSI_VC_DECL(avc), int fflags, struct AFS_UCRED *acred, int waitfor)
1048 #else                           /* AFS_OSF_ENV */
1049 #if defined(AFS_SGI_ENV) || defined(AFS_SUN53_ENV)
1050 afs_fsync(OSI_VC_DECL(avc), int flag, struct AFS_UCRED *acred
1051 #ifdef AFS_SGI65_ENV
1052           , off_t start, off_t stop
1053 #endif /* AFS_SGI65_ENV */
1054     )
1055 #else /* !OSF && !SUN53 && !SGI */
1056 afs_fsync(OSI_VC_DECL(avc), struct AFS_UCRED *acred)
1057 #endif
1058 #endif
1059 {
1060     register afs_int32 code;
1061     struct vrequest treq;
1062     OSI_VC_CONVERT(avc);
1063
1064     if (avc->vc_error)
1065         return avc->vc_error;
1066
1067 #if defined(AFS_SUN5_ENV)
1068     /* back out if called from NFS server */
1069     if (curthread->t_flag & T_DONTPEND)
1070         return 0;
1071 #endif
1072
1073     AFS_STATCNT(afs_fsync);
1074     afs_Trace1(afs_iclSetp, CM_TRACE_FSYNC, ICL_TYPE_POINTER, avc);
1075     if ((code = afs_InitReq(&treq, acred)))
1076         return code;
1077     AFS_DISCON_LOCK();
1078 #if defined(AFS_SGI_ENV)
1079     AFS_RWLOCK((vnode_t *) avc, VRWLOCK_WRITE);
1080     if (flag & FSYNC_INVAL)
1081         osi_VM_FSyncInval(avc);
1082 #endif /* AFS_SGI_ENV */
1083
1084     ObtainSharedLock(&avc->lock, 18);
1085     code = 0;
1086     if (avc->execsOrWriters > 0) {
1087
1088         if (!AFS_IS_DISCONNECTED && !AFS_IS_DISCON_RW) {
1089                 /* Your average flush. */
1090
1091                 /* put the file back */
1092                 UpgradeSToWLock(&avc->lock, 41);
1093                 code = afs_StoreAllSegments(avc, &treq, AFS_SYNC);
1094                 ConvertWToSLock(&avc->lock);
1095
1096 #if defined(AFS_DISCON_ENV)
1097         } else {
1098             /* Disconnected flush. */
1099             ObtainWriteLock(&afs_DDirtyVCListLock, 708);
1100
1101             if (!avc->ddirty_flags ||
1102                 (avc->ddirty_flags == VDisconShadowed)) {
1103
1104                 /* Add to disconnected dirty list. */
1105                 AFS_DISCON_ADD_DIRTY(avc);
1106             }
1107
1108             UpgradeSToWLock(&avc->lock, 711);
1109             /* Set disconnected write flag. */
1110             avc->ddirty_flags |= VDisconWriteFlush;
1111             ConvertWToSLock(&avc->lock);
1112
1113             ReleaseWriteLock(&afs_DDirtyVCListLock);
1114 #endif
1115         }               /* if not disconnected */
1116     }                   /* if (avc->execsOrWriters > 0) */
1117
1118 #if defined(AFS_SGI_ENV)
1119     AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
1120     if (code == VNOVNODE) {
1121         /* syncing an unlinked file! - non-informative to pass an errno
1122          * 102 (== VNOVNODE) to user
1123          */
1124         code = ENOENT;
1125     }
1126 #endif
1127     AFS_DISCON_UNLOCK();
1128     code = afs_CheckCode(code, &treq, 33);
1129     ReleaseSharedLock(&avc->lock);
1130     return code;
1131 }