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