solars-sparc32-largefile-20051011
[openafs.git] / src / afs / SOLARIS / osi_vnodeops.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 #include <afsconfig.h>
11 #include "afs/param.h"
12
13 RCSID
14     ("$Header$");
15
16 /*
17  * SOLARIS/osi_vnodeops.c
18  *
19  * Implements:
20  *
21  * Functions: AFS_TRYUP, _init, _info, _fini, afs_addmap, afs_delmap,
22  * afs_vmread, afs_vmwrite, afs_getpage, afs_GetOnePage, afs_putpage,
23  * afs_putapage, afs_nfsrdwr, afs_map, afs_PageLeft, afs_pathconf/afs_cntl,
24  * afs_ioctl, afs_rwlock, afs_rwunlock, afs_seek, afs_space, afs_dump,
25  * afs_cmp, afs_realvp, afs_pageio, afs_dumpctl, afs_dispose, afs_setsecattr,
26  * afs_getsecattr, gafs_open, gafs_close, gafs_getattr, gafs_setattr,
27  * gafs_access, gafs_lookup, gafs_create, gafs_remove, gafs_link,
28  * gafs_rename, gafs_mkdir, gafs_rmdir, gafs_readdir, gafs_symlink,
29  * gafs_readlink, gafs_fsync, afs_inactive, gafs_inactive, gafs_fid
30  *
31  *
32  * Variables: Afs_vnodeops
33  *
34  */
35 #include "afs/sysincludes.h"    /* Standard vendor system headers */
36 #include "afsincludes.h"        /* Afs-based standard headers */
37 #include "afs/afs_stats.h"      /* statistics */
38 #include "afs/nfsclient.h"
39
40
41 #include <sys/mman.h>
42 #include <vm/hat.h>
43 #include <vm/as.h>
44 #include <vm/page.h>
45 #include <vm/pvn.h>
46 #include <vm/seg.h>
47 #include <vm/seg_map.h>
48 #include <vm/seg_vn.h>
49 #include <vm/rm.h>
50 #include <sys/modctl.h>
51 #include <sys/syscall.h>
52 #include <sys/debug.h>
53 #include <sys/fs_subr.h>
54
55 /* 
56  * XXX Temporary fix for problems with Solaris rw_tryupgrade() lock.
57  * It isn't very persistent in getting the upgrade when others are
58  * waiting for it and returns 0.  So the UpgradeSToW() macro that the
59  * rw_tryupgrade used to map to wasn't good enough and we need to use
60  * the following code instead.  Obviously this isn't the proper place
61  * for it but it's only called from here for now
62  * 
63  */
64 #ifndef AFS_SUN54_ENV
65 AFS_TRYUP(lock)
66      afs_rwlock_t *lock;
67 {
68     if (!rw_tryupgrade(lock)) {
69         rw_exit(lock);
70         rw_enter(lock, RW_WRITER);
71     }
72 }
73 #endif
74
75
76 /* Translate a faultcode_t as returned by some of the vm routines
77  * into a suitable errno value.
78  */
79 static int
80 afs_fc2errno(faultcode_t fc)
81 {
82     switch (FC_CODE(fc)) {
83     case 0:
84         return 0;
85
86     case FC_OBJERR:
87         return FC_ERRNO(fc);
88
89     default:
90         return EIO;
91     }
92 }
93
94
95 extern struct as kas;           /* kernel addr space */
96 extern unsigned char *afs_indexFlags;
97 extern afs_lock_t afs_xdcache;
98
99 /* Additional vnodeops for SunOS 4.0.x */
100 int afs_nfsrdwr(), afs_getpage(), afs_putpage(), afs_map();
101 int afs_dump(), afs_cmp(), afs_realvp(), afs_GetOnePage();
102
103 int afs_pvn_vptrunc;
104
105 int
106 afs_addmap(avp, offset, asp, addr, length, prot, maxprot, flags, credp)
107      register struct vnode *avp;
108      offset_t offset;
109      struct as *asp;
110      caddr_t addr;
111      int length, prot, maxprot, flags;
112      struct AFS_UCRED *credp;
113 {
114     /* XXX What should we do here?? XXX */
115     return (0);
116 }
117
118 int
119 afs_delmap(avp, offset, asp, addr, length, prot, maxprot, flags, credp)
120      register struct vnode *avp;
121      offset_t offset;
122      struct as *asp;
123      caddr_t addr;
124      int length, prot, maxprot, flags;
125      struct AFS_UCRED *credp;
126 {
127     /* XXX What should we do here?? XXX */
128     return (0);
129 }
130
131 #ifdef AFS_SUN510_ENV
132 int
133 afs_vmread(avp, auio, ioflag, acred, ct)
134      register struct vnode *avp;
135      struct uio *auio;
136      int ioflag;
137      struct AFS_UCRED *acred;
138      caller_context_t *ct;
139 #else
140 int
141 afs_vmread(avp, auio, ioflag, acred)
142      register struct vnode *avp;
143      struct uio *auio;
144      int ioflag;
145      struct AFS_UCRED *acred;
146 #endif
147 {
148     register int code;
149
150     if (!RW_READ_HELD(&(VTOAFS(avp))->rwlock))
151         osi_Panic("afs_vmread: !rwlock");
152     AFS_GLOCK();
153     code = afs_nfsrdwr(VTOAFS(avp), auio, UIO_READ, ioflag, acred);
154     AFS_GUNLOCK();
155     return code;
156 }
157
158
159 #ifdef AFS_SUN510_ENV
160 int
161 afs_vmwrite(avp, auio, ioflag, acred, ct)
162      register struct vnode *avp;
163      struct uio *auio;
164      int ioflag;
165      struct AFS_UCRED *acred;
166      caller_context_t *ct;
167 #else
168 int
169 afs_vmwrite(avp, auio, ioflag, acred)
170      register struct vnode *avp;
171      struct uio *auio;
172      int ioflag;
173      struct AFS_UCRED *acred;
174 #endif
175 {
176     register int code;
177
178     if (!RW_WRITE_HELD(&(VTOAFS(avp))->rwlock))
179         osi_Panic("afs_vmwrite: !rwlock");
180     AFS_GLOCK();
181     code = afs_nfsrdwr(VTOAFS(avp), auio, UIO_WRITE, ioflag, acred);
182     AFS_GUNLOCK();
183     return code;
184 }
185
186 int
187 afs_getpage(vp, off, len, protp, pl, plsz, seg, addr, rw, acred)
188      struct vnode *vp;
189      u_int len;
190      u_int *protp;
191      struct page *pl[];
192      u_int plsz;
193      struct seg *seg;
194      offset_t off;
195      caddr_t addr;
196      enum seg_rw rw;
197      struct AFS_UCRED *acred;
198 {
199     register afs_int32 code = 0;
200     AFS_STATCNT(afs_getpage);
201
202     if (vp->v_flag & VNOMAP)    /* File doesn't allow mapping */
203         return (ENOSYS);
204
205     AFS_GLOCK();
206
207 #if     defined(AFS_SUN56_ENV)
208     if (len <= PAGESIZE)
209         code =
210             afs_GetOnePage(vp, off, len, protp, pl, plsz, seg, addr, rw,
211                            acred);
212 #else
213     if (len <= PAGESIZE)
214         code =
215             afs_GetOnePage(vp, (u_int) off, len, protp, pl, plsz, seg, addr,
216                            rw, acred);
217 #endif
218     else {
219         struct vcache *vcp = VTOAFS(vp);
220         ObtainWriteLock(&vcp->vlock, 548);
221         vcp->multiPage++;
222         ReleaseWriteLock(&vcp->vlock);
223         afs_BozonLock(&vcp->pvnLock, vcp);
224 #if     defined(AFS_SUN56_ENV)
225         code =
226             pvn_getpages(afs_GetOnePage, vp, off, len, protp, pl, plsz, seg,
227                          addr, rw, acred);
228 #else
229         code =
230             pvn_getpages(afs_GetOnePage, vp, (u_int) off, len, protp, pl,
231                          plsz, seg, addr, rw, acred);
232 #endif
233         afs_BozonUnlock(&vcp->pvnLock, vcp);
234         ObtainWriteLock(&vcp->vlock, 549);
235         vcp->multiPage--;
236         ReleaseWriteLock(&vcp->vlock);
237     }
238     AFS_GUNLOCK();
239     return code;
240 }
241
242 /* Return all the pages from [off..off+len) in file */
243 int
244 afs_GetOnePage(vp, off, alen, protp, pl, plsz, seg, addr, rw, acred)
245      u_int alen;
246      struct vnode *vp;
247 #if     defined(AFS_SUN56_ENV)
248      u_offset_t off;
249 #else
250      u_int off;
251 #endif
252      u_int *protp;
253      struct page *pl[];
254      u_int plsz;
255      struct seg *seg;
256      caddr_t addr;
257      enum seg_rw rw;
258      struct AFS_UCRED *acred;
259 {
260     register struct page *page;
261     register afs_int32 code = 0;
262     u_int len;
263     struct buf *buf;
264     afs_int32 tlen;
265     register struct vcache *avc;
266     register struct dcache *tdc;
267     int i, s, pexists;
268     int slot;
269     afs_size_t offset = 0, nlen;
270     struct vrequest treq;
271     afs_int32 mapForRead = 0, Code = 0;
272     u_offset_t toffset;
273
274     if (!acred)
275         osi_Panic("GetOnePage: !acred");
276
277     avc = VTOAFS(vp);           /* cast to afs vnode */
278
279     if (avc->credp              /*&& AFS_NFSXLATORREQ(acred) */
280         && AFS_NFSXLATORREQ(avc->credp)) {
281         acred = avc->credp;
282     }
283     if (code = afs_InitReq(&treq, acred))
284         return code;
285
286     if (!pl) {
287         /* This is a read-ahead request, e.g. due to madvise.  */
288         int plen = alen;
289         ObtainReadLock(&avc->lock);
290
291         while (plen > 0 && !afs_BBusy()) {
292             /* Obtain a dcache entry at off.  2 means don't fetch data. */
293             tdc =
294                 afs_GetDCache(avc, (afs_offs_t) off, &treq, &offset, &nlen,
295                               2);
296             if (!tdc)
297                 break;
298
299             /* Write-lock the dcache entry, if we don't succeed, just go on */
300             if (0 != NBObtainWriteLock(&tdc->lock, 642)) {
301                 afs_PutDCache(tdc);
302                 goto next_prefetch;
303             }
304
305             /* If we aren't already fetching this dcache entry, queue it */
306             if (!(tdc->mflags & DFFetchReq)) {
307                 struct brequest *bp;
308
309                 tdc->mflags |= DFFetchReq;
310                 bp = afs_BQueue(BOP_FETCH, avc, B_DONTWAIT, 0, acred,
311                                 (afs_size_t) off, (afs_size_t) 1, tdc);
312                 if (!bp) {
313                     /* Unable to start background fetch; might as well stop */
314                     tdc->mflags &= ~DFFetchReq;
315                     ReleaseWriteLock(&tdc->lock);
316                     afs_PutDCache(tdc);
317                     break;
318                 }
319                 ReleaseWriteLock(&tdc->lock);
320             } else {
321                 ReleaseWriteLock(&tdc->lock);
322                 afs_PutDCache(tdc);
323             }
324
325           next_prefetch:
326             /* Adjust our offset and remaining length values */
327             off += nlen;
328             plen -= nlen;
329
330             /* If we aren't making progress for some reason, bail out */
331             if (nlen <= 0)
332                 break;
333         }
334
335         ReleaseReadLock(&avc->lock);
336         return 0;
337     }
338
339     len = PAGESIZE;
340     pl[0] = NULL;               /* Make sure it's empty */
341
342     /* first, obtain the proper lock for the VM system */
343
344     /* if this is a read request, map the page in read-only.  This will
345      * allow us to swap out the dcache entry if there are only read-only
346      * pages created for the chunk, which helps a *lot* when dealing
347      * with small caches.  Otherwise, we have to invalidate the vm
348      * pages for the range covered by a chunk when we swap out the
349      * chunk.
350      */
351     if (rw == S_READ || rw == S_EXEC)
352         mapForRead = 1;
353
354     if (protp)
355         *protp = PROT_ALL;
356
357   retry:
358     if (rw == S_WRITE || rw == S_CREATE)
359         tdc = afs_GetDCache(avc, (afs_offs_t) off, &treq, &offset, &nlen, 5);
360     else
361         tdc = afs_GetDCache(avc, (afs_offs_t) off, &treq, &offset, &nlen, 1);
362     if (!tdc)
363         return EINVAL;
364     code = afs_VerifyVCache(avc, &treq);
365     if (code) {
366         afs_PutDCache(tdc);
367         return afs_CheckCode(code, &treq, 44);  /* failed to get it */
368     }
369
370     afs_BozonLock(&avc->pvnLock, avc);
371     ObtainReadLock(&avc->lock);
372
373     afs_Trace4(afs_iclSetp, CM_TRACE_PAGEIN, ICL_TYPE_POINTER, (afs_int32) vp,
374                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(off), ICL_TYPE_LONG, len,
375                ICL_TYPE_LONG, (int)rw);
376
377     tlen = len;
378     slot = 0;
379     toffset = off;
380     /* Check to see if we're in the middle of a VM purge, and if we are, release
381      * the locks and try again when the VM purge is done. */
382     ObtainWriteLock(&avc->vlock, 550);
383     if (avc->activeV) {
384         ReleaseReadLock(&avc->lock);
385         ReleaseWriteLock(&avc->vlock);
386         afs_BozonUnlock(&avc->pvnLock, avc);
387         afs_PutDCache(tdc);
388         /* Check activeV again, it may have been turned off
389          * while we were waiting for a lock in afs_PutDCache */
390         ObtainWriteLock(&avc->vlock, 574);
391         if (avc->activeV) {
392             avc->vstates |= VRevokeWait;
393             ReleaseWriteLock(&avc->vlock);
394             afs_osi_Sleep(&avc->vstates);
395         } else {
396             ReleaseWriteLock(&avc->vlock);
397         }
398         goto retry;
399     }
400     ReleaseWriteLock(&avc->vlock);
401
402     /* We're about to do stuff with our dcache entry..  Lock it. */
403     ObtainReadLock(&tdc->lock);
404
405     /* Check to see whether the cache entry is still valid */
406     if (!(avc->states & CStatd)
407         || !hsame(avc->m.DataVersion, tdc->f.versionNo)) {
408         ReleaseReadLock(&tdc->lock);
409         ReleaseReadLock(&avc->lock);
410         afs_BozonUnlock(&avc->pvnLock, avc);
411         afs_PutDCache(tdc);
412         goto retry;
413     }
414
415     AFS_GUNLOCK();
416     while (1) {                 /* loop over all pages */
417         /* now, try to find the page in memory (it may already be intransit or laying
418          * around the free list */
419         page =
420             page_lookup(vp, toffset, (rw == S_CREATE ? SE_EXCL : SE_SHARED));
421         if (page)
422             goto nextpage;
423
424         /* if we make it here, we can't find the page in memory.  Do a real disk read
425          * from the cache to get the data */
426         Code |= 0x200;          /* XXX */
427 #if     defined(AFS_SUN54_ENV)
428         /* use PG_EXCL because we know the page does not exist already.  If it 
429          * actually does exist, we have somehow raced between lookup and create.
430          * As of 4/98, that shouldn't be possible, but we'll be defensive here
431          * in case someone tries to relax all the serialization of read and write
432          * operations with harmless things like stat. */
433 #if    defined(AFS_SUN58_ENV)
434         page =
435             page_create_va(vp, toffset, PAGESIZE, PG_WAIT | PG_EXCL, seg,
436                            addr);
437 #else
438         page =
439             page_create_va(vp, toffset, PAGESIZE, PG_WAIT | PG_EXCL,
440                            seg->s_as, addr);
441 #endif
442 #else
443         page = page_create(vp, toffset, PAGESIZE, PG_WAIT);
444 #endif
445         if (!page) {
446             continue;
447         }
448         if (alen < PAGESIZE)
449             pagezero(page, alen, PAGESIZE - alen);
450
451         if (rw == S_CREATE) {
452             /* XXX Don't read from AFS in write only cases XXX */
453             page_io_unlock(page);
454         } else
455         {
456             /* now it is time to start I/O operation */
457             buf = pageio_setup(page, PAGESIZE, vp, B_READ);     /* allocate a buf structure */
458             buf->b_edev = 0;
459             buf->b_dev = 0;
460 #if defined(AFS_SUN56_ENV)
461             buf->b_lblkno = lbtodb(toffset);
462 #else
463             buf->b_blkno = btodb(toffset);
464 #endif
465             bp_mapin(buf);      /* map it in to our address space */
466
467             AFS_GLOCK();
468             /* afs_ustrategy will want to lock the dcache entry */
469             ReleaseReadLock(&tdc->lock);
470             code = afs_ustrategy(buf, acred);   /* do the I/O */
471             ObtainReadLock(&tdc->lock);
472             AFS_GUNLOCK();
473
474             /* Before freeing unmap the buffer */
475             bp_mapout(buf);
476             pageio_done(buf);
477             if (code) {
478                 goto bad;
479             }
480             page_io_unlock(page);
481         }
482
483         /* come here when we have another page (already held) to enter */
484       nextpage:
485         /* put page in array and continue */
486         /* The p_selock must be downgraded to a shared lock after the page is read */
487 #if     defined(AFS_SUN56_ENV)
488         if ((rw != S_CREATE) && !(PAGE_SHARED(page)))
489 #else
490         if ((rw != S_CREATE) && !(se_shared_assert(&page->p_selock)))
491 #endif
492         {
493             page_downgrade(page);
494         }
495         pl[slot++] = page;
496         code = page_iolock_assert(page);
497         code = 0;
498         toffset += PAGESIZE;
499         addr += PAGESIZE;
500         tlen -= PAGESIZE;
501         if (tlen <= 0)
502             break;              /* done all the pages */
503     }                           /* while (1) ... */
504
505     AFS_GLOCK();
506     pl[slot] = NULL;
507     ReleaseReadLock(&tdc->lock);
508
509     /* Prefetch next chunk if we're at a chunk boundary */
510     if (AFS_CHUNKOFFSET(off) == 0) {
511         if (!(tdc->mflags & DFNextStarted))
512             afs_PrefetchChunk(avc, tdc, acred, &treq);
513     }
514
515     ReleaseReadLock(&avc->lock);
516     ObtainWriteLock(&afs_xdcache, 246);
517     if (!mapForRead) {
518         /* track that we have dirty (or dirty-able) pages for this chunk. */
519         afs_indexFlags[tdc->index] |= IFDirtyPages;
520     }
521     afs_indexFlags[tdc->index] |= IFAnyPages;
522     ReleaseWriteLock(&afs_xdcache);
523     afs_BozonUnlock(&avc->pvnLock, avc);
524     afs_PutDCache(tdc);
525     afs_Trace3(afs_iclSetp, CM_TRACE_PAGEINDONE, ICL_TYPE_LONG, code,
526                ICL_TYPE_LONG, (int)page, ICL_TYPE_LONG, Code);
527     return 0;
528
529   bad:
530     AFS_GLOCK();
531     afs_Trace3(afs_iclSetp, CM_TRACE_PAGEINDONE, ICL_TYPE_LONG, code,
532                ICL_TYPE_LONG, (int)page, ICL_TYPE_LONG, Code);
533     /* release all pages, drop locks, return code */
534     if (page)
535         pvn_read_done(page, B_ERROR);
536     ReleaseReadLock(&avc->lock);
537     afs_BozonUnlock(&avc->pvnLock, avc);
538     ReleaseReadLock(&tdc->lock);
539     afs_PutDCache(tdc);
540     return code;
541 }
542
543 int
544 afs_putpage(vp, off, len, flags, cred)
545      struct vnode *vp;
546      offset_t off;
547      u_int len;
548      int flags;
549      struct AFS_UCRED *cred;
550 {
551     struct vcache *avc;
552     struct page *pages;
553     afs_int32 code = 0;
554 #if    defined(AFS_SUN58_ENV)
555     size_t tlen;
556 #else
557     afs_int32 tlen;
558 #endif
559     afs_offs_t endPos;
560     afs_int32 NPages = 0;
561 #if     defined(AFS_SUN56_ENV)
562     u_offset_t toff = off;
563 #else
564     int toff = (int)off;
565 #endif
566     int didWriteLock;
567
568     AFS_STATCNT(afs_putpage);
569     if (vp->v_flag & VNOMAP)    /* file doesn't allow mapping */
570         return (ENOSYS);
571
572     /*
573      * Putpage (ASYNC) is called every sec to flush out dirty vm pages 
574      */
575     AFS_GLOCK();
576     afs_Trace4(afs_iclSetp, CM_TRACE_PAGEOUT, ICL_TYPE_POINTER,
577                (afs_int32) vp, ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(off),
578                ICL_TYPE_INT32, (afs_int32) len, ICL_TYPE_LONG, (int)flags);
579     avc = VTOAFS(vp);
580     afs_BozonLock(&avc->pvnLock, avc);
581     ObtainSharedLock(&avc->lock, 247);
582     didWriteLock = 0;
583
584     /* Get a list of modified (or whatever) pages */
585     if (len) {
586         endPos = (afs_offs_t) off + len;        /* position we're supposed to write up to */
587         while ((afs_offs_t) toff < endPos
588                && (afs_offs_t) toff < avc->m.Length) {
589             /* If not invalidating pages use page_lookup_nowait to avoid reclaiming
590              * them from the free list
591              */
592             AFS_GUNLOCK();
593             if (flags & (B_FREE | B_INVAL))
594                 pages = page_lookup(vp, toff, SE_EXCL);
595             else
596                 pages = page_lookup_nowait(vp, toff, SE_SHARED);
597             if (!pages || !pvn_getdirty(pages, flags))
598                 tlen = PAGESIZE;
599             else {
600                 if (!didWriteLock) {
601                     AFS_GLOCK();
602                     didWriteLock = 1;
603                     UpgradeSToWLock(&avc->lock, 671);
604                     AFS_GUNLOCK();
605                 }
606                 NPages++;
607                 code = afs_putapage(vp, pages, &toff, &tlen, flags, cred);
608                 if (code) {
609                     AFS_GLOCK();
610                     break;
611                 }
612             }
613             toff += tlen;
614             AFS_GLOCK();
615         }
616     } else {
617         if (!didWriteLock) {
618             UpgradeSToWLock(&avc->lock, 670);
619             didWriteLock = 1;
620         }
621
622         AFS_GUNLOCK();
623 #if     defined(AFS_SUN56_ENV)
624         code = pvn_vplist_dirty(vp, toff, afs_putapage, flags, cred);
625 #else
626         code = pvn_vplist_dirty(vp, (u_int) off, afs_putapage, flags, cred);
627 #endif
628         AFS_GLOCK();
629     }
630
631     if (code && !avc->vc_error) {
632         if (!didWriteLock) {
633             UpgradeSToWLock(&avc->lock, 669);
634             didWriteLock = 1;
635         }
636         avc->vc_error = code;
637     }
638
639     if (didWriteLock)
640         ReleaseWriteLock(&avc->lock);
641     else
642         ReleaseSharedLock(&avc->lock);
643     afs_BozonUnlock(&avc->pvnLock, avc);
644     afs_Trace2(afs_iclSetp, CM_TRACE_PAGEOUTDONE, ICL_TYPE_LONG, code,
645                ICL_TYPE_LONG, NPages);
646     AFS_GUNLOCK();
647     return (code);
648 }
649
650
651 int
652 afs_putapage(struct vnode *vp, struct page *pages,
653 #if     defined(AFS_SUN56_ENV)
654              u_offset_t * offp,
655 #else
656              u_int * offp,
657 #endif
658 #if    defined(AFS_SUN58_ENV)
659              size_t * lenp,
660 #else
661              u_int * lenp,
662 #endif
663              int flags, struct AFS_UCRED *credp)
664 {
665     struct buf *tbuf;
666     struct vcache *avc = VTOAFS(vp);
667     afs_int32 code = 0;
668     u_int tlen = PAGESIZE;
669     afs_offs_t off = (pages->p_offset / PAGESIZE) * PAGESIZE;
670
671     /*
672      * Now we've got the modified pages.  All pages are locked and held 
673      * XXX Find a kluster that fits in one block (or page). We also
674      * adjust the i/o if the file space is less than a while page. XXX
675      */
676     if (off + tlen > avc->m.Length) {
677         tlen = avc->m.Length - off;
678     }
679     /* can't call mapout with 0 length buffers (rmfree panics) */
680     if (((tlen >> 24) & 0xff) == 0xff) {
681         tlen = 0;
682     }
683     if ((int)tlen > 0) {
684         /*
685          * Can't call mapout with 0 length buffers since we'll get rmfree panics
686          */
687         tbuf = pageio_setup(pages, tlen, vp, B_WRITE | flags);
688         if (!tbuf)
689             return (ENOMEM);
690
691         tbuf->b_dev = 0;
692 #if defined(AFS_SUN56_ENV)
693         tbuf->b_lblkno = lbtodb(pages->p_offset);
694 #else
695         tbuf->b_blkno = btodb(pages->p_offset);
696 #endif
697         bp_mapin(tbuf);
698         AFS_GLOCK();
699         afs_Trace4(afs_iclSetp, CM_TRACE_PAGEOUTONE, ICL_TYPE_LONG, avc,
700                    ICL_TYPE_LONG, pages, ICL_TYPE_LONG, tlen, ICL_TYPE_OFFSET,
701                    ICL_HANDLE_OFFSET(off));
702         code = afs_ustrategy(tbuf, credp);      /* unlocks page */
703         AFS_GUNLOCK();
704         bp_mapout(tbuf);
705     }
706     pvn_write_done(pages, ((code) ? B_ERROR : 0) | B_WRITE | flags);
707     if ((int)tlen > 0)
708         pageio_done(tbuf);
709     if (offp)
710         *offp = off;
711     if (lenp)
712         *lenp = tlen;
713     return code;
714 }
715
716 int
717 afs_nfsrdwr(avc, auio, arw, ioflag, acred)
718      register struct vcache *avc;
719      struct uio *auio;
720      enum uio_rw arw;
721      int ioflag;
722      struct AFS_UCRED *acred;
723 {
724     register afs_int32 code;
725     afs_int32 code2;
726     int counter;
727     afs_int32 mode, sflags;
728     register char *data;
729     struct dcache *dcp, *dcp_newpage;
730     afs_size_t fileBase, size;
731     afs_size_t pageBase;
732     register afs_int32 tsize;
733     register afs_int32 pageOffset, extraResid = 0;
734     register afs_size_t origLength;     /* length when reading/writing started */
735     register long appendLength; /* length when this call will finish */
736     int created;                /* created pages instead of faulting them */
737     int lockCode;
738     int didFakeOpen, eof;
739     struct vrequest treq;
740     caddr_t raddr;
741     u_int rsize;
742
743     AFS_STATCNT(afs_nfsrdwr);
744
745     /* can't read or write other things */
746     if (vType(avc) != VREG)
747         return EISDIR;
748
749     if (auio->uio_resid == 0)
750         return (0);
751
752     afs_Trace4(afs_iclSetp, CM_TRACE_VMRW, ICL_TYPE_POINTER, (afs_int32) avc,
753                ICL_TYPE_LONG, (arw == UIO_WRITE ? 1 : 0), ICL_TYPE_OFFSET,
754                ICL_HANDLE_OFFSET(auio->uio_loffset), ICL_TYPE_OFFSET,
755                ICL_HANDLE_OFFSET(auio->uio_resid));
756
757 #ifndef AFS_64BIT_CLIENT
758     if (AfsLargeFileUio(auio))  /* file is larger than 2 GB */
759         return (EFBIG);
760 #endif
761
762     if (!acred)
763         osi_Panic("rdwr: !acred");
764
765     if (code = afs_InitReq(&treq, acred))
766         return code;
767
768     /* It's not really possible to know if a write cause a growth in the
769      * cache size, we we wait for a cache drain for any write.
770      */
771     afs_MaybeWakeupTruncateDaemon();
772     while ((arw == UIO_WRITE)
773            && (afs_blocksUsed > PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks))) {
774         if (afs_blocksUsed - afs_blocksDiscarded >
775             PERCENT(CM_WAITFORDRAINPCT, afs_cacheBlocks)) {
776             afs_WaitForCacheDrain = 1;
777             afs_osi_Sleep(&afs_WaitForCacheDrain);
778         }
779         afs_MaybeFreeDiscardedDCache();
780         afs_MaybeWakeupTruncateDaemon();
781     }
782     code = afs_VerifyVCache(avc, &treq);
783     if (code)
784         return afs_CheckCode(code, &treq, 45);
785
786     afs_BozonLock(&avc->pvnLock, avc);
787     osi_FlushPages(avc, acred); /* hold bozon lock, but not basic vnode lock */
788
789     ObtainWriteLock(&avc->lock, 250);
790
791     /* adjust parameters when appending files */
792     if ((ioflag & IO_APPEND) && arw == UIO_WRITE) {
793 #if defined(AFS_SUN56_ENV)
794         auio->uio_loffset = avc->m.Length;      /* write at EOF position */
795 #else
796         auio->uio_offset = avc->m.Length;       /* write at EOF position */
797 #endif
798     }
799     if (auio->afsio_offset < 0 || (auio->afsio_offset + auio->uio_resid) < 0) {
800         ReleaseWriteLock(&avc->lock);
801         afs_BozonUnlock(&avc->pvnLock, avc);
802         return EINVAL;
803     }
804 #ifndef AFS_64BIT_CLIENT
805     /* file is larger than 2GB */
806     if (AfsLargeFileSize(auio->uio_offset, auio->uio_resid)) {
807         ReleaseWriteLock(&avc->lock);
808         afs_BozonUnlock(&avc->pvnLock, avc);
809         return EFBIG;
810     }
811 #endif
812
813     didFakeOpen = 0;            /* keep track of open so we can do close */
814     if (arw == UIO_WRITE) {
815         /* do ulimit processing; shrink resid or fail */
816 #if     defined(AFS_SUN56_ENV)
817         if (auio->uio_loffset + auio->afsio_resid > auio->uio_llimit) {
818             if (auio->uio_loffset >= auio->uio_llimit) {
819                 ReleaseWriteLock(&avc->lock);
820                 afs_BozonUnlock(&avc->pvnLock, avc);
821                 return EFBIG;
822             } else {
823                 /* track # of bytes we should write, but won't because of
824                  * ulimit; we must add this into the final resid value
825                  * so caller knows we punted some data.
826                  */
827                 extraResid = auio->uio_resid;
828                 auio->uio_resid = auio->uio_llimit - auio->uio_loffset;
829                 extraResid -= auio->uio_resid;
830             }
831         }
832 #else
833 #ifdef  AFS_SUN52_ENV
834         if (auio->afsio_offset + auio->afsio_resid > auio->uio_limit) {
835             if (auio->afsio_offset >= auio->uio_limit) {
836                 ReleaseWriteLock(&avc->lock);
837                 afs_BozonUnlock(&avc->pvnLock, avc);
838                 return EFBIG;
839             } else {
840                 /* track # of bytes we should write, but won't because of
841                  * ulimit; we must add this into the final resid value
842                  * so caller knows we punted some data.
843                  */
844                 extraResid = auio->uio_resid;
845                 auio->uio_resid = auio->uio_limit - auio->afsio_offset;
846                 extraResid -= auio->uio_resid;
847             }
848         }
849 #endif
850 #endif /* SUN56 */
851         mode = S_WRITE;         /* segment map-in mode */
852         afs_FakeOpen(avc);      /* do this for writes, so data gets put back
853                                  * when we want it to be put back */
854         didFakeOpen = 1;        /* we'll be doing a fake open */
855         /* before starting any I/O, we must ensure that the file is big enough
856          * to hold the results (since afs_putpage will be called to force the I/O */
857         size = auio->afsio_resid + auio->afsio_offset;  /* new file size */
858         appendLength = size;
859         origLength = avc->m.Length;
860         if (size > avc->m.Length) {
861             afs_Trace4(afs_iclSetp, CM_TRACE_SETLENGTH, ICL_TYPE_STRING,
862                        __FILE__, ICL_TYPE_LONG, __LINE__, ICL_TYPE_OFFSET,
863                        ICL_HANDLE_OFFSET(avc->m.Length), ICL_TYPE_OFFSET,
864                        ICL_HANDLE_OFFSET(size));
865             avc->m.Length = size;       /* file grew */
866         }
867         avc->states |= CDirty;  /* Set the dirty bit */
868         avc->m.Date = osi_Time();       /* Set file date (for ranlib) */
869     } else {
870         mode = S_READ;          /* map-in read-only */
871         origLength = avc->m.Length;
872     }
873
874     if (acred && AFS_NFSXLATORREQ(acred)) {
875         if (arw == UIO_READ) {
876             if (!afs_AccessOK
877                 (avc, PRSFS_READ, &treq,
878                  CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {
879                 ReleaseWriteLock(&avc->lock);
880                 afs_BozonUnlock(&avc->pvnLock, avc);
881                 return EACCES;
882             }
883         }
884         crhold(acred);
885         if (avc->credp) {
886             crfree(avc->credp);
887         }
888         avc->credp = acred;
889     }
890     counter = 0;                /* don't call afs_DoPartialWrite first time through. */
891     while (1) {
892         /* compute the amount of data to move into this block,
893          * based on auio->afsio_resid.  Note that we copy data in units of
894          * MAXBSIZE, not PAGESIZE.  This is because segmap_getmap panics if you
895          * call it with an offset based on blocks smaller than MAXBSIZE
896          * (implying that it should be named BSIZE, since it is clearly both a
897          * max and a min). */
898         size = auio->afsio_resid;       /* transfer size */
899         fileBase = auio->afsio_offset;  /* start file position for xfr */
900         pageBase = fileBase & ~(MAXBSIZE - 1);  /* file position of the page */
901         pageOffset = fileBase & (MAXBSIZE - 1); /* xfr start's offset within page */
902         tsize = MAXBSIZE - pageOffset;  /* how much more fits in this page */
903         /* we'll read tsize bytes, but first must make sure tsize isn't too big */
904         if (tsize > size)
905             tsize = size;       /* don't read past end of request */
906         eof = 0;                /* flag telling us if we hit the EOF on the read */
907         if (arw == UIO_READ) {  /* we're doing a read operation */
908             /* don't read past EOF */
909             if (fileBase + tsize > origLength) {
910                 tsize = origLength - fileBase;
911                 eof = 1;        /* we did hit the EOF */
912                 if (tsize < 0)
913                     tsize = 0;  /* better safe than sorry */
914             }
915             sflags = 0;
916         } else {
917             /* Purge dirty chunks of file if there are too many dirty
918              * chunks. Inside the write loop, we only do this at a chunk
919              * boundary. Clean up partial chunk if necessary at end of loop.
920              */
921             if (counter > 0 && code == 0 && AFS_CHUNKOFFSET(fileBase) == 0) {
922                 code = afs_DoPartialWrite(avc, &treq);
923                 if (code)
924                     break;
925             }
926             /* write case, we ask segmap_release to call putpage.  Really, we
927              * don't have to do this on every page mapin, but for now we're
928              * lazy, and don't modify the rest of AFS to scan for modified
929              * pages on a close or other "synchronize with file server"
930              * operation.  This makes things a little cleaner, but probably
931              * hurts performance. */
932             sflags = SM_WRITE;
933         }
934         if (tsize <= 0) {
935             code = 0;
936             break;              /* nothing to transfer, we're done */
937         }
938         if (arw == UIO_WRITE)
939             avc->states |= CDirty;      /* may have been cleared by DoPartialWrite */
940
941         /* Before dropping lock, hold the chunk (create it if necessary).  This
942          * serves two purposes:  (1) Ensure Cache Truncate Daemon doesn't try
943          * to purge the chunk's pages while we have them locked.  This would
944          * cause deadlock because we might be waiting for the CTD to free up
945          * a chunk.  (2)  If we're writing past the original EOF, and we're
946          * at the base of the chunk, then make sure it exists online
947          * before we do the uiomove, since the segmap_release will
948          * write out to the chunk, causing it to get fetched if it hasn't
949          * been created yet.  The code that would otherwise notice that
950          * we're fetching a chunk past EOF won't work, since we've
951          * already adjusted the file size above.
952          */
953         ObtainWriteLock(&avc->vlock, 551);
954         while (avc->vstates & VPageCleaning) {
955             ReleaseWriteLock(&avc->vlock);
956             ReleaseWriteLock(&avc->lock);
957             afs_osi_Sleep(&avc->vstates);
958             ObtainWriteLock(&avc->lock, 334);
959             ObtainWriteLock(&avc->vlock, 552);
960         }
961         ReleaseWriteLock(&avc->vlock);
962         {
963             afs_size_t toff, tlen;
964             dcp = afs_GetDCache(avc, fileBase, &treq, &toff, &tlen, 2);
965             if (!dcp) {
966                 code = ENOENT;
967                 break;
968             }
969         }
970         ReleaseWriteLock(&avc->lock);   /* uiomove may page fault */
971         AFS_GUNLOCK();
972 #if     defined(AFS_SUN56_ENV)
973         data = segmap_getmap(segkmap, AFSTOV(avc), (u_offset_t) pageBase);
974         raddr = (caddr_t) (((uintptr_t) data + pageOffset) & PAGEMASK);
975 #else
976         data = segmap_getmap(segkmap, AFSTOV(avc), pageBase);
977         raddr = (caddr_t) (((u_int) data + pageOffset) & PAGEMASK);
978 #endif
979         rsize =
980             (((u_int) data + pageOffset + tsize + PAGEOFFSET) & PAGEMASK) -
981             (u_int) raddr;
982         if (code == 0) {
983             /* if we're doing a write, and we're starting at the rounded
984              * down page base, and we're writing enough data to cover all
985              * created pages, then we must be writing all of the pages
986              * in this MAXBSIZE window that we're creating.
987              */
988             created = 0;
989             if (arw == UIO_WRITE && ((long)raddr == (long)data + pageOffset)
990                 && tsize >= rsize) {
991                 /* probably the dcache backing this guy is around, but if
992                  * not, we can't do this optimization, since we're creating
993                  * writable pages, which must be backed by a chunk.
994                  */
995                 AFS_GLOCK();
996                 dcp_newpage = afs_FindDCache(avc, pageBase);
997                 if (dcp_newpage
998                     && hsame(avc->m.DataVersion, dcp_newpage->f.versionNo)) {
999                     ObtainWriteLock(&avc->lock, 251);
1000                     ObtainWriteLock(&avc->vlock, 576);
1001                     ObtainReadLock(&dcp_newpage->lock);
1002                     if ((avc->activeV == 0)
1003                         && hsame(avc->m.DataVersion, dcp_newpage->f.versionNo)
1004                         && !(dcp_newpage->dflags & (DFFetching))) {
1005                         AFS_GUNLOCK();
1006                         segmap_pagecreate(segkmap, raddr, rsize, 1);
1007                         AFS_GLOCK();
1008                         ObtainWriteLock(&afs_xdcache, 252);
1009                         /* Mark the pages as created and dirty */
1010                         afs_indexFlags[dcp_newpage->index]
1011                             |= (IFAnyPages | IFDirtyPages);
1012                         ReleaseWriteLock(&afs_xdcache);
1013                         created = 1;
1014                     }
1015                     ReleaseReadLock(&dcp_newpage->lock);
1016                     afs_PutDCache(dcp_newpage);
1017                     ReleaseWriteLock(&avc->vlock);
1018                     ReleaseWriteLock(&avc->lock);
1019                 } else if (dcp_newpage)
1020                     afs_PutDCache(dcp_newpage);
1021                 AFS_GUNLOCK();
1022             }
1023             if (!created)
1024                 code =
1025                     afs_fc2errno(segmap_fault
1026                                  (kas.a_hat, segkmap, raddr, rsize,
1027                                   F_SOFTLOCK, mode));
1028         }
1029         if (code == 0) {
1030             AFS_UIOMOVE(data + pageOffset, tsize, arw, auio, code);
1031             segmap_fault(kas.a_hat, segkmap, raddr, rsize, F_SOFTUNLOCK,
1032                          mode);
1033         }
1034         if (code == 0) {
1035             code = segmap_release(segkmap, data, sflags);
1036         } else {
1037             (void)segmap_release(segkmap, data, 0);
1038         }
1039         AFS_GLOCK();
1040         ObtainWriteLock(&avc->lock, 253);
1041         counter++;
1042         if (dcp)
1043             afs_PutDCache(dcp);
1044         if (code)
1045             break;
1046     }
1047     if (didFakeOpen) {
1048         afs_FakeClose(avc, acred);
1049     }
1050     if (arw == UIO_WRITE && (avc->states & CDirty)) {
1051         code2 = afs_DoPartialWrite(avc, &treq);
1052         if (!code)
1053             code = code2;
1054     }
1055
1056     if (!code && avc->vc_error) {
1057         code = avc->vc_error;
1058     }
1059     ReleaseWriteLock(&avc->lock);
1060     afs_BozonUnlock(&avc->pvnLock, avc);
1061     if (!code) {
1062 #ifdef  AFS_SUN53_ENV
1063         if ((ioflag & FSYNC) && (arw == UIO_WRITE)
1064             && !AFS_NFSXLATORREQ(acred))
1065             code = afs_fsync(avc, 0, acred);
1066 #else
1067         if ((ioflag & IO_SYNC) && (arw == UIO_WRITE)
1068             && !AFS_NFSXLATORREQ(acred))
1069             code = afs_fsync(avc, acred);
1070 #endif
1071     }
1072 #ifdef  AFS_SUN52_ENV
1073     /* 
1074      * If things worked, add in as remaining in request any bytes
1075      * we didn't write due to file size ulimit.
1076      */
1077     if (code == 0 && extraResid > 0)
1078         auio->uio_resid += extraResid;
1079 #endif
1080     return afs_CheckCode(code, &treq, 46);
1081 }
1082
1083 afs_map(vp, off, as, addr, len, prot, maxprot, flags, cred)
1084      struct vnode *vp;
1085      struct as *as;
1086      offset_t off;
1087      caddr_t *addr;
1088      u_int len;
1089      u_char prot, maxprot;
1090      u_int flags;
1091      struct AFS_UCRED *cred;
1092 {
1093     struct segvn_crargs crargs;
1094     register afs_int32 code;
1095     struct vrequest treq;
1096     register struct vcache *avc = VTOAFS(vp);
1097
1098     AFS_STATCNT(afs_map);
1099
1100
1101     /* check for reasonableness on segment bounds; apparently len can be < 0 */
1102     if (off < 0 || off + len < 0) {
1103         return (EINVAL);
1104     }
1105 #ifndef AFS_64BIT_CLIENT
1106     if (AfsLargeFileSize(off, len)) {   /* file is larger than 2 GB */
1107         code = EFBIG;
1108         goto out;
1109     }
1110 #endif
1111
1112     if (vp->v_flag & VNOMAP)    /* File isn't allowed to be mapped */
1113         return (ENOSYS);
1114
1115     if (vp->v_filocks)          /* if locked, disallow mapping */
1116         return (EAGAIN);
1117
1118     AFS_GLOCK();
1119     if (code = afs_InitReq(&treq, cred))
1120         goto out;
1121
1122     if (vp->v_type != VREG) {
1123         code = ENODEV;
1124         goto out;
1125     }
1126
1127     code = afs_VerifyVCache(avc, &treq);
1128     if (code) {
1129         goto out;
1130     }
1131     afs_BozonLock(&avc->pvnLock, avc);
1132     osi_FlushPages(avc, cred);  /* ensure old pages are gone */
1133     avc->states |= CMAPPED;     /* flag cleared at afs_inactive */
1134     afs_BozonUnlock(&avc->pvnLock, avc);
1135
1136     AFS_GUNLOCK();
1137     as_rangelock(as);
1138     if ((flags & MAP_FIXED) == 0) {
1139 #if     defined(AFS_SUN57_ENV)
1140         map_addr(addr, len, off, 1, flags);
1141 #elif   defined(AFS_SUN56_ENV)
1142         map_addr(addr, len, off, 1);
1143 #else
1144         map_addr(addr, len, (off_t) off, 1);
1145 #endif
1146         if (*addr == NULL) {
1147             as_rangeunlock(as);
1148             code = ENOMEM;
1149             goto out1;
1150         }
1151     } else
1152         (void)as_unmap(as, *addr, len); /* unmap old address space use */
1153     /* setup the create parameter block for the call */
1154     crargs.vp = AFSTOV(avc);
1155     crargs.offset = (u_int) off;
1156     crargs.cred = cred;
1157     crargs.type = flags & MAP_TYPE;
1158     crargs.prot = prot;
1159     crargs.maxprot = maxprot;
1160     crargs.amp = (struct anon_map *)0;
1161     crargs.flags = flags & ~MAP_TYPE;
1162
1163     code = as_map(as, *addr, len, segvn_create, (char *)&crargs);
1164     as_rangeunlock(as);
1165   out1:
1166     AFS_GLOCK();
1167     code = afs_CheckCode(code, &treq, 47);
1168     AFS_GUNLOCK();
1169     return code;
1170   out:
1171     code = afs_CheckCode(code, &treq, 48);
1172     AFS_GUNLOCK();
1173     return code;
1174 }
1175
1176
1177 /*
1178  * For Now We use standard local kernel params for AFS system values. Change this
1179  * at some point.
1180  */
1181 afs_pathconf(vp, cmd, outdatap, credp)
1182      register struct AFS_UCRED *credp;
1183      struct vnode *vp;
1184      int cmd;
1185      u_long *outdatap;
1186 {
1187     AFS_STATCNT(afs_cntl);
1188     switch (cmd) {
1189     case _PC_LINK_MAX:
1190         *outdatap = MAXLINK;
1191         break;
1192     case _PC_NAME_MAX:
1193         *outdatap = MAXNAMLEN;
1194         break;
1195     case _PC_PATH_MAX:
1196         *outdatap = MAXPATHLEN;
1197         break;
1198     case _PC_CHOWN_RESTRICTED:
1199         *outdatap = 1;
1200         break;
1201     case _PC_NO_TRUNC:
1202         *outdatap = 1;
1203         break;
1204     default:
1205         return EINVAL;
1206     }
1207     return 0;
1208 }
1209
1210 afs_ioctl(vnp, com, arg, flag, credp, rvalp)
1211      struct vnode *vnp;
1212      int com, arg, flag;
1213      cred_t *credp;
1214      int *rvalp;
1215 {
1216     return (ENOTTY);
1217 }
1218
1219 void
1220 afs_rwlock(vnp, wlock)
1221      struct vnode *vnp;
1222      int wlock;
1223 {
1224     rw_enter(&(VTOAFS(vnp))->rwlock, (wlock ? RW_WRITER : RW_READER));
1225 }
1226
1227
1228 void
1229 afs_rwunlock(vnp, wlock)
1230      struct vnode *vnp;
1231      int wlock;
1232 {
1233     rw_exit(&(VTOAFS(vnp))->rwlock);
1234 }
1235
1236
1237 /* NOT SUPPORTED */
1238 afs_seek(vnp, ooff, noffp)
1239      struct vnode *vnp;
1240      offset_t ooff;
1241      offset_t *noffp;
1242 {
1243     register int code = 0;
1244
1245 #ifndef AFS_64BIT_CLIENT
1246 # define __MAXOFF_T MAXOFF_T
1247 #else
1248 # define __MAXOFF_T MAXOFFSET_T
1249 #endif
1250
1251     if ((*noffp < 0 || *noffp > __MAXOFF_T))
1252         code = EINVAL;
1253     return code;
1254 }
1255
1256 int
1257 afs_frlock(vnp, cmd, ap, flag, off,
1258 #ifdef AFS_SUN59_ENV
1259            flkcb,
1260 #endif
1261            credp)
1262      struct vnode *vnp;
1263      int cmd;
1264 #if     defined(AFS_SUN56_ENV)
1265      struct flock64 *ap;
1266 #else
1267      struct flock *ap;
1268 #endif
1269      int flag;
1270      offset_t off;
1271 #ifdef AFS_SUN59_ENV
1272      struct flk_callback *flkcb;
1273 #endif
1274      struct AFS_UCRED *credp;
1275 {
1276     register afs_int32 code = 0;
1277     /*
1278      * Implement based on afs_lockctl
1279      */
1280     AFS_GLOCK();
1281 #ifdef AFS_SUN59_ENV
1282     if (flkcb)
1283         afs_warn("Don't know how to deal with flk_callback's!\n");
1284 #endif
1285     if ((cmd == F_GETLK) || (cmd == F_O_GETLK) || (cmd == F_SETLK)
1286         || (cmd == F_SETLKW)) {
1287 #ifdef  AFS_SUN53_ENV
1288         ap->l_pid = ttoproc(curthread)->p_pid;
1289         ap->l_sysid = 0;
1290 #else
1291         ap->l_pid = ttoproc(curthread)->p_epid;
1292         ap->l_sysid = ttoproc(curthread)->p_sysid;
1293 #endif
1294
1295         AFS_GUNLOCK();
1296 #ifdef  AFS_SUN56_ENV
1297         code = convoff(vnp, ap, 0, off);
1298 #else
1299         code = convoff(vnp, ap, 0, (off_t) off);
1300 #endif
1301         if (code)
1302             return code;
1303         AFS_GLOCK();
1304     }
1305
1306     code = afs_lockctl(VTOAFS(vnp), ap, cmd, credp);
1307     AFS_GUNLOCK();
1308     return code;
1309 }
1310
1311
1312 int
1313 afs_space(vnp, cmd, ap, flag, off, credp)
1314      struct vnode *vnp;
1315      int cmd;
1316 #if     defined(AFS_SUN56_ENV)
1317      struct flock64 *ap;
1318 #else
1319      struct flock *ap;
1320 #endif
1321      int flag;
1322      offset_t off;
1323      struct AFS_UCRED *credp;
1324 {
1325     register afs_int32 code = EINVAL;
1326     struct vattr vattr;
1327
1328     if ((cmd == F_FREESP)
1329 #ifdef  AFS_SUN56_ENV
1330         && ((code = convoff(vnp, ap, 0, off)) == 0)) {
1331 #else
1332         && ((code = convoff(vnp, ap, 0, (off_t) off)) == 0)) {
1333 #endif
1334         AFS_GLOCK();
1335         if (!ap->l_len) {
1336             vattr.va_mask = AT_SIZE;
1337             vattr.va_size = ap->l_start;
1338             code = afs_setattr(VTOAFS(vnp), &vattr, 0, credp);
1339         }
1340         AFS_GUNLOCK();
1341     }
1342     return (code);
1343 }
1344
1345 int
1346 afs_dump(vp, addr, i1, i2)
1347      struct vnode *vp;
1348      caddr_t addr;
1349      int i1, i2;
1350 {
1351     AFS_STATCNT(afs_dump);
1352     afs_warn("AFS_DUMP. MUST IMPLEMENT THIS!!!\n");
1353     return EINVAL;
1354 }
1355
1356
1357 /* Nothing fancy here; just compare if vnodes are identical ones */
1358 afs_cmp(vp1, vp2)
1359      struct vnode *vp1, *vp2;
1360 {
1361     AFS_STATCNT(afs_cmp);
1362     return (vp1 == vp2);
1363 }
1364
1365
1366 int
1367 afs_realvp(struct vnode *vp, struct vnode **vpp)
1368 {
1369     AFS_STATCNT(afs_realvp);
1370     return EINVAL;
1371 }
1372
1373
1374 int
1375 afs_pageio(vp, pp, ui1, ui2, i1, credp)
1376      struct vnode *vp;
1377      struct page *pp;
1378      u_int ui1, ui2;
1379      int i1;
1380      struct cred *credp;
1381 {
1382     afs_warn("afs_pageio: Not implemented\n");
1383     return EINVAL;
1384 }
1385
1386 int
1387 afs_dumpctl(vp, i
1388 #ifdef AFS_SUN59_ENV
1389             , blkp
1390 #endif
1391     )
1392      struct vnode *vp;
1393      int i;
1394 #ifdef AFS_SUN59_ENV
1395      int *blkp;
1396 #endif
1397 {
1398     afs_warn("afs_dumpctl: Not implemented\n");
1399     return EINVAL;
1400 }
1401
1402 #ifdef  AFS_SUN54_ENV
1403 extern void
1404 afs_dispose(vp, p, fl, dn, cr)
1405      struct vnode *vp;
1406      struct page *p;
1407      int fl, dn;
1408      struct cred *cr;
1409 {
1410     fs_dispose(vp, p, fl, dn, cr);
1411 }
1412
1413 int
1414 afs_setsecattr(vp, vsecattr, flag, creds)
1415      struct vnode *vp;
1416      vsecattr_t *vsecattr;
1417      int flag;
1418      struct cred *creds;
1419 {
1420     return ENOSYS;
1421 }
1422
1423 int
1424 afs_getsecattr(vp, vsecattr, flag, creds)
1425      struct vnode *vp;
1426      vsecattr_t *vsecattr;
1427      int flag;
1428      struct cred *creds;
1429 {
1430     return fs_fab_acl(vp, vsecattr, flag, creds);
1431 }
1432 #endif
1433
1434 #ifdef  AFS_GLOBAL_SUNLOCK
1435 extern int gafs_open(), gafs_close(), afs_ioctl(), gafs_access();
1436 extern int gafs_getattr(), gafs_setattr(), gafs_lookup(), gafs_create();
1437 extern int gafs_remove(), gafs_link(), gafs_rename(), gafs_mkdir();
1438 extern int gafs_rmdir(), gafs_readdir(), gafs_fsync(), gafs_symlink();
1439 extern int gafs_fid(), gafs_readlink(), fs_setfl(), afs_pathconf();
1440 extern int afs_lockctl();
1441 extern void gafs_inactive();
1442
1443 #ifdef AFS_SUN510_ENV
1444 struct fs_operation_def afs_vnodeops_template[] = {
1445     { VOPNAME_OPEN,             gafs_open },
1446     { VOPNAME_CLOSE,            gafs_close },
1447     { VOPNAME_READ,             afs_vmread },
1448     { VOPNAME_WRITE,            afs_vmwrite },
1449     { VOPNAME_IOCTL,            afs_ioctl },
1450     { VOPNAME_SETFL,            fs_setfl },
1451     { VOPNAME_GETATTR,          gafs_getattr },
1452     { VOPNAME_SETATTR,          gafs_setattr },
1453     { VOPNAME_ACCESS,           gafs_access },
1454     { VOPNAME_LOOKUP,           gafs_lookup },
1455     { VOPNAME_CREATE,           gafs_create },
1456     { VOPNAME_REMOVE,           gafs_remove },
1457     { VOPNAME_LINK,             gafs_link },
1458     { VOPNAME_RENAME,           gafs_rename },
1459     { VOPNAME_MKDIR,            gafs_mkdir },
1460     { VOPNAME_RMDIR,            gafs_rmdir },
1461     { VOPNAME_READDIR,          gafs_readdir },
1462     { VOPNAME_SYMLINK,          gafs_symlink },   
1463     { VOPNAME_READLINK,         gafs_readlink },
1464     { VOPNAME_FSYNC,            gafs_fsync },
1465     { VOPNAME_INACTIVE,         gafs_inactive },
1466     { VOPNAME_FID,              gafs_fid },
1467     { VOPNAME_RWLOCK,           afs_rwlock },
1468     { VOPNAME_RWUNLOCK,         afs_rwunlock },
1469     { VOPNAME_SEEK,             afs_seek },
1470     { VOPNAME_CMP,              afs_cmp },
1471     { VOPNAME_FRLOCK,           afs_frlock },
1472     { VOPNAME_SPACE,            afs_space },
1473     { VOPNAME_REALVP,           afs_realvp },
1474     { VOPNAME_GETPAGE,          afs_getpage },
1475     { VOPNAME_PUTPAGE,          afs_putpage },
1476     { VOPNAME_MAP,              afs_map },
1477     { VOPNAME_ADDMAP,           afs_addmap },
1478     { VOPNAME_DELMAP,           afs_delmap },
1479     { VOPNAME_POLL,             fs_poll },
1480     { VOPNAME_DUMP,             afs_dump },
1481     { VOPNAME_PATHCONF,         afs_pathconf },
1482     { VOPNAME_PAGEIO,           afs_pageio },
1483     { VOPNAME_DUMPCTL,          afs_dumpctl },   
1484     { VOPNAME_DISPOSE,          afs_dispose },
1485     { VOPNAME_GETSECATTR,       afs_getsecattr },
1486     { VOPNAME_SETSECATTR,       afs_setsecattr },
1487     { VOPNAME_SHRLOCK,          fs_shrlock },
1488     NULL,
1489 };
1490 struct vnodeops *afs_ops;
1491 #else
1492 struct vnodeops Afs_vnodeops = {
1493     gafs_open,
1494     gafs_close,
1495     afs_vmread,
1496     afs_vmwrite,
1497     afs_ioctl,
1498     fs_setfl,
1499     gafs_getattr,
1500     gafs_setattr,
1501     gafs_access,
1502     gafs_lookup,
1503     gafs_create,
1504     gafs_remove,
1505     gafs_link,
1506     gafs_rename,
1507     gafs_mkdir,
1508     gafs_rmdir,
1509     gafs_readdir,
1510     gafs_symlink,
1511     gafs_readlink,
1512     gafs_fsync,
1513     gafs_inactive,
1514     gafs_fid,
1515     afs_rwlock,
1516     afs_rwunlock,
1517     afs_seek,
1518     afs_cmp,
1519     afs_frlock,
1520     afs_space,
1521     afs_realvp,
1522     afs_getpage,
1523     afs_putpage,
1524     afs_map,
1525     afs_addmap,
1526     afs_delmap,
1527     fs_poll,
1528     afs_dump,
1529     afs_pathconf,
1530     afs_pageio,
1531     afs_dumpctl,
1532 #ifdef  AFS_SUN54_ENV
1533     afs_dispose,
1534     afs_setsecattr,
1535     afs_getsecattr,
1536 #endif
1537 #if     defined(AFS_SUN56_ENV)
1538     fs_shrlock,
1539 #endif
1540 };
1541 struct vnodeops *afs_ops = &Afs_vnodeops;
1542 #endif
1543
1544
1545
1546 gafs_open(avcp, aflags, acred)
1547      register struct vcache **avcp;
1548      afs_int32 aflags;
1549      struct AFS_UCRED *acred;
1550 {
1551     register int code;
1552
1553     AFS_GLOCK();
1554     code = afs_open(avcp, aflags, acred);
1555     AFS_GUNLOCK();
1556     return (code);
1557 }
1558
1559
1560 gafs_close(avc, aflags, count, offset, acred)
1561      offset_t offset;
1562      int count;
1563      register struct vcache *avc;
1564      afs_int32 aflags;
1565      struct AFS_UCRED *acred;
1566 {
1567     register int code;
1568
1569     AFS_GLOCK();
1570     code = afs_close(avc, aflags, count, offset, acred);
1571     AFS_GUNLOCK();
1572     return (code);
1573 }
1574
1575
1576 gafs_getattr(avc, attrs, flags, acred)
1577      int flags;
1578      register struct vcache *avc;
1579      register struct vattr *attrs;
1580      struct AFS_UCRED *acred;
1581 {
1582     register int code;
1583
1584     AFS_GLOCK();
1585     code = afs_getattr(avc, attrs, flags, acred);
1586     AFS_GUNLOCK();
1587     return (code);
1588 }
1589
1590
1591 gafs_setattr(avc, attrs, flags, acred)
1592      int flags;
1593      register struct vcache *avc;
1594      register struct vattr *attrs;
1595      struct AFS_UCRED *acred;
1596 {
1597     register int code;
1598
1599     AFS_GLOCK();
1600     code = afs_setattr(avc, attrs, flags, acred);
1601     AFS_GUNLOCK();
1602     return (code);
1603 }
1604
1605
1606 gafs_access(avc, amode, flags, acred)
1607      int flags;
1608      register struct vcache *avc;
1609      register afs_int32 amode;
1610      struct AFS_UCRED *acred;
1611 {
1612     register int code;
1613
1614     AFS_GLOCK();
1615     code = afs_access(avc, amode, flags, acred);
1616     AFS_GUNLOCK();
1617     return (code);
1618 }
1619
1620
1621 gafs_lookup(adp, aname, avcp, pnp, flags, rdir, acred)
1622      struct pathname *pnp;
1623      int flags;
1624      struct vnode *rdir;
1625      register struct vcache *adp, **avcp;
1626      char *aname;
1627      struct AFS_UCRED *acred;
1628 {
1629     register int code;
1630
1631     AFS_GLOCK();
1632     code = afs_lookup(adp, aname, avcp, pnp, flags, rdir, acred);
1633     AFS_GUNLOCK();
1634     return (code);
1635 }
1636
1637
1638 gafs_create(adp, aname, attrs, aexcl, amode, avcp, acred)
1639      register struct vcache *adp;
1640      char *aname;
1641      struct vattr *attrs;
1642      enum vcexcl aexcl;
1643      int amode;
1644      struct vcache **avcp;
1645      struct AFS_UCRED *acred;
1646 {
1647     register int code;
1648
1649     AFS_GLOCK();
1650     code = afs_create(adp, aname, attrs, aexcl, amode, avcp, acred);
1651     AFS_GUNLOCK();
1652     return (code);
1653 }
1654
1655 gafs_remove(adp, aname, acred)
1656      register struct vcache *adp;
1657      char *aname;
1658      struct AFS_UCRED *acred;
1659 {
1660     register int code;
1661
1662     AFS_GLOCK();
1663     code = afs_remove(adp, aname, acred);
1664     AFS_GUNLOCK();
1665     return (code);
1666 }
1667
1668 gafs_link(adp, avc, aname, acred)
1669      register struct vcache *avc;
1670      register struct vcache *adp;
1671      char *aname;
1672      struct AFS_UCRED *acred;
1673 {
1674     register int code;
1675
1676     AFS_GLOCK();
1677     code = afs_link(adp, avc, aname, acred);
1678     AFS_GUNLOCK();
1679     return (code);
1680 }
1681
1682 gafs_rename(aodp, aname1, andp, aname2, acred)
1683      register struct vcache *aodp, *andp;
1684      char *aname1, *aname2;
1685      struct AFS_UCRED *acred;
1686 {
1687     register int code;
1688
1689     AFS_GLOCK();
1690     code = afs_rename(aodp, aname1, andp, aname2, acred);
1691 #ifdef AFS_SUN510_ENV
1692     if (code == 0) {
1693         struct vcache *avcp = NULL;
1694         
1695         (void) afs_lookup(andp, aname2, &avcp, NULL, 0, NULL, acred);
1696         if (avcp) {
1697             struct vnode *vp = AFSTOV(avcp), *pvp = AFSTOV(andp);
1698             
1699             mutex_enter(&vp->v_lock);
1700             kmem_free(vp->v_path, strlen(vp->v_path) + 1);
1701             vp->v_path = NULL;
1702             mutex_exit(&vp->v_lock);
1703             VN_SETPATH(afs_globalVp, pvp, vp, aname2, strlen(aname2));
1704             
1705             AFS_RELE(avcp);
1706         }
1707     }
1708 #endif
1709     AFS_GUNLOCK();
1710     return (code);
1711 }
1712
1713 gafs_mkdir(adp, aname, attrs, avcp, acred)
1714      register struct vcache *adp;
1715      register struct vcache **avcp;
1716      char *aname;
1717      struct vattr *attrs;
1718      struct AFS_UCRED *acred;
1719 {
1720     register int code;
1721
1722     AFS_GLOCK();
1723     code = afs_mkdir(adp, aname, attrs, avcp, acred);
1724     AFS_GUNLOCK();
1725     return (code);
1726 }
1727
1728
1729 gafs_rmdir(adp, aname, cdirp, acred)
1730      struct vnode *cdirp;
1731      register struct vcache *adp;
1732      char *aname;
1733      struct AFS_UCRED *acred;
1734 {
1735     register int code;
1736
1737     AFS_GLOCK();
1738     code = afs_rmdir(adp, aname, cdirp, acred);
1739     AFS_GUNLOCK();
1740     return (code);
1741 }
1742
1743
1744 gafs_readdir(avc, auio, acred, eofp)
1745      int *eofp;
1746      register struct vcache *avc;
1747      struct uio *auio;
1748      struct AFS_UCRED *acred;
1749 {
1750     register int code;
1751
1752     AFS_GLOCK();
1753     code = afs_readdir(avc, auio, acred, eofp);
1754     AFS_GUNLOCK();
1755     return (code);
1756 }
1757
1758 gafs_symlink(adp, aname, attrs, atargetName, acred)
1759      register struct vcache *adp;
1760      register char *atargetName;
1761      char *aname;
1762      struct vattr *attrs;
1763      struct AFS_UCRED *acred;
1764 {
1765     register int code;
1766
1767     AFS_GLOCK();
1768     code = afs_symlink(adp, aname, attrs, atargetName, acred);
1769     AFS_GUNLOCK();
1770     return (code);
1771 }
1772
1773
1774 gafs_readlink(avc, auio, acred)
1775      register struct vcache *avc;
1776      struct uio *auio;
1777      struct AFS_UCRED *acred;
1778 {
1779     register int code;
1780
1781     AFS_GLOCK();
1782     code = afs_readlink(avc, auio, acred);
1783     AFS_GUNLOCK();
1784     return (code);
1785 }
1786
1787 #ifdef  AFS_SUN53_ENV
1788 gafs_fsync(avc, flag, acred)
1789      int flag;
1790 #else
1791 gafs_fsync(avc, acred)
1792 #endif
1793      register struct vcache *avc;
1794      struct AFS_UCRED *acred;
1795 {
1796     register int code;
1797
1798     AFS_GLOCK();
1799 #ifdef  AFS_SUN53_ENV
1800     code = afs_fsync(avc, flag, acred);
1801 #else
1802     code = afs_fsync(avc, acred);
1803 #endif
1804     AFS_GUNLOCK();
1805     return (code);
1806 }
1807
1808 void
1809 afs_inactive(struct vcache *avc, struct AFS_UCRED *acred)
1810 {
1811     struct vnode *vp = AFSTOV(avc);
1812     if (afs_shuttingdown)
1813         return;
1814
1815     /*
1816      * In Solaris and HPUX s800 and HP-UX10.0 they actually call us with
1817      * v_count 1 on last reference!
1818      */
1819     mutex_enter(&vp->v_lock);
1820     if (avc->vrefCount <= 0)
1821         osi_Panic("afs_inactive : v_count <=0\n");
1822
1823     /*
1824      * If more than 1 don't unmap the vnode but do decrement the ref count
1825      */
1826     vp->v_count--;
1827     if (vp->v_count > 0) {
1828         mutex_exit(&vp->v_lock);
1829         return;
1830     }
1831     mutex_exit(&vp->v_lock);
1832
1833     /*
1834      * Solaris calls VOP_OPEN on exec, but doesn't call VOP_CLOSE when
1835      * the executable exits.  So we clean up the open count here.
1836      *
1837      * Only do this for mvstat 0 vnodes: when using fakestat, we can't
1838      * lose the open count for volume roots (mvstat 2), even though they
1839      * will get VOP_INACTIVE'd when released by afs_PutFakeStat().
1840      */
1841     if (avc->opens > 0 && avc->mvstat == 0 && !(avc->states & CCore))
1842         avc->opens = avc->execsOrWriters = 0;
1843
1844     afs_InactiveVCache(avc, acred);
1845 }
1846
1847 void
1848 gafs_inactive(avc, acred)
1849      register struct vcache *avc;
1850      struct AFS_UCRED *acred;
1851 {
1852     AFS_GLOCK();
1853     afs_inactive(avc, acred);
1854     AFS_GUNLOCK();
1855 }
1856
1857
1858 gafs_fid(avc, fidpp)
1859      struct vcache *avc;
1860      struct fid **fidpp;
1861 {
1862     register int code;
1863
1864     AFS_GLOCK();
1865     code = afs_fid(avc, fidpp);
1866     AFS_GUNLOCK();
1867     return (code);
1868 }
1869
1870 #endif /* AFS_GLOBAL_SUNLOCK */