b86347e163a11410386a160fd8be1f6fd4952efb
[openafs.git] / src / afs / AIX / 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
14 #include "h/systm.h"
15 #include "h/types.h"
16 #include "h/errno.h"
17 #include "h/stat.h"
18 #include "h/user.h"
19 #include "h/uio.h"
20 #include "h/vattr.h"
21 #include "h/file.h"
22 #include "h/vfs.h"
23 #include "h/chownx.h"
24 #include "h/systm.h"
25 #include "h/access.h"
26 #ifdef AFS_AIX51_ENV
27 #include "h/acl.h"
28 #endif
29 #include "rpc/types.h"
30 #include "osi_vfs.h"
31 #include "netinet/in.h"
32 #include "h/mbuf.h"
33 #include "h/vmuser.h"
34 #include "h/shm.h"
35 #include "rpc/types.h"
36 #include "rpc/xdr.h"
37
38 #include "afs/stds.h"
39 #include "afs/afs_osi.h"
40 #define RFTP_INTERNALS 1
41 #include "afs/volerrors.h"
42 #include "afsint.h"
43 #include "vldbint.h"
44 #include "afs/lock.h"
45 #include "afs/exporter.h"
46 #include "afs/afs.h"
47 #include "afs/afs_chunkops.h"
48 #include "afs/afs_stats.h"
49 #include "afs/nfsclient.h"
50 #include "afs/icl.h"
51 #include "afs/prs_fs.h"
52 #include "h/flock.h"
53 #include "afsincludes.h"
54
55
56 int
57 afs_gn_link(struct vnode *vp, 
58             struct vnode *dp, 
59             char *name, 
60             struct ucred *cred)
61 {
62     int error;
63
64     AFS_STATCNT(afs_gn_link);
65     error = afs_link(vp, dp, name, cred);
66     afs_Trace3(afs_iclSetp, CM_TRACE_GNLINK, ICL_TYPE_POINTER, vp,
67                ICL_TYPE_STRING, name, ICL_TYPE_LONG, error);
68     return (error);
69 }
70
71
72 int
73 afs_gn_mkdir(struct vnode *dp, 
74              char *name, 
75              int32long64_t Mode, 
76              struct ucred *cred)
77 {
78     struct vattr va;
79     struct vnode *vp;
80     int error;
81     int mode = Mode;
82
83     AFS_STATCNT(afs_gn_mkdir);
84     VATTR_NULL(&va);
85     va.va_type = VDIR;
86     va.va_mode = (mode & 07777) & ~get_umask();
87     error = afs_mkdir(dp, name, &va, &vp, cred);
88     if (!error) {
89         AFS_RELE(vp);
90     }
91     afs_Trace4(afs_iclSetp, CM_TRACE_GMKDIR, ICL_TYPE_POINTER, vp,
92                ICL_TYPE_STRING, name, ICL_TYPE_LONG, mode, ICL_TYPE_LONG,
93                error);
94     return (error);
95 }
96
97
98 int
99 afs_gn_mknod(struct vnode *dp, 
100              char *name, 
101              int32long64_t Mode, 
102              dev_t dev, 
103              struct ucred *cred)
104 {
105     struct vattr va;
106     struct vnode *vp;
107     int error;
108     int mode = Mode;
109
110     AFS_STATCNT(afs_gn_mknod);
111     VATTR_NULL(&va);
112     va.va_type = IFTOVT(mode);
113     va.va_mode = (mode & 07777) & ~get_umask();
114
115 /**** I'm not sure if suser() should stay here since it makes no sense in AFS; however the documentation says that one "should be super-user unless making a FIFO file. Others systems such as SUN do this checking in the early stages of mknod (before the abstraction), so it's equivalently the same! *****/
116     if (va.va_type != VFIFO && !suser((char *)&error))
117         return (EPERM);
118     switch (va.va_type) {
119     case VDIR:
120         error = afs_mkdir(dp, name, &va, &vp, cred);
121         break;
122     case VNON:
123         error = EINVAL;
124         break;
125     case VBAD:
126     case VCHR:
127     case VBLK:
128         va.va_rdev = dev;
129     default:
130         error = afs_create(VTOAFS(dp), name, &va, NONEXCL, mode, (struct vcache **)&vp, cred);
131     }
132     if (!error) {
133         AFS_RELE(vp);
134     }
135     afs_Trace4(afs_iclSetp, CM_TRACE_GMKNOD, ICL_TYPE_POINTER, (afs_int32) vp,
136                ICL_TYPE_STRING, name, ICL_TYPE_LONG, mode, ICL_TYPE_LONG,
137                error);
138     return (error);
139 }
140
141
142 int
143 afs_gn_remove(struct vnode *vp,         /* Ignored in AFS */
144               struct vnode * dp, 
145               char *name, 
146               struct ucred *cred)
147 {
148     int error;
149
150     AFS_STATCNT(afs_gn_remove);
151     error = afs_remove(dp, name, cred);
152     afs_Trace3(afs_iclSetp, CM_TRACE_GREMOVE, ICL_TYPE_POINTER, dp,
153                ICL_TYPE_STRING, name, ICL_TYPE_LONG, error);
154     return (error);
155 }
156
157
158 int
159 afs_gn_rename(struct vnode *vp,                 /* Ignored in AFS */
160               struct vnode *dp, 
161               char *name, 
162               struct vnode *tp,                 /* Ignored in AFS */
163               struct vnode *tdp, 
164               char *tname, 
165               struct ucred *cred)
166 {
167     int error;
168
169     AFS_STATCNT(afs_gn_rename);
170     error = afs_rename(dp, name, tdp, tname, cred);
171     afs_Trace4(afs_iclSetp, CM_TRACE_GRENAME, ICL_TYPE_POINTER, dp,
172                ICL_TYPE_STRING, name, ICL_TYPE_STRING, tname, ICL_TYPE_LONG,
173                error);
174     return (error);
175 }
176
177
178 int
179 afs_gn_rmdir(struct vnode *vp,          /* Ignored in AFS */
180              struct vnode *dp, 
181              char *name, 
182              struct ucred *cred)
183 {
184     int error;
185
186     AFS_STATCNT(afs_gn_rmdir);
187     error = afs_rmdir(dp, name, cred);
188     if (error) {
189         if (error == 66 /* 4.3's ENOTEMPTY */ )
190             error = EEXIST;     /* AIX returns EEXIST where 4.3 used ENOTEMPTY */
191     }
192     afs_Trace3(afs_iclSetp, CM_TRACE_GRMDIR, ICL_TYPE_POINTER, dp,
193                ICL_TYPE_STRING, name, ICL_TYPE_LONG, error);
194     return (error);
195 }
196
197
198 int
199 afs_gn_lookup(struct vnode *dp, 
200               struct vnode **vpp, 
201               char *name, 
202               int32long64_t Flags,      /* includes FOLLOW... */
203               struct vattr *vattrp, 
204               struct ucred *cred)
205 {
206     int error;
207     int flags = Flags;
208
209     AFS_STATCNT(afs_gn_lookup);
210     error = afs_lookup(dp, name, vpp, cred);
211     afs_Trace3(afs_iclSetp, CM_TRACE_GLOOKUP, ICL_TYPE_POINTER, dp,
212                ICL_TYPE_STRING, name, ICL_TYPE_LONG, error);
213     if (vattrp != NULL && error == 0)
214         afs_gn_getattr(*vpp, vattrp, cred);
215     return (error);
216 }
217
218
219 int
220 afs_gn_fid(struct vnode *vp, 
221         struct fid *fidp, 
222         struct ucred *cred)
223 {
224     int error;
225
226     AFS_STATCNT(afs_gn_fid);
227     error = afs_fid(vp, fidp);
228     afs_Trace3(afs_iclSetp, CM_TRACE_GFID, ICL_TYPE_POINTER, vp,
229                ICL_TYPE_LONG, (afs_int32) fidp, ICL_TYPE_LONG, error);
230     return (error);
231 }
232
233
234 int
235 afs_gn_open(struct vnode *vp, 
236             int32long64_t Flags, 
237             ext_t ext, 
238             struct ucred **vinfop, 
239             struct ucred *cred)
240 {
241     int error;
242     struct vattr va;
243     struct vcache *tvp = VTOAFS(vp);
244     afs_int32 modes;
245     int flags = Flags;
246
247     AFS_STATCNT(afs_gn_open);
248     modes = 0;
249     if ((flags & FREAD))
250         modes |= R_ACC;
251     if ((flags & FEXEC))
252         modes |= X_ACC;
253     if ((flags & FWRITE) || (flags & FTRUNC))
254         modes |= W_ACC;
255
256     while ((flags & FNSHARE) && tvp->opens) {
257         if (!(flags & FDELAY)) {
258             error = ETXTBSY;
259             goto abort;
260         }
261         afs_osi_Sleep(&tvp->opens);
262     }
263
264     error = afs_access(VTOAFS(vp), modes, cred);
265     if (error) {
266         goto abort;
267     }
268
269     error = afs_open((struct vcache **) &vp, flags, cred);
270     if (!error) {
271         if (flags & FTRUNC) {
272             VATTR_NULL(&va);
273             va.va_size = 0;
274             error = afs_setattr(VTOAFS(vp), &va, cred);
275         }
276
277         if (flags & FNSHARE)
278             tvp->f.states |= CNSHARE;
279
280         if (!error) {
281             *vinfop = cred;     /* fp->f_vinfo is like fp->f_cred in suns */
282         } else {
283             /* an error occurred; we've told CM that the file
284              * is open, so close it now so that open and
285              * writer counts are correct.  Ignore error code,
286              * as it is likely to fail (the setattr just did).
287              */
288             afs_close(vp, flags, cred);
289         }
290     }
291
292   abort:
293     afs_Trace3(afs_iclSetp, CM_TRACE_GOPEN, ICL_TYPE_POINTER, vp,
294                ICL_TYPE_LONG, flags, ICL_TYPE_LONG, error);
295     return (error);
296 }
297
298
299 int
300 afs_gn_create(struct vnode *dp, 
301               struct vnode **vpp, 
302               int32long64_t Flags, 
303               char *name, 
304               int32long64_t Mode, 
305               struct ucred **vinfop, /* return ptr for fp->f_vinfo, used as fp->f_cred */
306               struct ucred *cred)
307
308 {
309     struct vattr va;
310     enum vcexcl exclusive;
311     int error, modes = 0;
312     int flags = Flags;
313     int mode = Mode;
314
315     AFS_STATCNT(afs_gn_create);
316     if ((flags & (O_EXCL | O_CREAT)) == (O_EXCL | O_CREAT))
317         exclusive = EXCL;
318     else
319         exclusive = NONEXCL;
320     VATTR_NULL(&va);
321     va.va_type = VREG;
322     va.va_mode = (mode & 07777) & ~get_umask();
323     if ((flags & FREAD))
324         modes |= R_ACC;
325     if ((flags & FEXEC))
326         modes |= X_ACC;
327     if ((flags & FWRITE) || (flags & FTRUNC))
328         modes |= W_ACC;
329     error = afs_create(VTOAFS(dp), name, &va, exclusive, modes, (struct vcache **)vpp, cred);
330     if (error) {
331         return error;
332     }
333     /* 'cr_luid' is a flag (when it comes thru the NFS server it's set to
334      * RMTUSER_REQ) that determines if we should call afs_open(). We shouldn't
335      * call it when this NFS traffic since the close will never happen thus
336      * we'd never flush the files out to the server! Gross but the simplest
337      * solution we came out with */
338     if (cred->cr_luid != RMTUSER_REQ) {
339         while ((flags & FNSHARE) && VTOAFS(*vpp)->opens) {
340             if (!(flags & FDELAY))
341                 return ETXTBSY;
342             afs_osi_Sleep(&VTOAFS(*vpp)->opens);
343         }
344         /* Since in the standard copen() for bsd vnode kernels they do an
345          * vop_open after the vop_create, we must do the open here since there
346          * are stuff in afs_open that we need. For example advance the
347          * execsOrWriters flag (else we'll be treated as the sun's "core"
348          * case). */
349         *vinfop = cred;         /* save user creds in fp->f_vinfo */
350         error = afs_open((struct vcache **)vpp, flags, cred);
351     }
352     afs_Trace4(afs_iclSetp, CM_TRACE_GCREATE, ICL_TYPE_POINTER, dp,
353                ICL_TYPE_STRING, name, ICL_TYPE_LONG, mode, ICL_TYPE_LONG,
354                error);
355     return error;
356 }
357
358
359 int
360 afs_gn_hold(struct vnode *vp)
361 {
362     AFS_STATCNT(afs_gn_hold);
363     ++(vp->v_count);
364     return (0);
365 }
366
367 int vmPageHog = 0;
368
369 int
370 afs_gn_rele(struct vnode *vp)
371 {
372     struct vcache *vcp = VTOAFS(vp);
373     int error = 0;
374
375     AFS_STATCNT(afs_gn_rele);
376     if (vp->v_count == 0)
377         osi_Panic("afs_rele: zero v_count");
378     if (--(vp->v_count) == 0) {
379         if (vcp->f.states & CPageHog) {
380             vmPageHog--;
381             vcp->f.states &= ~CPageHog;
382         }
383         error = afs_inactive(vp, 0);
384     }
385     return (error);
386 }
387
388
389 int
390 afs_gn_close(struct vnode *vp, 
391              int32long64_t Flags, 
392              caddr_t vinfo,             /* Ignored in AFS */
393              struct ucred *cred)
394 {
395     int error;
396     struct vcache *tvp = VTOAFS(vp);
397     int flags = Flags;
398
399     AFS_STATCNT(afs_gn_close);
400
401     if (flags & FNSHARE) {
402         tvp->f.states &= ~CNSHARE;
403         afs_osi_Wakeup(&tvp->opens);
404     }
405
406     error = afs_close(vp, flags, cred);
407     afs_Trace3(afs_iclSetp, CM_TRACE_GCLOSE, ICL_TYPE_POINTER, (afs_int32) vp,
408                ICL_TYPE_LONG, flags, ICL_TYPE_LONG, error);
409     return (error);
410 }
411
412
413 int
414 afs_gn_map(struct vnode *vp, 
415            caddr_t addr, 
416            uint32long64_t Len, 
417            uint32long64_t Off, 
418            uint32long64_t Flag, 
419            struct ucred *cred)
420 {
421     struct vcache *vcp = VTOAFS(vp);
422     struct vrequest treq;
423     afs_int32 error;
424     afs_int32 len = Len;
425     afs_int32 off = Off;
426     afs_int32 flag = Flag;
427
428     AFS_STATCNT(afs_gn_map);
429 #ifdef  notdef
430     if (error = afs_InitReq(&treq, cred))
431         return error;
432     error = afs_VerifyVCache(vcp, &treq);
433     if (error)
434         return afs_CheckCode(error, &treq, 49);
435 #endif
436     osi_FlushPages(vcp, cred);  /* XXX ensure old pages are gone XXX */
437     ObtainWriteLock(&vcp->lock, 401);
438     vcp->f.states |= CMAPPED;   /* flag cleared at afs_inactive */
439     /*
440      * We map the segment into our address space using the handle returned by vm_create.
441      */
442     if (!vcp->segid) {
443         afs_uint32 tlen = vcp->f.m.Length;
444 #ifdef AFS_64BIT_CLIENT
445         if (vcp->f.m.Length > afs_vmMappingEnd)
446             tlen = afs_vmMappingEnd;
447 #endif
448         /* Consider  V_INTRSEG too for interrupts */
449         if (error =
450             vms_create(&vcp->segid, V_CLIENT, (dev_t) vcp->v.v_gnode, tlen, 0, 0)) {
451             ReleaseWriteLock(&vcp->lock);
452             return (EOPNOTSUPP);
453         }
454 #ifdef AFS_64BIT_KERNEL
455         vcp->vmh = vm_handle(vcp->segid, (int32long64_t) 0);
456 #else
457         vcp->vmh = SRVAL(vcp->segid, 0, 0);
458 #endif
459     }
460     vcp->v.v_gnode->gn_seg = vcp->segid;        /* XXX Important XXX */
461     if (flag & SHM_RDONLY) {
462         vp->v_gnode->gn_mrdcnt++;
463     } else {
464         vp->v_gnode->gn_mwrcnt++;
465     }
466     /*
467      * We keep the caller's credentials since an async daemon will handle the 
468      * request at some point. We assume that the same credentials will be used.
469      */
470     if (!vcp->credp || (vcp->credp != cred)) {
471         crhold(cred);
472         if (vcp->credp) {
473             struct ucred *crp = vcp->credp;
474             vcp->credp = NULL;
475             crfree(crp);
476         }
477         vcp->credp = cred;
478     }
479     ReleaseWriteLock(&vcp->lock);
480     VN_HOLD(vp);
481     afs_Trace4(afs_iclSetp, CM_TRACE_GMAP, ICL_TYPE_POINTER, vp,
482                ICL_TYPE_LONG, addr, ICL_TYPE_LONG, len, ICL_TYPE_LONG, off);
483     return (0);
484 }
485
486
487 int
488 afs_gn_unmap(struct vnode *vp, 
489              int32long64_t flag, 
490              struct ucred *cred)
491 {
492     struct vcache *vcp = VTOAFS(vp);
493     AFS_STATCNT(afs_gn_unmap);
494     ObtainWriteLock(&vcp->lock, 402);
495     if (flag & SHM_RDONLY) {
496         vp->v_gnode->gn_mrdcnt--;
497         if (vp->v_gnode->gn_mrdcnt <= 0)
498             vp->v_gnode->gn_mrdcnt = 0;
499     } else {
500         vp->v_gnode->gn_mwrcnt--;
501         if (vp->v_gnode->gn_mwrcnt <= 0)
502             vp->v_gnode->gn_mwrcnt = 0;
503     }
504     ReleaseWriteLock(&vcp->lock);
505
506     AFS_RELE(vp);
507     return 0;
508 }
509
510
511 int
512 afs_gn_access(struct vnode *vp, 
513               int32long64_t Mode, 
514               int32long64_t Who, 
515               struct ucred *cred)
516 {
517     int error;
518     struct vattr vattr;
519     int mode = Mode;
520     int who = Who;
521
522     AFS_STATCNT(afs_gn_access);
523     if (mode & ~0x7) {
524         error = EINVAL;
525         goto out;
526     }
527
528     error = afs_access(VTOAFS(vp), mode, cred);
529     if (!error) {
530         /* Additional testing */
531         if (who == ACC_OTHERS || who == ACC_ANY) {
532             error = afs_getattr(VTOAFS(vp), &vattr, cred);
533             if (!error) {
534                 if (who == ACC_ANY) {
535                     if (((vattr.va_mode >> 6) & mode) == mode) {
536                         error = 0;
537                         goto out;
538                     }
539                 }
540                 if (((vattr.va_mode >> 3) & mode) == mode)
541                     error = 0;
542                 else
543                     error = EACCES;
544             }
545         } else if (who == ACC_ALL) {
546             error = afs_getattr(VTOAFS(vp), &vattr, cred);
547             if (!error) {
548                 if ((!((vattr.va_mode >> 6) & mode))
549                     || (!((vattr.va_mode >> 3) & mode))
550                     || (!(vattr.va_mode & mode)))
551                     error = EACCES;
552                 else
553                     error = 0;
554             }
555         }
556
557     }
558   out:
559     afs_Trace3(afs_iclSetp, CM_TRACE_GACCESS, ICL_TYPE_POINTER, vp,
560                ICL_TYPE_LONG, mode, ICL_TYPE_LONG, error);
561     return (error);
562 }
563
564
565 int
566 afs_gn_getattr(struct vnode *vp, 
567                struct vattr *vattrp, 
568                struct ucred *cred)
569 {
570     int error;
571
572     AFS_STATCNT(afs_gn_getattr);
573     error = afs_getattr(VTOAFS(vp), vattrp, cred);
574     afs_Trace2(afs_iclSetp, CM_TRACE_GGETATTR, ICL_TYPE_POINTER, vp,
575                ICL_TYPE_LONG, error);
576     return (error);
577 }
578
579
580 int
581 afs_gn_setattr(struct vnode *vp, 
582                int32long64_t op, 
583                int32long64_t arg1, 
584                int32long64_t arg2, 
585                int32long64_t arg3, 
586                struct ucred *cred)
587 {
588     struct vattr va;
589     int error = 0;
590
591     AFS_STATCNT(afs_gn_setattr);
592     VATTR_NULL(&va);
593     switch (op) {
594         /* change mode */
595     case V_MODE:
596         va.va_mode = arg1;
597         break;
598     case V_OWN:
599         if ((arg1 & T_OWNER_AS_IS) == 0)
600             va.va_uid = arg2;
601         if ((arg1 & T_GROUP_AS_IS) == 0)
602             va.va_gid = arg3;
603         break;
604     case V_UTIME:
605 #ifdef  notdef
606         error = afs_access(vp, VWRITE, cred);
607         if (error)
608             goto out;
609 #endif
610         if (arg1 & T_SETTIME) {
611             va.va_atime.tv_sec = time;
612             va.va_mtime.tv_sec = time;
613         } else {
614             va.va_atime = *(struct timestruc_t *)arg2;
615             va.va_mtime = *(struct timestruc_t *)arg3;
616         }
617         break;
618     default:
619         error = EINVAL;
620         goto out;
621     }
622
623     error = afs_setattr(VTOAFS(vp), &va, cred);
624   out:
625     afs_Trace2(afs_iclSetp, CM_TRACE_GSETATTR, ICL_TYPE_POINTER, vp,
626                ICL_TYPE_LONG, error);
627     return (error);
628 }
629
630
631 char zero_buffer[PAGESIZE];
632 int
633 afs_gn_fclear(struct vnode *vp, 
634               int32long64_t flags, 
635               offset_t offset, 
636               offset_t length, 
637               caddr_t vinfo, 
638               struct ucred *cred)
639 {
640     int i, len, error = 0;
641     struct iovec iov;
642     struct uio uio;
643     static int fclear_init = 0;
644     struct vcache *avc = VTOAFS(vp);
645
646     AFS_STATCNT(afs_gn_fclear);
647     if (!fclear_init) {
648         memset(zero_buffer, 0, PAGESIZE);
649         fclear_init = 1;
650     }
651     /*
652      * Don't clear past ulimit
653      */
654     if (offset + length > get_ulimit())
655         return (EFBIG);
656
657     /* Flush all pages first */
658     if (avc->segid) {
659         AFS_GUNLOCK();
660         vm_flushp(avc->segid, 0, MAXFSIZE / PAGESIZE - 1);
661         vms_iowait(avc->segid);
662         AFS_GLOCK();
663     }
664     uio.afsio_offset = offset;
665     for (i = offset; i < offset + length; i = uio.afsio_offset) {
666         len = offset + length - i;
667         iov.iov_len = (len > PAGESIZE) ? PAGESIZE : len;
668         iov.iov_base = zero_buffer;
669         uio.afsio_iov = &iov;
670         uio.afsio_iovcnt = 1;
671         uio.afsio_seg = AFS_UIOSYS;
672         uio.afsio_resid = iov.iov_len;
673         if (error = afs_rdwr(VTOAFS(vp), &uio, UIO_WRITE, 0, cred))
674             break;
675     }
676     afs_Trace4(afs_iclSetp, CM_TRACE_GFCLEAR, ICL_TYPE_POINTER, vp,
677                ICL_TYPE_LONG, offset, ICL_TYPE_LONG, length, ICL_TYPE_LONG,
678                error);
679     return (error);
680 }
681
682
683 int
684 afs_gn_fsync(struct vnode *vp, 
685              int32long64_t flags,       /* Not used by AFS */
686              int32long64_t vinfo,       /* Not used by AFS */
687              struct ucred *cred)
688 {
689     int error;
690
691     AFS_STATCNT(afs_gn_fsync);
692     error = afs_fsync(vp, cred);
693     afs_Trace3(afs_iclSetp, CM_TRACE_GFSYNC, ICL_TYPE_POINTER, vp,
694                ICL_TYPE_LONG, flags, ICL_TYPE_LONG, error);
695     return (error);
696 }
697
698
699 int
700 afs_gn_ftrunc(struct vnode *vp, 
701               int32long64_t flags, 
702               offset_t length, 
703               caddr_t vinfo, 
704               struct ucred *cred)
705 {
706     struct vattr va;
707     int error;
708
709     AFS_STATCNT(afs_gn_ftrunc);
710     VATTR_NULL(&va);
711     va.va_size = length;
712     error = afs_setattr(VTOAFS(vp), &va, cred);
713     afs_Trace4(afs_iclSetp, CM_TRACE_GFTRUNC, ICL_TYPE_POINTER, vp,
714                ICL_TYPE_LONG, flags, ICL_TYPE_OFFSET,
715                ICL_HANDLE_OFFSET(length), ICL_TYPE_LONG, error);
716     return (error);
717 }
718
719 /* Min size of a file which is dumping core before we declare it a page hog. */
720 #define MIN_PAGE_HOG_SIZE 8388608
721
722 int
723 afs_gn_rdwr(struct vnode *vp, 
724             enum uio_rw op, 
725             int32long64_t Flags, 
726             struct uio *ubuf, 
727             ext_t ext,                  /* Ignored in AFS */
728             caddr_t vinfo,              /* Ignored in AFS */
729             struct vattr *vattrp, 
730             struct ucred *cred)
731 {
732     struct vcache *vcp = VTOAFS(vp);
733     struct vrequest treq;
734     int error = 0;
735     int free_cred = 0;
736     int flags = Flags;
737
738     AFS_STATCNT(afs_gn_rdwr);
739
740     if (vcp->vc_error) {
741         if (op == UIO_WRITE) {
742             afs_Trace2(afs_iclSetp, CM_TRACE_GRDWR1, ICL_TYPE_POINTER, vp,
743                        ICL_TYPE_LONG, vcp->vc_error);
744             return vcp->vc_error;
745         } else
746             return EIO;
747     }
748
749     ObtainSharedLock(&vcp->lock, 507);
750     /*
751      * We keep the caller's credentials since an async daemon will handle the 
752      * request at some point. We assume that the same credentials will be used.
753      * If this is being called from an NFS server thread, then dupe the
754      * cred and only use that copy in calls and for the stach. 
755      */
756     if (!vcp->credp || (vcp->credp != cred)) {
757 #ifdef AFS_AIX_IAUTH_ENV
758         if (AFS_NFSXLATORREQ(cred)) {
759             /* Must be able to use cred later, so dupe it so that nfs server
760              * doesn't overwrite it's contents.
761              */
762             cred = crdup(cred);
763             free_cred = 1;
764         }
765 #endif
766         crhold(cred);           /* Bump refcount for reference in vcache */
767
768         if (vcp->credp) {
769             struct ucred *crp;
770             UpgradeSToWLock(&vcp->lock, 508);
771             crp = vcp->credp;
772             vcp->credp = NULL;
773             ConvertWToSLock(&vcp->lock);
774             crfree(crp);
775         }
776         vcp->credp = cred;
777     }
778     ReleaseSharedLock(&vcp->lock);
779
780     /*
781      * XXX Is the following really required?? XXX
782      */
783     if (error = afs_InitReq(&treq, cred))
784         return error;
785     if (error = afs_VerifyVCache(vcp, &treq))
786         return afs_CheckCode(error, &treq, 50);
787     osi_FlushPages(vcp, cred);  /* Flush old pages */
788
789     if (AFS_NFSXLATORREQ(cred)) {
790         if (flags & FSYNC)
791             flags &= ~FSYNC;
792         if (op == UIO_READ) {
793             if (!afs_AccessOK
794                 (vcp, PRSFS_READ, &treq,
795                  CHECK_MODE_BITS | CMB_ALLOW_EXEC_AS_READ)) {
796                 if (free_cred)
797                     crfree(cred);
798                 return EACCES;
799             }
800         }
801     }
802
803     /*
804      * We have to bump the open/exwriters field here courtesy of the nfs xlator
805      * because there're no open/close nfs rpcs to call our afs_open/close.
806      * We do a similar thing on the afs_read/write interface.
807      */
808     if (op == UIO_WRITE) {
809 #ifdef AFS_64BIT_CLIENT
810         if (ubuf->afsio_offset < afs_vmMappingEnd) {
811 #endif /* AFS_64BIT_CLIENT */
812             ObtainWriteLock(&vcp->lock, 240);
813             vcp->f.states |= CDirty;    /* Set the dirty bit */
814             afs_FakeOpen(vcp);
815             ReleaseWriteLock(&vcp->lock);
816 #ifdef AFS_64BIT_CLIENT
817         }
818 #endif /* AFS_64BIT_CLIENT */
819     }
820
821     error = afs_vm_rdwr(vp, ubuf, op, flags, cred);
822
823     if (op == UIO_WRITE) {
824 #ifdef AFS_64BIT_CLIENT
825         if (ubuf->afsio_offset < afs_vmMappingEnd) {
826 #endif /* AFS_64BIT_CLIENT */
827             ObtainWriteLock(&vcp->lock, 241);
828             afs_FakeClose(vcp, cred);   /* XXXX For nfs trans and cores XXXX */
829             ReleaseWriteLock(&vcp->lock);
830 #ifdef AFS_64BIT_CLIENT
831         }
832 #endif /* AFS_64BIT_CLIENT */
833     }
834     if (vattrp != NULL && error == 0)
835         afs_gn_getattr(vp, vattrp, cred);
836
837     afs_Trace4(afs_iclSetp, CM_TRACE_GRDWR, ICL_TYPE_POINTER, vp,
838                ICL_TYPE_LONG, flags, ICL_TYPE_LONG, op, ICL_TYPE_LONG, error);
839
840     if (free_cred)
841         crfree(cred);
842     return (error);
843 }
844
845 #define AFS_MAX_VM_CHUNKS 10
846 static int
847 afs_vm_rdwr(struct vnode *vp, 
848             struct uio *uiop, 
849             enum uio_rw rw, 
850             int ioflag, 
851             struct ucred *credp)
852 {
853     afs_int32 code = 0;
854     int i;
855     afs_int32 blockSize;
856     afs_size_t fileSize, xfrOffset, offset, old_offset, xfrSize;
857     vmsize_t txfrSize;
858 #ifdef AFS_64BIT_CLIENT
859     afs_size_t finalOffset;
860     off_t toffset;
861     int mixed = 0;
862     afs_size_t add2resid = 0;
863 #endif /* AFS_64BIT_CLIENT */
864     struct vcache *vcp = VTOAFS(vp);
865     struct dcache *tdc;
866     afs_size_t start_offset;
867     afs_int32 save_resid = uiop->afsio_resid;
868     int first_page, last_page, pages;
869     int count, len;
870     int counter = 0;
871     struct vrequest treq;
872
873     if (code = afs_InitReq(&treq, credp))
874         return code;
875
876     /* special case easy transfer; apparently a lot are done */
877     if ((xfrSize = uiop->afsio_resid) == 0)
878         return 0;
879
880     ObtainReadLock(&vcp->lock);
881     fileSize = vcp->f.m.Length;
882     if (rw == UIO_WRITE && (ioflag & IO_APPEND)) {      /* handle IO_APPEND mode */
883         uiop->afsio_offset = fileSize;
884     }
885     /* compute xfrOffset now, and do some checks */
886     xfrOffset = uiop->afsio_offset;
887     if (xfrOffset < 0 || xfrOffset + xfrSize < 0) {
888         code = EINVAL;
889         ReleaseReadLock(&vcp->lock);
890         goto fail;
891     }
892 #ifndef AFS_64BIT_CLIENT
893     /* check for "file too big" error, which should really be done above us */
894     if (rw == UIO_WRITE && xfrSize + fileSize > get_ulimit()) {
895         code = EFBIG;
896         ReleaseReadLock(&vcp->lock);
897         goto fail;
898     }
899 #endif /* AFS_64BIT_CLIENT */
900
901 #ifdef AFS_64BIT_CLIENT
902     if (xfrOffset + xfrSize > afs_vmMappingEnd) {
903         if (rw == UIO_READ) {
904             /* don't read past EOF */
905             if (xfrSize+xfrOffset > fileSize) {
906                 add2resid = xfrSize + xfrOffset - fileSize;
907                 xfrSize = fileSize - xfrOffset;
908                 if (xfrSize <= 0) {
909                     ReleaseReadLock(&vcp->lock);
910                     goto fail;
911                 }
912                 txfrSize = xfrSize;
913                 afsio_trim(uiop, txfrSize);
914             }
915         }
916         if (xfrOffset < afs_vmMappingEnd) {
917             /* special case of a buffer crossing the VM mapping line */
918             struct uio tuio;
919             struct iovec tvec[16];      /* Should have access to #define */
920             afs_int32 tsize;
921
922             mixed = 1;
923             finalOffset = xfrOffset + xfrSize;
924             tsize = (afs_size_t) (xfrOffset + xfrSize - afs_vmMappingEnd);
925             txfrSize = xfrSize;
926             afsio_copy(uiop, &tuio, tvec);
927             afsio_skip(&tuio, txfrSize - tsize);
928             afsio_trim(&tuio, tsize);
929             tuio.afsio_offset = afs_vmMappingEnd;
930             ReleaseReadLock(&vcp->lock);
931             ObtainWriteLock(&vcp->lock, 243);
932             afs_FakeClose(vcp, credp);  /* XXXX For nfs trans and cores XXXX */
933             ReleaseWriteLock(&vcp->lock);
934             code = afs_direct_rdwr(vp, &tuio, rw, ioflag, credp);
935             ObtainWriteLock(&vcp->lock, 244);
936             afs_FakeOpen(vcp);  /* XXXX For nfs trans and cores XXXX */
937             ReleaseWriteLock(&vcp->lock);
938             if (code)
939                 goto fail;
940             ObtainReadLock(&vcp->lock);
941             xfrSize = afs_vmMappingEnd - xfrOffset;
942             txfrSize = xfrSize;
943             afsio_trim(uiop, txfrSize);
944         } else {
945             ReleaseReadLock(&vcp->lock);
946             code = afs_direct_rdwr(vp, uiop, rw, ioflag, credp);
947             uiop->uio_resid += add2resid;
948             return code;
949         }
950     }
951 #endif /* AFS_64BIT_CLIENT */
952
953     if (!vcp->segid) {
954         afs_uint32 tlen = vcp->f.m.Length;
955 #ifdef AFS_64BIT_CLIENT
956         if (vcp->f.m.Length > afs_vmMappingEnd)
957             tlen = afs_vmMappingEnd;
958 #endif
959         /* Consider  V_INTRSEG too for interrupts */
960         if (code =
961             vms_create(&vcp->segid, V_CLIENT, (dev_t) vcp->v.v_gnode, tlen, 0, 0)) {
962             ReleaseReadLock(&vcp->lock);
963             goto fail;
964         }
965 #ifdef AFS_64BIT_KERNEL
966         vcp->vmh = vm_handle(vcp->segid, (int32long64_t) 0);
967 #else
968         vcp->vmh = SRVAL(vcp->segid, 0, 0);
969 #endif
970     }
971     vcp->v.v_gnode->gn_seg = vcp->segid;
972     if (rw == UIO_READ) {
973         ReleaseReadLock(&vcp->lock);
974         /* don't read past EOF */
975         if (xfrSize + xfrOffset > fileSize)
976             xfrSize = fileSize - xfrOffset;
977         if (xfrSize <= 0)
978             goto fail;
979 #ifdef AFS_64BIT_CLIENT
980         toffset = xfrOffset;
981         uiop->afsio_offset = xfrOffset;
982         afs_Trace3(afs_iclSetp, CM_TRACE_VMWRITE, ICL_TYPE_POINTER, vcp,
983                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(xfrOffset),
984                    ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(xfrSize));
985         AFS_GUNLOCK();
986         txfrSize = xfrSize;
987         code = vm_move(vcp->segid, toffset, txfrSize, rw, uiop);
988 #else /* AFS_64BIT_CLIENT */
989         AFS_GUNLOCK();
990         code = vm_move(vcp->segid, xfrOffset, xfrSize, rw, uiop);
991 #endif /* AFS_64BIT_CLIENT */
992         AFS_GLOCK();
993         /*
994          * If at a chunk boundary and staying within chunk,
995          * start prefetch of next chunk.
996          */
997         if (counter == 0 || AFS_CHUNKOFFSET(xfrOffset) == 0
998             && xfrSize <= AFS_CHUNKSIZE(xfrOffset)) {
999             ObtainWriteLock(&vcp->lock, 407);
1000             tdc = afs_FindDCache(vcp, xfrOffset);
1001             if (tdc) {
1002                 if (!(tdc->mflags & DFNextStarted))
1003                     afs_PrefetchChunk(vcp, tdc, credp, &treq);
1004                 afs_PutDCache(tdc);
1005             }
1006             ReleaseWriteLock(&vcp->lock);
1007         }
1008 #ifdef AFS_64BIT_CLIENT
1009         if (mixed) {
1010             uiop->afsio_offset = finalOffset;
1011         }
1012         uiop->uio_resid += add2resid;
1013 #endif /* AFS_64BIT_CLIENT */
1014         return code;
1015     }
1016
1017     /* UIO_WRITE */
1018     start_offset = uiop->afsio_offset;
1019     afs_Trace3(afs_iclSetp, CM_TRACE_VMWRITE, ICL_TYPE_POINTER, vcp,
1020                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(start_offset),
1021                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(xfrSize));
1022     ReleaseReadLock(&vcp->lock);
1023     ObtainWriteLock(&vcp->lock, 400);
1024     vcp->f.m.Date = osi_Time(); /* Set file date (for ranlib) */
1025     /* extend file */
1026     /* un-protect last page. */
1027     last_page = vcp->f.m.Length / PAGESIZE;
1028 #ifdef AFS_64BIT_CLIENT
1029     if (vcp->f.m.Length > afs_vmMappingEnd)
1030         last_page = afs_vmMappingEnd / PAGESIZE;
1031 #endif
1032     vm_protectp(vcp->segid, last_page, 1, FILEKEY);
1033     if (xfrSize + xfrOffset > fileSize) {
1034         vcp->f.m.Length = xfrSize + xfrOffset;
1035     }
1036     if ((!(vcp->f.states & CPageHog)) && (xfrSize >= MIN_PAGE_HOG_SIZE)) {
1037         vmPageHog++;
1038         vcp->f.states |= CPageHog;
1039     }
1040     ReleaseWriteLock(&vcp->lock);
1041
1042     /* If the write will fit into a single chunk we'll write all of it
1043      * at once. Otherwise, we'll write one chunk at a time, flushing
1044      * some of it to disk.
1045      */
1046     count = 0;
1047
1048     /* Only create a page to avoid excess VM access if we're writing a
1049      * small file which is either new or completely overwrites the 
1050      * existing file.
1051      */
1052     if ((xfrOffset == 0) && (xfrSize < PAGESIZE) && (xfrSize >= fileSize)
1053         && (vcp->v.v_gnode->gn_mwrcnt == 0)
1054         && (vcp->v.v_gnode->gn_mrdcnt == 0)) {
1055         (void)vm_makep(vcp->segid, 0);
1056     }
1057
1058     while (xfrSize > 0) {
1059         offset = AFS_CHUNKBASE(xfrOffset);
1060         len = xfrSize;
1061
1062         if (AFS_CHUNKSIZE(xfrOffset) <= len)
1063             len =
1064                 (afs_size_t) AFS_CHUNKSIZE(xfrOffset) - (xfrOffset - offset);
1065
1066         if (len == xfrSize) {
1067             /* All data goes to this one chunk. */
1068             AFS_GUNLOCK();
1069             old_offset = uiop->afsio_offset;
1070 #ifdef AFS_64BIT_CLIENT
1071             uiop->afsio_offset = xfrOffset;
1072             toffset = xfrOffset;
1073             txfrSize = xfrSize;
1074             code = vm_move(vcp->segid, toffset, txfrSize, rw, uiop);
1075 #else /* AFS_64BIT_CLIENT */
1076             code = vm_move(vcp->segid, xfrOffset, xfrSize, rw, uiop);
1077 #endif /* AFS_64BIT_CLIENT */
1078             AFS_GLOCK();
1079             if (code) {
1080                 goto fail;
1081             }
1082             xfrOffset += len;
1083             xfrSize = 0;
1084         } else {
1085             /* Write just one chunk's worth of data. */
1086             struct uio tuio;
1087             struct iovec tvec[16];      /* Should have access to #define */
1088
1089             /* Purge dirty chunks of file if there are too many dirty chunks.
1090              * Inside the write loop, we only do this at a chunk boundary.
1091              * Clean up partial chunk if necessary at end of loop.
1092              */
1093             if (counter > 0 && code == 0 && xfrOffset == offset) {
1094                 ObtainWriteLock(&vcp->lock, 403);
1095                 if (xfrOffset > vcp->f.m.Length)
1096                     vcp->f.m.Length = xfrOffset;
1097                 code = afs_DoPartialWrite(vcp, &treq);
1098                 vcp->f.states |= CDirty;
1099                 ReleaseWriteLock(&vcp->lock);
1100                 if (code) {
1101                     goto fail;
1102                 }
1103             }
1104             counter++;
1105
1106             afsio_copy(uiop, &tuio, tvec);
1107             afsio_trim(&tuio, len);
1108             tuio.afsio_offset = xfrOffset;
1109
1110             AFS_GUNLOCK();
1111             old_offset = uiop->afsio_offset;
1112 #ifdef AFS_64BIT_CLIENT
1113             toffset = xfrOffset;
1114             code = vm_move(vcp->segid, toffset, len, rw, &tuio);
1115 #else /* AFS_64BIT_CLIENT */
1116             code = vm_move(vcp->segid, xfrOffset, len, rw, &tuio);
1117 #endif /* AFS_64BIT_CLIENT */
1118             AFS_GLOCK();
1119             len -= tuio.afsio_resid;
1120             if (code || (len <= 0)) {
1121                 code = code ? code : EINVAL;
1122                 goto fail;
1123             }
1124             afsio_skip(uiop, len);
1125             xfrSize -= len;
1126             xfrOffset += len;
1127         }
1128
1129         first_page = (afs_size_t) old_offset >> PGSHIFT;
1130         pages =
1131             1 + (((afs_size_t) old_offset + (len - 1)) >> PGSHIFT) -
1132             first_page;
1133         afs_Trace3(afs_iclSetp, CM_TRACE_VMWRITE2, ICL_TYPE_POINTER, vcp,
1134                    ICL_TYPE_INT32, first_page, ICL_TYPE_INT32, pages);
1135         AFS_GUNLOCK();
1136         code = vm_writep(vcp->segid, first_page, pages);
1137         if (code) {
1138             AFS_GLOCK();
1139             goto fail;
1140         }
1141         if (++count > AFS_MAX_VM_CHUNKS) {
1142             count = 0;
1143             code = vms_iowait(vcp->segid);
1144             if (code) {
1145                 /* cache device failure? */
1146                 AFS_GLOCK();
1147                 goto fail;
1148             }
1149         }
1150         AFS_GLOCK();
1151
1152     }
1153
1154     if (count) {
1155         AFS_GUNLOCK();
1156         code = vms_iowait(vcp->segid);
1157         AFS_GLOCK();
1158         if (code) {
1159             /* cache device failure? */
1160             goto fail;
1161         }
1162     }
1163
1164     ObtainWriteLock(&vcp->lock, 242);
1165     if (code == 0 && (vcp->f.states & CDirty)) {
1166         code = afs_DoPartialWrite(vcp, &treq);
1167     }
1168     vm_protectp(vcp->segid, last_page, 1, RDONLY);
1169     ReleaseWriteLock(&vcp->lock);
1170
1171     /* If requested, fsync the file after every write */
1172     if (ioflag & FSYNC)
1173         afs_fsync(vp, credp);
1174
1175     ObtainReadLock(&vcp->lock);
1176     if (vcp->vc_error) {
1177         /* Pretend we didn't write anything. We need to get the error back to
1178          * the user. If we don't it's possible for a quota error for this
1179          * write to succeed and the file to be closed without the user ever
1180          * having seen the store error. And AIX syscall clears the error if
1181          * anything was written.
1182          */
1183         code = vcp->vc_error;
1184         if (code == EDQUOT || code == ENOSPC)
1185             uiop->afsio_resid = save_resid;
1186     }
1187 #ifdef AFS_64BIT_CLIENT
1188     if (mixed) {
1189         uiop->afsio_offset = finalOffset;
1190     }
1191 #endif /* AFS_64BIT_CLIENT */
1192     ReleaseReadLock(&vcp->lock);
1193
1194   fail:
1195     afs_Trace2(afs_iclSetp, CM_TRACE_VMWRITE3, ICL_TYPE_POINTER, vcp,
1196                ICL_TYPE_INT32, code);
1197     return code;
1198 }
1199
1200
1201 static int
1202 afs_direct_rdwr(struct vnode *vp, 
1203                 struct uio *uiop, 
1204                 enum uio_rw rw, 
1205                 int ioflag, 
1206                 struct ucred *credp)
1207 {
1208     afs_int32 code = 0;
1209     afs_size_t fileSize, xfrOffset, offset, old_offset, xfrSize;
1210     struct vcache *vcp = VTOAFS(vp);
1211     afs_int32 save_resid = uiop->afsio_resid;
1212     struct vrequest treq;
1213
1214     if (code = afs_InitReq(&treq, credp))
1215         return code;
1216
1217     /* special case easy transfer; apparently a lot are done */
1218     if ((xfrSize = uiop->afsio_resid) == 0)
1219         return 0;
1220
1221     ObtainReadLock(&vcp->lock);
1222     fileSize = vcp->f.m.Length;
1223     if (rw == UIO_WRITE && (ioflag & IO_APPEND)) {      /* handle IO_APPEND mode */
1224         uiop->afsio_offset = fileSize;
1225     }
1226     /* compute xfrOffset now, and do some checks */
1227     xfrOffset = uiop->afsio_offset;
1228     if (xfrOffset < 0 || xfrOffset + xfrSize < 0) {
1229         code = EINVAL;
1230         ReleaseReadLock(&vcp->lock);
1231         goto fail;
1232     }
1233
1234     /* check for "file too big" error, which should really be done above us */
1235 #ifdef notdef
1236     if (rw == UIO_WRITE && xfrSize + fileSize > get_ulimit()) {
1237         code = EFBIG;
1238         ReleaseReadLock(&vcp->lock);
1239         goto fail;
1240     }
1241 #endif
1242     ReleaseReadLock(&vcp->lock);
1243     if (rw == UIO_WRITE) {
1244         ObtainWriteLock(&vcp->lock, 400);
1245         vcp->f.m.Date = osi_Time();     /* Set file date (for ranlib) */
1246         /* extend file */
1247         if (xfrSize + xfrOffset > fileSize)
1248             vcp->f.m.Length = xfrSize + xfrOffset;
1249         ReleaseWriteLock(&vcp->lock);
1250     }
1251     afs_Trace3(afs_iclSetp, CM_TRACE_DIRECTRDWR, ICL_TYPE_POINTER, vp,
1252                ICL_TYPE_OFFSET, ICL_HANDLE_OFFSET(uiop->afsio_offset),
1253                ICL_TYPE_LONG, uiop->afsio_resid);
1254     code = afs_rdwr(VTOAFS(vp), uiop, rw, ioflag, credp);
1255     if (code != 0) {
1256         uiop->afsio_resid = save_resid;
1257     } else {
1258         uiop->afsio_offset = xfrOffset + xfrSize;
1259         if (uiop->afsio_resid > 0) {
1260             /* should zero here the remaining buffer */
1261             uiop->afsio_resid = 0;
1262         }
1263         /* Purge dirty chunks of file if there are too many dirty chunks.
1264          * Inside the write loop, we only do this at a chunk boundary.
1265          * Clean up partial chunk if necessary at end of loop.
1266          */
1267         if (AFS_CHUNKBASE(uiop->afsio_offset) != AFS_CHUNKBASE(xfrOffset)) {
1268             ObtainWriteLock(&vcp->lock, 402);
1269             code = afs_DoPartialWrite(vcp, &treq);
1270             vcp->f.states |= CDirty;
1271             ReleaseWriteLock(&vcp->lock);
1272         }
1273     }
1274
1275   fail:
1276     return code;
1277 }
1278
1279
1280 static int
1281 lock_normalize(struct vnode *vp, 
1282                struct flock *lckdat, 
1283                offset_t offset, 
1284                struct ucred *cred)
1285 {
1286     struct vattr vattr;
1287     int code;
1288
1289     switch (lckdat->l_whence) {
1290     case 0:
1291         return 0;
1292     case 1:
1293         lckdat->l_start += (off_t) offset;
1294         break;
1295     case 2:
1296         code = afs_getattr(VTOAFS(vp), &vattr, cred);
1297         if (code != 0)
1298             return code;
1299         lckdat->l_start += (off_t) vattr.va_size;
1300         break;
1301     default:
1302         return EINVAL;
1303     }
1304     lckdat->l_whence = 0;
1305     return 0;
1306 }
1307
1308
1309
1310 int
1311 afs_gn_lockctl(struct vnode *vp, 
1312                offset_t offset, 
1313                struct eflock *lckdat, 
1314                int32long64_t cmd, 
1315                int (*ignored_fcn) (),
1316 #ifdef AFS_AIX52_ENV /* Changed in AIX 5.2 and up */
1317                ulong * ignored_id, 
1318 #else /* AFS_AIX52_ENV */
1319                ulong32int64_t * ignored_id,
1320 #endif /* AFS_AIX52_ENV */
1321                struct ucred *cred)
1322 {
1323     int error, ncmd = 0;
1324     struct flock flkd;
1325     struct vattr *attrs;
1326
1327     AFS_STATCNT(afs_gn_lockctl);
1328     /* Convert from AIX's cmd to standard lockctl lock types... */
1329     if (cmd == 0)
1330         ncmd = F_GETLK;
1331     else if (cmd & SETFLCK) {
1332         ncmd = F_SETLK;
1333         if (cmd & SLPFLCK)
1334             ncmd = F_SETLKW;
1335     }
1336     flkd.l_type = lckdat->l_type;
1337     flkd.l_whence = lckdat->l_whence;
1338     flkd.l_start = lckdat->l_start;
1339     flkd.l_len = lckdat->l_len;
1340     flkd.l_pid = lckdat->l_pid;
1341     flkd.l_sysid = lckdat->l_sysid;
1342
1343     if (flkd.l_start != lckdat->l_start || flkd.l_len != lckdat->l_len)
1344         return EINVAL;
1345     if (error = lock_normalize(vp, &flkd, offset, cred))
1346         return (error);
1347     error = afs_lockctl(vp, &flkd, ncmd, cred);
1348     lckdat->l_type = flkd.l_type;
1349     lckdat->l_whence = flkd.l_whence;
1350     lckdat->l_start = flkd.l_start;
1351     lckdat->l_len = flkd.l_len;
1352     lckdat->l_pid = flkd.l_pid;
1353     lckdat->l_sysid = flkd.l_sysid;
1354     afs_Trace3(afs_iclSetp, CM_TRACE_GLOCKCTL, ICL_TYPE_POINTER, vp,
1355                ICL_TYPE_LONG, ncmd, ICL_TYPE_LONG, error);
1356     return (error);
1357 }
1358
1359
1360 /* NOTE: In the nfs glue routine (nfs_gn2sun.c) the order was wrong (vp, flags, cmd, arg, ext); was that another typo? */
1361 int
1362 afs_gn_ioctl(struct vnode *vp, 
1363              int32long64_t Cmd, 
1364              caddr_t arg, 
1365              size_t flags,              /* Ignored in AFS */
1366              ext_t ext,                 /* Ignored in AFS */
1367              struct ucred *crp)         /* Ignored in AFS */
1368 {
1369     int error;
1370     int cmd = Cmd;
1371
1372     AFS_STATCNT(afs_gn_ioctl);
1373     /* This seems to be a perfect fit for our ioctl redirection (afs_xioctl hack); thus the ioctl(2) entry in sysent.c is unaffected in the aix/afs port. */
1374     error = afs_ioctl(vp, cmd, arg);
1375     afs_Trace3(afs_iclSetp, CM_TRACE_GIOCTL, ICL_TYPE_POINTER, vp,
1376                ICL_TYPE_LONG, cmd, ICL_TYPE_LONG, error);
1377     return (error);
1378 }
1379
1380
1381 int
1382 afs_gn_readlink(struct vnode *vp, 
1383                 struct uio *uiop, 
1384                 struct ucred *cred)
1385 {
1386     int error;
1387
1388     AFS_STATCNT(afs_gn_readlink);
1389     error = afs_readlink(vp, uiop, cred);
1390     afs_Trace2(afs_iclSetp, CM_TRACE_GREADLINK, ICL_TYPE_POINTER, vp,
1391                ICL_TYPE_LONG, error);
1392     return (error);
1393 }
1394
1395
1396 int
1397 afs_gn_select(struct vnode *vp, 
1398               int32long64_t correl,
1399               ushort e,
1400               ushort *re,
1401               void (* notify)(),
1402               caddr_t vinfo,
1403               struct ucred *crp)
1404 {
1405     AFS_STATCNT(afs_gn_select);
1406     /* NO SUPPORT for this in afs YET! */
1407     return (EOPNOTSUPP);
1408 }
1409
1410
1411 int
1412 afs_gn_symlink(struct vnode *vp, 
1413                char *link, 
1414                char *target, 
1415                struct ucred *cred)
1416 {
1417     struct vattr va;
1418     int error;
1419
1420     AFS_STATCNT(afs_gn_symlink);
1421     VATTR_NULL(&va);
1422     va.va_mode = 0777;
1423     error = afs_symlink(vp, link, &va, target, NULL, cred);
1424     afs_Trace4(afs_iclSetp, CM_TRACE_GSYMLINK, ICL_TYPE_POINTER, vp,
1425                ICL_TYPE_STRING, link, ICL_TYPE_STRING, target, ICL_TYPE_LONG,
1426                error);
1427     return (error);
1428 }
1429
1430
1431 int
1432 afs_gn_readdir(struct vnode *vp, 
1433                struct uio *uiop, 
1434                struct ucred *cred)
1435 {
1436     int error;
1437
1438     AFS_STATCNT(afs_gn_readdir);
1439     error = afs_readdir(vp, uiop, cred);
1440     afs_Trace2(afs_iclSetp, CM_TRACE_GREADDIR, ICL_TYPE_POINTER, vp,
1441                ICL_TYPE_LONG, error);
1442     return (error);
1443 }
1444
1445
1446 extern Simple_lock afs_asyncbuf_lock;
1447 extern struct buf *afs_asyncbuf;
1448 extern int afs_asyncbuf_cv;
1449
1450 /*
1451  * Buffers are ranked by age.  A buffer's age is the value of afs_biotime
1452  * when the buffer is processed by afs_gn_strategy.  afs_biotime is
1453  * incremented for each buffer.  A buffer's age is kept in its av_back field.
1454  * The age ranking is used by the daemons, which favor older buffers.
1455  */
1456 afs_int32 afs_biotime = 0;
1457
1458 /* This function is called with a list of buffers, threaded through
1459  * the av_forw field.  Our goal is to copy the list of buffers into the
1460  * afs_asyncbuf list, sorting buffers into sublists linked by the b_work field.
1461  * Within buffers within the same work group, the guy with the lowest address
1462  * has to be located at the head of the queue; his b_bcount field will also
1463  * be increased to cover all of the buffers in the b_work queue.
1464  */
1465 #define AIX_VM_BLKSIZE  8192
1466 /* Note: This function seems to be called as ddstrategy entry point, ie
1467  * has one argument. However, it also needs to be present as
1468  * vn_strategy entry point which has three arguments, but it seems to never
1469  * be called in that capacity (it would fail horribly due to the argument
1470  * mismatch). I'm confused, but it obviously has to be this way, maybe
1471  * some IBM people can shed som light on this 
1472  */
1473 int
1474 afs_gn_strategy(struct buf *abp)
1475 {
1476     struct buf **lbp, *tbp;
1477     struct buf **lwbp;
1478     struct buf *nbp, *qbp, *qnbp, *firstComparable;
1479     int doMerge;
1480     int oldPriority;
1481
1482 #define EFS_COMPARABLE(x,y)     ((x)->b_vp == (y)->b_vp \
1483                                  && (x)->b_xmemd.subspace_id == (y)->b_xmemd.subspace_id \
1484                                  && (x)->b_flags == (y)->b_flags \
1485                                  && !((x)->b_flags & B_PFPROT) \
1486                                  && !((y)->b_flags & B_PFPROT))
1487
1488     oldPriority = disable_lock(INTMAX, &afs_asyncbuf_lock);
1489     for (tbp = abp; tbp; tbp = nbp) {
1490         nbp = tbp->av_forw;     /* remember for later */
1491         tbp->b_work = 0;
1492         tbp->av_back = (struct buf *)afs_biotime++;
1493
1494         /* first insert the buffer into the afs_async queue.  Insert buffer
1495          * sorted within its disk position within a set of comparable buffers.
1496          * Ensure that all comparable buffers are grouped contiguously.
1497          * Later on, we'll merge adjacent buffers into a single request.
1498          */
1499         firstComparable = NULL;
1500         lbp = &afs_asyncbuf;
1501         for (qbp = *lbp; qbp; lbp = &qbp->av_forw, qbp = *lbp) {
1502             if (EFS_COMPARABLE(tbp, qbp)) {
1503                 if (!firstComparable)
1504                     firstComparable = qbp;
1505                 /* this buffer is comparable, so see if the next buffer
1506                  * is farther in the file; if it is insert before next buffer.
1507                  */
1508                 if (tbp->b_blkno < qbp->b_blkno) {
1509                     break;
1510                 }
1511             } else {
1512                 /* If we're at the end of a block of comparable buffers, we
1513                  * insert the buffer here to keep all comparable buffers
1514                  * contiguous.
1515                  */
1516                 if (firstComparable)
1517                     break;
1518             }
1519         }
1520         /* do the insert before qbp now */
1521         tbp->av_forw = *lbp;
1522         *lbp = tbp;
1523         if (firstComparable == NULL) {
1524             /* next we're going to do all sorts of buffer merging tricks, but
1525              * here we know we're the only COMPARABLE block in the
1526              * afs_asyncbuf list, so we just skip that and continue with
1527              * the next input buffer.
1528              */
1529             continue;
1530         }
1531
1532         /* we may have actually added the "new" firstComparable */
1533         if (tbp->av_forw == firstComparable)
1534             firstComparable = tbp;
1535         /*
1536          * when we get here, firstComparable points to the first dude in the
1537          * same vnode and subspace that we (tbp) are in.  We go through the
1538          * area of this list with COMPARABLE buffers (a contiguous region) and
1539          * repeated merge buffers that are contiguous and in the same block or
1540          * buffers that are contiguous and are both integral numbers of blocks.
1541          * Note that our end goal is to have as big blocks as we can, but we
1542          * must minimize the transfers that are not integral #s of blocks on
1543          * block boundaries, since Episode will do those smaller and/or
1544          * unaligned I/Os synchronously.
1545          *
1546          * A useful example to consider has the async queue with this in it:
1547          * [8K block, 2 pages] [4K block, 1 page] [4K hole] [8K block, 2 pages]
1548          * If we get a request that fills the 4K hole, we want to merge this
1549          * whole mess into a 24K, 6 page transfer.  If we don't, however, we
1550          * don't want to do any merging since adding the 4K transfer to the 8K
1551          * transfer makes the 8K transfer synchronous.
1552          *
1553          * Note that if there are any blocks whose size is a multiple of
1554          * the file system block size, then we know that such blocks are also
1555          * on block boundaries.
1556          */
1557
1558         doMerge = 1;            /* start the loop */
1559         while (doMerge) {       /* loop until an iteration doesn't
1560                                  * make any more changes */
1561             doMerge = 0;
1562             for (qbp = firstComparable;; qbp = qnbp) {
1563                 qnbp = qbp->av_forw;
1564                 if (!qnbp)
1565                     break;      /* we're done */
1566                 if (!EFS_COMPARABLE(qbp, qnbp))
1567                     break;
1568
1569                 /* try to merge qbp and qnbp */
1570
1571                 /* first check if both not adjacent go on to next region */
1572                 if ((dbtob(qbp->b_blkno) + qbp->b_bcount) !=
1573                     dbtob(qnbp->b_blkno))
1574                     continue;
1575
1576                 /* note if both in the same block, the first byte of leftmost guy
1577                  * and last byte of rightmost guy are in the same block.
1578                  */
1579                 if ((dbtob(qbp->b_blkno) & ~(AIX_VM_BLKSIZE - 1)) ==
1580                     ((dbtob(qnbp->b_blkno) + qnbp->b_bcount -
1581                       1) & ~(AIX_VM_BLKSIZE - 1))) {
1582                     doMerge = 1;        /* both in same block */
1583                 } else if ((qbp->b_bcount & (AIX_VM_BLKSIZE - 1)) == 0
1584                            && (qnbp->b_bcount & (AIX_VM_BLKSIZE - 1)) == 0) {
1585                     doMerge = 1;        /* both integral #s of blocks */
1586                 }
1587                 if (doMerge) {
1588                     struct buf *xbp;
1589
1590                     /* merge both of these blocks together */
1591                     /* first set age to the older of the two */
1592                     if ((int32long64_t) qnbp->av_back - 
1593                             (int32long64_t) qbp->av_back < 0) {
1594                         qbp->av_back = qnbp->av_back;
1595                     }
1596                     lwbp = (struct buf **) &qbp->b_work;
1597                     /* find end of qbp's work queue */
1598                     for (xbp = *lwbp; xbp;
1599                          lwbp = (struct buf **) &xbp->b_work, xbp = *lwbp);
1600                     /*
1601                      * now setting *lwbp will change the last ptr in the qbp's
1602                      * work chain
1603                      */
1604                     qbp->av_forw = qnbp->av_forw;       /* splice out qnbp */
1605                     qbp->b_bcount += qnbp->b_bcount;    /* fix count */
1606                     *lwbp = qnbp;       /* append qnbp to end */
1607                     /*
1608                      * note that qnbp is bogus, but it doesn't matter because
1609                      * we're going to restart the for loop now.
1610                      */
1611                     break;      /* out of the for loop */
1612                 }
1613             }
1614         }
1615     }                           /* for loop for all interrupt data */
1616     /* at this point, all I/O has been queued.  Wakeup the daemon */
1617     e_wakeup_one((int *)&afs_asyncbuf_cv);
1618     unlock_enable(oldPriority, &afs_asyncbuf_lock);
1619     return 0;
1620 }
1621
1622
1623 int
1624 afs_inactive(struct vcache *avc, 
1625              afs_ucred_t *acred)
1626 {
1627     afs_InactiveVCache(avc, acred);
1628 }
1629
1630 int
1631 afs_gn_revoke(struct vnode *vp,
1632               int32long64_t cmd,
1633               int32long64_t flag,
1634               struct vattr *vinfop,
1635               struct ucred *crp)
1636 {
1637     AFS_STATCNT(afs_gn_revoke);
1638     /* NO SUPPORT for this in afs YET! */
1639     return (EOPNOTSUPP);
1640 }
1641
1642 int
1643 afs_gn_getacl(struct vnode *vp, 
1644               struct uio *uiop, 
1645               struct ucred *cred)
1646 {
1647     return ENOSYS;
1648 };
1649
1650
1651 int
1652 afs_gn_setacl(struct vnode *vp, 
1653               struct uio *uiop, 
1654               struct ucred *cred)
1655 {
1656     return ENOSYS;
1657 };
1658
1659
1660 int
1661 afs_gn_getpcl(struct vnode *vp, 
1662               struct uio *uiop, 
1663               struct ucred *cred)
1664 {
1665     return ENOSYS;
1666 };
1667
1668
1669 int
1670 afs_gn_setpcl(struct vnode *vp, 
1671               struct uio *uiop, 
1672               struct ucred *cred)
1673 {
1674     return ENOSYS;
1675 };
1676
1677
1678 int
1679 afs_gn_seek(struct vnode* vp, offset_t * offp, struct ucred * crp)
1680 {
1681 /*
1682  * File systems which do not wish to do offset validation can simply
1683  * return 0.  File systems which do not provide the vn_seek entry point
1684  * will have a maximum offset of OFF_MAX (2 gigabytes minus 1) enforced
1685  * by the logical file system.
1686  */
1687     return 0;
1688 }
1689
1690
1691 int
1692 afs_gn_enosys()
1693 {
1694     return ENOSYS;
1695 }
1696
1697 /*
1698  * declare a struct vnodeops and initialize it with ptrs to all functions
1699  */
1700 struct vnodeops afs_gn_vnodeops = {
1701     /* creation/naming/deletion */
1702     afs_gn_link,
1703     afs_gn_mkdir,
1704     afs_gn_mknod,
1705     afs_gn_remove,
1706     afs_gn_rename,
1707     afs_gn_rmdir,
1708     /* lookup, file handle stuff */
1709     afs_gn_lookup,
1710     (int(*)(struct vnode*,struct fileid*,struct ucred*))
1711         afs_gn_fid,
1712     /* access to files */
1713     (int(*)(struct vnode *, int32long64_t, ext_t, caddr_t *,struct ucred *))
1714         afs_gn_open,
1715     (int(*)(struct vnode *, struct vnode **, int32long64_t,caddr_t, int32long64_t, caddr_t *, struct ucred *))
1716         afs_gn_create,
1717     afs_gn_hold,
1718     afs_gn_rele,
1719     afs_gn_close,
1720     afs_gn_map,
1721     afs_gn_unmap,
1722     /* manipulate attributes of files */
1723     afs_gn_access,
1724     afs_gn_getattr,
1725     afs_gn_setattr,
1726     /* data update operations */
1727     afs_gn_fclear,
1728     afs_gn_fsync,
1729     afs_gn_ftrunc,
1730     afs_gn_rdwr,
1731     afs_gn_lockctl,
1732     /* extensions */
1733     afs_gn_ioctl,
1734     afs_gn_readlink,
1735     afs_gn_select,
1736     afs_gn_symlink,
1737     afs_gn_readdir,
1738     /* buffer ops */
1739     (int(*)(struct vnode*,struct buf*,struct ucred*))
1740         afs_gn_strategy,
1741     /* security things */
1742     afs_gn_revoke,
1743     afs_gn_getacl,
1744     afs_gn_setacl,
1745     afs_gn_getpcl,
1746     afs_gn_setpcl,
1747     afs_gn_seek,
1748     (int(*)(struct vnode *, int32long64_t, int32long64_t, offset_t, offset_t, struct ucred *))
1749         afs_gn_enosys,          /* vn_fsync_range */
1750     (int(*)(struct vnode *, struct vnode **, int32long64_t, char *, struct vattr *, int32long64_t, caddr_t *, struct ucred *))
1751         afs_gn_enosys,          /* vn_create_attr */
1752     (int(*)(struct vnode *, int32long64_t, void *, size_t, struct ucred *))
1753         afs_gn_enosys,          /* vn_finfo */
1754     (int(*)(struct vnode *, caddr_t, offset_t, offset_t, uint32long64_t, uint32long64_t, struct ucred *))
1755         afs_gn_enosys,          /* vn_map_lloff */
1756     (int(*)(struct vnode*,struct uio*,int*,struct ucred*))
1757         afs_gn_enosys,          /* vn_readdir_eofp */
1758     (int(*)(struct vnode *, enum uio_rw, int32long64_t, struct uio *, ext_t , caddr_t, struct vattr *, struct vattr *, struct ucred *))
1759         afs_gn_enosys,          /* vn_rdwr_attr */
1760     (int(*)(struct vnode*,int,void*,struct ucred*))
1761         afs_gn_enosys,          /* vn_memcntl */
1762 #ifdef AFS_AIX53_ENV /* Present in AIX 5.3 and up */
1763     (int(*)(struct vnode*,const char*,struct uio*,struct ucred*))
1764         afs_gn_enosys,          /* vn_getea */
1765     (int(*)(struct vnode*,const char*,struct uio*,int,struct ucred*))
1766         afs_gn_enosys,          /* vn_setea */
1767     (int(*)(struct vnode *, struct uio *, struct ucred *))
1768         afs_gn_enosys,          /* vn_listea */
1769     (int(*)(struct vnode *, const char *, struct ucred *))
1770         afs_gn_enosys,          /* vn_removeea */
1771     (int(*)(struct vnode *, const char *, struct vattr *, struct ucred *))
1772         afs_gn_enosys,          /* vn_statea */
1773     (int(*)(struct vnode *, uint64_t, acl_type_t *, struct uio *, size_t *, mode_t *, struct ucred *))
1774         afs_gn_enosys,          /* vn_getxacl */
1775     (int(*)(struct vnode *, uint64_t, acl_type_t, struct uio *, mode_t,  struct ucred *))
1776         afs_gn_enosys,          /* vn_setxacl */
1777 #else /* AFS_AIX53_ENV */
1778     afs_gn_enosys,              /* vn_spare7 */
1779     afs_gn_enosys,              /* vn_spare8 */
1780     afs_gn_enosys,              /* vn_spare9 */
1781     afs_gn_enosys,              /* vn_spareA */
1782     afs_gn_enosys,              /* vn_spareB */
1783     afs_gn_enosys,              /* vn_spareC */
1784     afs_gn_enosys,              /* vn_spareD */
1785 #endif /* AFS_AIX53_ENV */
1786     afs_gn_enosys,              /* vn_spareE */
1787     afs_gn_enosys               /* vn_spareF */
1788 #ifdef AFS_AIX51_ENV
1789     ,(int(*)(struct gnode*,long long,char*,unsigned long*, unsigned long*,unsigned int*))
1790         afs_gn_enosys,          /* pagerBackRange */
1791     (int64_t(*)(struct gnode*))
1792         afs_gn_enosys,          /* pagerGetFileSize */
1793     (void(*)(struct gnode *, vpn_t, vpn_t *, vpn_t *, vpn_t *, boolean_t))
1794         afs_gn_enosys,          /* pagerReadAhead */
1795     (void(*)(struct gnode *, int64_t, int64_t, uint))
1796         afs_gn_enosys,          /* pagerReadWriteBehind */
1797     (void(*)(struct gnode*,long long,unsigned long,unsigned long,unsigned int))
1798         afs_gn_enosys           /* pagerEndCopy */
1799 #endif
1800 };
1801 struct vnodeops *afs_ops = &afs_gn_vnodeops;
1802
1803
1804
1805 extern struct vfsops Afs_vfsops;
1806 extern int Afs_init();
1807
1808 #define AFS_CALLOUT_TBL_SIZE    256
1809
1810 /*
1811  * the following additional layer of gorp is due to the fact that the
1812  * filesystem layer no longer obtains the kernel lock for me.  I was relying
1813  * on this behavior to avoid having to think about locking.
1814  */
1815
1816 static
1817 vfs_mount(struct vfs *a, struct ucred *b)
1818 {
1819     int glockOwner, ret;
1820
1821     glockOwner = ISAFS_GLOCK();
1822     if (!glockOwner)
1823         AFS_GLOCK();
1824     ret = (*Afs_vfsops.vfs_mount) (a, b);
1825     if (!glockOwner)
1826         AFS_GUNLOCK();
1827
1828     return ret;
1829 }
1830
1831 static
1832 vfs_unmount(struct vfs *a, int b, struct ucred *c)
1833 {
1834     int glockOwner, ret;
1835
1836     glockOwner = ISAFS_GLOCK();
1837     if (!glockOwner)
1838         AFS_GLOCK();
1839     ret = (*Afs_vfsops.vfs_unmount) (a, b, c);
1840     if (!glockOwner)
1841         AFS_GUNLOCK();
1842
1843     return ret;
1844 }
1845
1846 static
1847 vfs_root(struct vfs *a, struct vnode **b, struct ucred *c)
1848 {
1849     int glockOwner, ret;
1850
1851     glockOwner = ISAFS_GLOCK();
1852     if (!glockOwner)
1853         AFS_GLOCK();
1854     ret = (*Afs_vfsops.vfs_root) (a, b, c);
1855     if (!glockOwner)
1856         AFS_GUNLOCK();
1857
1858     return ret;
1859 }
1860
1861 static
1862 vfs_statfs(struct vfs *a, struct statfs *b, struct ucred *c)
1863 {
1864     int glockOwner, ret;
1865
1866     glockOwner = ISAFS_GLOCK();
1867     if (!glockOwner)
1868         AFS_GLOCK();
1869     ret = (*Afs_vfsops.vfs_statfs) (a, b, c);
1870     if (!glockOwner)
1871         AFS_GUNLOCK();
1872
1873     return ret;
1874 }
1875
1876 static
1877 vfs_sync(struct gfs *a)
1878 {
1879     int glockOwner, ret;
1880
1881     glockOwner = ISAFS_GLOCK();
1882     if (!glockOwner)
1883         AFS_GLOCK();
1884     ret = (*Afs_vfsops.vfs_sync) (a);
1885     if (!glockOwner)
1886         AFS_GUNLOCK();
1887     return ret;
1888 }
1889
1890 static
1891 vfs_vget(struct vfs *a, struct vnode **b, struct fileid *c, struct ucred *d)
1892 {
1893     int glockOwner, ret;
1894
1895     glockOwner = ISAFS_GLOCK();
1896     if (!glockOwner)
1897         AFS_GLOCK();
1898     ret = (*Afs_vfsops.vfs_vget) (a, b, c, d);
1899     if (!glockOwner)
1900         AFS_GUNLOCK();
1901
1902     return ret;
1903 }
1904
1905 static
1906 vfs_cntl(struct vfs *a, int b, caddr_t c, size_t d, struct ucred *e)
1907 {
1908     int glockOwner, ret;
1909
1910     glockOwner = ISAFS_GLOCK();
1911     if (!glockOwner)
1912         AFS_GLOCK();
1913     ret = (*Afs_vfsops.vfs_cntl) (a, b, c, d, e);
1914     if (!glockOwner)
1915         AFS_GUNLOCK();
1916
1917     return ret;
1918 }
1919
1920 static
1921 vfs_quotactl(struct vfs *a, int b, uid_t c, caddr_t d, struct ucred *e)
1922 {
1923     int glockOwner, ret;
1924
1925     glockOwner = ISAFS_GLOCK();
1926     if (!glockOwner)
1927         AFS_GLOCK();
1928     ret = (*Afs_vfsops.vfs_quotactl) (a, b, c, d, e);
1929     if (!glockOwner)
1930         AFS_GUNLOCK();
1931
1932     return ret;
1933 }
1934
1935 #ifdef AFS_AIX51_ENV
1936 static
1937 vfs_syncvfs(struct gfs *a, struct vfs *b, int c, struct ucred *d)
1938 {
1939     int glockOwner, ret;
1940
1941     glockOwner = ISAFS_GLOCK();
1942     if (!glockOwner)
1943         AFS_GLOCK();
1944     ret = (*Afs_vfsops.vfs_syncvfs) (a, b, c, d);
1945     if (!glockOwner)
1946         AFS_GUNLOCK();
1947
1948     return ret;
1949 }
1950 #endif
1951
1952
1953 struct vfsops locked_Afs_vfsops = {
1954     vfs_mount,
1955     vfs_unmount,
1956     vfs_root,
1957     vfs_statfs,
1958     vfs_sync,
1959     vfs_vget,
1960     vfs_cntl,
1961     vfs_quotactl,
1962 #ifdef AFS_AIX51_ENV
1963     vfs_syncvfs
1964 #endif
1965 };
1966
1967 static
1968 vn_link(struct vnode *a, struct vnode *b, char *c, struct ucred *d)
1969 {
1970     int glockOwner, ret;
1971
1972     glockOwner = ISAFS_GLOCK();
1973     if (!glockOwner)
1974         AFS_GLOCK();
1975     ret = (*afs_gn_vnodeops.vn_link) (a, b, c, d);
1976     if (!glockOwner)
1977         AFS_GUNLOCK();
1978
1979     return ret;
1980 }
1981
1982 static
1983 vn_mkdir(struct vnode *a, char *b, int32long64_t c, struct ucred *d)
1984 {
1985     int glockOwner, ret;
1986
1987     glockOwner = ISAFS_GLOCK();
1988     if (!glockOwner)
1989         AFS_GLOCK();
1990     ret = (*afs_gn_vnodeops.vn_mkdir) (a, b, c, d);
1991     if (!glockOwner)
1992         AFS_GUNLOCK();
1993
1994     return ret;
1995 }
1996
1997 static
1998 vn_mknod(struct vnode *a, caddr_t b, int32long64_t c, dev_t d,
1999          struct ucred *e)
2000 {
2001     int glockOwner, ret;
2002
2003     glockOwner = ISAFS_GLOCK();
2004     if (!glockOwner)
2005         AFS_GLOCK();
2006     ret = (*afs_gn_vnodeops.vn_mknod) (a, b, c, d, e);
2007     if (!glockOwner)
2008         AFS_GUNLOCK();
2009
2010     return ret;
2011 }
2012
2013 static
2014 vn_remove(struct vnode *a, struct vnode *b, char *c, struct ucred *d)
2015 {
2016     int glockOwner, ret;
2017
2018     glockOwner = ISAFS_GLOCK();
2019     if (!glockOwner)
2020         AFS_GLOCK();
2021     ret = (*afs_gn_vnodeops.vn_remove) (a, b, c, d);
2022     if (!glockOwner)
2023         AFS_GUNLOCK();
2024
2025     return ret;
2026 }
2027
2028 static
2029 vn_rename(struct vnode *a, struct vnode *b, caddr_t c, struct vnode *d,
2030           struct vnode *e, caddr_t f, struct ucred *g)
2031 {
2032     int glockOwner, ret;
2033
2034     glockOwner = ISAFS_GLOCK();
2035     if (!glockOwner)
2036         AFS_GLOCK();
2037     ret = (*afs_gn_vnodeops.vn_rename) (a, b, c, d, e, f, g);
2038     if (!glockOwner)
2039         AFS_GUNLOCK();
2040
2041     return ret;
2042 }
2043
2044 static
2045 vn_rmdir(struct vnode *a, struct vnode *b, char *c, struct ucred *d)
2046 {
2047     int glockOwner, ret;
2048
2049     glockOwner = ISAFS_GLOCK();
2050     if (!glockOwner)
2051         AFS_GLOCK();
2052     ret = (*afs_gn_vnodeops.vn_rmdir) (a, b, c, d);
2053     if (!glockOwner)
2054         AFS_GUNLOCK();
2055
2056     return ret;
2057 }
2058
2059 static
2060 vn_lookup(struct vnode *a, struct vnode **b, char *c, int32long64_t d,
2061           struct vattr *v, struct ucred *e)
2062 {
2063     int glockOwner, ret;
2064
2065     glockOwner = ISAFS_GLOCK();
2066     if (!glockOwner)
2067         AFS_GLOCK();
2068     ret = (*afs_gn_vnodeops.vn_lookup) (a, b, c, d, v, e);
2069     if (!glockOwner)
2070         AFS_GUNLOCK();
2071
2072     return ret;
2073 }
2074
2075 static
2076 vn_fid(struct vnode *a, struct fileid *b, struct ucred *c)
2077 {
2078     int glockOwner, ret;
2079
2080     glockOwner = ISAFS_GLOCK();
2081     if (!glockOwner)
2082         AFS_GLOCK();
2083     ret = (*afs_gn_vnodeops.vn_fid) (a, b, c);
2084     if (!glockOwner)
2085         AFS_GUNLOCK();
2086
2087     return ret;
2088 }
2089
2090 static
2091 vn_open(struct vnode *a, 
2092         int32long64_t b, 
2093         ext_t c, 
2094         caddr_t * d, 
2095         struct ucred *e)
2096 {
2097     int glockOwner, ret;
2098
2099     glockOwner = ISAFS_GLOCK();
2100     if (!glockOwner)
2101         AFS_GLOCK();
2102     ret = (*afs_gn_vnodeops.vn_open) (a, b, c, d, e);
2103     if (!glockOwner)
2104         AFS_GUNLOCK();
2105
2106     return ret;
2107 }
2108
2109 static
2110 vn_create(struct vnode *a, struct vnode **b, int32long64_t c, caddr_t d,
2111           int32long64_t e, caddr_t * f, struct ucred *g)
2112 {
2113     int glockOwner, ret;
2114
2115     glockOwner = ISAFS_GLOCK();
2116     if (!glockOwner)
2117         AFS_GLOCK();
2118     ret = (*afs_gn_vnodeops.vn_create) (a, b, c, d, e, f, g);
2119     if (!glockOwner)
2120         AFS_GUNLOCK();
2121
2122     return ret;
2123 }
2124
2125 static
2126 vn_hold(struct vnode *a)
2127 {
2128     int glockOwner, ret;
2129
2130     glockOwner = ISAFS_GLOCK();
2131     if (!glockOwner)
2132         AFS_GLOCK();
2133     ret = (*afs_gn_vnodeops.vn_hold) (a);
2134     if (!glockOwner)
2135         AFS_GUNLOCK();
2136
2137     return ret;
2138 }
2139
2140 static
2141 vn_rele(struct vnode *a)
2142 {
2143     int glockOwner, ret;
2144
2145     glockOwner = ISAFS_GLOCK();
2146     if (!glockOwner)
2147         AFS_GLOCK();
2148     ret = (*afs_gn_vnodeops.vn_rele) (a);
2149     if (!glockOwner)
2150         AFS_GUNLOCK();
2151
2152     return ret;
2153 }
2154
2155 static
2156 vn_close(struct vnode *a, int32long64_t b, caddr_t c, struct ucred *d)
2157 {
2158     int glockOwner, ret;
2159
2160     glockOwner = ISAFS_GLOCK();
2161     if (!glockOwner)
2162         AFS_GLOCK();
2163     ret = (*afs_gn_vnodeops.vn_close) (a, b, c, d);
2164     if (!glockOwner)
2165         AFS_GUNLOCK();
2166
2167     return ret;
2168 }
2169
2170 static
2171 vn_map(struct vnode *a, caddr_t b, uint32long64_t c, uint32long64_t d,
2172        uint32long64_t e, struct ucred *f)
2173 {
2174     int glockOwner, ret;
2175
2176     glockOwner = ISAFS_GLOCK();
2177     if (!glockOwner)
2178         AFS_GLOCK();
2179     ret = (*afs_gn_vnodeops.vn_map) (a, b, c, d, e, f);
2180     if (!glockOwner)
2181         AFS_GUNLOCK();
2182
2183     return ret;
2184 }
2185
2186 static
2187 vn_unmap(struct vnode *a, int32long64_t b, struct ucred *c)
2188 {
2189     int glockOwner, ret;
2190
2191     glockOwner = ISAFS_GLOCK();
2192     if (!glockOwner)
2193         AFS_GLOCK();
2194     ret = (*afs_gn_vnodeops.vn_unmap) (a, b, c);
2195     if (!glockOwner)
2196         AFS_GUNLOCK();
2197
2198     return ret;
2199 }
2200
2201 static
2202 vn_access(struct vnode *a, int32long64_t b, int32long64_t c, struct ucred *d)
2203 {
2204     int glockOwner, ret;
2205
2206     glockOwner = ISAFS_GLOCK();
2207     if (!glockOwner)
2208         AFS_GLOCK();
2209     ret = (*afs_gn_vnodeops.vn_access) (a, b, c, d);
2210     if (!glockOwner)
2211         AFS_GUNLOCK();
2212
2213     return ret;
2214 }
2215
2216 static
2217 vn_getattr(struct vnode *a, struct vattr *b, struct ucred *c)
2218 {
2219     int glockOwner, ret;
2220
2221     glockOwner = ISAFS_GLOCK();
2222     if (!glockOwner)
2223         AFS_GLOCK();
2224     ret = (*afs_gn_vnodeops.vn_getattr) (a, b, c);
2225     if (!glockOwner)
2226         AFS_GUNLOCK();
2227
2228     return ret;
2229 }
2230
2231 static
2232 vn_setattr(struct vnode *a, int32long64_t b, int32long64_t c, int32long64_t d,
2233            int32long64_t e, struct ucred *f)
2234 {
2235     int glockOwner, ret;
2236
2237     glockOwner = ISAFS_GLOCK();
2238     if (!glockOwner)
2239         AFS_GLOCK();
2240     ret = (*afs_gn_vnodeops.vn_setattr) (a, b, c, d, e, f);
2241     if (!glockOwner)
2242         AFS_GUNLOCK();
2243
2244     return ret;
2245 }
2246
2247 static
2248 vn_fclear(struct vnode *a, int32long64_t b, offset_t c, offset_t d
2249           , caddr_t e, struct ucred *f)
2250 {
2251     int glockOwner, ret;
2252
2253     glockOwner = ISAFS_GLOCK();
2254     if (!glockOwner)
2255         AFS_GLOCK();
2256     ret = (*afs_gn_vnodeops.vn_fclear) (a, b, c, d, e, f);
2257     if (!glockOwner)
2258         AFS_GUNLOCK();
2259
2260     return ret;
2261 }
2262
2263 static
2264 vn_fsync(struct vnode *a, int32long64_t b, int32long64_t c, struct ucred *d)
2265 {
2266     int glockOwner, ret;
2267
2268     glockOwner = ISAFS_GLOCK();
2269     if (!glockOwner)
2270         AFS_GLOCK();
2271     ret = (*afs_gn_vnodeops.vn_fsync) (a, b, c, d);
2272     if (!glockOwner)
2273         AFS_GUNLOCK();
2274
2275     return ret;
2276 }
2277
2278 static
2279 vn_ftrunc(struct vnode *a, int32long64_t b, offset_t c, caddr_t d,
2280           struct ucred *e)
2281 {
2282     int glockOwner, ret;
2283
2284     glockOwner = ISAFS_GLOCK();
2285     if (!glockOwner)
2286         AFS_GLOCK();
2287     ret = (*afs_gn_vnodeops.vn_ftrunc) (a, b, c, d, e);
2288     if (!glockOwner)
2289         AFS_GUNLOCK();
2290
2291     return ret;
2292 }
2293
2294 static
2295 vn_rdwr(struct vnode *a, enum uio_rw b, int32long64_t c, struct uio *d,
2296         ext_t e, caddr_t f, struct vattr *v, struct ucred *g)
2297 {
2298     int glockOwner, ret;
2299
2300     glockOwner = ISAFS_GLOCK();
2301     if (!glockOwner)
2302         AFS_GLOCK();
2303     ret = (*afs_gn_vnodeops.vn_rdwr) (a, b, c, d, e, f, v, g);
2304     if (!glockOwner)
2305         AFS_GUNLOCK();
2306
2307     return ret;
2308 }
2309
2310 static
2311 vn_lockctl(struct vnode *a,
2312            offset_t b,
2313            struct eflock *c,
2314            int32long64_t d,
2315            int (*e) (),
2316 #ifdef AFS_AIX52_ENV /* Changed in AIX 5.2 and up */
2317                ulong * f, 
2318 #else /* AFS_AIX52_ENV */
2319                ulong32int64_t * f,
2320 #endif /* AFS_AIX52_ENV */
2321            struct ucred *g)
2322 {
2323     int glockOwner, ret;
2324
2325     glockOwner = ISAFS_GLOCK();
2326     if (!glockOwner)
2327         AFS_GLOCK();
2328     ret = (*afs_gn_vnodeops.vn_lockctl) (a, b, c, d, e, f, g);
2329     if (!glockOwner)
2330         AFS_GUNLOCK();
2331
2332     return ret;
2333 }
2334
2335 static
2336 vn_ioctl(struct vnode *a, int32long64_t b, caddr_t c, size_t d, ext_t e,
2337          struct ucred *f)
2338 {
2339     int glockOwner, ret;
2340
2341     glockOwner = ISAFS_GLOCK();
2342     if (!glockOwner)
2343         AFS_GLOCK();
2344     ret = (*afs_gn_vnodeops.vn_ioctl) (a, b, c, d, e, f);
2345     if (!glockOwner)
2346         AFS_GUNLOCK();
2347
2348     return ret;
2349 }
2350
2351 static
2352 vn_readlink(struct vnode *a, struct uio *b, struct ucred *c)
2353 {
2354     int glockOwner, ret;
2355
2356     glockOwner = ISAFS_GLOCK();
2357     if (!glockOwner)
2358         AFS_GLOCK();
2359     ret = (*afs_gn_vnodeops.vn_readlink) (a, b, c);
2360     if (!glockOwner)
2361         AFS_GUNLOCK();
2362
2363     return ret;
2364 }
2365
2366 static
2367 vn_select(struct vnode *a, int32long64_t b, ushort c, ushort * d,
2368           void (*e) (), caddr_t f, struct ucred *g)
2369 {
2370     int glockOwner, ret;
2371
2372     glockOwner = ISAFS_GLOCK();
2373     if (!glockOwner)
2374         AFS_GLOCK();
2375     ret = (*afs_gn_vnodeops.vn_select) (a, b, c, d, e, f, g);
2376     if (!glockOwner)
2377         AFS_GUNLOCK();
2378
2379     return ret;
2380 }
2381
2382 static
2383 vn_symlink(struct vnode *a, char *b, char *c, struct ucred *d)
2384 {
2385     int glockOwner, ret;
2386
2387     glockOwner = ISAFS_GLOCK();
2388     if (!glockOwner)
2389         AFS_GLOCK();
2390     ret = (*afs_gn_vnodeops.vn_symlink) (a, b, c, d);
2391     if (!glockOwner)
2392         AFS_GUNLOCK();
2393
2394     return ret;
2395 }
2396
2397 static
2398 vn_readdir(struct vnode *a, struct uio *b, struct ucred *c)
2399 {
2400     int glockOwner, ret;
2401
2402     glockOwner = ISAFS_GLOCK();
2403     if (!glockOwner)
2404         AFS_GLOCK();
2405     ret = (*afs_gn_vnodeops.vn_readdir) (a, b, c);
2406     if (!glockOwner)
2407         AFS_GUNLOCK();
2408
2409     return ret;
2410 }
2411
2412 static
2413 vn_revoke(struct vnode *a, int32long64_t b, int32long64_t c, struct vattr *d,
2414           struct ucred *e)
2415 {
2416     int glockOwner, ret;
2417
2418     glockOwner = ISAFS_GLOCK();
2419     if (!glockOwner)
2420         AFS_GLOCK();
2421     ret = (*afs_gn_vnodeops.vn_revoke) (a, b, c, d, e);
2422     if (!glockOwner)
2423         AFS_GUNLOCK();
2424
2425     return ret;
2426 }
2427
2428 static
2429 vn_getacl(struct vnode *a, struct uio *b, struct ucred *c)
2430 {
2431     int glockOwner, ret;
2432
2433     glockOwner = ISAFS_GLOCK();
2434     if (!glockOwner)
2435         AFS_GLOCK();
2436     ret = (*afs_gn_vnodeops.vn_getacl) (a, b, c);
2437     if (!glockOwner)
2438         AFS_GUNLOCK();
2439
2440     return ret;
2441 }
2442
2443 static
2444 vn_setacl(struct vnode *a, struct uio *b, struct ucred *c)
2445 {
2446     int glockOwner, ret;
2447
2448     glockOwner = ISAFS_GLOCK();
2449     if (!glockOwner)
2450         AFS_GLOCK();
2451     ret = (*afs_gn_vnodeops.vn_setacl) (a, b, c);
2452     if (!glockOwner)
2453         AFS_GUNLOCK();
2454
2455     return ret;
2456 }
2457
2458 static
2459 vn_getpcl(struct vnode *a, struct uio *b, struct ucred *c)
2460 {
2461     int glockOwner, ret;
2462
2463     glockOwner = ISAFS_GLOCK();
2464     if (!glockOwner)
2465         AFS_GLOCK();
2466     ret = (*afs_gn_vnodeops.vn_getpcl) (a, b, c);
2467     if (!glockOwner)
2468         AFS_GUNLOCK();
2469
2470     return ret;
2471 }
2472
2473 static
2474 vn_setpcl(struct vnode *a, struct uio *b, struct ucred *c)
2475 {
2476     int glockOwner, ret;
2477
2478     glockOwner = ISAFS_GLOCK();
2479     if (!glockOwner)
2480         AFS_GLOCK();
2481     ret = (*afs_gn_vnodeops.vn_setpcl) (a, b, c);
2482     if (!glockOwner)
2483         AFS_GUNLOCK();
2484
2485     return ret;
2486 }
2487
2488
2489 struct vnodeops locked_afs_gn_vnodeops = {
2490     vn_link,
2491     vn_mkdir,
2492     vn_mknod,
2493     vn_remove,
2494     vn_rename,
2495     vn_rmdir,
2496     vn_lookup,
2497     vn_fid,
2498     vn_open,
2499     vn_create,
2500     vn_hold,
2501     vn_rele,
2502     vn_close,
2503     vn_map,
2504     vn_unmap,
2505     vn_access,
2506     vn_getattr,
2507     vn_setattr,
2508     vn_fclear,
2509     vn_fsync,
2510     vn_ftrunc,
2511     vn_rdwr,
2512     vn_lockctl,
2513     vn_ioctl,
2514     vn_readlink,
2515     vn_select,
2516     vn_symlink,
2517     vn_readdir,
2518     (int(*)(struct vnode*,struct buf*,struct ucred*))
2519         afs_gn_strategy,        /* no locking!!! (discovered the hard way) */
2520     vn_revoke,
2521     vn_getacl,
2522     vn_setacl,
2523     vn_getpcl,
2524     vn_setpcl,
2525     afs_gn_seek,
2526     (int(*)(struct vnode *, int32long64_t, int32long64_t, offset_t, offset_t, struct ucred *))
2527         afs_gn_enosys,          /* vn_fsync_range */
2528     (int(*)(struct vnode *, struct vnode **, int32long64_t, char *, struct vattr *, int32long64_t, caddr_t *, struct ucred *))
2529         afs_gn_enosys,          /* vn_create_attr */
2530     (int(*)(struct vnode *, int32long64_t, void *, size_t, struct ucred *))
2531         afs_gn_enosys,          /* vn_finfo */
2532     (int(*)(struct vnode *, caddr_t, offset_t, offset_t, uint32long64_t, uint32long64_t, struct ucred *))
2533         afs_gn_enosys,          /* vn_map_lloff */
2534     (int(*)(struct vnode*,struct uio*,int*,struct ucred*))
2535         afs_gn_enosys,          /* vn_readdir_eofp */
2536     (int(*)(struct vnode *, enum uio_rw, int32long64_t, struct uio *, ext_t , caddr_t, struct vattr *, struct vattr *, struct ucred *))
2537         afs_gn_enosys,          /* vn_rdwr_attr */
2538     (int(*)(struct vnode*,int,void*,struct ucred*))
2539         afs_gn_enosys,          /* vn_memcntl */
2540 #ifdef AFS_AIX53_ENV /* Present in AIX 5.3 and up */
2541     (int(*)(struct vnode*,const char*,struct uio*,struct ucred*))
2542         afs_gn_enosys,          /* vn_getea */
2543     (int(*)(struct vnode*,const char*,struct uio*,int,struct ucred*))
2544         afs_gn_enosys,          /* vn_setea */
2545     (int(*)(struct vnode *, struct uio *, struct ucred *))
2546         afs_gn_enosys,          /* vn_listea */
2547     (int(*)(struct vnode *, const char *, struct ucred *))
2548         afs_gn_enosys,          /* vn_removeea */
2549     (int(*)(struct vnode *, const char *, struct vattr *, struct ucred *))
2550         afs_gn_enosys,          /* vn_statea */
2551     (int(*)(struct vnode *, uint64_t, acl_type_t *, struct uio *, size_t *, mode_t *, struct ucred *))
2552         afs_gn_enosys,          /* vn_getxacl */
2553     (int(*)(struct vnode *, uint64_t, acl_type_t, struct uio *, mode_t,  struct ucred *))
2554         afs_gn_enosys,          /* vn_setxacl */
2555 #else /* AFS_AIX53_ENV */
2556     afs_gn_enosys,              /* vn_spare7 */
2557     afs_gn_enosys,              /* vn_spare8 */
2558     afs_gn_enosys,              /* vn_spare9 */
2559     afs_gn_enosys,              /* vn_spareA */
2560     afs_gn_enosys,              /* vn_spareB */
2561     afs_gn_enosys,              /* vn_spareC */
2562     afs_gn_enosys,              /* vn_spareD */
2563 #endif /* AFS_AIX53_ENV */
2564     afs_gn_enosys,              /* vn_spareE */
2565     afs_gn_enosys               /* vn_spareF */
2566 #ifdef AFS_AIX51_ENV
2567     ,(int(*)(struct gnode*,long long,char*,unsigned long*, unsigned long*,unsigned int*))
2568         afs_gn_enosys,          /* pagerBackRange */
2569     (int64_t(*)(struct gnode*))
2570         afs_gn_enosys,          /* pagerGetFileSize */
2571     (void(*)(struct gnode *, vpn_t, vpn_t *, vpn_t *, vpn_t *, boolean_t))
2572         afs_gn_enosys,          /* pagerReadAhead */
2573     (void(*)(struct gnode *, int64_t, int64_t, uint))
2574         afs_gn_enosys,          /* pagerReadWriteBehind */
2575     (void(*)(struct gnode*,long long,unsigned long,unsigned long,unsigned int))
2576         afs_gn_enosys           /* pagerEndCopy */
2577 #endif
2578 };
2579
2580 struct gfs afs_gfs = {
2581     &locked_Afs_vfsops,
2582     &locked_afs_gn_vnodeops,
2583     AFS_MOUNT_AFS,
2584     "afs",
2585     Afs_init,
2586     GFS_VERSION4 | GFS_VERSION42 | GFS_REMOTE,
2587     NULL
2588 };