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