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 = 0;
 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
 543     for (index = afs_dvhashTbl[hash]; index != NULLIDX;) {
 544         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 545             tdc = afs_GetValidDSlot(index);
 546             if (!tdc) {
 547                 goto error;
 548             }
 549             ReleaseReadLock(&tdc->tlock);
 550             if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
 551                 /* same file? we'll zap it */
 552                 if (afs_indexFlags[index] & IFDataMod) {
 553                     afs_stats_cmperf.cacheCurrDirtyChunks--;
 554                     /* don't write it back */
 555                     afs_indexFlags[index] &= ~IFDataMod;
 556                 }
 557                 afs_indexFlags[index] &= ~IFAnyPages;
 558                 if (dcListCount < dcListMax)
 559                     dcList[dcListCount++] = tdc;
 560                 else
 561                     afs_PutDCache(tdc);
 562             } else {
 563                 afs_PutDCache(tdc);
 564             }
 565         }
 566         index = afs_dvnextTbl[index];
 567     }
 568     ReleaseWriteLock(&afs_xdcache);
 569
 570     for (i = 0; i < dcListCount; i++) {
 571         tdc = dcList[i];
 572
 573         ObtainWriteLock(&tdc->lock, 679);
 574         ZapDCE(tdc);
 575         if (vType(avc) == VDIR)
 576             DZap(tdc);
 577         ReleaseWriteLock(&tdc->lock);
 578         afs_PutDCache(tdc);
 579     }
 580
 581     osi_Free(dcList, dcListMax * sizeof(struct dcache *));
 582
 583     return 0;
 584
 585  error:
 586     ReleaseWriteLock(&afs_xdcache);
 587
 588     if (dcList) {
 589         for (i = 0; i < dcListCount; i++) {
 590             tdc = dcList[i];
 591             if (tdc) {
 592                 afs_PutDCache(tdc);
 593             }
 594         }
 595         osi_Free(dcList, dcListMax * sizeof(struct dcache *));
 596     }
 597     return EIO;
 598 }
 599
 600
 601 /*
 602  * afs_InvalidateAllSegments
 603  *
 604  * Description:
 605  *      Invalidates all chunks for a given file
 606  *
 607  * Parameters:
 608  *      avc      : Pointer to vcache entry.
 609  *
 610  * Environment:
 611  *      For example, called after an error has been detected.  Called
 612  *      with avc write-locked, and afs_xdcache unheld.
 613  */
 614
 615 void
 616 afs_InvalidateAllSegments(struct vcache *avc)
 617 {
 618     int code;
 619     afs_uint32 last_warn;
 620
 621     code = afs_InvalidateAllSegments_once(avc);
 622     if (code == 0) {
 623         /* Success; nothing more to do. */
 624         return;
 625     }
 626
 627     /*
 628      * If afs_InvalidateAllSegments_once failed, we cannot simply return an
 629      * error to our caller. This function is called when we encounter a fatal
 630      * error during stores, in which case we MUST invalidate all chunks for the
 631      * given file. If we fail to invalidate some chunks, they will be left with
 632      * the 'new' dirty/written data that was never successfully stored on the
 633      * server, but the DV in the dcache is still the old DV. So, if its left
 634      * alone, we may indefinitely serve data to applications that is not
 635      * actually in the file on the fileserver.
 636      *
 637      * So to make sure we never serve userspace bad data after such a failure,
 638      * we must keep trying to invalidate the dcaches for the given file. (Note
 639      * that we cannot simply set a flag on the vcache to retry the invalidate
 640      * later on, because the vcache may go away, but the 'bad' dcaches could
 641      * remain.) We do this below, via background daemon requests because in
 642      * some scenarios we can always get I/O errors on accessing the cache if we
 643      * access via a user pid. (e.g. on LINUX, this can happen if the pid has a
 644      * pending SIGKILL.) Doing this via background daemon ops should avoid
 645      * that.
 646      */
 647
 648     last_warn = osi_Time();
 649     afs_warn("afs: Failed to invalidate cache chunks for fid %d.%d.%d.%d; our "
 650              "local disk cache may be throwing errors. We must invalidate "
 651              "these chunks to avoid possibly serving incorrect data, so we'll "
 652              "retry until we succeed. If AFS access seems to hang, this may "
 653              "be why.\n",
 654              avc->f.fid.Cell, avc->f.fid.Fid.Volume, avc->f.fid.Fid.Vnode,
 655              avc->f.fid.Fid.Unique);
 656
 657     do {
 658         static const afs_uint32 warn_int = 60*60; /* warn once every hour */
 659         afs_uint32 now = osi_Time();
 660         struct brequest *bp;
 661
 662         if (now < last_warn || now - last_warn > warn_int) {
 663             last_warn = now;
 664             afs_warn("afs: Still trying to invalidate cache chunks for fid "
 665                      "%d.%d.%d.%d. We will retry until we succeed; if AFS "
 666                      "access seems to hang, this may be why.\n",
 667                      avc->f.fid.Cell, avc->f.fid.Fid.Volume,
 668                      avc->f.fid.Fid.Vnode, avc->f.fid.Fid.Unique);
 669         }
 670
 671         /* Wait 10 seconds between attempts. */
 672         afs_osi_Wait(1000 * 10, NULL, 0);
 673
 674         /*
 675          * Ask a background daemon to do this request for us. Note that _we_ hold
 676          * the write lock on 'avc', while the background daemon does the work. This
 677          * is a little weird, but it helps avoid any issues with lock ordering
 678          * or if our caller does not expect avc->lock to be dropped while
 679          * running.
 680          */
 681         bp = afs_BQueue(BOP_INVALIDATE_SEGMENTS, avc, 0, 1, NULL, 0, 0, NULL,
 682                         NULL, NULL);
 683         while ((bp->flags & BUVALID) == 0) {
 684             bp->flags |= BUWAIT;
 685             afs_osi_Sleep(bp);
 686         }
 687         code = bp->code_raw;
 688         afs_BRelease(bp);
 689     } while (code);
 690 }
 691
 692 /*!
 693  *
 694  * Extend a cache file
 695  *
 696  * \param avc pointer to vcache to extend data for
 697  * \param alen Length to extend file to
 698  * \param areq
 699  *
 700  * \note avc must be write locked. May release and reobtain avc and GLOCK
 701  */
 702 int
 703 afs_ExtendSegments(struct vcache *avc, afs_size_t alen, struct vrequest *areq)
 704 {
 705     afs_size_t offset, toAdd;
 706     struct osi_file *tfile;
 707     afs_int32 code = 0;
 708     struct dcache *tdc;
 709     void *zeros;
 710
 711     zeros = afs_osi_Alloc(AFS_PAGESIZE);
 712     if (zeros == NULL)
 713         return ENOMEM;
 714     memset(zeros, 0, AFS_PAGESIZE);
 715
 716     while (avc->f.m.Length < alen) {
 717         tdc = afs_ObtainDCacheForWriting(avc, avc->f.m.Length, alen - avc->f.m.Length, areq, 0);
 718         if (!tdc) {
 719             code = EIO;
 720             break;
 721         }
 722
 723         toAdd = alen - avc->f.m.Length;
 724
 725         offset = avc->f.m.Length - AFS_CHUNKTOBASE(tdc->f.chunk);
 726         if (offset + toAdd > AFS_CHUNKTOSIZE(tdc->f.chunk)) {
 727             toAdd = AFS_CHUNKTOSIZE(tdc->f.chunk) - offset;
 728         }
 729         tfile = afs_CFileOpen(&tdc->f.inode);
 730         osi_Assert(tfile);
 731         while(tdc->validPos < avc->f.m.Length + toAdd) {
 732              afs_size_t towrite;
 733
 734              towrite = (avc->f.m.Length + toAdd) - tdc->validPos;
 735              if (towrite > AFS_PAGESIZE) towrite = AFS_PAGESIZE;
 736
 737              code = afs_CFileWrite(tfile,
 738                                    tdc->validPos - AFS_CHUNKTOBASE(tdc->f.chunk),
 739                                    zeros, towrite);
 740              tdc->validPos += towrite;
 741         }
 742         afs_CFileClose(tfile);
 743         afs_AdjustSize(tdc, offset + toAdd );
 744         avc->f.m.Length += toAdd;
 745         ReleaseWriteLock(&tdc->lock);
 746         afs_PutDCache(tdc);
 747     }
 748
 749     afs_osi_Free(zeros, AFS_PAGESIZE);
 750     return code;
 751 }
 752
 753 /*
 754  * afs_TruncateAllSegments
 755  *
 756  * Description:
 757  *      Truncate a cache file.
 758  *
 759  * Parameters:
 760  *      avc  : Ptr to vcache entry to truncate.
 761  *      alen : Number of bytes to make the file.
 762  *      areq : Ptr to request structure.
 763  *
 764  * Environment:
 765  *      Called with avc write-locked; in VFS40 systems, pvnLock is also
 766  *      held.
 767  */
 768 int
 769 afs_TruncateAllSegments(struct vcache *avc, afs_size_t alen,
 770                         struct vrequest *areq, afs_ucred_t *acred)
 771 {
 772     struct dcache *tdc;
 773     afs_int32 code;
 774     afs_int32 index;
 775     afs_size_t newSize;
 776
 777     int dcCount, dcPos;
 778     struct dcache **tdcArray = NULL;
 779
 780     AFS_STATCNT(afs_TruncateAllSegments);
 781     avc->f.m.Date = osi_Time();
 782     afs_Trace3(afs_iclSetp, CM_TRACE_TRUNCALL, ICL_TYPE_POINTER, avc,
 783                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length),
 784                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(alen));
 785     if (alen >= avc->f.m.Length) {
 786         /*
 787          * Special speedup since Sun's vm extends the file this way;
 788          * we've never written to the file thus we can just set the new
 789          * length and avoid the needless calls below.
 790          * Also used for ftruncate calls which can extend the file.
 791          * To completely minimize the possible extra StoreMini RPC, we really
 792          * should keep the ExtendedPos as well and clear this flag if we
 793          * truncate below that value before we store the file back.
 794          */
 795         avc->f.states |= CExtendedFile;
 796         avc->f.m.Length = alen;
 797         return 0;
 798     }
 799 #if     (defined(AFS_SUN5_ENV))
 800
 801     /* Zero unused portion of last page */
 802     osi_VM_PreTruncate(avc, alen, acred);
 803
 804 #endif
 805
 806 #if     (defined(AFS_SUN5_ENV))
 807     ObtainWriteLock(&avc->vlock, 546);
 808     avc->activeV++;             /* Block new getpages */
 809     ReleaseWriteLock(&avc->vlock);
 810 #endif
 811
 812     ReleaseWriteLock(&avc->lock);
 813     AFS_GUNLOCK();
 814
 815     /* Flush pages beyond end-of-file. */
 816     osi_VM_Truncate(avc, alen, acred);
 817
 818     AFS_GLOCK();
 819     ObtainWriteLock(&avc->lock, 79);
 820
 821     avc->f.m.Length = alen;
 822
 823     if (alen < avc->f.truncPos)
 824         avc->f.truncPos = alen;
 825     code = DVHash(&avc->f.fid);
 826
 827     /* block out others from screwing with this table */
 828     ObtainWriteLock(&afs_xdcache, 287);
 829
 830     dcCount = 0;
 831     for (index = afs_dvhashTbl[code]; index != NULLIDX;) {
 832         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 833             tdc = afs_GetValidDSlot(index);
 834             if (!tdc) {
 835                 ReleaseWriteLock(&afs_xdcache);
 836                 code = EIO;
 837                 goto done;
 838             }
 839             ReleaseReadLock(&tdc->tlock);
 840             if (!FidCmp(&tdc->f.fid, &avc->f.fid))
 841                 dcCount++;
 842             afs_PutDCache(tdc);
 843         }
 844         index = afs_dvnextTbl[index];
 845     }
 846
 847     /* Now allocate space where we can save those dcache entries, and
 848      * do a second pass over them..  Since we're holding xdcache, it
 849      * shouldn't be changing.
 850      */
 851     tdcArray = osi_Alloc(dcCount * sizeof(struct dcache *));
 852     dcPos = 0;
 853
 854     for (index = afs_dvhashTbl[code]; index != NULLIDX; index = afs_dvnextTbl[index]) {
 855         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 856             tdc = afs_GetValidDSlot(index);
 857             if (!tdc) {
 858                 /* make sure we put back all of the tdcArray members before
 859                  * bailing out */
 860                 /* remember, the last valid tdc is at dcPos-1, so start at
 861                  * dcPos-1, not at dcPos itself. */
 862                 for (dcPos = dcPos - 1; dcPos >= 0; dcPos--) {
 863                     tdc = tdcArray[dcPos];
 864                     afs_PutDCache(tdc);
 865                 }
 866                 code = EIO;
 867                 goto done;
 868             }
 869             ReleaseReadLock(&tdc->tlock);
 870             if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
 871                 /* same file, and modified, we'll store it back */
 872                 if (dcPos < dcCount) {
 873                     tdcArray[dcPos++] = tdc;
 874                 } else {
 875                     afs_PutDCache(tdc);
 876                 }
 877             } else {
 878                 afs_PutDCache(tdc);
 879             }
 880         }
 881     }
 882
 883     ReleaseWriteLock(&afs_xdcache);
 884
 885     /* Now we loop over the array of dcache entries and truncate them */
 886     for (index = 0; index < dcPos; index++) {
 887         struct osi_file *tfile;
 888
 889         tdc = tdcArray[index];
 890
 891         newSize = alen - AFS_CHUNKTOBASE(tdc->f.chunk);
 892         if (newSize < 0)
 893             newSize = 0;
 894         ObtainSharedLock(&tdc->lock, 672);
 895         if (newSize < tdc->f.chunkBytes && newSize < MAX_AFS_UINT32) {
 896             UpgradeSToWLock(&tdc->lock, 673);
 897             tdc->f.states |= DWriting;
 898             tfile = afs_CFileOpen(&tdc->f.inode);
 899             osi_Assert(tfile);
 900             afs_CFileTruncate(tfile, (afs_int32)newSize);
 901             afs_CFileClose(tfile);
 902             afs_AdjustSize(tdc, (afs_int32)newSize);
 903             if (alen < tdc->validPos) {
 904                 if (alen < AFS_CHUNKTOBASE(tdc->f.chunk))
 905                     tdc->validPos = 0;
 906                 else
 907                     tdc->validPos = alen;
 908             }
 909             ConvertWToSLock(&tdc->lock);
 910         }
 911         ReleaseSharedLock(&tdc->lock);
 912         afs_PutDCache(tdc);
 913     }
 914
 915     code = 0;
 916
 917  done:
 918     if (tdcArray) {
 919         osi_Free(tdcArray, dcCount * sizeof(struct dcache *));
 920     }
 921 #if     (defined(AFS_SUN5_ENV))
 922     ObtainWriteLock(&avc->vlock, 547);
 923     if (--avc->activeV == 0 && (avc->vstates & VRevokeWait)) {
 924         avc->vstates &= ~VRevokeWait;
 925         afs_osi_Wakeup((char *)&avc->vstates);
 926     }
 927     ReleaseWriteLock(&avc->vlock);
 928 #endif
 929
 930     return code;
 931 }