src/afs/afs_segments.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  * --------------------- Required definitions ---------------------
  12  */
  13 #include <afsconfig.h>
  14 #include "afs/param.h"
  15
  16
  17 #include "afs/sysincludes.h"    /*Standard vendor system headers */
  18 #include "afsincludes.h"        /*AFS-based standard headers */
  19 #include "afs/afs_stats.h"      /* statistics */
  20 #include "afs/afs_cbqueue.h"
  21 #include "afs/afs_osidnlc.h"
  22
  23 afs_uint32 afs_stampValue = 0;
  24
  25 /*
  26  * afs_StoreMini
  27  *
  28  * Description:
  29  *      Send a truncation request to a FileServer.
  30  *
  31  * Parameters:
  32  *      xxx : description
  33  *
  34  * Environment:
  35  *      We're write-locked upon entry.
  36  */
  37
  38 static int
  39 afs_StoreMini(struct vcache *avc, struct vrequest *areq)
  40 {
  41     struct afs_conn *tc;
  42     struct AFSStoreStatus InStatus;
  43     struct AFSFetchStatus OutStatus;
  44     struct AFSVolSync tsync;
  45     afs_int32 code;
  46     struct rx_call *tcall;
  47     struct rx_connection *rxconn;
  48     afs_size_t tlen, xlen = 0;
  49     XSTATS_DECLS;
  50     AFS_STATCNT(afs_StoreMini);
  51     afs_Trace2(afs_iclSetp, CM_TRACE_STOREMINI, ICL_TYPE_POINTER, avc,
  52                ICL_TYPE_INT32, avc->f.m.Length);
  53     tlen = avc->f.m.Length;
  54     if (avc->f.truncPos < tlen)
  55         tlen = avc->f.truncPos;
  56     avc->f.truncPos = AFS_NOTRUNC;
  57     avc->f.states &= ~CExtendedFile;
  58     memset(&InStatus, 0, sizeof(InStatus));
  59
  60     do {
  61         tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
  62         if (tc) {
  63 #ifdef AFS_64BIT_CLIENT
  64           retry:
  65 #endif
  66             RX_AFS_GUNLOCK();
  67             tcall = rx_NewCall(rxconn);
  68             RX_AFS_GLOCK();
  69             /* Set the client mod time since we always want the file
  70              * to have the client's mod time and not the server's one
  71              * (to avoid problems with make, etc.) It almost always
  72              * works fine with standard afs because them server/client
  73              * times are in sync and more importantly this storemini
  74              * it's a special call that would typically be followed by
  75              * the proper store-data or store-status calls.
  76              */
  77             InStatus.Mask = AFS_SETMODTIME;
  78             InStatus.ClientModTime = avc->f.m.Date;
  79             XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_STOREDATA);
  80             afs_Trace4(afs_iclSetp, CM_TRACE_STOREDATA64, ICL_TYPE_FID,
  81                        &avc->f.fid.Fid, ICL_TYPE_OFFSET,
  82                        ICL_HANDLE_OFFSET(avc->f.m.Length), ICL_TYPE_OFFSET,
  83                        ICL_HANDLE_OFFSET(xlen), ICL_TYPE_OFFSET,
  84                        ICL_HANDLE_OFFSET(tlen));
  85             RX_AFS_GUNLOCK();
  86 #ifdef AFS_64BIT_CLIENT
  87             if (!afs_serverHasNo64Bit(tc)) {
  88                 code =
  89                     StartRXAFS_StoreData64(tcall,
  90                                            (struct AFSFid *)&avc->f.fid.Fid,
  91                                            &InStatus, avc->f.m.Length,
  92                                            (afs_size_t) 0, tlen);
  93             } else {
  94                 afs_int32 l1, l2;
  95                 l1 = avc->f.m.Length;
  96                 l2 = tlen;
  97                 if ((avc->f.m.Length > 0x7fffffff) ||
  98                     (tlen > 0x7fffffff) ||
  99                     ((0x7fffffff - tlen) < avc->f.m.Length)) {
 100                     code = EFBIG;
 101                     goto error;
 102                 }
 103                 code =
 104                     StartRXAFS_StoreData(tcall,
 105                                          (struct AFSFid *)&avc->f.fid.Fid,
 106                                          &InStatus, l1, 0, l2);
 107             }
 108 #else /* AFS_64BIT_CLIENT */
 109             code =
 110                 StartRXAFS_StoreData(tcall, (struct AFSFid *)&avc->f.fid.Fid,
 111                                      &InStatus, avc->f.m.Length, 0, tlen);
 112 #endif /* AFS_64BIT_CLIENT */
 113             if (code == 0) {
 114                 code = EndRXAFS_StoreData(tcall, &OutStatus, &tsync);
 115             }
 116 #ifdef AFS_64BIT_CLIENT
 117         error:
 118 #endif
 119             code = rx_EndCall(tcall, code);
 120             RX_AFS_GLOCK();
 121             XSTATS_END_TIME;
 122 #ifdef AFS_64BIT_CLIENT
 123             if (code == RXGEN_OPCODE && !afs_serverHasNo64Bit(tc)) {
 124                 afs_serverSetNo64Bit(tc);
 125                 goto retry;
 126             }
 127 #endif /* AFS_64BIT_CLIENT */
 128         } else
 129             code = -1;
 130     } while (afs_Analyze
 131              (tc, rxconn, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_STOREDATA,
 132               SHARED_LOCK, NULL));
 133
 134     if (code == 0)
 135         afs_ProcessFS(avc, &OutStatus, areq);
 136
 137     return code;
 138 }                               /*afs_StoreMini */
 139
 140 /*
 141  * afs_StoreAllSegments
 142  *
 143  * Description:
 144  *      Stores all modified segments back to server
 145  *
 146  * Parameters:
 147  *      avc  : Pointer to vcache entry.
 148  *      areq : Pointer to request structure.
 149  *
 150  * Environment:
 151  *      Called with avc write-locked.
 152  */
 153 #if defined (AFS_HPUX_ENV)
 154 int NCHUNKSATONCE = 3;
 155 #else
 156 int NCHUNKSATONCE = 64;
 157 #endif
 158 int afs_dvhack = 0;
 159
 160
 161 int
 162 afs_StoreAllSegments(struct vcache *avc, struct vrequest *areq,
 163                      int sync)
 164 {
 165     struct dcache *tdc;
 166     afs_int32 code = 0;
 167     afs_int32 index;
 168     afs_int32 origCBs, foreign = 0;
 169     int hash;
 170     afs_hyper_t newDV, oldDV;   /* DV when we start, and finish, respectively */
 171     struct dcache **dcList;
 172     unsigned int i, j, minj, moredata, high, off;
 173     afs_size_t maxStoredLength; /* highest offset we've written to server. */
 174     int safety, marineronce = 0;
 175
 176     AFS_STATCNT(afs_StoreAllSegments);
 177
 178     hash = DVHash(&avc->f.fid);
 179     foreign = (avc->f.states & CForeign);
 180     dcList = osi_AllocLargeSpace(AFS_LRALLOCSIZ);
 181     afs_Trace2(afs_iclSetp, CM_TRACE_STOREALL, ICL_TYPE_POINTER, avc,
 182                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));
 183 #if !defined(AFS_AIX32_ENV) && !defined(AFS_SGI65_ENV)
 184     /* In the aix vm implementation we need to do the vm_writep even
 185      * on the memcache case since that's we adjust the file's size
 186      * and finish flushing partial vm pages.
 187      */
 188     if ((cacheDiskType != AFS_FCACHE_TYPE_MEM) ||
 189         (sync & AFS_VMSYNC_INVAL) || (sync & AFS_VMSYNC) ||
 190         (sync & AFS_LASTSTORE))
 191 #endif /* !AFS_AIX32_ENV && !AFS_SGI65_ENV */
 192     {
 193         /* If we're not diskless, reading a file may stress the VM
 194          * system enough to cause a pageout, and this vnode would be
 195          * locked when the pageout occurs.  We can prevent this problem
 196          * by making sure all dirty pages are already flushed.  We don't
 197          * do this when diskless because reading a diskless (i.e.
 198          * memory-resident) chunk doesn't require using new VM, and we
 199          * also don't want to dump more dirty data into a diskless cache,
 200          * since they're smaller, and we might exceed its available
 201          * space.
 202          */
 203 #if     defined(AFS_SUN5_ENV)
 204         if (sync & AFS_VMSYNC_INVAL)    /* invalidate VM pages */
 205             osi_VM_TryToSmush(avc, CRED(), 1);
 206         else
 207 #endif
 208             osi_VM_StoreAllSegments(avc);
 209     }
 210     if (AFS_IS_DISCONNECTED && !AFS_IN_SYNC) {
 211         /* This will probably make someone sad ... */
 212         /*printf("Net down in afs_StoreSegments\n");*/
 213         return ENETDOWN;
 214     }
 215
 216     /*
 217      * Can't do this earlier because osi_VM_StoreAllSegments drops locks
 218      * and can indirectly do some stores that increase the DV.
 219      */
 220     hset(oldDV, avc->f.m.DataVersion);
 221     hset(newDV, avc->f.m.DataVersion);
 222
 223     ConvertWToSLock(&avc->lock);
 224
 225     /*
 226      * Subsequent code expects a sorted list, and it expects all the
 227      * chunks in the list to be contiguous, so we need a sort and a
 228      * while loop in here, too - but this will work for a first pass...
 229      * 92.10.05 - OK, there's a sort in here now.  It's kind of a modified
 230      *            bin sort, I guess.  Chunk numbers start with 0
 231      *
 232      * - Have to get a write lock on xdcache because GetDSlot might need it (if
 233      *   the chunk doesn't have a dcache struct).
 234      *   This seems like overkill in most cases.
 235      * - I'm not sure that it's safe to do "index = .hvNextp", then unlock
 236      *   xdcache, then relock xdcache and try to use index.  It is done
 237      *   a lot elsewhere in the CM, but I'm not buying that argument.
 238      * - should be able to check IFDataMod without doing the GetDSlot (just
 239      *   hold afs_xdcache).  That way, it's easy to do this without the
 240      *   writelock on afs_xdcache, and we save unneccessary disk
 241      *   operations. I don't think that works, 'cuz the next pointers
 242      *   are still on disk.
 243      */
 244     origCBs = afs_allCBs;
 245
 246     maxStoredLength = 0;
 247     minj = 0;
 248
 249     do {
 250         memset(dcList, 0, NCHUNKSATONCE * sizeof(struct dcache *));
 251         high = 0;
 252         moredata = FALSE;
 253
 254         /* lock and start over from beginning of hash chain
 255          * in order to avoid a race condition. */
 256         ObtainWriteLock(&afs_xdcache, 284);
 257         index = afs_dvhashTbl[hash];
 258
 259         for (j = 0; index != NULLIDX;) {
 260             if ((afs_indexFlags[index] & IFDataMod)
 261                 && (afs_indexUnique[index] == avc->f.fid.Fid.Unique)) {
 262                 tdc = afs_GetValidDSlot(index); /* refcount+1. */
 263                 if (!tdc) {
 264                     ReleaseWriteLock(&afs_xdcache);
 265                     code = EIO;
 266                     goto done;
 267                 }
 268                 ReleaseReadLock(&tdc->tlock);
 269                 if (!FidCmp(&tdc->f.fid, &avc->f.fid) && tdc->f.chunk >= minj) {
 270                     off = tdc->f.chunk - minj;
 271                     if (off < NCHUNKSATONCE) {
 272                         if (dcList[off])
 273                             osi_Panic("dclist slot already in use!");
 274                         if (afs_mariner && !marineronce) {
 275                             /* first chunk only */
 276                             afs_MarinerLog("store$Storing", avc);
 277                             marineronce++;
 278                         }
 279                         dcList[off] = tdc;
 280                         if (off > high)
 281                             high = off;
 282                         j++;
 283                         /* DCLOCKXXX: chunkBytes is protected by tdc->lock which we
 284                          * can't grab here, due to lock ordering with afs_xdcache.
 285                          * So, disable this shortcut for now.  -- kolya 2001-10-13
 286                          */
 287                         /* shortcut: big win for little files */
 288                         /* tlen -= tdc->f.chunkBytes;
 289                          * if (tlen <= 0)
 290                          *    break;
 291                          */
 292                     } else {
 293                         moredata = TRUE;
 294                         afs_PutDCache(tdc);
 295                         if (j == NCHUNKSATONCE)
 296                             break;
 297                     }
 298                 } else {
 299                     afs_PutDCache(tdc);
 300                 }
 301             }
 302             index = afs_dvnextTbl[index];
 303         }
 304         ReleaseWriteLock(&afs_xdcache);
 305
 306         /* this guy writes chunks, puts back dcache structs, and bumps newDV */
 307         /* "moredata" just says "there are more dirty chunks yet to come".
 308          */
 309         if (j) {
 310             code =
 311                 afs_CacheStoreVCache(dcList, avc, areq, sync,
 312                                    minj, high, moredata,
 313                                    &newDV, &maxStoredLength);
 314             /* Release any zero-length dcache entries in our interval
 315              * that we locked but didn't store back above.
 316              */
 317             for (j = 0; j <= high; j++) {
 318                 tdc = dcList[j];
 319                 if (tdc) {
 320                     osi_Assert(tdc->f.chunkBytes == 0);
 321                     ReleaseSharedLock(&tdc->lock);
 322                     afs_PutDCache(tdc);
 323                 }
 324             }
 325         }
 326         /* if (j) */
 327         minj += NCHUNKSATONCE;
 328     } while (!code && moredata);
 329
 330  done:
 331     UpgradeSToWLock(&avc->lock, 29);
 332
 333     /* send a trivial truncation store if did nothing else */
 334     if (code == 0) {
 335         /*
 336          * Call StoreMini if we haven't written enough data to extend the
 337          * file at the fileserver to the client's notion of the file length.
 338          */
 339         if ((avc->f.truncPos != AFS_NOTRUNC)
 340             || ((avc->f.states & CExtendedFile)
 341                 && (maxStoredLength < avc->f.m.Length))) {
 342             code = afs_StoreMini(avc, areq);
 343             if (code == 0)
 344                 hadd32(newDV, 1);       /* just bumped here, too */
 345         }
 346         avc->f.states &= ~CExtendedFile;
 347     }
 348
 349     /*
 350      * Finally, turn off DWriting, turn on DFEntryMod,
 351      * update f.versionNo.
 352      * A lot of this could be integrated into the loop above
 353      */
 354     if (!code) {
 355         afs_hyper_t h_unset;
 356         hones(h_unset);
 357
 358         minj = 0;
 359
 360         do {
 361             moredata = FALSE;
 362             memset(dcList, 0,
 363                    NCHUNKSATONCE * sizeof(struct dcache *));
 364
 365             /* overkill, but it gets the lock in case GetDSlot needs it */
 366             ObtainWriteLock(&afs_xdcache, 285);
 367
 368             for (j = 0, safety = 0, index = afs_dvhashTbl[hash];
 369                  index != NULLIDX && safety < afs_cacheFiles + 2;
 370                  index = afs_dvnextTbl[index]) {
 371
 372                 if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 373                     tdc = afs_GetValidDSlot(index);
 374                     if (!tdc) {
 375                         /* This is okay; since manipulating the dcaches at this
 376                          * point is best-effort. We only get a dcache here to
 377                          * increment the dv and turn off DWriting. If we were
 378                          * supposed to do that for a dcache, but could not
 379                          * due to an I/O error, it just means the dv won't
 380                          * be updated so we don't be able to use that cached
 381                          * chunk in the future. That's inefficient, but not
 382                          * an error. */
 383                         break;
 384                     }
 385                     ReleaseReadLock(&tdc->tlock);
 386
 387                     if (!FidCmp(&tdc->f.fid, &avc->f.fid)
 388                         && tdc->f.chunk >= minj) {
 389                         off = tdc->f.chunk - minj;
 390                         if (off < NCHUNKSATONCE) {
 391                             /* this is the file, and the correct chunk range */
 392                             if (j >= NCHUNKSATONCE)
 393                                 osi_Panic
 394                                     ("Too many dcache entries in range\n");
 395                             dcList[j++] = tdc;
 396                         } else {
 397                             moredata = TRUE;
 398                             afs_PutDCache(tdc);
 399                             if (j == NCHUNKSATONCE)
 400                                 break;
 401                         }
 402                     } else {
 403                         afs_PutDCache(tdc);
 404                     }
 405                 }
 406             }
 407             ReleaseWriteLock(&afs_xdcache);
 408
 409             for (i = 0; i < j; i++) {
 410                 /* Iterate over the dcache entries we collected above */
 411                 tdc = dcList[i];
 412                 ObtainSharedLock(&tdc->lock, 677);
 413
 414                 /* was code here to clear IFDataMod, but it should only be done
 415                  * in storedcache and storealldcache.
 416                  */
 417                 /* Only increase DV if we had up-to-date data to start with.
 418                  * Otherwise, we could be falsely upgrading an old chunk
 419                  * (that we never read) into one labelled with the current
 420                  * DV #.  Also note that we check that no intervening stores
 421                  * occurred, otherwise we might mislabel cache information
 422                  * for a chunk that we didn't store this time
 423                  */
 424                 /* Don't update the version number if it's not yet set. */
 425                 if (!hsame(tdc->f.versionNo, h_unset)
 426                     && hcmp(tdc->f.versionNo, oldDV) >= 0) {
 427
 428                     if ((!(afs_dvhack || foreign)
 429                          && hsame(avc->f.m.DataVersion, newDV))
 430                         || ((afs_dvhack || foreign)
 431                             && (origCBs == afs_allCBs))) {
 432                         /* no error, this is the DV */
 433
 434                         UpgradeSToWLock(&tdc->lock, 678);
 435                         hset(tdc->f.versionNo, avc->f.m.DataVersion);
 436                         tdc->dflags |= DFEntryMod;
 437                         /* DWriting may not have gotten cleared above, if all
 438                          * we did was a StoreMini */
 439                         tdc->f.states &= ~DWriting;
 440                         ConvertWToSLock(&tdc->lock);
 441                     }
 442                 }
 443
 444                 ReleaseSharedLock(&tdc->lock);
 445                 afs_PutDCache(tdc);
 446             }
 447
 448             minj += NCHUNKSATONCE;
 449
 450         } while (moredata);
 451     }
 452
 453     if (code) {
 454         /*
 455          * Invalidate chunks after an error for ccores files since
 456          * afs_inactive won't be called for these and they won't be
 457          * invalidated. Also discard data if it's a permanent error from the
 458          * fileserver.
 459          */
 460         if (areq->permWriteError || (avc->f.states & CCore)) {
 461             afs_InvalidateAllSegments(avc);
 462         }
 463     }
 464     afs_Trace3(afs_iclSetp, CM_TRACE_STOREALLDONE, ICL_TYPE_POINTER, avc,
 465                ICL_TYPE_INT32, avc->f.m.Length, ICL_TYPE_INT32, code);
 466     /* would like a Trace5, but it doesn't exist... */
 467     afs_Trace3(afs_iclSetp, CM_TRACE_AVCLOCKER, ICL_TYPE_POINTER, avc,
 468                ICL_TYPE_INT32, avc->lock.wait_states, ICL_TYPE_INT32,
 469                avc->lock.excl_locked);
 470     afs_Trace4(afs_iclSetp, CM_TRACE_AVCLOCKEE, ICL_TYPE_POINTER, avc,
 471                ICL_TYPE_INT32, avc->lock.wait_states, ICL_TYPE_INT32,
 472                avc->lock.readers_reading, ICL_TYPE_INT32,
 473                avc->lock.num_waiting);
 474
 475     /*
 476      * Finally, if updated DataVersion matches newDV, we did all of the
 477      * stores.  If mapDV indicates that the page cache was flushed up
 478      * to when we started the store, then we can relabel them as flushed
 479      * as recently as newDV.
 480      * Turn off CDirty bit because the stored data is now in sync with server.
 481      */
 482     if (code == 0 && hcmp(avc->mapDV, oldDV) >= 0) {
 483         if ((!(afs_dvhack || foreign) && hsame(avc->f.m.DataVersion, newDV))
 484             || ((afs_dvhack || foreign) && (origCBs == afs_allCBs))) {
 485             hset(avc->mapDV, newDV);
 486             avc->f.states &= ~CDirty;
 487         }
 488     }
 489     osi_FreeLargeSpace(dcList);
 490
 491     /* If not the final write a temporary error is ok. */
 492     if (code && !areq->permWriteError && !(sync & AFS_LASTSTORE))
 493         code = 0;
 494
 495     return code;
 496
 497 }                               /*afs_StoreAllSegments (new 03/02/94) */
 498
 499 int
 500 afs_InvalidateAllSegments_once(struct vcache *avc)
 501 {
 502     struct dcache *tdc;
 503     afs_int32 hash;
 504     afs_int32 index;
 505     struct dcache **dcList = NULL;
 506     int i, dcListMax, dcListCount;
 507
 508     AFS_STATCNT(afs_InvalidateAllSegments);
 509     afs_Trace2(afs_iclSetp, CM_TRACE_INVALL, ICL_TYPE_POINTER, avc,
 510                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));
 511     hash = DVHash(&avc->f.fid);
 512     avc->f.truncPos = AFS_NOTRUNC;      /* don't truncate later */
 513     avc->f.states &= ~CExtendedFile;    /* not any more */
 514     afs_StaleVCacheFlags(avc, 0, CDirty);
 515     /* Blow away pages; for now, only for Solaris */
 516 #if     (defined(AFS_SUN5_ENV))
 517     if (WriteLocked(&avc->lock))
 518         osi_ReleaseVM(avc, (afs_ucred_t *)0);
 519 #endif
 520     /*
 521      * Block out others from screwing with this table; is a read lock
 522      * sufficient?
 523      */
 524     ObtainWriteLock(&afs_xdcache, 286);
 525     dcListMax = 0;
 526
 527     for (index = afs_dvhashTbl[hash]; index != NULLIDX;) {
 528         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 529             tdc = afs_GetValidDSlot(index);
 530             if (!tdc) {
 531                 goto error;
 532             }
 533             ReleaseReadLock(&tdc->tlock);
 534             if (!FidCmp(&tdc->f.fid, &avc->f.fid))
 535                 dcListMax++;
 536             afs_PutDCache(tdc);
 537         }
 538         index = afs_dvnextTbl[index];
 539     }
 540
 541     dcList = osi_Alloc(dcListMax * sizeof(struct dcache *));
 542     dcListCount = 0;
 543
 544     for (index = afs_dvhashTbl[hash]; index != NULLIDX;) {
 545         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 546             tdc = afs_GetValidDSlot(index);
 547             if (!tdc) {
 548                 goto error;
 549             }
 550             ReleaseReadLock(&tdc->tlock);
 551             if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
 552                 /* same file? we'll zap it */
 553                 if (afs_indexFlags[index] & IFDataMod) {
 554                     afs_stats_cmperf.cacheCurrDirtyChunks--;
 555                     /* don't write it back */
 556                     afs_indexFlags[index] &= ~IFDataMod;
 557                 }
 558                 afs_indexFlags[index] &= ~IFAnyPages;
 559                 if (dcListCount < dcListMax)
 560                     dcList[dcListCount++] = tdc;
 561                 else
 562                     afs_PutDCache(tdc);
 563             } else {
 564                 afs_PutDCache(tdc);
 565             }
 566         }
 567         index = afs_dvnextTbl[index];
 568     }
 569     ReleaseWriteLock(&afs_xdcache);
 570
 571     for (i = 0; i < dcListCount; i++) {
 572         tdc = dcList[i];
 573
 574         ObtainWriteLock(&tdc->lock, 679);
 575         ZapDCE(tdc);
 576         if (vType(avc) == VDIR)
 577             DZap(tdc);
 578         ReleaseWriteLock(&tdc->lock);
 579         afs_PutDCache(tdc);
 580     }
 581
 582     osi_Free(dcList, dcListMax * sizeof(struct dcache *));
 583
 584     return 0;
 585
 586  error:
 587     ReleaseWriteLock(&afs_xdcache);
 588
 589     if (dcList) {
 590         for (i = 0; i < dcListCount; i++) {
 591             tdc = dcList[i];
 592             if (tdc) {
 593                 afs_PutDCache(tdc);
 594             }
 595         }
 596         osi_Free(dcList, dcListMax * sizeof(struct dcache *));
 597     }
 598     return EIO;
 599 }
 600
 601
 602 /*
 603  * afs_InvalidateAllSegments
 604  *
 605  * Description:
 606  *      Invalidates all chunks for a given file
 607  *
 608  * Parameters:
 609  *      avc      : Pointer to vcache entry.
 610  *
 611  * Environment:
 612  *      For example, called after an error has been detected.  Called
 613  *      with avc write-locked, and afs_xdcache unheld.
 614  */
 615
 616 void
 617 afs_InvalidateAllSegments(struct vcache *avc)
 618 {
 619     int code;
 620     afs_uint32 last_warn;
 621
 622     code = afs_InvalidateAllSegments_once(avc);
 623     if (code == 0) {
 624         /* Success; nothing more to do. */
 625         return;
 626     }
 627
 628     /*
 629      * If afs_InvalidateAllSegments_once failed, we cannot simply return an
 630      * error to our caller. This function is called when we encounter a fatal
 631      * error during stores, in which case we MUST invalidate all chunks for the
 632      * given file. If we fail to invalidate some chunks, they will be left with
 633      * the 'new' dirty/written data that was never successfully stored on the
 634      * server, but the DV in the dcache is still the old DV. So, if its left
 635      * alone, we may indefinitely serve data to applications that is not
 636      * actually in the file on the fileserver.
 637      *
 638      * So to make sure we never serve userspace bad data after such a failure,
 639      * we must keep trying to invalidate the dcaches for the given file. (Note
 640      * that we cannot simply set a flag on the vcache to retry the invalidate
 641      * later on, because the vcache may go away, but the 'bad' dcaches could
 642      * remain.) We do this below, via background daemon requests because in
 643      * some scenarios we can always get I/O errors on accessing the cache if we
 644      * access via a user pid. (e.g. on LINUX, this can happen if the pid has a
 645      * pending SIGKILL.) Doing this via background daemon ops should avoid
 646      * that.
 647      */
 648
 649     last_warn = osi_Time();
 650     afs_warn("afs: Failed to invalidate cache chunks for fid %d.%d.%d.%d; our "
 651              "local disk cache may be throwing errors. We must invalidate "
 652              "these chunks to avoid possibly serving incorrect data, so we'll "
 653              "retry until we succeed. If AFS access seems to hang, this may "
 654              "be why.\n",
 655              avc->f.fid.Cell, avc->f.fid.Fid.Volume, avc->f.fid.Fid.Vnode,
 656              avc->f.fid.Fid.Unique);
 657
 658     do {
 659         static const afs_uint32 warn_int = 60*60; /* warn once every hour */
 660         afs_uint32 now = osi_Time();
 661         struct brequest *bp;
 662
 663         if (now < last_warn || now - last_warn > warn_int) {
 664             last_warn = now;
 665             afs_warn("afs: Still trying to invalidate cache chunks for fid "
 666                      "%d.%d.%d.%d. We will retry until we succeed; if AFS "
 667                      "access seems to hang, this may be why.\n",
 668                      avc->f.fid.Cell, avc->f.fid.Fid.Volume,
 669                      avc->f.fid.Fid.Vnode, avc->f.fid.Fid.Unique);
 670         }
 671
 672         /* Wait 10 seconds between attempts. */
 673         afs_osi_Wait(1000 * 10, NULL, 0);
 674
 675         /*
 676          * Ask a background daemon to do this request for us. Note that _we_ hold
 677          * the write lock on 'avc', while the background daemon does the work. This
 678          * is a little weird, but it helps avoid any issues with lock ordering
 679          * or if our caller does not expect avc->lock to be dropped while
 680          * running.
 681          */
 682         bp = afs_BQueue(BOP_INVALIDATE_SEGMENTS, avc, 0, 1, NULL, 0, 0, NULL,
 683                         NULL, NULL);
 684         while ((bp->flags & BUVALID) == 0) {
 685             bp->flags |= BUWAIT;
 686             afs_osi_Sleep(bp);
 687         }
 688         code = bp->code_raw;
 689         afs_BRelease(bp);
 690     } while (code);
 691 }
 692
 693 /*!
 694  *
 695  * Extend a cache file
 696  *
 697  * \param avc pointer to vcache to extend data for
 698  * \param alen Length to extend file to
 699  * \param areq
 700  *
 701  * \note avc must be write locked. May release and reobtain avc and GLOCK
 702  */
 703 int
 704 afs_ExtendSegments(struct vcache *avc, afs_size_t alen, struct vrequest *areq)
 705 {
 706     afs_size_t offset, toAdd;
 707     struct osi_file *tfile;
 708     afs_int32 code = 0;
 709     struct dcache *tdc;
 710     void *zeros;
 711
 712     zeros = afs_osi_Alloc(AFS_PAGESIZE);
 713     if (zeros == NULL)
 714         return ENOMEM;
 715     memset(zeros, 0, AFS_PAGESIZE);
 716
 717     while (avc->f.m.Length < alen) {
 718         tdc = afs_ObtainDCacheForWriting(avc, avc->f.m.Length, alen - avc->f.m.Length, areq, 0);
 719         if (!tdc) {
 720             code = EIO;
 721             break;
 722         }
 723
 724         toAdd = alen - avc->f.m.Length;
 725
 726         offset = avc->f.m.Length - AFS_CHUNKTOBASE(tdc->f.chunk);
 727         if (offset + toAdd > AFS_CHUNKTOSIZE(tdc->f.chunk)) {
 728             toAdd = AFS_CHUNKTOSIZE(tdc->f.chunk) - offset;
 729         }
 730         tfile = afs_CFileOpen(&tdc->f.inode);
 731         osi_Assert(tfile);
 732         while(tdc->validPos < avc->f.m.Length + toAdd) {
 733              afs_size_t towrite;
 734
 735              towrite = (avc->f.m.Length + toAdd) - tdc->validPos;
 736              if (towrite > AFS_PAGESIZE) towrite = AFS_PAGESIZE;
 737
 738              code = afs_CFileWrite(tfile,
 739                                    tdc->validPos - AFS_CHUNKTOBASE(tdc->f.chunk),
 740                                    zeros, towrite);
 741              tdc->validPos += towrite;
 742         }
 743         afs_CFileClose(tfile);
 744         afs_AdjustSize(tdc, offset + toAdd );
 745         avc->f.m.Length += toAdd;
 746         ReleaseWriteLock(&tdc->lock);
 747         afs_PutDCache(tdc);
 748     }
 749
 750     afs_osi_Free(zeros, AFS_PAGESIZE);
 751     return code;
 752 }
 753
 754 /*
 755  * afs_TruncateAllSegments
 756  *
 757  * Description:
 758  *      Truncate a cache file.
 759  *
 760  * Parameters:
 761  *      avc  : Ptr to vcache entry to truncate.
 762  *      alen : Number of bytes to make the file.
 763  *      areq : Ptr to request structure.
 764  *
 765  * Environment:
 766  *      Called with avc write-locked; in VFS40 systems, pvnLock is also
 767  *      held.
 768  */
 769 int
 770 afs_TruncateAllSegments(struct vcache *avc, afs_size_t alen,
 771                         struct vrequest *areq, afs_ucred_t *acred)
 772 {
 773     struct dcache *tdc;
 774     afs_int32 code;
 775     afs_int32 index;
 776     afs_size_t newSize;
 777
 778     int dcCount, dcPos;
 779     struct dcache **tdcArray = NULL;
 780
 781     AFS_STATCNT(afs_TruncateAllSegments);
 782     avc->f.m.Date = osi_Time();
 783     afs_Trace3(afs_iclSetp, CM_TRACE_TRUNCALL, ICL_TYPE_POINTER, avc,
 784                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length),
 785                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(alen));
 786     if (alen >= avc->f.m.Length) {
 787         /*
 788          * Special speedup since Sun's vm extends the file this way;
 789          * we've never written to the file thus we can just set the new
 790          * length and avoid the needless calls below.
 791          * Also used for ftruncate calls which can extend the file.
 792          * To completely minimize the possible extra StoreMini RPC, we really
 793          * should keep the ExtendedPos as well and clear this flag if we
 794          * truncate below that value before we store the file back.
 795          */
 796         avc->f.states |= CExtendedFile;
 797         avc->f.m.Length = alen;
 798         return 0;
 799     }
 800 #if     (defined(AFS_SUN5_ENV))
 801
 802     /* Zero unused portion of last page */
 803     osi_VM_PreTruncate(avc, alen, acred);
 804
 805 #endif
 806
 807 #if     (defined(AFS_SUN5_ENV))
 808     ObtainWriteLock(&avc->vlock, 546);
 809     avc->activeV++;             /* Block new getpages */
 810     ReleaseWriteLock(&avc->vlock);
 811 #endif
 812
 813     ReleaseWriteLock(&avc->lock);
 814     AFS_GUNLOCK();
 815
 816     /* Flush pages beyond end-of-file. */
 817     osi_VM_Truncate(avc, alen, acred);
 818
 819     AFS_GLOCK();
 820     ObtainWriteLock(&avc->lock, 79);
 821
 822     avc->f.m.Length = alen;
 823
 824     if (alen < avc->f.truncPos)
 825         avc->f.truncPos = alen;
 826     code = DVHash(&avc->f.fid);
 827
 828     /* block out others from screwing with this table */
 829     ObtainWriteLock(&afs_xdcache, 287);
 830
 831     dcCount = 0;
 832     for (index = afs_dvhashTbl[code]; index != NULLIDX;) {
 833         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 834             tdc = afs_GetValidDSlot(index);
 835             if (!tdc) {
 836                 ReleaseWriteLock(&afs_xdcache);
 837                 code = EIO;
 838                 goto done;
 839             }
 840             ReleaseReadLock(&tdc->tlock);
 841             if (!FidCmp(&tdc->f.fid, &avc->f.fid))
 842                 dcCount++;
 843             afs_PutDCache(tdc);
 844         }
 845         index = afs_dvnextTbl[index];
 846     }
 847
 848     /* Now allocate space where we can save those dcache entries, and
 849      * do a second pass over them..  Since we're holding xdcache, it
 850      * shouldn't be changing.
 851      */
 852     tdcArray = osi_Alloc(dcCount * sizeof(struct dcache *));
 853     dcPos = 0;
 854
 855     for (index = afs_dvhashTbl[code]; index != NULLIDX; index = afs_dvnextTbl[index]) {
 856         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 857             tdc = afs_GetValidDSlot(index);
 858             if (!tdc) {
 859                 /* make sure we put back all of the tdcArray members before
 860                  * bailing out */
 861                 /* remember, the last valid tdc is at dcPos-1, so start at
 862                  * dcPos-1, not at dcPos itself. */
 863                 for (dcPos = dcPos - 1; dcPos >= 0; dcPos--) {
 864                     tdc = tdcArray[dcPos];
 865                     afs_PutDCache(tdc);
 866                 }
 867                 code = EIO;
 868                 goto done;
 869             }
 870             ReleaseReadLock(&tdc->tlock);
 871             if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
 872                 /* same file, and modified, we'll store it back */
 873                 if (dcPos < dcCount) {
 874                     tdcArray[dcPos++] = tdc;
 875                 } else {
 876                     afs_PutDCache(tdc);
 877                 }
 878             } else {
 879                 afs_PutDCache(tdc);
 880             }
 881         }
 882     }
 883
 884     ReleaseWriteLock(&afs_xdcache);
 885
 886     /* Now we loop over the array of dcache entries and truncate them */
 887     for (index = 0; index < dcPos; index++) {
 888         struct osi_file *tfile;
 889
 890         tdc = tdcArray[index];
 891
 892         newSize = alen - AFS_CHUNKTOBASE(tdc->f.chunk);
 893         if (newSize < 0)
 894             newSize = 0;
 895         ObtainSharedLock(&tdc->lock, 672);
 896         if (newSize < tdc->f.chunkBytes && newSize < MAX_AFS_UINT32) {
 897             UpgradeSToWLock(&tdc->lock, 673);
 898             tdc->f.states |= DWriting;
 899             tfile = afs_CFileOpen(&tdc->f.inode);
 900             osi_Assert(tfile);
 901             afs_CFileTruncate(tfile, (afs_int32)newSize);
 902             afs_CFileClose(tfile);
 903             afs_AdjustSize(tdc, (afs_int32)newSize);
 904             if (alen < tdc->validPos) {
 905                 if (alen < AFS_CHUNKTOBASE(tdc->f.chunk))
 906                     tdc->validPos = 0;
 907                 else
 908                     tdc->validPos = alen;
 909             }
 910             ConvertWToSLock(&tdc->lock);
 911         }
 912         ReleaseSharedLock(&tdc->lock);
 913         afs_PutDCache(tdc);
 914     }
 915
 916     code = 0;
 917
 918  done:
 919     if (tdcArray) {
 920         osi_Free(tdcArray, dcCount * sizeof(struct dcache *));
 921     }
 922 #if     (defined(AFS_SUN5_ENV))
 923     ObtainWriteLock(&avc->vlock, 547);
 924     if (--avc->activeV == 0 && (avc->vstates & VRevokeWait)) {
 925         avc->vstates &= ~VRevokeWait;
 926         afs_osi_Wakeup((char *)&avc->vstates);
 927     }
 928     ReleaseWriteLock(&avc->vlock);
 929 #endif
 930
 931     return code;
 932 }