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