Commit | Line | Data |
---|---|---|
805e021f CE |
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, NULL, NULL); | |
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 | }; |