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                         continue;
 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
 500 /*
 501  * afs_InvalidateAllSegments
 502  *
 503  * Description:
 504  *      Invalidates all chunks for a given file
 505  *
 506  * Parameters:
 507  *      avc      : Pointer to vcache entry.
 508  *
 509  * Environment:
 510  *      For example, called after an error has been detected.  Called
 511  *      with avc write-locked, and afs_xdcache unheld.
 512  */
 513
 514 int
 515 afs_InvalidateAllSegments(struct vcache *avc)
 516 {
 517     struct dcache *tdc;
 518     afs_int32 hash;
 519     afs_int32 index;
 520     struct dcache **dcList;
 521     int i, dcListMax, dcListCount;
 522
 523     AFS_STATCNT(afs_InvalidateAllSegments);
 524     afs_Trace2(afs_iclSetp, CM_TRACE_INVALL, ICL_TYPE_POINTER, avc,
 525                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length));
 526     hash = DVHash(&avc->f.fid);
 527     avc->f.truncPos = AFS_NOTRUNC;      /* don't truncate later */
 528     avc->f.states &= ~CExtendedFile;    /* not any more */
 529     ObtainWriteLock(&afs_xcbhash, 459);
 530     afs_DequeueCallback(avc);
 531     avc->f.states &= ~(CStatd | CDirty);        /* mark status information as bad, too */
 532     ReleaseWriteLock(&afs_xcbhash);
 533     if (avc->f.fid.Fid.Vnode & 1 || (vType(avc) == VDIR))
 534         osi_dnlc_purgedp(avc);
 535     /* Blow away pages; for now, only for Solaris */
 536 #if     (defined(AFS_SUN5_ENV))
 537     if (WriteLocked(&avc->lock))
 538         osi_ReleaseVM(avc, (afs_ucred_t *)0);
 539 #endif
 540     /*
 541      * Block out others from screwing with this table; is a read lock
 542      * sufficient?
 543      */
 544     ObtainWriteLock(&afs_xdcache, 286);
 545     dcListMax = 0;
 546
 547     for (index = afs_dvhashTbl[hash]; index != NULLIDX;) {
 548         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 549             tdc = afs_GetValidDSlot(index);
 550             if (!tdc) {
 551                 /* In the case of fatal errors during stores, we MUST
 552                  * invalidate all of the relevant chunks. Otherwise, the chunks
 553                  * will be left with the 'new' data that was never successfully
 554                  * written to the server, but the DV in the dcache is still the
 555                  * old DV. So, we may indefinitely serve data to applications
 556                  * that is not actually in the file on the fileserver. If we
 557                  * cannot afs_GetValidDSlot the appropriate entries, currently
 558                  * there is no way to ensure the dcache is invalidated. So for
 559                  * now, to avoid risking serving bad data from the cache, panic
 560                  * instead. */
 561                 osi_Panic("afs_InvalidateAllSegments tdc count");
 562             }
 563             ReleaseReadLock(&tdc->tlock);
 564             if (!FidCmp(&tdc->f.fid, &avc->f.fid))
 565                 dcListMax++;
 566             afs_PutDCache(tdc);
 567         }
 568         index = afs_dvnextTbl[index];
 569     }
 570
 571     dcList = osi_Alloc(dcListMax * sizeof(struct dcache *));
 572     dcListCount = 0;
 573
 574     for (index = afs_dvhashTbl[hash]; index != NULLIDX;) {
 575         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 576             tdc = afs_GetValidDSlot(index);
 577             if (!tdc) {
 578                 /* We cannot proceed after getting this error; we risk serving
 579                  * incorrect data to applications. So panic instead. See the
 580                  * above comment next to the previous afs_GetValidDSlot call
 581                  * for details. */
 582                 osi_Panic("afs_InvalidateAllSegments tdc store");
 583             }
 584             ReleaseReadLock(&tdc->tlock);
 585             if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
 586                 /* same file? we'll zap it */
 587                 if (afs_indexFlags[index] & IFDataMod) {
 588                     afs_stats_cmperf.cacheCurrDirtyChunks--;
 589                     /* don't write it back */
 590                     afs_indexFlags[index] &= ~IFDataMod;
 591                 }
 592                 afs_indexFlags[index] &= ~IFAnyPages;
 593                 if (dcListCount < dcListMax)
 594                     dcList[dcListCount++] = tdc;
 595                 else
 596                     afs_PutDCache(tdc);
 597             } else {
 598                 afs_PutDCache(tdc);
 599             }
 600         }
 601         index = afs_dvnextTbl[index];
 602     }
 603     ReleaseWriteLock(&afs_xdcache);
 604
 605     for (i = 0; i < dcListCount; i++) {
 606         tdc = dcList[i];
 607
 608         ObtainWriteLock(&tdc->lock, 679);
 609         ZapDCE(tdc);
 610         if (vType(avc) == VDIR)
 611             DZap(tdc);
 612         ReleaseWriteLock(&tdc->lock);
 613         afs_PutDCache(tdc);
 614     }
 615
 616     osi_Free(dcList, dcListMax * sizeof(struct dcache *));
 617
 618     return 0;
 619 }
 620
 621 /*!
 622  *
 623  * Extend a cache file
 624  *
 625  * \param avc pointer to vcache to extend data for
 626  * \param alen Length to extend file to
 627  * \param areq
 628  *
 629  * \note avc must be write locked. May release and reobtain avc and GLOCK
 630  */
 631 int
 632 afs_ExtendSegments(struct vcache *avc, afs_size_t alen, struct vrequest *areq)
 633 {
 634     afs_size_t offset, toAdd;
 635     struct osi_file *tfile;
 636     afs_int32 code = 0;
 637     struct dcache *tdc;
 638     void *zeros;
 639
 640     zeros = afs_osi_Alloc(AFS_PAGESIZE);
 641     if (zeros == NULL)
 642         return ENOMEM;
 643     memset(zeros, 0, AFS_PAGESIZE);
 644
 645     while (avc->f.m.Length < alen) {
 646         tdc = afs_ObtainDCacheForWriting(avc, avc->f.m.Length, alen - avc->f.m.Length, areq, 0);
 647         if (!tdc) {
 648             code = EIO;
 649             break;
 650         }
 651
 652         toAdd = alen - avc->f.m.Length;
 653
 654         offset = avc->f.m.Length - AFS_CHUNKTOBASE(tdc->f.chunk);
 655         if (offset + toAdd > AFS_CHUNKTOSIZE(tdc->f.chunk)) {
 656             toAdd = AFS_CHUNKTOSIZE(tdc->f.chunk) - offset;
 657         }
 658         tfile = afs_CFileOpen(&tdc->f.inode);
 659         while(tdc->validPos < avc->f.m.Length + toAdd) {
 660              afs_size_t towrite;
 661
 662              towrite = (avc->f.m.Length + toAdd) - tdc->validPos;
 663              if (towrite > AFS_PAGESIZE) towrite = AFS_PAGESIZE;
 664
 665              code = afs_CFileWrite(tfile,
 666                                    tdc->validPos - AFS_CHUNKTOBASE(tdc->f.chunk),
 667                                    zeros, towrite);
 668              tdc->validPos += towrite;
 669         }
 670         afs_CFileClose(tfile);
 671         afs_AdjustSize(tdc, offset + toAdd );
 672         avc->f.m.Length += toAdd;
 673         ReleaseWriteLock(&tdc->lock);
 674         afs_PutDCache(tdc);
 675     }
 676
 677     afs_osi_Free(zeros, AFS_PAGESIZE);
 678     return code;
 679 }
 680
 681 /*
 682  * afs_TruncateAllSegments
 683  *
 684  * Description:
 685  *      Truncate a cache file.
 686  *
 687  * Parameters:
 688  *      avc  : Ptr to vcache entry to truncate.
 689  *      alen : Number of bytes to make the file.
 690  *      areq : Ptr to request structure.
 691  *
 692  * Environment:
 693  *      Called with avc write-locked; in VFS40 systems, pvnLock is also
 694  *      held.
 695  */
 696 int
 697 afs_TruncateAllSegments(struct vcache *avc, afs_size_t alen,
 698                         struct vrequest *areq, afs_ucred_t *acred)
 699 {
 700     struct dcache *tdc;
 701     afs_int32 code;
 702     afs_int32 index;
 703     afs_size_t newSize;
 704
 705     int dcCount, dcPos;
 706     struct dcache **tdcArray = NULL;
 707
 708     AFS_STATCNT(afs_TruncateAllSegments);
 709     avc->f.m.Date = osi_Time();
 710     afs_Trace3(afs_iclSetp, CM_TRACE_TRUNCALL, ICL_TYPE_POINTER, avc,
 711                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(avc->f.m.Length),
 712                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(alen));
 713     if (alen >= avc->f.m.Length) {
 714         /*
 715          * Special speedup since Sun's vm extends the file this way;
 716          * we've never written to the file thus we can just set the new
 717          * length and avoid the needless calls below.
 718          * Also used for ftruncate calls which can extend the file.
 719          * To completely minimize the possible extra StoreMini RPC, we really
 720          * should keep the ExtendedPos as well and clear this flag if we
 721          * truncate below that value before we store the file back.
 722          */
 723         avc->f.states |= CExtendedFile;
 724         avc->f.m.Length = alen;
 725         return 0;
 726     }
 727 #if     (defined(AFS_SUN5_ENV))
 728
 729     /* Zero unused portion of last page */
 730     osi_VM_PreTruncate(avc, alen, acred);
 731
 732 #endif
 733
 734 #if     (defined(AFS_SUN5_ENV))
 735     ObtainWriteLock(&avc->vlock, 546);
 736     avc->activeV++;             /* Block new getpages */
 737     ReleaseWriteLock(&avc->vlock);
 738 #endif
 739
 740     ReleaseWriteLock(&avc->lock);
 741     AFS_GUNLOCK();
 742
 743     /* Flush pages beyond end-of-file. */
 744     osi_VM_Truncate(avc, alen, acred);
 745
 746     AFS_GLOCK();
 747     ObtainWriteLock(&avc->lock, 79);
 748
 749     avc->f.m.Length = alen;
 750
 751     if (alen < avc->f.truncPos)
 752         avc->f.truncPos = alen;
 753     code = DVHash(&avc->f.fid);
 754
 755     /* block out others from screwing with this table */
 756     ObtainWriteLock(&afs_xdcache, 287);
 757
 758     dcCount = 0;
 759     for (index = afs_dvhashTbl[code]; index != NULLIDX;) {
 760         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 761             tdc = afs_GetValidDSlot(index);
 762             if (!tdc) {
 763                 ReleaseWriteLock(&afs_xdcache);
 764                 code = EIO;
 765                 goto done;
 766             }
 767             ReleaseReadLock(&tdc->tlock);
 768             if (!FidCmp(&tdc->f.fid, &avc->f.fid))
 769                 dcCount++;
 770             afs_PutDCache(tdc);
 771         }
 772         index = afs_dvnextTbl[index];
 773     }
 774
 775     /* Now allocate space where we can save those dcache entries, and
 776      * do a second pass over them..  Since we're holding xdcache, it
 777      * shouldn't be changing.
 778      */
 779     tdcArray = osi_Alloc(dcCount * sizeof(struct dcache *));
 780     dcPos = 0;
 781
 782     for (index = afs_dvhashTbl[code]; index != NULLIDX; index = afs_dvnextTbl[index]) {
 783         if (afs_indexUnique[index] == avc->f.fid.Fid.Unique) {
 784             tdc = afs_GetValidDSlot(index);
 785             if (!tdc) {
 786                 /* make sure we put back all of the tdcArray members before
 787                  * bailing out */
 788                 /* remember, the last valid tdc is at dcPos-1, so start at
 789                  * dcPos-1, not at dcPos itself. */
 790                 for (dcPos = dcPos - 1; dcPos >= 0; dcPos--) {
 791                     tdc = tdcArray[dcPos];
 792                     afs_PutDCache(tdc);
 793                 }
 794                 code = EIO;
 795                 goto done;
 796             }
 797             ReleaseReadLock(&tdc->tlock);
 798             if (!FidCmp(&tdc->f.fid, &avc->f.fid)) {
 799                 /* same file, and modified, we'll store it back */
 800                 if (dcPos < dcCount) {
 801                     tdcArray[dcPos++] = tdc;
 802                 } else {
 803                     afs_PutDCache(tdc);
 804                 }
 805             } else {
 806                 afs_PutDCache(tdc);
 807             }
 808         }
 809     }
 810
 811     ReleaseWriteLock(&afs_xdcache);
 812
 813     /* Now we loop over the array of dcache entries and truncate them */
 814     for (index = 0; index < dcPos; index++) {
 815         struct osi_file *tfile;
 816
 817         tdc = tdcArray[index];
 818
 819         newSize = alen - AFS_CHUNKTOBASE(tdc->f.chunk);
 820         if (newSize < 0)
 821             newSize = 0;
 822         ObtainSharedLock(&tdc->lock, 672);
 823         if (newSize < tdc->f.chunkBytes && newSize < MAX_AFS_UINT32) {
 824             UpgradeSToWLock(&tdc->lock, 673);
 825             tdc->f.states |= DWriting;
 826             tfile = afs_CFileOpen(&tdc->f.inode);
 827             afs_CFileTruncate(tfile, (afs_int32)newSize);
 828             afs_CFileClose(tfile);
 829             afs_AdjustSize(tdc, (afs_int32)newSize);
 830             if (alen < tdc->validPos) {
 831                 if (alen < AFS_CHUNKTOBASE(tdc->f.chunk))
 832                     tdc->validPos = 0;
 833                 else
 834                     tdc->validPos = alen;
 835             }
 836             ConvertWToSLock(&tdc->lock);
 837         }
 838         ReleaseSharedLock(&tdc->lock);
 839         afs_PutDCache(tdc);
 840     }
 841
 842     code = 0;
 843
 844  done:
 845     if (tdcArray) {
 846         osi_Free(tdcArray, dcCount * sizeof(struct dcache *));
 847     }
 848 #if     (defined(AFS_SUN5_ENV))
 849     ObtainWriteLock(&avc->vlock, 547);
 850     if (--avc->activeV == 0 && (avc->vstates & VRevokeWait)) {
 851         avc->vstates &= ~VRevokeWait;
 852         afs_osi_Wakeup((char *)&avc->vstates);
 853     }
 854     ReleaseWriteLock(&avc->vlock);
 855 #endif
 856
 857     return code;
 858 }