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