2 * Copyright 2000, International Business Machines Corporation and others.
5 * This software has been released under the terms of the IBM Public
6 * License. For details, see the LICENSE file in the top-level source
7 * directory or online at http://www.openafs.org/dl/license10.html
11 * osi_vfsops.c for DUX
13 #include <afsconfig.h>
14 #include "../afs/param.h"
18 #include "../afs/sysincludes.h" /* Standard vendor system headers */
19 #include "../afs/afsincludes.h" /* Afs-based standard headers */
20 #include "../afs/afs_stats.h" /* statistics stuff */
21 #include <sys/types.h>
22 #include <kern/mach_param.h>
23 #include <sys/sysconfig.h>
24 #include <sys/systm.h>
25 #include <sys/resource.h>
26 #include <sys/errno.h>
28 #include <machine/machlimits.h>
31 struct vcache *afs_globalVp = 0;
32 struct mount *afs_globalVFS = 0;
34 static u_char afs_mntid;
36 udecl_simple_lock_data(, afsmntid_lock)
37 #define AFSMNTID_LOCK() usimple_lock(&afsmntid_lock)
38 #define AFSMNTID_UNLOCK() usimple_unlock(&afsmntid_lock)
39 #define AFSMNTID_LOCK_INIT() usimple_lock_init(&afsmntid_lock)
42 int mp_afs_mount(struct mount *afsp,char * path, caddr_t data,
43 struct nameidata *ndp)
48 struct mount *xmp, *getvfs();
52 AFS_STATCNT(afs_mount);
54 if (afs_globalVFS) { /* Don't allow remounts. */
60 afsp->vfs_bsize = 8192;
62 * Generate a unique afs mount i.d. ( see nfs_mount() ).
64 afsp->m_stat.f_fsid.val[0] = makedev(130, 0);
65 afsp->m_stat.f_fsid.val[1] = MOUNT_AFS;
71 tfsid.val[0] = makedev(130, afs_mntid);
72 tfsid.val[1] = MOUNT_AFS;
73 BM(AFSMNTID_UNLOCK());
75 while (xmp = getvfs(&tfsid)) {
76 UNMOUNT_READ_UNLOCK(xmp);
82 if (major(tfsid.val[0]) != 130) {
86 afsp->m_stat.f_fsid.val[0] = tfsid.val[0];
88 afsp->m_stat.f_mntonname = AFS_KALLOC(MNAMELEN);
89 afsp->m_stat.f_mntfromname = AFS_KALLOC(MNAMELEN);
90 if ( !afsp->m_stat.f_mntonname || !afsp->m_stat.f_mntfromname)
91 panic("malloc failure in afs_mount\n");
93 memset(afsp->m_stat.f_mntonname, 0, MNAMELEN);
94 memset(afsp->m_stat.f_mntfromname, 0, MNAMELEN);
95 AFS_COPYINSTR(path, (caddr_t)afsp->m_stat.f_mntonname, MNAMELEN, &size, code);
96 memcpy(afsp->m_stat.f_mntfromname, "AFS", 4);
98 (void) mp_afs_statfs(afsp);
100 afs_vfsdev = afsp->m_stat.f_fsid.val[0];
102 #ifndef AFS_NONFSTRANS
103 /* Set up the xlator in case it wasn't done elsewhere */
112 int mp_afs_unmount (struct mount *afsp, int flag)
115 AFS_STATCNT(afs_unmount);
123 int mp_afs_start(struct mount *mp, int flags)
128 int mp_afs_root (struct mount *afsp, struct vnode **avpp)
130 register afs_int32 code = 0;
131 struct vrequest treq;
132 register struct vcache *tvp=0;
135 AFS_STATCNT(afs_root);
136 if (afs_globalVp && (afs_globalVp->states & CStatd)) {
139 if (!(code = afs_InitReq(&treq, u.u_cred)) &&
140 !(code = afs_CheckInit())) {
141 tvp = afs_GetVCache(&afs_rootFid, &treq, (afs_int32 *)0,
142 (struct vcache*)0, WRITE_LOCK);
143 /* we really want this to stay around */
151 struct vnode *vp = AFSTOV(tvp);
155 vp->v_flag |= VROOT; /* No-op on Ultrix 2.2 */
159 afs_globalVFS = afsp;
163 afs_Trace2(afs_iclSetp, CM_TRACE_VFSROOT, ICL_TYPE_POINTER, *avpp,
164 ICL_TYPE_INT32, code);
170 mp_afs_quotactl(struct mount *mp, int cmd, uid_t uid, caddr_t arg)
175 int mp_afs_statfs(struct mount *afsp)
177 struct nstatfs *abp = &afsp->m_stat;
180 AFS_STATCNT(afs_statfs);
182 abp->f_type = MOUNT_AFS;
183 abp->f_bsize = afsp->vfs_bsize;
185 /* Fake a high number below to satisfy programs that use the statfs call
186 * to make sure that there's enough space in the device partition before
187 * storing something there.
189 abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
190 abp->f_ffree = 2000000;
193 abp->f_fsid.val[0] = afsp->m_stat.f_fsid.val[0];
194 abp->f_fsid.val[1] = afsp->m_stat.f_fsid.val[1];
201 int mp_afs_sync(struct mount *mp, int flags)
203 AFS_STATCNT(afs_sync);
209 int mp_afs_smoothsync(struct mount *mp, u_int age, u_int smsync_flag)
211 AFS_STATCNT(afs_sync);
216 int mp_afs_fhtovp(struct mount *afsp, struct fid *fidp, struct vnode **avcp)
218 struct vrequest treq;
222 AFS_STATCNT(afs_vget);
226 if ((code = afs_InitReq(&treq, u.u_cred)) == 0) {
227 code = afs_osi_vget((struct vcache**)avcp, fidp, &treq);
230 afs_Trace3(afs_iclSetp, CM_TRACE_VGET, ICL_TYPE_POINTER, *avcp,
231 ICL_TYPE_INT32, treq.uid, ICL_TYPE_FID, fidp);
233 code = afs_CheckCode(code, &treq, 42);
242 * afs_vptofh can return two flavors of NFS fid, depending on if submounts are
243 * allowed. The reason for this is that we can't guarantee that we found all
244 * the entry points any OS might use to get the fid for the NFS mountd.
245 * Hence we return a "magic" fid for all but /afs. If it goes through the
246 * translator code, it will get transformed into a SmallFid that we recognize.
247 * So, if submounts are disallowed, and an NFS client tries a submount, it will
248 * get a fid which we don't recognize and the mount will either fail or we
249 * will ignore subsequent requests for that mount.
251 * The Alpha fid is organized differently than for other platforms. Their
252 * intention was to have the data portion of the fid aligned on a 4 byte
253 * boundary. To do so, the fid is organized as:
257 * The len field is the length of the entire fid, from reserved through data.
258 * This length is used by fid_copy to include copying the reserved field.
259 * Alpha's zero the reserved field before handing us the fid, but they use
260 * it in fid_cmp. We use the reserved field to store the 16 bits of the Vnode.
262 * Note that the SmallFid only allows for 8 bits of the cell index and
263 * 16 bits of the vnode.
266 #define AFS_FIDDATASIZE 8
267 #define AFS_SIZEOFSMALLFID 12 /* full size of fid, including len field */
268 extern int afs_NFSRootOnly; /* 1 => only allow NFS mounts of /afs. */
269 int afs_fid_vnodeoverflow=0, afs_fid_uniqueoverflow=0;
271 int mp_afs_vptofh(struct vnode *avn, struct fid *fidp)
273 struct SmallFid Sfid;
275 register struct cell *tcell;
277 struct vcache *avc = VTOAFS(avn);
280 AFS_STATCNT(afs_fid);
282 if (afs_shuttingdown) {
287 if (afs_NFSRootOnly && (avc == afs_globalVp)) rootvp = 1;
288 if (!afs_NFSRootOnly || rootvp) {
289 tcell = afs_GetCell(avc->fid.Cell, READ_LOCK);
290 Sfid.Volume = avc->fid.Fid.Volume;
291 fidp->fid_reserved = avc->fid.Fid.Vnode;
292 Sfid.CellAndUnique = ((tcell->cellIndex << 24) +
293 (avc->fid.Fid.Unique & 0xffffff));
294 afs_PutCell(tcell, READ_LOCK);
295 if (avc->fid.Fid.Vnode > 0xffff)
296 afs_fid_vnodeoverflow++;
297 if (avc->fid.Fid.Unique > 0xffffff)
298 afs_fid_uniqueoverflow++;
300 fidp->fid_reserved = AFS_XLATOR_MAGIC;
303 VN_HOLD(AFSTOV(avc));
307 /* Use the fid pointer passed to us. */
308 fidp->fid_len = AFS_SIZEOFSMALLFID;
309 if (afs_NFSRootOnly) {
311 memcpy(fidp->fid_data, (caddr_t)&Sfid, AFS_FIDDATASIZE);
313 memcpy(fidp->fid_data, (caddr_t)addr, AFS_FIDDATASIZE);
316 memcpy(fidp->fid_data, (caddr_t)&Sfid, AFS_FIDDATASIZE);
323 int mp_Afs_init(void); /* vfs_init - defined below */
326 /* This is only called by vfs_mount when afs is going to be mounted as root.
327 * Since we don't support diskless clients we shouldn't come here.
330 int mp_afs_mountroot(struct mount *afsp, struct vnode **vp)
333 AFS_STATCNT(afs_mountroot);
340 /* It's called to setup swapping over the net for diskless clients; again
344 int mp_afs_swapvp(void)
347 AFS_STATCNT(afs_swapvp);
354 struct vfsops afs_vfsops = {
362 mp_afs_fhtovp, /* afs_vget */
374 * System Call Entry Points
376 #define NULL_FUNC (int (*)(int))0
378 int (*afs_syscall_func)() = NULL_FUNC;
379 int (*afs_xsetgroups_func)() = NULL_FUNC;
380 int (*afs_xioctl_func)() = NULL_FUNC;
382 afssyscall(p, args, retval)
391 func = afs_syscall_func;
392 if (func == NULL_FUNC) {
393 code = nosys(p, args, retval);
395 code = (*func)(p, args, retval);
401 afsxsetgroups(p, args, retval)
410 func = afs_xsetgroups_func;
411 if (func == NULL_FUNC) {
412 code = nosys(p, args, retval);
414 code = (*func)(p, args, retval);
420 afsxioctl(p, args, retval)
429 func = afs_xioctl_func;
430 if (func == NULL_FUNC) {
431 code = nosys(p, args, retval);
433 code = (*func)(p, args, retval);
441 * VFS initialization and unload
450 cfg_subsys_attr_t afs_attributes[] = {
451 {"", 0, 0, 0, 0, 0, 0} /* must be the last element */
454 afs_configure(cfg_op_t op, caddr_t indata, size_t indata_size, caddr_t outdata, size_t outdata_size)
456 cfg_attr_t *attributes;
462 case CFG_OP_CONFIGURE:
464 * The indata parameter is a list of attributes to be configured, and
465 * indata_size is the count of attributes.
467 if ((ret = vfssw_add_fsname(MOUNT_AFS, &afs_vfsops, "afs")) != 0)
470 case CFG_OP_UNCONFIGURE:
471 if ((ret = afs_unconfig()) != 0)
482 int mp_Afs_init(void)
484 extern int Afs_xsetgroups(), afs_xioctl(), afs3_syscall();
487 sysent[AFS_SYSCALL].sy_call = afs3_syscall;
489 sysent[AFS_SYSCALL].sy_info = 6;
491 sysent[AFS_SYSCALL].sy_parallel = 0;
492 sysent[AFS_SYSCALL].sy_narg = 6;
494 sysent[SYS_setgroups].sy_call = Afs_xsetgroups;
495 afs_xioctl_func = afsxioctl;
496 afs_xsetgroups_func = afsxsetgroups;
497 afs_syscall_func = afssyscall;