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         tfile = (struct osi_file *)osi_UFSOpen(tdc->f.inode);
 547         len = totalLength;      /* write this amount by default */
 548         offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 549         max = AFS_CHUNKTOSIZE(tdc->f.chunk);    /* max size of this chunk */
 550         if (max <= len + offset) {      /*if we'd go past the end of this chunk */
 551             /* it won't all fit in this chunk, so write as much
 552              * as will fit */
 553             len = max - offset;
 554         }
 555
 556 #ifdef  AFS_DARWIN80_ENV
 557         if (tuiop)
 558             uio_free(tuiop);
 559         trimlen = len;
 560         tuiop = afsio_darwin_partialcopy(auio, trimlen);
 561 #else
 562         /* mung uio structure to be right for this transfer */
 563         afsio_copy(auio, &tuio, tvec);
 564         trimlen = len;
 565         afsio_trim(&tuio, trimlen);
 566 #endif
 567         AFS_UIO_SETOFFSET(tuiop, offset);
 568
 569 #if defined(AFS_AIX41_ENV)
 570         AFS_GUNLOCK();
 571         code =
 572             VNOP_RDWR(tfile->vnode, UIO_WRITE, FWRITE, &tuio, NULL, NULL,
 573                       NULL, afs_osi_credp);
 574         AFS_GLOCK();
 575 #elif defined(AFS_AIX32_ENV)
 576         code = VNOP_RDWR(tfile->vnode, UIO_WRITE, FWRITE, &tuio, NULL, NULL);
 577 #elif defined(AFS_AIX_ENV)
 578         code =
 579             VNOP_RDWR(tfile->vnode, UIO_WRITE, FWRITE, (off_t) & offset,
 580                       &tuio, NULL, NULL, -1);
 581 #elif defined(AFS_SUN5_ENV)
 582         AFS_GUNLOCK();
 583 #ifdef AFS_SUN510_ENV
 584         {
 585             caller_context_t ct;
 586
 587             VOP_RWLOCK(tfile->vnode, 1, &ct);
 588             code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp, &ct);
 589             VOP_RWUNLOCK(tfile->vnode, 1, &ct);
 590         }
 591 #else
 592         VOP_RWLOCK(tfile->vnode, 1);
 593         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 594         VOP_RWUNLOCK(tfile->vnode, 1);
 595 #endif
 596         AFS_GLOCK();
 597         if (code == ENOSPC)
 598             afs_warnuser
 599                 ("\n\n\n*** Cache partition is full - decrease cachesize!!! ***\n\n\n");
 600 #elif defined(AFS_SGI_ENV)
 601         AFS_GUNLOCK();
 602         avc->states |= CWritingUFS;
 603         AFS_VOP_RWLOCK(tfile->vnode, VRWLOCK_WRITE);
 604         AFS_VOP_WRITE(tfile->vnode, &tuio, IO_ISLOCKED, afs_osi_credp, code);
 605         AFS_VOP_RWUNLOCK(tfile->vnode, VRWLOCK_WRITE);
 606         avc->states &= ~CWritingUFS;
 607         AFS_GLOCK();
 608 #elif defined(AFS_OSF_ENV)
 609         {
 610             struct ucred *tmpcred = u.u_cred;
 611             u.u_cred = afs_osi_credp;
 612             tuio.uio_rw = UIO_WRITE;
 613             AFS_GUNLOCK();
 614             VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp, code);
 615             AFS_GLOCK();
 616             u.u_cred = tmpcred;
 617         }
 618 #elif defined(AFS_HPUX100_ENV)
 619         {
 620             AFS_GUNLOCK();
 621             code = VOP_RDWR(tfile->vnode, &tuio, UIO_WRITE, 0, afs_osi_credp);
 622             AFS_GLOCK();
 623         }
 624 #elif defined(AFS_LINUX20_ENV)
 625         AFS_GUNLOCK();
 626         code = osi_rdwr(tfile, &tuio, UIO_WRITE);
 627         AFS_GLOCK();
 628 #elif defined(AFS_DARWIN80_ENV)
 629         AFS_GUNLOCK();
 630         code = VNOP_WRITE(tfile->vnode, tuiop, 0, afs_osi_ctxtp);
 631         AFS_GLOCK();
 632 #elif defined(AFS_DARWIN_ENV)
 633         AFS_GUNLOCK();
 634         VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, current_proc());
 635         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 636         VOP_UNLOCK(tfile->vnode, 0, current_proc());
 637         AFS_GLOCK();
 638 #elif defined(AFS_FBSD80_ENV)
 639         AFS_GUNLOCK();
 640         VOP_LOCK(tfile->vnode, LK_EXCLUSIVE);
 641         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 642         VOP_UNLOCK(tfile->vnode, 0);
 643         AFS_GLOCK();
 644 #elif defined(AFS_FBSD50_ENV)
 645         AFS_GUNLOCK();
 646         VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curthread);
 647         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 648         VOP_UNLOCK(tfile->vnode, 0, curthread);
 649         AFS_GLOCK();
 650 #elif defined(AFS_XBSD_ENV)
 651         AFS_GUNLOCK();
 652         VOP_LOCK(tfile->vnode, LK_EXCLUSIVE, curproc);
 653         code = VOP_WRITE(tfile->vnode, &tuio, 0, afs_osi_credp);
 654         VOP_UNLOCK(tfile->vnode, 0, curproc);
 655         AFS_GLOCK();
 656 #else
 657 #ifdef  AFS_HPUX_ENV
 658         tuio.uio_fpflags &= ~FSYNCIO;   /* don't do sync io */
 659 #endif
 660         code = VOP_RDWR(tfile->vnode, &tuio, UIO_WRITE, 0, afs_osi_credp);
 661 #endif
 662         if (code) {
 663             error = code;
 664             ZapDCE(tdc);        /* bad data */
 665             osi_UFSTruncate(tfile, 0);  /* fake truncate the segment */
 666             afs_AdjustSize(tdc, 0);     /* sets f.chunkSize to 0 */
 667             afs_stats_cmperf.cacheCurrDirtyChunks--;
 668             afs_indexFlags[tdc->index] &= ~IFDataMod;   /* so it does disappear */
 669             afs_CFileClose(tfile);
 670             ReleaseWriteLock(&tdc->lock);
 671             afs_PutDCache(tdc);
 672             break;
 673         }
 674         /* otherwise we've written some, fixup length, etc and continue with next seg */
 675         len = len - AFS_UIO_RESID(tuiop);       /* compute amount really transferred */
 676         tlen = len;
 677         afsio_skip(auio, tlen); /* advance auio over data written */
 678         /* compute new file size */
 679         if (offset + len > tdc->f.chunkBytes) {
 680             afs_int32 tlength = offset + len;
 681             afs_AdjustSize(tdc, tlength);
 682             if (tdc->validPos < filePos + len)
 683                 tdc->validPos = filePos + len;
 684         }
 685         totalLength -= len;
 686         transferLength += len;
 687         filePos += len;
 688 #if defined(AFS_SGI_ENV)
 689         /* afs_xwrite handles setting m.Length */
 690         osi_Assert(filePos <= avc->m.Length);
 691 #else
 692         if (filePos > avc->m.Length) {
 693             afs_Trace4(afs_iclSetp, CM_TRACE_SETLENGTH, ICL_TYPE_STRING,
 694                        __FILE__, ICL_TYPE_LONG, __LINE__, ICL_TYPE_OFFSET,
 695                        ICL_HANDLE_OFFSET(avc->m.Length), ICL_TYPE_OFFSET,
 696                        ICL_HANDLE_OFFSET(filePos));
 697             avc->m.Length = filePos;
 698         }
 699 #endif
 700         osi_UFSClose(tfile);
 701         ReleaseWriteLock(&tdc->lock);
 702         afs_PutDCache(tdc);
 703 #if !defined(AFS_VM_RDWR_ENV)
 704         /*
 705          * If write is implemented via VM, afs_DoPartialWrite() is called from
 706          * the high-level write op.
 707          */
 708         if (!noLock) {
 709             code = afs_DoPartialWrite(avc, &treq);
 710             if (code) {
 711                 error = code;
 712                 break;
 713             }
 714         }
 715 #endif
 716     }
 717 #ifndef AFS_VM_RDWR_ENV
 718     afs_FakeClose(avc, acred);
 719 #endif
 720     error = afs_CheckCode(error, &treq, 7);
 721     /* This set is here so we get the CheckCode. */
 722     if (error && !avc->vc_error)
 723         avc->vc_error = error;
 724     if (!noLock)
 725         ReleaseWriteLock(&avc->lock);
 726 #ifdef AFS_DARWIN80_ENV
 727     uio_free(tuiop);
 728 #else
 729     osi_FreeSmallSpace(tvec);
 730 #endif
 731 #ifndef AFS_VM_RDWR_ENV
 732     /*
 733      * If write is implemented via VM, afs_fsync() is called from the high-level
 734      * write op.
 735      */
 736 #if defined(AFS_DARWIN_ENV) || defined(AFS_XBSD_ENV)
 737     if (noLock && (aio & IO_SYNC)) {
 738 #else
 739 #ifdef  AFS_HPUX_ENV
 740     /* On hpux on synchronous writes syncio will be set to IO_SYNC. If
 741      * we're doing them because the file was opened with O_SYNCIO specified,
 742      * we have to look in the u area. No single mechanism here!!
 743      */
 744     if (noLock && ((aio & IO_SYNC) | (auio->uio_fpflags & FSYNCIO))) {
 745 #else
 746     if (noLock && (aio & FSYNC)) {
 747 #endif
 748 #endif
 749         if (!AFS_NFSXLATORREQ(acred))
 750             afs_fsync(avc, acred);
 751     }
 752 #endif
 753     return error;
 754 }
 755
 756 /* do partial write if we're low on unmodified chunks */
 757 int
 758 afs_DoPartialWrite(register struct vcache *avc, struct vrequest *areq)
 759 {
 760     register afs_int32 code;
 761
 762     if (afs_stats_cmperf.cacheCurrDirtyChunks <=
 763         afs_stats_cmperf.cacheMaxDirtyChunks)
 764         return 0;               /* nothing to do */
 765     /* otherwise, call afs_StoreDCache (later try to do this async, if possible) */
 766     afs_Trace2(afs_iclSetp, CM_TRACE_PARTIALWRITE, ICL_TYPE_POINTER, avc,
 767                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->m.Length));
 768
 769 #if     defined(AFS_SUN5_ENV)
 770     code = afs_StoreAllSegments(avc, areq, AFS_ASYNC | AFS_VMSYNC_INVAL);
 771 #else
 772     code = afs_StoreAllSegments(avc, areq, AFS_ASYNC);
 773 #endif
 774     return code;
 775 }
 776
 777 #ifdef AFS_OSF_ENV
 778 #ifdef AFS_DUX50_ENV
 779 #define vno_close(X) vn_close((X), 0, NOCRED)
 780 #elif defined(AFS_DUX40_ENV)
 781 #define      vno_close       vn_close
 782 #endif
 783 /* We don't need this for AIX since:
 784  * (1) aix doesn't use fileops and it call close directly intead
 785  * (where the unlocking should be done) and
 786  * (2) temporarily, the aix lockf isn't supported yet.
 787  *
 788  *  this stupid routine is used to release the flocks held on a
 789  *  particular file descriptor.  Sun doesn't pass file descr. info
 790  *  through to the vnode layer, and yet we must unlock flocked files
 791  *  on the *appropriate* (not first, as in System V) close call.  Thus
 792  *  this code.
 793  * How does this code get invoked? The afs AFS_FLOCK plugs in the new afs
 794  * file ops structure into any afs file when it gets flocked.
 795  * N.B: Intercepting close syscall doesn't trap aborts or exit system
 796  * calls.
 797 */
 798 int
 799 afs_closex(register struct file *afd)
 800 {
 801     struct vrequest treq;
 802     struct vcache *tvc;
 803     afs_int32 flags;
 804     int closeDone;
 805     afs_int32 code = 0;
 806     struct afs_fakestat_state fakestat;
 807
 808     AFS_STATCNT(afs_closex);
 809     /* setup the credentials */
 810     if ((code = afs_InitReq(&treq, u.u_cred)))
 811         return code;
 812     afs_InitFakeStat(&fakestat);
 813
 814     closeDone = 0;
 815     /* we're the last one.  If we're an AFS vnode, clear the flags,
 816      * close the file and release the lock when done.  Otherwise, just
 817      * let the regular close code work.      */
 818     if (afd->f_type == DTYPE_VNODE) {
 819         tvc = VTOAFS(afd->f_data);
 820         if (IsAfsVnode(AFSTOV(tvc))) {
 821             code = afs_EvalFakeStat(&tvc, &fakestat, &treq);
 822             if (code) {
 823                 afs_PutFakeStat(&fakestat);
 824                 return code;
 825             }
 826             VN_HOLD(AFSTOV(tvc));
 827             flags = afd->f_flag & (FSHLOCK | FEXLOCK);
 828             afd->f_flag &= ~(FSHLOCK | FEXLOCK);
 829             code = vno_close(afd);
 830             if (flags)
 831                 HandleFlock(tvc, LOCK_UN, &treq, u.u_procp->p_pid,
 832                             1 /*onlymine */ );
 833             AFS_RELE(AFSTOV(tvc));
 834             closeDone = 1;
 835         }
 836     }
 837     /* now, if close not done, do it */
 838     if (!closeDone) {
 839         code = vno_close(afd);
 840     }
 841     afs_PutFakeStat(&fakestat);
 842     return code;                /* return code from vnode layer */
 843 }
 844 #endif
 845
 846
 847 /* handle any closing cleanup stuff */
 848 int
 849 #ifdef  AFS_SGI_ENV
 850 afs_close(OSI_VC_ARG(avc), aflags, lastclose,
 851 #if !defined(AFS_SGI65_ENV)
 852           offset,
 853 #endif
 854           acred
 855 #if defined(AFS_SGI64_ENV) && !defined(AFS_SGI65_ENV)
 856           , flp
 857 #endif
 858     )
 859      lastclose_t lastclose;
 860 #if !defined(AFS_SGI65_ENV)
 861      off_t offset;
 862 #if defined(AFS_SGI64_ENV)
 863      struct flid *flp;
 864 #endif
 865 #endif
 866 #elif defined(AFS_SUN5_ENV)
 867 afs_close(OSI_VC_ARG(avc), aflags, count, offset, acred)
 868      offset_t offset;
 869      int count;
 870 #else
 871 afs_close(OSI_VC_ARG(avc), aflags, acred)
 872 #endif
 873      OSI_VC_DECL(avc);
 874      afs_int32 aflags;
 875      struct AFS_UCRED *acred;
 876 {
 877     register afs_int32 code;
 878     register struct brequest *tb;
 879     struct vrequest treq;
 880 #ifdef AFS_SGI65_ENV
 881     struct flid flid;
 882 #endif
 883     struct afs_fakestat_state fakestat;
 884     OSI_VC_CONVERT(avc);
 885
 886     AFS_STATCNT(afs_close);
 887     afs_Trace2(afs_iclSetp, CM_TRACE_CLOSE, ICL_TYPE_POINTER, avc,
 888                ICL_TYPE_INT32, aflags);
 889     code = afs_InitReq(&treq, acred);
 890     if (code)
 891         return code;
 892     afs_InitFakeStat(&fakestat);
 893     code = afs_EvalFakeStat(&avc, &fakestat, &treq);
 894     if (code) {
 895         afs_PutFakeStat(&fakestat);
 896         return code;
 897     }
 898     AFS_DISCON_LOCK();
 899 #ifdef  AFS_SUN5_ENV
 900     if (avc->flockCount) {
 901         HandleFlock(avc, LOCK_UN, &treq, 0, 1 /*onlymine */ );
 902     }
 903 #endif
 904 #if defined(AFS_SGI_ENV)
 905     if (!lastclose) {
 906         afs_PutFakeStat(&fakestat);
 907         AFS_DISCON_UNLOCK();
 908         return 0;
 909     }
 910     /* unlock any locks for pid - could be wrong for child .. */
 911     AFS_RWLOCK((vnode_t *) avc, VRWLOCK_WRITE);
 912 #ifdef AFS_SGI65_ENV
 913     get_current_flid(&flid);
 914     cleanlocks((vnode_t *) avc, flid.fl_pid, flid.fl_sysid);
 915     HandleFlock(avc, LOCK_UN, &treq, flid.fl_pid, 1 /*onlymine */ );
 916 #else
 917 #ifdef AFS_SGI64_ENV
 918     cleanlocks((vnode_t *) avc, flp);
 919 #else /* AFS_SGI64_ENV */
 920     cleanlocks((vnode_t *) avc, u.u_procp->p_epid, u.u_procp->p_sysid);
 921 #endif /* AFS_SGI64_ENV */
 922     HandleFlock(avc, LOCK_UN, &treq, OSI_GET_CURRENT_PID(), 1 /*onlymine */ );
 923 #endif /* AFS_SGI65_ENV */
 924     /* afs_chkpgoob will drop and re-acquire the global lock. */
 925     afs_chkpgoob(&avc->v, btoc(avc->m.Length));
 926 #elif   defined(AFS_SUN5_ENV)
 927     if (count > 1) {
 928         /* 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. */
 929         afs_PutFakeStat(&fakestat);
 930         AFS_DISCON_UNLOCK();
 931         return 0;
 932     }
 933 #else /* AFS_SGI_ENV */
 934     if (avc->flockCount) {      /* Release Lock */
 935 #if     defined(AFS_OSF_ENV)
 936         HandleFlock(avc, LOCK_UN, &treq, u.u_procp->p_pid, 1 /*onlymine */ );
 937 #else
 938         HandleFlock(avc, LOCK_UN, &treq, 0, 1 /*onlymine */ );
 939 #endif
 940     }
 941 #endif /* AFS_SGI_ENV */
 942     if (aflags & (FWRITE | FTRUNC)) {
 943         if (afs_BBusy() || (AFS_NFSXLATORREQ(acred)) || AFS_IS_DISCONNECTED) {
 944             /* do it yourself if daemons are all busy */
 945             ObtainWriteLock(&avc->lock, 124);
 946             code = afs_StoreOnLastReference(avc, &treq);
 947             ReleaseWriteLock(&avc->lock);
 948 #if defined(AFS_SGI_ENV)
 949             AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
 950 #endif
 951         } else {
 952 #if defined(AFS_SGI_ENV)
 953             AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
 954 #endif
 955             /* at least one daemon is idle, so ask it to do the store.
 956              * Also, note that  we don't lock it any more... */
 957             tb = afs_BQueue(BOP_STORE, avc, 0, 1, acred,
 958                             (afs_size_t) acred->cr_uid, (afs_size_t) 0,
 959                             (void *)0);
 960             /* sleep waiting for the store to start, then retrieve error code */
 961             while ((tb->flags & BUVALID) == 0) {
 962                 tb->flags |= BUWAIT;
 963                 afs_osi_Sleep(tb);
 964             }
 965             code = tb->code;
 966             afs_BRelease(tb);
 967         }
 968
 969         /* VNOVNODE is "acceptable" error code from close, since
 970          * may happen when deleting a file on another machine while
 971          * it is open here. We do the same for ENOENT since in afs_CheckCode we map VNOVNODE -> ENOENT */
 972         if (code == VNOVNODE || code == ENOENT)
 973             code = 0;
 974
 975         /* Ensure last closer gets the error. If another thread caused
 976          * DoPartialWrite and this thread does not actually store the data,
 977          * it may not see the quota error.
 978          */
 979         ObtainWriteLock(&avc->lock, 406);
 980         if (avc->vc_error) {
 981 #ifdef AFS_AIX32_ENV
 982             osi_ReleaseVM(avc, acred);
 983 #endif
 984             printf("avc->vc_error=%d\n", avc->vc_error);
 985             code = avc->vc_error;
 986             avc->vc_error = 0;
 987         }
 988         ReleaseWriteLock(&avc->lock);
 989
 990         /* some codes merit specific complaint */
 991         if (code < 0) {
 992             afs_warnuser("afs: failed to store file (network problems)\n");
 993         }
 994 #ifdef  AFS_SUN5_ENV
 995         else if (code == ENOSPC) {
 996             afs_warnuser
 997                 ("afs: failed to store file (over quota or partition full)\n");
 998         }
 999 #else
1000         else if (code == ENOSPC) {
1001             afs_warnuser("afs: failed to store file (partition full)\n");
1002         } else if (code == EDQUOT) {
1003             afs_warnuser("afs: failed to store file (over quota)\n");
1004         }
1005 #endif
1006         else if (code != 0)
1007             afs_warnuser("afs: failed to store file (%d)\n", code);
1008
1009         /* finally, we flush any text pages lying around here */
1010         hzero(avc->flushDV);
1011         osi_FlushText(avc);
1012     } else {
1013 #if defined(AFS_SGI_ENV)
1014         AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
1015         osi_Assert(avc->opens > 0);
1016 #endif
1017         /* file open for read */
1018         ObtainWriteLock(&avc->lock, 411);
1019         if (avc->vc_error) {
1020 #ifdef AFS_AIX32_ENV
1021             osi_ReleaseVM(avc, acred);
1022 #endif
1023             code = avc->vc_error;
1024             avc->vc_error = 0;
1025         }
1026         avc->opens--;
1027         ReleaseWriteLock(&avc->lock);
1028     }
1029 #ifdef  AFS_OSF_ENV
1030     if ((VREFCOUNT(avc) <= 2) && (avc->states & CUnlinked)) {
1031         afs_remunlink(avc, 1);  /* ignore any return code */
1032     }
1033 #endif
1034     AFS_DISCON_UNLOCK();
1035     afs_PutFakeStat(&fakestat);
1036     code = afs_CheckCode(code, &treq, 5);
1037     return code;
1038 }
1039
1040
1041 int
1042 #ifdef  AFS_OSF_ENV
1043 afs_fsync(OSI_VC_DECL(avc), int fflags, struct AFS_UCRED *acred, int waitfor)
1044 #else                           /* AFS_OSF_ENV */
1045 #if defined(AFS_SGI_ENV) || defined(AFS_SUN53_ENV)
1046 afs_fsync(OSI_VC_DECL(avc), int flag, struct AFS_UCRED *acred
1047 #ifdef AFS_SGI65_ENV
1048           , off_t start, off_t stop
1049 #endif /* AFS_SGI65_ENV */
1050     )
1051 #else /* !OSF && !SUN53 && !SGI */
1052 afs_fsync(OSI_VC_DECL(avc), struct AFS_UCRED *acred)
1053 #endif
1054 #endif
1055 {
1056     register afs_int32 code;
1057     struct vrequest treq;
1058     OSI_VC_CONVERT(avc);
1059
1060     if (avc->vc_error)
1061         return avc->vc_error;
1062
1063 #if defined(AFS_SUN5_ENV)
1064     /* back out if called from NFS server */
1065     if (curthread->t_flag & T_DONTPEND)
1066         return 0;
1067 #endif
1068
1069     AFS_STATCNT(afs_fsync);
1070     afs_Trace1(afs_iclSetp, CM_TRACE_FSYNC, ICL_TYPE_POINTER, avc);
1071     if ((code = afs_InitReq(&treq, acred)))
1072         return code;
1073     AFS_DISCON_LOCK();
1074 #if defined(AFS_SGI_ENV)
1075     AFS_RWLOCK((vnode_t *) avc, VRWLOCK_WRITE);
1076     if (flag & FSYNC_INVAL)
1077         osi_VM_FSyncInval(avc);
1078 #endif /* AFS_SGI_ENV */
1079
1080     ObtainSharedLock(&avc->lock, 18);
1081     code = 0;
1082     if (avc->execsOrWriters > 0) {
1083
1084         if (!AFS_IS_DISCONNECTED && !AFS_IS_DISCON_RW) {
1085                 /* Your average flush. */
1086
1087                 /* put the file back */
1088                 UpgradeSToWLock(&avc->lock, 41);
1089                 code = afs_StoreAllSegments(avc, &treq, AFS_SYNC);
1090                 ConvertWToSLock(&avc->lock);
1091
1092 #if defined(AFS_DISCON_ENV)
1093         } else {
1094             /* Disconnected flush. */
1095             ObtainWriteLock(&afs_DDirtyVCListLock, 708);
1096
1097             if (!avc->ddirty_flags ||
1098                 (avc->ddirty_flags == VDisconShadowed)) {
1099
1100                 /* Add to disconnected dirty list. */
1101                 AFS_DISCON_ADD_DIRTY(avc);
1102             }
1103
1104             UpgradeSToWLock(&avc->lock, 711);
1105             /* Set disconnected write flag. */
1106             avc->ddirty_flags |= VDisconWriteFlush;
1107             ConvertWToSLock(&avc->lock);
1108
1109             ReleaseWriteLock(&afs_DDirtyVCListLock);
1110 #endif
1111         }               /* if not disconnected */
1112     }                   /* if (avc->execsOrWriters > 0) */
1113
1114 #if defined(AFS_SGI_ENV)
1115     AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
1116     if (code == VNOVNODE) {
1117         /* syncing an unlinked file! - non-informative to pass an errno
1118          * 102 (== VNOVNODE) to user
1119          */
1120         code = ENOENT;
1121     }
1122 #endif
1123     AFS_DISCON_UNLOCK();
1124     code = afs_CheckCode(code, &treq, 33);
1125     ReleaseSharedLock(&avc->lock);
1126     return code;
1127 }