afs: Remove useless afs_GetVCache arguments
[openafs.git] / src / afs / DARWIN / osi_vfsops.c
1 /*
2  * Portions Copyright (c) 2003 Apple Computer, Inc.  All rights reserved.
3  */
4 #include <afsconfig.h>
5 #include <afs/param.h>
6
7
8 #include <afs/sysincludes.h>    /* Standard vendor system headers */
9 #include <afsincludes.h>        /* Afs-based standard headers */
10 #include <afs/afs_stats.h>      /* statistics */
11 #include <sys/malloc.h>
12 #include <sys/namei.h>
13 #include <sys/conf.h>
14 #ifndef AFS_DARWIN80_ENV
15 #include <sys/syscall.h>
16 #endif
17 #include <sys/sysctl.h>
18 #include "../afs/sysctl.h"
19
20 #ifndef M_UFSMNT
21 #define M_UFSMNT M_TEMP /* DARWIN80 MALLOC doesn't look at the type anyway */
22 #endif
23
24 struct vcache *afs_globalVp = 0;
25 struct mount *afs_globalVFS = 0;
26 int afs_vfs_typenum;
27
28 int
29 afs_quotactl()
30 {
31     return ENOTSUP;
32 }
33
34 int
35 afs_fhtovp(struct mount *mp, struct fid *fhp, struct vnode **vpp)
36 {
37     return (EINVAL);
38 }
39
40 int
41 afs_vptofh(struct vnode *vp, struct fid *fhp)
42 {
43     return (EINVAL);
44 }
45
46 #ifdef AFS_DARWIN80_ENV
47 #define CTX_TYPE vfs_context_t
48 #define CTX_PROC_CONVERT(C) vfs_context_proc((C))
49 #define STATFS_TYPE struct vfsstatfs
50 #else
51 #define CTX_TYPE struct proc *
52 #define CTX_PROC_CONVERT(C) (C)
53 #define STATFS_TYPE struct statfs
54 #define vfs_statfs(VFS) &(VFS)->mnt_stat
55 #endif
56 #define PROC_DECL(out,in) struct proc *out = CTX_PROC_CONVERT(in)
57
58 int
59 afs_start(struct mount *mp, int flags, CTX_TYPE p)
60 {
61     return (0);                 /* nothing to do. ? */
62 }
63
64 int
65 afs_statfs(struct mount *mp, STATFS_TYPE *abp, CTX_TYPE ctx);
66 #ifdef AFS_DARWIN80_ENV
67 int
68 afs_mount(struct mount *mp, vnode_t *devvp, user_addr_t data, vfs_context_t ctx)
69 #else
70 int
71 afs_mount(struct mount *mp, char *path, caddr_t data, struct nameidata *ndp, CTX_TYPE ctx)
72 #endif
73 {
74     /* ndp contains the mounted-from device.  Just ignore it.
75      * we also don't care about our proc struct. */
76     size_t size;
77     int error;
78 #ifdef AFS_DARWIN80_ENV
79     struct vfsioattr ioattr;
80     /* vfs_statfs advertised as RO, but isn't */
81     /* new api will be needed to initialize this information (nfs needs to
82        set mntfromname too) */
83 #endif
84     STATFS_TYPE *mnt_stat = vfs_statfs(mp); 
85
86     if (vfs_isupdate(mp))
87         return EINVAL;
88
89     AFS_GLOCK();
90     AFS_STATCNT(afs_mount);
91
92     if (data == 0 && afs_globalVFS) {   /* Don't allow remounts. */
93         AFS_GUNLOCK();
94         return (EBUSY);
95     }
96
97     afs_globalVFS = mp;
98 #ifdef AFS_DARWIN80_ENV
99     vfs_ioattr(mp, &ioattr);
100     ioattr.io_devblocksize = (16 * 32768);
101     vfs_setioattr(mp, &ioattr);
102     /* f_iosize is handled in VFS_GETATTR */
103 #else
104     mp->vfs_bsize = 8192;
105     mp->mnt_stat.f_iosize = 8192;
106 #endif
107     vfs_getnewfsid(mp);
108
109 #ifndef AFS_DARWIN80_ENV
110     (void)copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
111     memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
112 #endif
113     memset(mnt_stat->f_mntfromname, 0, MNAMELEN);
114
115     if (data == 0) {
116         strcpy(mnt_stat->f_mntfromname, "AFS");
117         /* null terminated string "AFS" will fit, just leave it be. */
118         vfs_setfsprivate(mp, NULL);
119     } else {
120         struct VenusFid *rootFid = NULL;
121         struct volume *tvp;
122         char volName[MNAMELEN];
123
124         (void)copyinstr(data, volName, MNAMELEN - 1, &size);
125         memset(volName + size, 0, MNAMELEN - size);
126
127         if (volName[0] == 0) {
128             strcpy(mnt_stat->f_mntfromname, "AFS");
129             vfs_setfsprivate(mp, &afs_rootFid);
130         } else {
131             struct cell *localcell = afs_GetPrimaryCell(READ_LOCK);
132             if (localcell == NULL) {
133                 AFS_GUNLOCK();
134                 return ENODEV;
135             }
136
137             /* Set the volume identifier to "AFS:volume.name" */
138             snprintf(mnt_stat->f_mntfromname, MNAMELEN - 1, "AFS:%s",
139                      volName);
140             tvp =
141                 afs_GetVolumeByName(volName, localcell->cellNum, 1,
142                                     (struct vrequest *)0, READ_LOCK);
143
144             if (tvp) {
145                 int volid = (tvp->roVol ? tvp->roVol : tvp->volume);
146                 MALLOC(rootFid, struct VenusFid *, sizeof(*rootFid), M_UFSMNT,
147                        M_WAITOK);
148                 rootFid->Cell = localcell->cellNum;
149                 rootFid->Fid.Volume = volid;
150                 rootFid->Fid.Vnode = 1;
151                 rootFid->Fid.Unique = 1;
152             } else {
153                 AFS_GUNLOCK();
154                 return ENODEV;
155             }
156
157             vfs_setfsprivate(mp, &rootFid);
158         }
159     }
160 #ifdef AFS_DARWIN80_ENV
161     afs_vfs_typenum=vfs_typenum(mp);
162     vfs_setauthopaque(mp);
163     vfs_setauthopaqueaccess(mp);
164 #else
165     strcpy(mp->mnt_stat.f_fstypename, "afs");
166 #endif
167     AFS_GUNLOCK();
168     (void)afs_statfs(mp, mnt_stat, ctx);
169     return 0;
170 }
171
172 int
173 afs_unmount(struct mount *mp, int flags, CTX_TYPE ctx)
174 {
175     void *mdata = vfs_fsprivate(mp);
176     AFS_GLOCK();
177     AFS_STATCNT(afs_unmount);
178
179     if (mdata != (qaddr_t) - 1) {
180         if (mdata != NULL) {
181             vfs_setfsprivate(mp, (qaddr_t) - 1);
182             FREE(mdata, M_UFSMNT);
183         } else {
184             if (flags & MNT_FORCE) {
185                 if (afs_globalVp) {
186 #ifdef AFS_DARWIN80_ENV
187                     afs_PutVCache(afs_globalVp);
188 #else
189                     AFS_GUNLOCK();
190                     vrele(AFSTOV(afs_globalVp));
191                     AFS_GLOCK();
192 #endif
193                 }
194                 afs_globalVp = NULL;
195                 AFS_GUNLOCK();
196                 vflush(mp, NULLVP, FORCECLOSE/*0*/);
197                 AFS_GLOCK();
198                 afs_globalVFS = 0;
199                 afs_shutdown();
200             } else {
201                 AFS_GUNLOCK();
202                 return EBUSY;
203             }
204         }
205         vfs_clearflags(mp, MNT_LOCAL);
206     }
207
208     AFS_GUNLOCK();
209
210     return 0;
211 }
212
213 #ifdef AFS_DARWIN80_ENV
214 int
215 afs_root(struct mount *mp, struct vnode **vpp, vfs_context_t ctx)
216 #else
217 int
218 afs_root(struct mount *mp, struct vnode **vpp)
219 #endif
220 {
221     void *mdata = vfs_fsprivate(mp);
222     int error;
223     struct vrequest treq;
224     struct vcache *tvp = 0;
225     struct vcache *gvp;
226     int needref=0;
227 #ifdef AFS_DARWIN80_ENV
228     struct ucred *cr = vfs_context_ucred(ctx);
229 #else
230     struct proc *p = current_proc();
231     struct ucred _cr;
232     struct ucred *cr = &_cr;
233
234     pcred_readlock(p);
235     _cr = *p->p_cred->pc_ucred;
236     pcred_unlock(p);
237 #endif
238     AFS_GLOCK();
239     AFS_STATCNT(afs_root);
240
241 again:
242     if (mdata == NULL && afs_globalVp
243         && (afs_globalVp->f.states & CStatd)) {
244         tvp = afs_globalVp;
245         error = 0;
246         needref=1;
247     } else if (mdata == (qaddr_t) - 1) {
248         error = ENOENT;
249     } else {
250         struct VenusFid *rootFid = (mdata == NULL)
251             ? &afs_rootFid : (struct VenusFid *)mdata;
252
253         if (!(error = afs_InitReq(&treq, cr)) && !(error = afs_CheckInit())) {
254             tvp = afs_GetVCache(rootFid, &treq);
255 #ifdef AFS_DARWIN80_ENV
256             if (tvp) {
257                 AFS_GUNLOCK();
258                 error = afs_darwin_finalizevnode(tvp, NULL, NULL, 1, 0);
259                 AFS_GLOCK();
260                 if (error)
261                    tvp = NULL;
262                 else
263                    /* re-acquire the usecount that finalizevnode disposed of */
264                    vnode_ref(AFSTOV(tvp));
265             }
266 #endif
267             /* we really want this to stay around */
268             if (tvp) {
269                 if (mdata == NULL) {
270                     gvp = afs_globalVp;
271                     afs_globalVp = tvp;
272                     if (gvp) {
273                         afs_PutVCache(gvp);
274                         if (tvp != afs_globalVp) {
275                             /* someone else got there before us! */
276                             afs_PutVCache(tvp);
277                             tvp = 0;
278                             goto again;
279                         }
280                     }
281                     needref=1;
282                 }
283             } else
284                 error = EIO;
285         }
286     }
287     if (tvp) {
288 #ifndef AFS_DARWIN80_ENV /* KPI callers don't need a usecount reference */
289         osi_vnhold(tvp, 0);
290         AFS_GUNLOCK();
291         vn_lock(AFSTOV(tvp), LK_EXCLUSIVE | LK_RETRY, p);
292         AFS_GLOCK();
293 #endif
294
295         if (needref)
296 #ifdef AFS_DARWIN80_ENV
297             /* This iocount is for the caller. the initial iocount
298              * is for the eventual afs_PutVCache. for mdata != null,
299              * there will not be a PutVCache, so the caller gets the
300              * initial (from GetVCache or finalizevnode) iocount
301              */
302             vnode_get(AFSTOV(tvp));
303 #else
304             ;
305 #endif
306
307         if (mdata == NULL)
308             afs_globalVFS = mp;
309
310         *vpp = AFSTOV(tvp);
311 #ifndef AFS_DARWIN80_ENV 
312         AFSTOV(tvp)->v_flag |= VROOT;
313         AFSTOV(tvp)->v_vfsp = mp;
314 #endif
315     }
316
317     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *vpp,
318                ICL_TYPE_INT32, error);
319     AFS_GUNLOCK();
320     return error;
321 }
322
323 #ifndef AFS_DARWIN80_ENV /* vget vfsop never had this prototype AFAIK */
324 int
325 afs_vget(struct mount *mp, int lfl, struct vnode *vp)
326 {
327     int error;
328     //printf("vget called. help!\n");
329     if (vp->v_usecount < 0) {
330         vprint("bad usecount", vp);
331         panic("afs_vget");
332     }
333     error = vget(vp, lfl, current_proc());
334     if (!error)
335         insmntque(vp, mp);      /* take off free list */
336     return error;
337 }
338
339 int afs_vfs_vget(struct mount *mp, void *ino, struct vnode **vpp)
340 {
341    return ENOENT; /* cannot implement */
342 }
343
344 #endif
345
346 int
347 afs_statfs(struct mount *mp, STATFS_TYPE *abp, CTX_TYPE ctx)
348 {
349     STATFS_TYPE *sysstat = vfs_statfs(mp);
350     AFS_GLOCK();
351     AFS_STATCNT(afs_statfs);
352
353 #ifdef AFS_DARWIN80_ENV
354     abp->f_iosize = (256 * 1024);
355     abp->f_bsize = vfs_devblocksize(mp);
356 #else
357     abp->f_bsize = mp->vfs_bsize;
358     abp->f_iosize = mp->vfs_bsize;
359 #endif
360 #if 0
361     abp->f_type = MOUNT_AFS;
362 #endif
363
364     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
365       abp->f_ffree = AFS_VFS_FAKEFREE;
366
367     if (abp != sysstat) {
368         abp->f_fsid.val[0] = sysstat->f_fsid.val[0];
369         abp->f_fsid.val[1] = sysstat->f_fsid.val[1];
370 #ifndef AFS_DARWIN80_ENV
371         abp->f_type = vfs_typenum(mp);
372 #endif
373         memcpy((caddr_t) & abp->f_mntonname[0],
374                (caddr_t) sysstat->f_mntonname, MNAMELEN);
375         memcpy((caddr_t) & abp->f_mntfromname[0],
376                (caddr_t) sysstat->f_mntfromname, MNAMELEN);
377     }
378
379     AFS_GUNLOCK();
380     return 0;
381 }
382
383 #ifdef AFS_DARWIN80_ENV
384 int
385 afs_vfs_getattr(struct mount *mp, struct vfs_attr *outattrs,
386                 vfs_context_t context)
387 {
388     VFSATTR_RETURN(outattrs, f_bsize, vfs_devblocksize(mp));
389     VFSATTR_RETURN(outattrs, f_iosize, vfs_devblocksize(mp));
390     VFSATTR_RETURN(outattrs, f_blocks, 2000000);
391     VFSATTR_RETURN(outattrs, f_bfree, 2000000);
392     VFSATTR_RETURN(outattrs, f_bavail, 2000000);
393     VFSATTR_RETURN(outattrs, f_files, 2000000);
394     VFSATTR_RETURN(outattrs, f_ffree, 2000000);
395     if ( VFSATTR_IS_ACTIVE(outattrs, f_capabilities) )
396     {
397          vol_capabilities_attr_t *vcapattrptr;
398          vcapattrptr = &outattrs->f_capabilities;
399          vcapattrptr->capabilities[VOL_CAPABILITIES_FORMAT] =
400                    VOL_CAP_FMT_SYMBOLICLINKS |
401                    VOL_CAP_FMT_HARDLINKS |
402                    VOL_CAP_FMT_ZERO_RUNS |
403                    VOL_CAP_FMT_CASE_SENSITIVE |
404                    VOL_CAP_FMT_CASE_PRESERVING |
405                    VOL_CAP_FMT_PERSISTENTOBJECTIDS |
406                    VOL_CAP_FMT_2TB_FILESIZE |
407                    VOL_CAP_FMT_FAST_STATFS;
408          vcapattrptr->capabilities[VOL_CAPABILITIES_INTERFACES] = 
409                    VOL_CAP_INT_ADVLOCK | 
410                    VOL_CAP_INT_FLOCK;
411          vcapattrptr->capabilities[VOL_CAPABILITIES_RESERVED1] = 0;
412          vcapattrptr->capabilities[VOL_CAPABILITIES_RESERVED2] = 0;
413
414          /* Capabilities we know about: */
415          vcapattrptr->valid[VOL_CAPABILITIES_FORMAT] =
416                  VOL_CAP_FMT_PERSISTENTOBJECTIDS |
417                  VOL_CAP_FMT_SYMBOLICLINKS |
418                  VOL_CAP_FMT_HARDLINKS |
419                  VOL_CAP_FMT_JOURNAL |
420                  VOL_CAP_FMT_JOURNAL_ACTIVE |
421                  VOL_CAP_FMT_NO_ROOT_TIMES |
422                  VOL_CAP_FMT_SPARSE_FILES |
423                  VOL_CAP_FMT_ZERO_RUNS |
424                  VOL_CAP_FMT_CASE_SENSITIVE |
425                  VOL_CAP_FMT_CASE_PRESERVING |
426                  VOL_CAP_FMT_PERSISTENTOBJECTIDS |
427                  VOL_CAP_FMT_2TB_FILESIZE |
428                  VOL_CAP_FMT_FAST_STATFS;
429          vcapattrptr->valid[VOL_CAPABILITIES_INTERFACES] =
430                  VOL_CAP_INT_SEARCHFS |
431                  VOL_CAP_INT_ATTRLIST |
432                  VOL_CAP_INT_NFSEXPORT |
433                  VOL_CAP_INT_READDIRATTR |
434                  VOL_CAP_INT_EXCHANGEDATA |
435                  VOL_CAP_INT_COPYFILE |
436                  VOL_CAP_INT_ALLOCATE |
437                  VOL_CAP_INT_VOL_RENAME |
438                  VOL_CAP_INT_ADVLOCK |
439                  VOL_CAP_INT_FLOCK;
440          vcapattrptr->valid[VOL_CAPABILITIES_RESERVED1] = 0;
441          vcapattrptr->valid[VOL_CAPABILITIES_RESERVED2] = 0;
442              
443          VFSATTR_SET_SUPPORTED(outattrs, f_capabilities);
444     }
445     return 0;
446 }
447 #endif
448
449 #ifdef AFS_DARWIN80_ENV
450 int
451 afs_sync(struct mount *mp, int waitfor, CTX_TYPE ctx)
452 #else
453 int
454 afs_sync(struct mount *mp, int waitfor, struct ucred *cred, struct proc *p)
455 #endif
456 {
457     return 0;
458 }
459
460 u_int32_t afs_darwin_realmodes = 0;
461 u_int32_t afs_darwin_fsevents = 0;
462 extern int AFSDOBULK;
463
464 int
465 afs_sysctl_int(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
466                user_addr_t newp, size_t newlen, u_int32_t *object)
467 {
468 #ifdef AFS_DARWIN80_ENV
469     int error;
470
471     if (oldp != USER_ADDR_NULL && oldlenp == NULL)
472         return (EFAULT);
473     if (oldp && *oldlenp < sizeof(u_int32_t))
474         return (ENOMEM);
475     if (newp && newlen != sizeof(u_int32_t))
476         return (EINVAL);
477     *oldlenp = sizeof(u_int32_t);
478     if (oldp) {
479         if ((error = copyout(object,
480                              oldp, sizeof(u_int32_t)))) {
481             return error;
482         }
483     }
484     if (newp)
485         return copyin(newp, object, sizeof(u_int32_t));
486     return 0;
487 #else
488     return sysctl_int(oldp, oldlenp, newp, newlen,
489                       object);
490 #endif
491 }
492
493 #ifdef AFS_DARWIN80_ENV
494 int
495 afs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
496                user_addr_t newp, size_t newlen, vfs_context_t context)
497 #else
498 int
499 afs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
500                void *newp, size_t newlen, struct proc *p)
501 #endif
502 {
503     switch (name[0]) {
504     case AFS_SC_ALL:
505         /* nothing defined */
506         break;
507     case AFS_SC_DARWIN:
508         if (namelen < 3)
509             return ENOENT;
510         switch (name[1]) {
511         case AFS_SC_DARWIN_ALL:
512             switch (name[2]) {
513             case AFS_SC_DARWIN_ALL_REALMODES:
514                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
515                                       newp, newlen, &afs_darwin_realmodes);
516             case AFS_SC_DARWIN_ALL_FSEVENTS:
517                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
518                                       newp, newlen, &afs_darwin_fsevents);
519             case AFS_SC_DARWIN_ALL_BULKSTAT:
520                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
521                                       newp, newlen, &AFSDOBULK);
522             }
523             break;
524             /* darwin version specific sysctl's goes here */
525         }
526         break;
527     }
528     return ENOTSUP;
529 }
530
531 typedef (*PFI) ();
532 extern int vfs_opv_numops;      /* The total number of defined vnode operations */
533 extern struct vnodeopv_desc afs_vnodeop_opv_desc;
534 int
535 afs_init(struct vfsconf *vfc)
536 {
537 #ifndef AFS_DARWIN80_ENV /* vfs_fsadd does all this junk */
538     int j;
539     int (**opv_desc_vector) ();
540     struct vnodeopv_entry_desc *opve_descp;
541
542
543
544     MALLOC(afs_vnodeop_p, PFI *, vfs_opv_numops * sizeof(PFI), M_TEMP,
545            M_WAITOK);
546
547     memset(afs_vnodeop_p, 0, vfs_opv_numops * sizeof(PFI));
548
549     opv_desc_vector = afs_vnodeop_p;
550     for (j = 0; afs_vnodeop_opv_desc.opv_desc_ops[j].opve_op; j++) {
551         opve_descp = &(afs_vnodeop_opv_desc.opv_desc_ops[j]);
552
553         /*
554          * Sanity check:  is this operation listed
555          * in the list of operations?  We check this
556          * by seeing if its offest is zero.  Since
557          * the default routine should always be listed
558          * first, it should be the only one with a zero
559          * offset.  Any other operation with a zero
560          * offset is probably not listed in
561          * vfs_op_descs, and so is probably an error.
562          *
563          * A panic here means the layer programmer
564          * has committed the all-too common bug
565          * of adding a new operation to the layer's
566          * list of vnode operations but
567          * not adding the operation to the system-wide
568          * list of supported operations.
569          */
570         if (opve_descp->opve_op->vdesc_offset == 0
571             && opve_descp->opve_op->vdesc_offset != VOFFSET(vop_default)) {
572             printf("afs_init: operation %s not listed in %s.\n",
573                    opve_descp->opve_op->vdesc_name, "vfs_op_descs");
574             panic("load_afs: bad operation");
575         }
576         /*
577          * Fill in this entry.
578          */
579         opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
580             opve_descp->opve_impl;
581     }
582
583     /*
584      * Finally, go back and replace unfilled routines
585      * with their default.  (Sigh, an O(n^3) algorithm.  I
586      * could make it better, but that'd be work, and n is small.)
587      */
588
589     /*
590      * Force every operations vector to have a default routine.
591      */
592     opv_desc_vector = afs_vnodeop_p;
593     if (opv_desc_vector[VOFFSET(vop_default)] == NULL) {
594         panic("afs_init: operation vector without default routine.");
595     }
596     for (j = 0; j < vfs_opv_numops; j++)
597         if (opv_desc_vector[j] == NULL)
598             opv_desc_vector[j] = opv_desc_vector[VOFFSET(vop_default)];
599 #endif
600     return 0;
601 }
602
603 struct vfsops afs_vfsops = {
604    afs_mount,
605    afs_start,
606    afs_unmount,
607    afs_root,
608 #ifdef AFS_DARWIN80_ENV
609    0,
610    afs_vfs_getattr,
611 #else
612    afs_quotactl,
613    afs_statfs,
614 #endif
615    afs_sync,
616 #ifdef AFS_DARWIN80_ENV
617    0,0,0,
618 #else
619    afs_vfs_vget,
620    afs_fhtovp,
621    afs_vptofh,
622 #endif
623    afs_init,
624    afs_sysctl, 
625 #ifdef AFS_DARWIN80_ENV
626    0 /*setattr */,
627    {0}
628 #endif
629 };