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