919a3d0a2bc4f19515b4f7e21434dbd035da29f3
[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 #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_PERSISTENTOBJECTIDS |
399                    VOL_CAP_FMT_2TB_FILESIZE |
400                    VOL_CAP_FMT_FAST_STATFS;
401          vcapattrptr->capabilities[VOL_CAPABILITIES_INTERFACES] = 
402                    VOL_CAP_INT_ADVLOCK | 
403                    VOL_CAP_INT_FLOCK;
404          vcapattrptr->capabilities[VOL_CAPABILITIES_RESERVED1] = 0;
405          vcapattrptr->capabilities[VOL_CAPABILITIES_RESERVED2] = 0;
406
407          /* Capabilities we know about: */
408          vcapattrptr->valid[VOL_CAPABILITIES_FORMAT] =
409                  VOL_CAP_FMT_PERSISTENTOBJECTIDS |
410                  VOL_CAP_FMT_SYMBOLICLINKS |
411                  VOL_CAP_FMT_HARDLINKS |
412                  VOL_CAP_FMT_JOURNAL |
413                  VOL_CAP_FMT_JOURNAL_ACTIVE |
414                  VOL_CAP_FMT_NO_ROOT_TIMES |
415                  VOL_CAP_FMT_SPARSE_FILES |
416                  VOL_CAP_FMT_ZERO_RUNS |
417                  VOL_CAP_FMT_CASE_SENSITIVE |
418                  VOL_CAP_FMT_CASE_PRESERVING |
419                  VOL_CAP_FMT_PERSISTENTOBJECTIDS |
420                  VOL_CAP_FMT_2TB_FILESIZE |
421                  VOL_CAP_FMT_FAST_STATFS;
422          vcapattrptr->valid[VOL_CAPABILITIES_INTERFACES] =
423                  VOL_CAP_INT_SEARCHFS |
424                  VOL_CAP_INT_ATTRLIST |
425                  VOL_CAP_INT_NFSEXPORT |
426                  VOL_CAP_INT_READDIRATTR |
427                  VOL_CAP_INT_EXCHANGEDATA |
428                  VOL_CAP_INT_COPYFILE |
429                  VOL_CAP_INT_ALLOCATE |
430                  VOL_CAP_INT_VOL_RENAME |
431                  VOL_CAP_INT_ADVLOCK |
432                  VOL_CAP_INT_FLOCK;
433          vcapattrptr->valid[VOL_CAPABILITIES_RESERVED1] = 0;
434          vcapattrptr->valid[VOL_CAPABILITIES_RESERVED2] = 0;
435              
436          VFSATTR_SET_SUPPORTED(outattrs, f_capabilities);
437     }
438     return 0;
439 }
440 #endif
441
442 #ifdef AFS_DARWIN80_ENV
443 int
444 afs_sync(struct mount *mp, int waitfor, CTX_TYPE ctx)
445 #else
446 int
447 afs_sync(struct mount *mp, int waitfor, struct ucred *cred, struct proc *p)
448 #endif
449 {
450     return 0;
451 }
452
453 u_int32_t afs_darwin_realmodes = 0;
454 u_int32_t afs_darwin_fsevents = 0;
455 extern int AFSDOBULK;
456
457 int
458 afs_sysctl_int(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
459                user_addr_t newp, size_t newlen, u_int32_t *object)
460 {
461 #ifdef AFS_DARWIN80_ENV
462     int error;
463
464     if (oldp != USER_ADDR_NULL && oldlenp == NULL)
465         return (EFAULT);
466     if (oldp && *oldlenp < sizeof(u_int32_t))
467         return (ENOMEM);
468     if (newp && newlen != sizeof(u_int32_t))
469         return (EINVAL);
470     *oldlenp = sizeof(u_int32_t);
471     if (oldp) {
472         if ((error = copyout(object,
473                              oldp, sizeof(u_int32_t)))) {
474             return error;
475         }
476     }
477     if (newp)
478         return copyin(newp, object, sizeof(u_int32_t));
479     return 0;
480 #else
481     return sysctl_int(oldp, oldlenp, newp, newlen,
482                       object);
483 #endif
484 }
485
486 #ifdef AFS_DARWIN80_ENV
487 int
488 afs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
489                user_addr_t newp, size_t newlen, vfs_context_t context)
490 #else
491 int
492 afs_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
493                void *newp, size_t newlen, struct proc *p)
494 #endif
495 {
496     switch (name[0]) {
497     case AFS_SC_ALL:
498         /* nothing defined */
499         break;
500     case AFS_SC_DARWIN:
501         if (namelen < 3)
502             return ENOENT;
503         switch (name[1]) {
504         case AFS_SC_DARWIN_ALL:
505             switch (name[2]) {
506             case AFS_SC_DARWIN_ALL_REALMODES:
507                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
508                                       newp, newlen, &afs_darwin_realmodes);
509             case AFS_SC_DARWIN_ALL_FSEVENTS:
510                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
511                                       newp, newlen, &afs_darwin_fsevents);
512             case AFS_SC_DARWIN_ALL_BULKSTAT:
513                 return afs_sysctl_int(name, namelen, oldp, oldlenp,
514                                       newp, newlen, &AFSDOBULK);
515             }
516             break;
517             /* darwin version specific sysctl's goes here */
518         }
519         break;
520     }
521     return ENOTSUP;
522 }
523
524 typedef (*PFI) ();
525 extern int vfs_opv_numops;      /* The total number of defined vnode operations */
526 extern struct vnodeopv_desc afs_vnodeop_opv_desc;
527 int
528 afs_init(struct vfsconf *vfc)
529 {
530 #ifndef AFS_DARWIN80_ENV /* vfs_fsadd does all this junk */
531     int j;
532     int (**opv_desc_vector) ();
533     struct vnodeopv_entry_desc *opve_descp;
534
535
536
537     MALLOC(afs_vnodeop_p, PFI *, vfs_opv_numops * sizeof(PFI), M_TEMP,
538            M_WAITOK);
539
540     memset(afs_vnodeop_p, 0, vfs_opv_numops * sizeof(PFI));
541
542     opv_desc_vector = afs_vnodeop_p;
543     for (j = 0; afs_vnodeop_opv_desc.opv_desc_ops[j].opve_op; j++) {
544         opve_descp = &(afs_vnodeop_opv_desc.opv_desc_ops[j]);
545
546         /*
547          * Sanity check:  is this operation listed
548          * in the list of operations?  We check this
549          * by seeing if its offest is zero.  Since
550          * the default routine should always be listed
551          * first, it should be the only one with a zero
552          * offset.  Any other operation with a zero
553          * offset is probably not listed in
554          * vfs_op_descs, and so is probably an error.
555          *
556          * A panic here means the layer programmer
557          * has committed the all-too common bug
558          * of adding a new operation to the layer's
559          * list of vnode operations but
560          * not adding the operation to the system-wide
561          * list of supported operations.
562          */
563         if (opve_descp->opve_op->vdesc_offset == 0
564             && opve_descp->opve_op->vdesc_offset != VOFFSET(vop_default)) {
565             printf("afs_init: operation %s not listed in %s.\n",
566                    opve_descp->opve_op->vdesc_name, "vfs_op_descs");
567             panic("load_afs: bad operation");
568         }
569         /*
570          * Fill in this entry.
571          */
572         opv_desc_vector[opve_descp->opve_op->vdesc_offset] =
573             opve_descp->opve_impl;
574     }
575
576     /*
577      * Finally, go back and replace unfilled routines
578      * with their default.  (Sigh, an O(n^3) algorithm.  I
579      * could make it better, but that'd be work, and n is small.)
580      */
581
582     /*
583      * Force every operations vector to have a default routine.
584      */
585     opv_desc_vector = afs_vnodeop_p;
586     if (opv_desc_vector[VOFFSET(vop_default)] == NULL) {
587         panic("afs_init: operation vector without default routine.");
588     }
589     for (j = 0; j < vfs_opv_numops; j++)
590         if (opv_desc_vector[j] == NULL)
591             opv_desc_vector[j] = opv_desc_vector[VOFFSET(vop_default)];
592 #endif
593     return 0;
594 }
595
596 struct vfsops afs_vfsops = {
597    afs_mount,
598    afs_start,
599    afs_unmount,
600    afs_root,
601 #ifdef AFS_DARWIN80_ENV
602    0,
603    afs_vfs_getattr,
604 #else
605    afs_quotactl,
606    afs_statfs,
607 #endif
608    afs_sync,
609 #ifdef AFS_DARWIN80_ENV
610    0,0,0,
611 #else
612    afs_vfs_vget,
613    afs_fhtovp,
614    afs_vptofh,
615 #endif
616    afs_init,
617    afs_sysctl, 
618 #ifdef AFS_DARWIN80_ENV
619    0 /*setattr */,
620    {0}
621 #endif
622 };