17545755733c6737d8fef0c465e2e1c954c01d49
[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 EOPNOTSUPP;
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     register struct vcache *tvp = 0;
225 #ifdef AFS_DARWIN80_ENV
226     struct ucred *cr = vfs_context_ucred(ctx);
227     int needref=0;
228 #else
229     struct proc *p = current_proc();
230     struct ucred _cr;
231     struct ucred *cr = &_cr;
232
233     pcred_readlock(p);
234     _cr = *p->p_cred->pc_ucred;
235     pcred_unlock(p);
236 #endif
237     AFS_GLOCK();
238     AFS_STATCNT(afs_root);
239     if (mdata == NULL && afs_globalVp
240         && (afs_globalVp->f.states & CStatd)) {
241         tvp = afs_globalVp;
242         error = 0;
243 #ifdef AFS_DARWIN80_ENV
244         needref=1;
245 #endif
246     } else if (mdata == (qaddr_t) - 1) {
247         error = ENOENT;
248     } else {
249         struct VenusFid *rootFid = (mdata == NULL)
250             ? &afs_rootFid : (struct VenusFid *)mdata;
251
252         if (!(error = afs_InitReq(&treq, cr)) && !(error = afs_CheckInit())) {
253             tvp = afs_GetVCache(rootFid, &treq, NULL, NULL);
254 #ifdef AFS_DARWIN80_ENV
255             if (tvp) {
256                 AFS_GUNLOCK();
257                 error = afs_darwin_finalizevnode(tvp, NULL, NULL, 1, 0);
258                 AFS_GLOCK();
259                 if (error)
260                    tvp = NULL;
261                 else 
262                    /* re-acquire the usecount that finalizevnode disposed of */
263                    vnode_ref(AFSTOV(tvp));
264             }
265 #endif
266             /* we really want this to stay around */
267             if (tvp) {
268                 if (mdata == NULL) {
269                     if (afs_globalVp) {
270                         afs_PutVCache(afs_globalVp);
271                         afs_globalVp = NULL;
272                     }
273                     afs_globalVp = tvp;
274 #ifdef AFS_DARWIN80_ENV
275                     needref=1;
276 #endif
277                 }
278             } else
279                 error = ENOENT;
280         }
281     }
282     if (tvp) {
283 #ifndef AFS_DARWIN80_ENV /* DARWIN80 caller does not need a usecount reference */
284         osi_vnhold(tvp, 0);
285         AFS_GUNLOCK();
286         vn_lock(AFSTOV(tvp), LK_EXCLUSIVE | LK_RETRY, p);
287         AFS_GLOCK();
288 #endif
289 #ifdef AFS_DARWIN80_ENV
290         if (needref) /* this iocount is for the caller. the initial iocount
291                         is for the eventual afs_PutVCache. for mdata != null,
292                         there will not be a PutVCache, so the caller gets the
293                         initial (from GetVCache or finalizevnode) iocount*/
294            vnode_get(AFSTOV(tvp));
295 #endif
296         if (mdata == NULL) {
297             afs_globalVFS = mp;
298         }
299         *vpp = AFSTOV(tvp);
300 #ifndef AFS_DARWIN80_ENV 
301         AFSTOV(tvp)->v_flag |= VROOT;
302         AFSTOV(tvp)->v_vfsp = mp;
303 #endif
304     }
305
306     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *vpp,
307                ICL_TYPE_INT32, error);
308     AFS_GUNLOCK();
309     return error;
310 }
311
312 #ifndef AFS_DARWIN80_ENV /* vget vfsop never had this prototype AFAIK */
313 int
314 afs_vget(struct mount *mp, int lfl, struct vnode *vp)
315 {
316     int error;
317     //printf("vget called. help!\n");
318     if (vp->v_usecount < 0) {
319         vprint("bad usecount", vp);
320         panic("afs_vget");
321     }
322     error = vget(vp, lfl, current_proc());
323     if (!error)
324         insmntque(vp, mp);      /* take off free list */
325     return error;
326 }
327
328 int afs_vfs_vget(struct mount *mp, void *ino, struct vnode **vpp)
329 {
330    return ENOENT; /* cannot implement */
331 }
332
333 #endif
334
335 int
336 afs_statfs(struct mount *mp, STATFS_TYPE *abp, CTX_TYPE ctx)
337 {
338     STATFS_TYPE *sysstat = vfs_statfs(mp);
339     AFS_GLOCK();
340     AFS_STATCNT(afs_statfs);
341
342 #ifdef AFS_DARWIN80_ENV
343     abp->f_iosize = (256 * 1024);
344     abp->f_bsize = vfs_devblocksize(mp);
345 #else
346     abp->f_bsize = mp->vfs_bsize;
347     abp->f_iosize = mp->vfs_bsize;
348 #endif
349 #if 0
350     abp->f_type = MOUNT_AFS;
351 #endif
352
353     /* Fake a high number below to satisfy programs that use the statfs call
354      * to make sure that there's enough space in the device partition before
355      * storing something there.
356      */
357     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
358       abp->f_ffree = 0x7fffffff;
359
360     if (abp != sysstat) {
361         abp->f_fsid.val[0] = sysstat->f_fsid.val[0];
362         abp->f_fsid.val[1] = sysstat->f_fsid.val[1];
363 #ifndef AFS_DARWIN80_ENV
364         abp->f_type = vfs_typenum(mp);
365 #endif
366         memcpy((caddr_t) & abp->f_mntonname[0],
367                (caddr_t) sysstat->f_mntonname, MNAMELEN);
368         memcpy((caddr_t) & abp->f_mntfromname[0],
369                (caddr_t) sysstat->f_mntfromname, MNAMELEN);
370     }
371
372     AFS_GUNLOCK();
373     return 0;
374 }
375
376 #ifdef AFS_DARWIN80_ENV
377 int
378 afs_vfs_getattr(struct mount *mp, struct vfs_attr *outattrs,
379                 vfs_context_t context)
380 {
381     VFSATTR_RETURN(outattrs, f_bsize, vfs_devblocksize(mp));
382     VFSATTR_RETURN(outattrs, f_iosize, vfs_devblocksize(mp));
383     VFSATTR_RETURN(outattrs, f_blocks, 2000000);
384     VFSATTR_RETURN(outattrs, f_bfree, 2000000);
385     VFSATTR_RETURN(outattrs, f_bavail, 2000000);
386     VFSATTR_RETURN(outattrs, f_files, 2000000);
387     VFSATTR_RETURN(outattrs, f_ffree, 2000000);
388     if ( VFSATTR_IS_ACTIVE(outattrs, f_capabilities) )
389     {
390          vol_capabilities_attr_t *vcapattrptr;
391          vcapattrptr = &outattrs->f_capabilities;
392          vcapattrptr->capabilities[VOL_CAPABILITIES_FORMAT] =
393                    VOL_CAP_FMT_SYMBOLICLINKS |
394                    VOL_CAP_FMT_HARDLINKS |
395                    VOL_CAP_FMT_ZERO_RUNS |
396                    VOL_CAP_FMT_CASE_SENSITIVE |
397                    VOL_CAP_FMT_CASE_PRESERVING |
398                    VOL_CAP_FMT_FAST_STATFS;
399          vcapattrptr->capabilities[VOL_CAPABILITIES_INTERFACES] = 
400                    VOL_CAP_INT_ADVLOCK | 
401                    VOL_CAP_INT_FLOCK;
402          vcapattrptr->capabilities[VOL_CAPABILITIES_RESERVED1] = 0;
403          vcapattrptr->capabilities[VOL_CAPABILITIES_RESERVED2] = 0;
404
405          /* Capabilities we know about: */
406          vcapattrptr->valid[VOL_CAPABILITIES_FORMAT] =
407                  VOL_CAP_FMT_PERSISTENTOBJECTIDS |
408                  VOL_CAP_FMT_SYMBOLICLINKS |
409                  VOL_CAP_FMT_HARDLINKS |
410                  VOL_CAP_FMT_JOURNAL |
411                  VOL_CAP_FMT_JOURNAL_ACTIVE |
412                  VOL_CAP_FMT_NO_ROOT_TIMES |
413                  VOL_CAP_FMT_SPARSE_FILES |
414                  VOL_CAP_FMT_ZERO_RUNS |
415                  VOL_CAP_FMT_CASE_SENSITIVE |
416                  VOL_CAP_FMT_CASE_PRESERVING |
417                  VOL_CAP_FMT_FAST_STATFS;
418          vcapattrptr->valid[VOL_CAPABILITIES_INTERFACES] =
419                  VOL_CAP_INT_SEARCHFS |
420                  VOL_CAP_INT_ATTRLIST |
421                  VOL_CAP_INT_NFSEXPORT |
422                  VOL_CAP_INT_READDIRATTR |
423                  VOL_CAP_INT_EXCHANGEDATA |
424                  VOL_CAP_INT_COPYFILE |
425                  VOL_CAP_INT_ALLOCATE |
426                  VOL_CAP_INT_VOL_RENAME |
427                  VOL_CAP_INT_ADVLOCK |
428                  VOL_CAP_INT_FLOCK;
429          vcapattrptr->valid[VOL_CAPABILITIES_RESERVED1] = 0;
430          vcapattrptr->valid[VOL_CAPABILITIES_RESERVED2] = 0;
431              
432          VFSATTR_SET_SUPPORTED(outattrs, f_capabilities);
433     }
434     return 0;
435 }
436 #endif
437
438 #ifdef AFS_DARWIN80_ENV
439 int
440 afs_sync(struct mount *mp, int waitfor, CTX_TYPE ctx)
441 #else
442 int
443 afs_sync(struct mount *mp, int waitfor, struct ucred *cred, struct proc *p)
444 #endif
445 {
446     return 0;
447 }
448
449 u_int32_t afs_darwin_realmodes = 0;
450
451 #ifdef AFS_DARWIN80_ENV
452 int afs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, 
453                user_addr_t newp, size_t newlen, vfs_context_t context)
454 #else
455 int afs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, 
456                void *newp, size_t newlen, struct proc *p)
457 #endif
458 {
459     int error;
460
461     switch (name[0]) {
462     case AFS_SC_ALL:
463         /* nothing defined */
464         break;
465     case AFS_SC_DARWIN:
466         if (namelen < 3)
467             return ENOENT;
468         switch (name[1]) {
469         case AFS_SC_DARWIN_ALL:
470             switch (name[2]) {
471             case AFS_SC_DARWIN_ALL_REALMODES:
472 #ifdef AFS_DARWIN80_ENV
473                 if (oldp != USER_ADDR_NULL && oldlenp == NULL)
474                     return (EFAULT);
475                 if (oldp && *oldlenp < sizeof(u_int32_t))
476                     return (ENOMEM);
477                 if (newp && newlen != sizeof(u_int32_t))
478                     return (EINVAL);
479                 *oldlenp = sizeof(u_int32_t);
480                 if (oldp) {
481                     if ((error = copyout(&afs_darwin_realmodes,
482                                          oldp, sizeof(u_int32_t)))) {
483                         return error;
484                     }
485                 }
486                 if (newp)
487                     return copyin(newp, &afs_darwin_realmodes,
488                                   sizeof(u_int32_t));
489                 return 0;
490 #else
491                 return sysctl_int(oldp, oldlenp, newp, newlen,
492                                   &afs_darwin_realmodes);
493 #endif
494             }
495             break;
496             /* darwin version specific sysctl's goes here */
497         }
498         break;
499     }
500     return EOPNOTSUPP;
501 }
502
503 typedef (*PFI) ();
504 extern int vfs_opv_numops;      /* The total number of defined vnode operations */
505 extern struct vnodeopv_desc afs_vnodeop_opv_desc;
506 int
507 afs_init(struct vfsconf *vfc)
508 {
509 #ifndef AFS_DARWIN80_ENV /* vfs_fsadd does all this junk */
510     int j;
511     int (**opv_desc_vector) ();
512     struct vnodeopv_entry_desc *opve_descp;
513
514
515
516     MALLOC(afs_vnodeop_p, PFI *, vfs_opv_numops * sizeof(PFI), M_TEMP,
517            M_WAITOK);
518
519     memset(afs_vnodeop_p, 0, vfs_opv_numops * sizeof(PFI));
520
521     opv_desc_vector = afs_vnodeop_p;
522     for (j = 0; afs_vnodeop_opv_desc.opv_desc_ops[j].opve_op; j++) {
523         opve_descp = &(afs_vnodeop_opv_desc.opv_desc_ops[j]);
524
525         /*
526          * Sanity check:  is this operation listed
527          * in the list of operations?  We check this
528          * by seeing if its offest is zero.  Since
529          * the default routine should always be listed
530          * first, it should be the only one with a zero
531          * offset.  Any other operation with a zero
532          * offset is probably not listed in
533          * vfs_op_descs, and so is probably an error.
534          *
535          * A panic here means the layer programmer
536          * has committed the all-too common bug
537          * of adding a new operation to the layer's
538          * list of vnode operations but
539          * not adding the operation to the system-wide
540          * list of supported operations.
541          */
542         if (opve_descp->opve_op->vdesc_offset == 0
543             && opve_descp->opve_op->vdesc_offset != VOFFSET(vop_default)) {
544             printf("afs_init: operation %s not listed in %s.\n",
545                    opve_descp->opve_op->vdesc_name, "vfs_op_descs");
546             panic("load_afs: bad operation");
547         }
548         /*
549          * Fill in this entry.
550          */
551         opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
552             opve_descp->opve_impl;
553     }
554
555     /*
556      * Finally, go back and replace unfilled routines
557      * with their default.  (Sigh, an O(n^3) algorithm.  I
558      * could make it better, but that'd be work, and n is small.)
559      */
560
561     /*
562      * Force every operations vector to have a default routine.
563      */
564     opv_desc_vector = afs_vnodeop_p;
565     if (opv_desc_vector[VOFFSET(vop_default)] == NULL) {
566         panic("afs_init: operation vector without default routine.");
567     }
568     for (j = 0; j < vfs_opv_numops; j++)
569         if (opv_desc_vector[j] == NULL)
570             opv_desc_vector[j] = opv_desc_vector[VOFFSET(vop_default)];
571 #endif
572     return 0;
573 }
574
575 struct vfsops afs_vfsops = {
576    afs_mount,
577    afs_start,
578    afs_unmount,
579    afs_root,
580 #ifdef AFS_DARWIN80_ENV
581    0,
582    afs_vfs_getattr,
583 #else
584    afs_quotactl,
585    afs_statfs,
586 #endif
587    afs_sync,
588 #ifdef AFS_DARWIN80_ENV
589    0,0,0,
590 #else
591    afs_vfs_vget,
592    afs_fhtovp,
593    afs_vptofh,
594 #endif
595    afs_init,
596    afs_sysctl, 
597 #ifdef AFS_DARWIN80_ENV
598    0 /*setattr */,
599    {0}
600 #endif
601 };