04fdf5cad18ca53d81a86b97ea9766dc77a3c2f4
[openafs.git] / src / afs / FBSD / osi_vfsops.c
1 #include <afsconfig.h>
2 #include <afs/param.h>
3
4 RCSID
5     ("$Header$");
6
7 #include <afs/sysincludes.h>    /* Standard vendor system headers */
8 #include <afsincludes.h>        /* Afs-based standard headers */
9 #include <afs/afs_stats.h>      /* statistics */
10 #include <sys/malloc.h>
11 #include <sys/namei.h>
12 #include <sys/conf.h>
13 #include <sys/syscall.h>
14
15 struct vcache *afs_globalVp = NULL;
16 struct mount *afs_globalVFS = NULL;
17 int afs_pbuf_freecnt = -1;
18
19 #ifdef AFS_FBSD50_ENV
20 #define THREAD_OR_PROC struct thread *p
21 #else
22 #define THREAD_OR_PROC struct proc *p
23 #endif
24
25 int
26 afs_start(struct mount *mp, int flags, THREAD_OR_PROC)
27 {
28     afs_pbuf_freecnt = nswbuf / 2 + 1;
29     return (0);                 /* nothing to do. ? */
30 }
31
32 #ifdef AFS_FBSD53_ENV
33 int
34 afs_mount(struct mount *mp, struct thread *td)
35 {
36     int afs_omount(struct mount *mp, char *path, caddr_t data, struct thread *p);
37
38     return afs_omount(mp, NULL, NULL, td);
39 }
40 #endif
41
42 int
43 #ifdef AFS_FBSD53_ENV
44 afs_omount(struct mount *mp, char *path, caddr_t data, struct thread *p)
45 #else
46 afs_omount(struct mount *mp, char *path, caddr_t data, struct nameidata *ndp,
47         THREAD_OR_PROC)
48 #endif
49 {
50     /* ndp contains the mounted-from device.  Just ignore it.
51      * we also don't care about our proc struct. */
52     size_t size;
53
54     if (mp->mnt_flag & MNT_UPDATE)
55         return EINVAL;
56
57     AFS_GLOCK();
58     AFS_STATCNT(afs_mount);
59
60     if (afs_globalVFS) {        /* Don't allow remounts. */
61         AFS_GUNLOCK();
62         return EBUSY;
63     }
64
65     afs_globalVFS = mp;
66     mp->vfs_bsize = 8192;
67     vfs_getnewfsid(mp);
68     mp->mnt_stat.f_iosize = 8192;
69
70     if (path)
71         (void) copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1, &size);
72     memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
73     memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
74     strcpy(mp->mnt_stat.f_mntfromname, "AFS");
75     /* null terminated string "AFS" will fit, just leave it be. */
76     strcpy(mp->mnt_stat.f_fstypename, "afs");
77     AFS_GUNLOCK();
78     (void)afs_statfs(mp, &mp->mnt_stat, p);
79     return 0;
80 }
81
82 int
83 afs_unmount(struct mount *mp, int flags, THREAD_OR_PROC)
84 {
85
86     /*
87      * Release any remaining vnodes on this mount point.
88      * The `1' means that we hold one extra reference on
89      * the root vnode (this is just a guess right now).
90      * This has to be done outside the global lock.
91      */
92 #ifdef AFS_FBSD53_ENV
93     vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0, p);
94 #else
95     vflush(mp, 1, (flags & MNT_FORCE) ? FORCECLOSE : 0);
96 #endif
97     AFS_GLOCK();
98     AFS_STATCNT(afs_unmount);
99     afs_globalVFS = 0;
100     afs_shutdown();
101     AFS_GUNLOCK();
102
103     return 0;
104 }
105
106 int
107 #ifdef AFS_FBSD53_ENV
108 afs_root(struct mount *mp, struct vnode **vpp, struct thread *td)
109 #else
110 afs_root(struct mount *mp, struct vnode **vpp)
111 #endif
112 {
113     int error;
114     struct vrequest treq;
115     register struct vcache *tvp = 0;
116 #ifdef AFS_FBSD50_ENV
117 #ifndef AFS_FBSD53_ENV
118     struct thread *td = curthread;
119 #endif
120     struct ucred *cr = td->td_ucred;
121 #else
122     struct proc *p = curproc;
123     struct ucred *cr = p->p_cred->pc_ucred;
124 #endif
125
126     AFS_GLOCK();
127     AFS_STATCNT(afs_root);
128     crhold(cr);
129     if (afs_globalVp && (afs_globalVp->states & CStatd)) {
130         tvp = afs_globalVp;
131         error = 0;
132     } else {
133 tryagain:
134         if (afs_globalVp) {
135             afs_PutVCache(afs_globalVp);
136             /* vrele() needed here or not? */
137             afs_globalVp = NULL;
138         }
139
140         if (!(error = afs_InitReq(&treq, cr)) && !(error = afs_CheckInit())) {
141             tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);
142             /* we really want this to stay around */
143             if (tvp)
144                 afs_globalVp = tvp;
145             else
146                 error = ENOENT;
147         }
148     }
149     if (tvp) {
150         struct vnode *vp = AFSTOV(tvp);
151
152 #ifdef AFS_FBSD50_ENV
153         ASSERT_VI_UNLOCKED(vp, "afs_root");
154 #endif
155         AFS_GUNLOCK();
156         /*
157          * I'm uncomfortable about this.  Shouldn't this happen at a
158          * higher level, and shouldn't we busy the top-level directory
159          * to prevent recycling?
160          */
161 #ifdef AFS_FBSD50_ENV
162         error = vget(vp, LK_EXCLUSIVE | LK_RETRY, td);
163         vp->v_vflag |= VV_ROOT;
164 #else
165         error = vget(vp, LK_EXCLUSIVE | LK_RETRY, p);
166         vp->v_flag |= VROOT;
167 #endif
168         AFS_GLOCK();
169         if (error != 0)
170                 goto tryagain;
171
172         afs_globalVFS = mp;
173         *vpp = vp;
174     }
175
176     afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *vpp,
177                ICL_TYPE_INT32, error);
178     AFS_GUNLOCK();
179     crfree(cr);
180     return error;
181 }
182
183 int
184 afs_statfs(struct mount *mp, struct statfs *abp, THREAD_OR_PROC)
185 {
186     AFS_GLOCK();
187     AFS_STATCNT(afs_statfs);
188
189     abp->f_bsize = mp->vfs_bsize;
190     abp->f_iosize = mp->vfs_bsize;
191
192     /* Fake a high number below to satisfy programs that use the statfs call
193      * to make sure that there's enough space in the device partition before
194      * storing something there.
195      */
196     abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
197         abp->f_ffree = 2000000;
198
199     abp->f_fsid.val[0] = mp->mnt_stat.f_fsid.val[0];
200     abp->f_fsid.val[1] = mp->mnt_stat.f_fsid.val[1];
201     if (abp != &mp->mnt_stat) {
202         abp->f_type = mp->mnt_vfc->vfc_typenum;
203         memcpy((caddr_t) & abp->f_mntonname[0],
204                (caddr_t) mp->mnt_stat.f_mntonname, MNAMELEN);
205         memcpy((caddr_t) & abp->f_mntfromname[0],
206                (caddr_t) mp->mnt_stat.f_mntfromname, MNAMELEN);
207     }
208
209     AFS_GUNLOCK();
210     return 0;
211 }
212
213 int
214 afs_sync(struct mount *mp, int waitfor, struct ucred *cred, THREAD_OR_PROC)
215 {
216     return 0;
217 }
218
219 int
220 afs_init(struct vfsconf *vfc)
221 {
222     return 0;
223 }
224
225 struct vfsops afs_vfsops = {
226 #ifdef AFS_FBSD53_ENV
227     afs_mount,
228 #endif
229     afs_omount,
230     afs_start,
231     afs_unmount,
232     afs_root,
233     vfs_stdquotactl,
234     afs_statfs,
235     afs_sync,
236     vfs_stdvget,
237     vfs_stdfhtovp,
238     vfs_stdcheckexp,
239     vfs_stdvptofh,
240     afs_init,
241     vfs_stduninit,
242     vfs_stdextattrctl,
243 #ifdef AFS_FBSD50_ENV
244     vfs_stdsysctl,
245 #endif
246 };