84dd3cad8b2fc90c4207bffb78c0d8225fc8fe3b
[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     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 u_int32_t afs_darwin_fsevents = 0;
451
452 int
453 afs_sysctl_int(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
454                user_addr_t newp, size_t newlen, u_int32_t *object)
455 {
456 #ifdef AFS_DARWIN80_ENV
457     int error;
458
459     if (oldp != USER_ADDR_NULL && oldlenp == NULL)
460         return (EFAULT);
461     if (oldp && *oldlenp < sizeof(u_int32_t))
462         return (ENOMEM);
463     if (newp && newlen != sizeof(u_int32_t))
464         return (EINVAL);
465     *oldlenp = sizeof(u_int32_t);
466     if (oldp) {
467         if ((error = copyout(object,
468                              oldp, sizeof(u_int32_t)))) {
469             return error;
470         }
471     }
472     if (newp)
473         return copyin(newp, object, sizeof(u_int32_t));
474     return 0;
475 #else
476     return sysctl_int(oldp, oldlenp, newp, newlen,
477                       object);
478 #endif
479 }
480
481 #ifdef AFS_DARWIN80_ENV
482 int
483 afs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
484                user_addr_t newp, size_t newlen, vfs_context_t context)
485 #else
486 int
487 afs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
488                void *newp, size_t newlen, struct proc *p)
489 #endif
490 {
491     switch (name[0]) {
492     case AFS_SC_ALL:
493         /* nothing defined */
494         break;
495     case AFS_SC_DARWIN:
496         if (namelen < 3)
497             return ENOENT;
498         switch (name[1]) {
499         case AFS_SC_DARWIN_ALL:
500             switch (name[2]) {
501             case AFS_SC_DARWIN_ALL_REALMODES:
502                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
503                                       newp, newlen, &afs_darwin_realmodes);
504             case AFS_SC_DARWIN_ALL_FSEVENTS:
505                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
506                                       newp, newlen, &afs_darwin_fsevents);
507             }
508             break;
509             /* darwin version specific sysctl's goes here */
510         }
511         break;
512     }
513     return EOPNOTSUPP;
514 }
515
516 typedef (*PFI) ();
517 extern int vfs_opv_numops;      /* The total number of defined vnode operations */
518 extern struct vnodeopv_desc afs_vnodeop_opv_desc;
519 int
520 afs_init(struct vfsconf *vfc)
521 {
522 #ifndef AFS_DARWIN80_ENV /* vfs_fsadd does all this junk */
523     int j;
524     int (**opv_desc_vector) ();
525     struct vnodeopv_entry_desc *opve_descp;
526
527
528
529     MALLOC(afs_vnodeop_p, PFI *, vfs_opv_numops * sizeof(PFI), M_TEMP,
530            M_WAITOK);
531
532     memset(afs_vnodeop_p, 0, vfs_opv_numops * sizeof(PFI));
533
534     opv_desc_vector = afs_vnodeop_p;
535     for (j = 0; afs_vnodeop_opv_desc.opv_desc_ops[j].opve_op; j++) {
536         opve_descp = &(afs_vnodeop_opv_desc.opv_desc_ops[j]);
537
538         /*
539          * Sanity check:  is this operation listed
540          * in the list of operations?  We check this
541          * by seeing if its offest is zero.  Since
542          * the default routine should always be listed
543          * first, it should be the only one with a zero
544          * offset.  Any other operation with a zero
545          * offset is probably not listed in
546          * vfs_op_descs, and so is probably an error.
547          *
548          * A panic here means the layer programmer
549          * has committed the all-too common bug
550          * of adding a new operation to the layer's
551          * list of vnode operations but
552          * not adding the operation to the system-wide
553          * list of supported operations.
554          */
555         if (opve_descp->opve_op->vdesc_offset == 0
556             && opve_descp->opve_op->vdesc_offset != VOFFSET(vop_default)) {
557             printf("afs_init: operation %s not listed in %s.\n",
558                    opve_descp->opve_op->vdesc_name, "vfs_op_descs");
559             panic("load_afs: bad operation");
560         }
561         /*
562          * Fill in this entry.
563          */
564         opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
565             opve_descp->opve_impl;
566     }
567
568     /*
569      * Finally, go back and replace unfilled routines
570      * with their default.  (Sigh, an O(n^3) algorithm.  I
571      * could make it better, but that'd be work, and n is small.)
572      */
573
574     /*
575      * Force every operations vector to have a default routine.
576      */
577     opv_desc_vector = afs_vnodeop_p;
578     if (opv_desc_vector[VOFFSET(vop_default)] == NULL) {
579         panic("afs_init: operation vector without default routine.");
580     }
581     for (j = 0; j < vfs_opv_numops; j++)
582         if (opv_desc_vector[j] == NULL)
583             opv_desc_vector[j] = opv_desc_vector[VOFFSET(vop_default)];
584 #endif
585     return 0;
586 }
587
588 struct vfsops afs_vfsops = {
589    afs_mount,
590    afs_start,
591    afs_unmount,
592    afs_root,
593 #ifdef AFS_DARWIN80_ENV
594    0,
595    afs_vfs_getattr,
596 #else
597    afs_quotactl,
598    afs_statfs,
599 #endif
600    afs_sync,
601 #ifdef AFS_DARWIN80_ENV
602    0,0,0,
603 #else
604    afs_vfs_vget,
605    afs_fhtovp,
606    afs_vptofh,
607 #endif
608    afs_init,
609    afs_sysctl, 
610 #ifdef AFS_DARWIN80_ENV
611    0 /*setattr */,
612    {0}
613 #endif
614 };