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