[hcoop/debian/openafs.git] / src / afs / NBSD / osi_vfsops.c

/*
 * OpenBSD specific assistance routines & VFS ops
 * Original NetBSD version for Transarc afs by John Kohl <jtk@MIT.EDU>
 * OpenBSD version by Jim Rees <rees@umich.edu>
 * Reported to NetBSD 4.0 by Matt Benjamin (matt@linuxbox.com)
 *
 * $Id: osi_vfsops.c,v 1.20 2005/03/08 21:58:04 shadow Exp $
 */

/*
copyright 2002
the regents of the university of michigan
all rights reserved

permission is granted to use, copy, create derivative works
and redistribute this software and such derivative works
for any purpose, so long as the name of the university of
michigan is not used in any advertising or publicity
pertaining to the use or distribution of this software
without specific, written prior authorization.  if the
above copyright notice or any other identification of the
university of michigan is included in any copy of any
portion of this software, then the disclaimer below must
also be included.

this software is provided as is, without representation
from the university of michigan as to its fitness for any
purpose, and without warranty by the university of
michigan of any kind, either express or implied, including
without limitation the implied warranties of
merchantability and fitness for a particular purpose. the
regents of the university of michigan shall not be liable
for any damages, including special, indirect, incidental, or
consequential damages, with respect to any claim arising
out of or in connection with the use of the software, even
if it has been or is hereafter advised of the possibility of
such damages.
*/

/*
Copyright 1995 Massachusetts Institute of Technology.  All Rights
Reserved.

You are hereby granted a worldwide, irrevocable, paid-up, right and
license to use, execute, display, modify, copy and distribute MIT's
Modifications, provided that (i) you abide by the terms and conditions
of the OpenAFS License Agreement, and (ii) you do not use the name
of MIT in any advertising or publicity without the prior written consent
of MIT.  MIT disclaims all liability for your use of MIT's
Modifications.  MIT's Modifications are provided "AS IS" WITHOUT
WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO,
ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
NONINFRINGEMENT.
*/

/*
 * Some code cribbed from ffs_vfsops and other NetBSD sources, which
 * are marked:
 */
/*
 * Copyright (c) 1989, 1991, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include <afsconfig.h>
#include "afs/param.h"

#include "afs/sysincludes.h"	/* Standard vendor system headers */
#include "afs/afsincludes.h"	/* Afs-based standard headers */
#include "afs/afs_stats.h"	/* statistics */

#include <sys/ioctl.h>
#ifndef AFS_NBSD60_ENV
#include <sys/lkm.h>
#endif
#include <sys/namei.h>
#include <miscfs/genfs/genfs.h>

VFS_PROTOS(afs);

#ifndef AFS_NBSD60_ENV
extern int sys_lkmnosys(struct lwp *, const void *, register_t *);
extern int afs3_syscall(struct lwp *, const void *, register_t *);
extern int afs_xioctl(struct lwp *, const void *, register_t *);
extern int Afs_xsetgroups(struct lwp *, const void *, register_t *);
static int afs_badcall(struct lwp *, const void *, register_t *);

static int lkmid = -1;

struct sysent afs_sysent = { 6,
			     sizeof(struct afs_sysargs),
			     0,
			     afs3_syscall};

static struct sysent old_sysent;
static struct sysent old_setgroups;
#endif

struct osi_vfs *afs_globalVFS;
struct vcache *afs_globalVp;
fsid_t afs_dynamic_fsid;

int afs_mount(struct mount *, const char *, void *, size_t *);
int afs_start(struct mount *, int);
int afs_unmount(struct mount *, int);
int afs_root(struct mount *, struct vnode **);
int afs_statvfs(struct mount *, struct statvfs *);
int afs_sync(struct mount *, int, kauth_cred_t);
void afs_init(void);
void afs_reinit(void);
void afs_done(void);

extern struct vnodeopv_desc afs_vnodeop_opv_desc;
static const struct vnodeopv_desc *afs_vnodeopv_descs[] = {
	&afs_vnodeop_opv_desc,
	NULL,
};

struct vfsops afs_vfsops = {
    AFS_MOUNT_AFS,
#ifdef AFS_NBSD50_ENV
	0,						/* vfs_min_mount_data */
#endif
    afs_mount,
    afs_start,
    afs_unmount,
    afs_root,
    (void *) eopnotsupp,	/* vfs_quotactl */
    afs_statvfs,
    afs_sync,
    (void *) eopnotsupp,	/* vfs_vget */
    (void *) eopnotsupp,	/* vfs_fhtovp */
    (void *) eopnotsupp,	/* vfs_vptofh */
    afs_init,
    afs_reinit,
    afs_done,
    (void *) eopnotsupp,	/* vfs_mountroot */
    (void *) eopnotsupp,	/* vfs_snapshot */
    vfs_stdextattrctl,
#ifdef AFS_NBSD50_ENV
    (void *) eopnotsupp, 	/* vfs_suspendctl */
    genfs_renamelock_enter,	/* vfs_renamelock_enter */
    genfs_renamelock_exit,	/* vfs_renamelock_exit */
    (void *) eopnotsupp,	/* vfs_fsync */
#endif
    afs_vnodeopv_descs,
    0,				/* vfs_refcount */
    { NULL, NULL },
};

int
afs_nbsd_lookupname(const char *fnamep, enum uio_seg segflg, int followlink,
		    struct vnode **compvpp)
{
    struct nameidata nd;
    int niflag;
    int error;

    if ((afs_debug & AFSDEB_VNLAYER) != 0) {
	afs_warn("afs_nbsd_lookupname enter (%s)\n", fnamep);
    }

    /*
     * Lookup pathname "fnamep", returning leaf in *compvpp.  segflg says
     * whether the pathname is user or system space.
     */
    /* XXX LOCKLEAF ? */
    niflag = followlink ? FOLLOW : NOFOLLOW;
	/*
	*	NBSD50 seems to have stopped caring about the curproc of things.
	*	mattjsm
	*/
#if defined(AFS_NBSD60_ENV)
    struct pathbuf *ipb = NULL;
    ipb = pathbuf_create(fnamep);
    NDINIT(&nd, LOOKUP, niflag, ipb);
#elif defined(AFS_NBSD50_ENV)
    NDINIT(&nd, LOOKUP, niflag, segflg, fnamep);
#else
    NDINIT(&nd, LOOKUP, niflag, segflg, fnamep, osi_curproc());
#endif
    if ((error = namei(&nd))) {
	goto out;
    }
    *compvpp = nd.ni_vp;
out:
#if defined(AFS_NBSD60_ENV)
    pathbuf_destroy(ipb);
#endif
    return error;
}

int
afs_start(struct mount *mp, int flags)
{
    return (0); /* nothing to do? */
}

void afs_done(void)
{
    return; /* nothing to do? */
}

int
afs_mount(struct mount *mp, const char *path, void *data,
	  size_t *dlen)
{
    /* ndp contains the mounted-from device.  Just ignore it.
     * we also don't care about our proc struct. */
    size_t size;

    AFS_STATCNT(afs_mount);

    if ((afs_debug & AFSDEB_VNLAYER) != 0) {
	afs_warn("afs_mount enter\n");
    }

    if (mp->mnt_flag & MNT_UPDATE)
	return EINVAL;

    if (afs_globalVFS != NULL) {
	/* Don't allow remounts */
	return EBUSY;
    }

    AFS_GLOCK();
#ifdef AFS_DISCON_ENV
    /* initialize the vcache entries before we start using them */

    /* XXX find a better place for this if possible  */
    init_vcache_entries();
#endif
    afs_globalVFS = mp;
    mp->mnt_stat.f_bsize = 8192;
    mp->mnt_stat.f_frsize = 8192;
    mp->mnt_stat.f_iosize = 8192;
    mp->mnt_fs_bshift = DEV_BSHIFT;
    mp->mnt_dev_bshift = DEV_BSHIFT;
    vfs_getnewfsid(mp);
    afs_dynamic_fsid = mp->mnt_stat.f_fsidx;
    (void)copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1,
		    &size);
    memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
    memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
    strcpy(mp->mnt_stat.f_mntfromname, "AFS");
    /* null terminated string "AFS" will fit, just leave it be. */
    strcpy(mp->mnt_stat.f_fstypename, AFS_MOUNT_AFS);
    AFS_GUNLOCK();
    (void)afs_statvfs(mp, &mp->mnt_stat);

    if ((afs_debug & AFSDEB_VNLAYER) != 0) {
	afs_warn("afs_mount exit\n");
    }

    return 0;
}

int
afs_unmount(struct mount *mp, int mntflags)
{
    AFS_STATCNT(afs_unmount);
#ifdef AFS_DISCON_ENV
    give_up_cbs();
#endif
    if (afs_globalVFS == NULL) {
	printf("afs already unmounted\n");
	return 0;
    }
    if (afs_globalVp)
	vrele(AFSTOV(afs_globalVp));
    afs_globalVp = NULL;

    vflush(mp, NULLVP, 0);	/* don't support forced */
    AFS_GLOCK();
    afs_globalVFS = NULL;
    afs_cold_shutdown = 1;
    afs_shutdown();		/* XXX */
    AFS_GUNLOCK();

    mp->mnt_data = NULL;

    printf("AFS unmounted.\n");
    return 0;
}

#ifndef AFS_NBSD60_ENV
static int
afs_badcall(struct lwp *l, const void *xx, register_t *yy)
{
    return ENOSYS;
}
#endif

int
afs_root(struct mount *mp, struct vnode **vpp)
{
    struct vrequest treq;
    struct vcache *tvp;
    struct vcache *gvp;
    int code;

    AFS_STATCNT(afs_root);

    if ((afs_debug & AFSDEB_VNLAYER) != 0) {
	int glocked = ISAFS_GLOCK();
	afs_warn("afs_root enter, glocked==%d\n", glocked);
    }

    AFS_GLOCK();

    if ((afs_debug & AFSDEB_VNLAYER) != 0) {
	afs_warn("afs_root: glocked\n");
    }

    tvp = NULL;
tryagain:
    if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {
	tvp = afs_globalVp;
	code = 0;
    } else {
	if (afs_globalVp) {
	    gvp = afs_globalVp;
	    afs_globalVp = NULL;
	    afs_PutVCache(gvp);
	}

	if (!(code = afs_InitReq(&treq, osi_curcred()))
	    && !(code = afs_CheckInit())) {
	    tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);

	    if (tvp) {
		if (afs_globalVp) {

		    afs_PutVCache(tvp);
		    tvp = NULL;
		    goto tryagain;
		}
		afs_globalVp = tvp;
	    } else
		code = EIO;
	}
    }
    if (tvp) {
	struct vnode *vp = AFSTOV(tvp);
	AFS_GUNLOCK();
	vref(vp);
	if (code != 0) {
		vrele(vp);
		return code;
	}
	if (!VOP_ISLOCKED(*vpp))
	    code = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
	AFS_GLOCK();
	if (!afs_globalVp || !(afs_globalVp->f.states & CStatd) ||
	    tvp != afs_globalVp) {
	    vput(vp);
	    afs_PutVCache(tvp);
	    tvp = NULL;
	    goto tryagain;
	}
	if (code != 0)
	    goto tryagain;
	vp->v_vflag |= VV_ROOT;
	if (afs_globalVFS != mp)
	    afs_globalVFS = mp;
	*vpp = vp;
    }
    AFS_GUNLOCK();

    if ((afs_debug & AFSDEB_VNLAYER) != 0) {
	afs_warn("afs_root exit\n");
    }

    return code;
}

int
afs_statvfs(struct mount *mp, struct statvfs *abp)
{
    AFS_STATCNT(afs_statfs);

    if ((afs_debug & AFSDEB_VNLAYER) != 0) {
	afs_warn("afs_statvfs enter\n");
    }

    /* thank you, NetBSD */
    copy_statvfs_info(abp, mp);

    /* not actually sure which we really must set, but
     * pretty sure of the right values (and in 40, none touched by
     * the above convenience function) */
    abp->f_bsize = mp->osi_vfs_bsize;
    abp->f_frsize = mp->osi_vfs_bsize;
    abp->f_iosize = mp->osi_vfs_bsize;

    abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
	abp->f_ffree = AFS_VFS_FAKEFREE;

    return (0);
}

int
afs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
{
    AFS_STATCNT(afs_sync);
#if defined(AFS_DISCON_ENV)
    /* Can't do this in OpenBSD 2.7, it faults when called from apm_suspend() */
    store_dirty_vcaches();
#endif
    return 0;
}

void
afs_init(void)
{
    osi_Init();
    return;
}

void
afs_reinit(void)
{
    return;
}

#ifndef AFS_NBSD60_ENV
/* LKM */

/*
 * declare the filesystem
 */
MOD_VFS("afs", -1, &afs_vfsops);

static int
afs_vfs_load(struct lkm_table *lkmtp, int cmd)
{
    lkmid = lkmtp->id;
    if (sysent[AFS_SYSCALL].sy_call != sys_lkmnosys) {
	printf("LKM afs_vfs_load(): AFS3 syscall %d already used\n",
	    AFS_SYSCALL);
	/* return EEXIST; */
    }

    old_sysent = sysent[AFS_SYSCALL];
    sysent[AFS_SYSCALL] = afs_sysent;
    old_setgroups = sysent[SYS_setgroups];
    sysent[SYS_setgroups].sy_call = Afs_xsetgroups;
#if NOTYET
    old_ioctl = sysent[SYS_ioctl];
    sysent[SYS_ioctl].sy_call = afs_xioctl;
#endif

    aprint_verbose("OpenAFS loaded\n");

    return (0);
}

static int
afs_vfs_unload(struct lkm_table *lktmp, int cmd)
{
    if (afs_globalVp)
	return EBUSY;

    if (sysent[AFS_SYSCALL].sy_call != afs_sysent.sy_call) {
	printf("LKM afs_vfs_load(): AFS3 syscall %d already used\n",
	       AFS_SYSCALL);
	return EEXIST;
    }

    sysent[AFS_SYSCALL] = old_sysent;
    sysent[SYS_setgroups] = old_setgroups;
#if NOTYET
    sysent[SYS_ioctl] = old_ioctl;
#endif
    printf("OpenAFS unloaded\n");

    return (0);
}

int libafs_lkmentry(struct lkm_table *, int, int);

int
libafs_lkmentry(struct lkm_table *lkmtp, int cmd, int ver)
{
    if (cmd == LKM_E_LOAD) {
	if (sysent[AFS_SYSCALL].sy_call == afs3_syscall
	    || sysent[AFS_SYSCALL].sy_call == afs_badcall) {
	    printf("AFS already loaded\n");
	    return EINVAL;
	}
    }

    DISPATCH(lkmtp, cmd, ver, afs_vfs_load, afs_vfs_unload, lkm_nofunc);
}
#endif
Commit	Line	Data
805e021f CE	1	/*
	2	* OpenBSD specific assistance routines & VFS ops
	3	* Original NetBSD version for Transarc afs by John Kohl <jtk@MIT.EDU>
	4	* OpenBSD version by Jim Rees <rees@umich.edu>
	5	* Reported to NetBSD 4.0 by Matt Benjamin (matt@linuxbox.com)
	6	*
	7	* $Id: osi_vfsops.c,v 1.20 2005/03/08 21:58:04 shadow Exp $
	8	*/
	9
	10	/*
	11	copyright 2002
	12	the regents of the university of michigan
	13	all rights reserved
	14
	15	permission is granted to use, copy, create derivative works
	16	and redistribute this software and such derivative works
	17	for any purpose, so long as the name of the university of
	18	michigan is not used in any advertising or publicity
	19	pertaining to the use or distribution of this software
	20	without specific, written prior authorization. if the
	21	above copyright notice or any other identification of the
	22	university of michigan is included in any copy of any
	23	portion of this software, then the disclaimer below must
	24	also be included.
	25
	26	this software is provided as is, without representation
	27	from the university of michigan as to its fitness for any
	28	purpose, and without warranty by the university of
	29	michigan of any kind, either express or implied, including
	30	without limitation the implied warranties of
	31	merchantability and fitness for a particular purpose. the
	32	regents of the university of michigan shall not be liable
	33	for any damages, including special, indirect, incidental, or
	34	consequential damages, with respect to any claim arising
	35	out of or in connection with the use of the software, even
	36	if it has been or is hereafter advised of the possibility of
	37	such damages.
	38	*/
	39
	40	/*
	41	Copyright 1995 Massachusetts Institute of Technology. All Rights
	42	Reserved.
	43
	44	You are hereby granted a worldwide, irrevocable, paid-up, right and
	45	license to use, execute, display, modify, copy and distribute MIT's
	46	Modifications, provided that (i) you abide by the terms and conditions
	47	of the OpenAFS License Agreement, and (ii) you do not use the name
	48	of MIT in any advertising or publicity without the prior written consent
	49	of MIT. MIT disclaims all liability for your use of MIT's
	50	Modifications. MIT's Modifications are provided "AS IS" WITHOUT
	51	WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO,
	52	ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
	53	NONINFRINGEMENT.
	54	*/
	55
	56	/*
	57	* Some code cribbed from ffs_vfsops and other NetBSD sources, which
	58	* are marked:
	59	*/
	60	/*
	61	* Copyright (c) 1989, 1991, 1993, 1994
	62	* The Regents of the University of California. All rights reserved.
	63	*
	64	* Redistribution and use in source and binary forms, with or without
65	* modification, are permitted provided that the following conditions
66	* are met:
67	* 1. Redistributions of source code must retain the above copyright
68	* notice, this list of conditions and the following disclaimer.
69	* 2. Redistributions in binary form must reproduce the above copyright
70	* notice, this list of conditions and the following disclaimer in the
71	* documentation and/or other materials provided with the distribution.
72	* 3. All advertising materials mentioning features or use of this software
73	* must display the following acknowledgement:
74	* This product includes software developed by the University of
75	* California, Berkeley and its contributors.
76	* 4. Neither the name of the University nor the names of its contributors
77	* may be used to endorse or promote products derived from this software
78	* without specific prior written permission.
79	*
80	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
81	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
82	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
83	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
84	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
85	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
86	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
87	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
88	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
89	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
90	* SUCH DAMAGE.
91	*
92	*/
93
94	#include <afsconfig.h>
95	#include "afs/param.h"
96
97	#include "afs/sysincludes.h" /* Standard vendor system headers */
98	#include "afs/afsincludes.h" /* Afs-based standard headers */
99	#include "afs/afs_stats.h" /* statistics */
100
101	#include <sys/ioctl.h>
102	#ifndef AFS_NBSD60_ENV
103	#include <sys/lkm.h>
104	#endif
105	#include <sys/namei.h>
106	#include <miscfs/genfs/genfs.h>
107
108	VFS_PROTOS(afs);
109
110	#ifndef AFS_NBSD60_ENV
111	extern int sys_lkmnosys(struct lwp , const void , register_t *);
112	extern int afs3_syscall(struct lwp , const void , register_t *);
113	extern int afs_xioctl(struct lwp , const void , register_t *);
114	extern int Afs_xsetgroups(struct lwp , const void , register_t *);
115	static int afs_badcall(struct lwp , const void , register_t *);
116
117	static int lkmid = -1;
118
119	struct sysent afs_sysent = { 6,
120	sizeof(struct afs_sysargs),
121	0,
122	afs3_syscall};
123
124	static struct sysent old_sysent;
125	static struct sysent old_setgroups;
126	#endif
127
128	struct osi_vfs *afs_globalVFS;
129	struct vcache *afs_globalVp;
130	fsid_t afs_dynamic_fsid;
131
132	int afs_mount(struct mount , const char , void , size_t );
133	int afs_start(struct mount *, int);
134	int afs_unmount(struct mount *, int);
135	int afs_root(struct mount , struct vnode *);
136	int afs_statvfs(struct mount , struct statvfs );
137	int afs_sync(struct mount *, int, kauth_cred_t);
138	void afs_init(void);
139	void afs_reinit(void);
140	void afs_done(void);
141
142	extern struct vnodeopv_desc afs_vnodeop_opv_desc;
143	static const struct vnodeopv_desc *afs_vnodeopv_descs[] = {
144	&afs_vnodeop_opv_desc,
145	NULL,
146	};
147
148	struct vfsops afs_vfsops = {
149	AFS_MOUNT_AFS,
150	#ifdef AFS_NBSD50_ENV
151	0, /* vfs_min_mount_data */
152	#endif
153	afs_mount,
154	afs_start,
155	afs_unmount,
156	afs_root,
157	(void ) eopnotsupp, / vfs_quotactl */
158	afs_statvfs,
159	afs_sync,
160	(void ) eopnotsupp, / vfs_vget */
161	(void ) eopnotsupp, / vfs_fhtovp */
162	(void ) eopnotsupp, / vfs_vptofh */
163	afs_init,
164	afs_reinit,
165	afs_done,
166	(void ) eopnotsupp, / vfs_mountroot */
167	(void ) eopnotsupp, / vfs_snapshot */
168	vfs_stdextattrctl,
169	#ifdef AFS_NBSD50_ENV
170	(void ) eopnotsupp, / vfs_suspendctl */
171	genfs_renamelock_enter, /* vfs_renamelock_enter */
172	genfs_renamelock_exit, /* vfs_renamelock_exit */
173	(void ) eopnotsupp, / vfs_fsync */
174	#endif
175	afs_vnodeopv_descs,
176	0, /* vfs_refcount */
177	{ NULL, NULL },
178	};
179
180	int
181	afs_nbsd_lookupname(const char *fnamep, enum uio_seg segflg, int followlink,
182	struct vnode **compvpp)
183	{
184	struct nameidata nd;
185	int niflag;
186	int error;
187
188	if ((afs_debug & AFSDEB_VNLAYER) != 0) {
189	afs_warn("afs_nbsd_lookupname enter (%s)\n", fnamep);
190	}
191
192	/*
193	* Lookup pathname "fnamep", returning leaf in *compvpp. segflg says
194	* whether the pathname is user or system space.
195	*/
196	/* XXX LOCKLEAF ? */
197	niflag = followlink ? FOLLOW : NOFOLLOW;
198	/*
199	* NBSD50 seems to have stopped caring about the curproc of things.
200	* mattjsm
201	*/
202	#if defined(AFS_NBSD60_ENV)
203	struct pathbuf *ipb = NULL;
204	ipb = pathbuf_create(fnamep);
205	NDINIT(&nd, LOOKUP, niflag, ipb);
206	#elif defined(AFS_NBSD50_ENV)
207	NDINIT(&nd, LOOKUP, niflag, segflg, fnamep);
208	#else
209	NDINIT(&nd, LOOKUP, niflag, segflg, fnamep, osi_curproc());
210	#endif
211	if ((error = namei(&nd))) {
212	goto out;
213	}
214	*compvpp = nd.ni_vp;
215	out:
216	#if defined(AFS_NBSD60_ENV)
217	pathbuf_destroy(ipb);
218	#endif
219	return error;
220	}
221
222	int
223	afs_start(struct mount *mp, int flags)
224	{
225	return (0); /* nothing to do? */
226	}
227
228	void afs_done(void)
229	{
230	return; /* nothing to do? */
231	}
232
233	int
234	afs_mount(struct mount mp, const char path, void *data,
235	size_t *dlen)
236	{
237	/* ndp contains the mounted-from device. Just ignore it.
238	* we also don't care about our proc struct. */
239	size_t size;
240
241	AFS_STATCNT(afs_mount);
242
243	if ((afs_debug & AFSDEB_VNLAYER) != 0) {
244	afs_warn("afs_mount enter\n");
245	}
246
247	if (mp->mnt_flag & MNT_UPDATE)
248	return EINVAL;
249
250	if (afs_globalVFS != NULL) {
251	/* Don't allow remounts */
252	return EBUSY;
253	}
254
255	AFS_GLOCK();
256	#ifdef AFS_DISCON_ENV
257	/* initialize the vcache entries before we start using them */
258
259	/* XXX find a better place for this if possible */
260	init_vcache_entries();
261	#endif
262	afs_globalVFS = mp;
263	mp->mnt_stat.f_bsize = 8192;
264	mp->mnt_stat.f_frsize = 8192;
265	mp->mnt_stat.f_iosize = 8192;
266	mp->mnt_fs_bshift = DEV_BSHIFT;
267	mp->mnt_dev_bshift = DEV_BSHIFT;
268	vfs_getnewfsid(mp);
269	afs_dynamic_fsid = mp->mnt_stat.f_fsidx;
270	(void)copyinstr(path, mp->mnt_stat.f_mntonname, MNAMELEN - 1,
271	&size);
272	memset(mp->mnt_stat.f_mntonname + size, 0, MNAMELEN - size);
273	memset(mp->mnt_stat.f_mntfromname, 0, MNAMELEN);
274	strcpy(mp->mnt_stat.f_mntfromname, "AFS");
275	/* null terminated string "AFS" will fit, just leave it be. */
276	strcpy(mp->mnt_stat.f_fstypename, AFS_MOUNT_AFS);
277	AFS_GUNLOCK();
278	(void)afs_statvfs(mp, &mp->mnt_stat);
279
280	if ((afs_debug & AFSDEB_VNLAYER) != 0) {
281	afs_warn("afs_mount exit\n");
282	}
283
284	return 0;
285	}
286
287	int
288	afs_unmount(struct mount *mp, int mntflags)
289	{
290	AFS_STATCNT(afs_unmount);
291	#ifdef AFS_DISCON_ENV
292	give_up_cbs();
293	#endif
294	if (afs_globalVFS == NULL) {
295	printf("afs already unmounted\n");
296	return 0;
297	}
298	if (afs_globalVp)
299	vrele(AFSTOV(afs_globalVp));
300	afs_globalVp = NULL;
301
302	vflush(mp, NULLVP, 0); /* don't support forced */
303	AFS_GLOCK();
304	afs_globalVFS = NULL;
305	afs_cold_shutdown = 1;
306	afs_shutdown(); /* XXX */
307	AFS_GUNLOCK();
308
309	mp->mnt_data = NULL;
310
311	printf("AFS unmounted.\n");
312	return 0;
313	}
314
315	#ifndef AFS_NBSD60_ENV
316	static int
317	afs_badcall(struct lwp l, const void xx, register_t *yy)
318	{
319	return ENOSYS;
320	}
321	#endif
322
323	int
324	afs_root(struct mount mp, struct vnode *vpp)
325	{
326	struct vrequest treq;
327	struct vcache *tvp;
328	struct vcache *gvp;
329	int code;
330
331	AFS_STATCNT(afs_root);
332
333	if ((afs_debug & AFSDEB_VNLAYER) != 0) {
334	int glocked = ISAFS_GLOCK();
335	afs_warn("afs_root enter, glocked==%d\n", glocked);
336	}
337
338	AFS_GLOCK();
339
340	if ((afs_debug & AFSDEB_VNLAYER) != 0) {
341	afs_warn("afs_root: glocked\n");
342	}
343
344	tvp = NULL;
345	tryagain:
346	if (afs_globalVp && (afs_globalVp->f.states & CStatd)) {
347	tvp = afs_globalVp;
348	code = 0;
349	} else {
350	if (afs_globalVp) {
351	gvp = afs_globalVp;
352	afs_globalVp = NULL;
353	afs_PutVCache(gvp);
354	}
355
356	if (!(code = afs_InitReq(&treq, osi_curcred()))
357	&& !(code = afs_CheckInit())) {
358	tvp = afs_GetVCache(&afs_rootFid, &treq, NULL, NULL);
359
360	if (tvp) {
361	if (afs_globalVp) {
362
363	afs_PutVCache(tvp);
364	tvp = NULL;
365	goto tryagain;
366	}
367	afs_globalVp = tvp;
368	} else
369	code = EIO;
370	}
371	}
372	if (tvp) {
373	struct vnode *vp = AFSTOV(tvp);
374	AFS_GUNLOCK();
375	vref(vp);
376	if (code != 0) {
377	vrele(vp);
378	return code;
379	}
380	if (!VOP_ISLOCKED(*vpp))
381	code = vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY);
382	AFS_GLOCK();
383	if (!afs_globalVp \|\| !(afs_globalVp->f.states & CStatd) \|\|
384	tvp != afs_globalVp) {
385	vput(vp);
386	afs_PutVCache(tvp);
387	tvp = NULL;
388	goto tryagain;
389	}
390	if (code != 0)
391	goto tryagain;
392	vp->v_vflag \|= VV_ROOT;
393	if (afs_globalVFS != mp)
394	afs_globalVFS = mp;
395	*vpp = vp;
396	}
397	AFS_GUNLOCK();
398
399	if ((afs_debug & AFSDEB_VNLAYER) != 0) {
400	afs_warn("afs_root exit\n");
401	}
402
403	return code;
404	}
405
406	int
407	afs_statvfs(struct mount mp, struct statvfs abp)
408	{
409	AFS_STATCNT(afs_statfs);
410
411	if ((afs_debug & AFSDEB_VNLAYER) != 0) {
412	afs_warn("afs_statvfs enter\n");
413	}
414
415	/* thank you, NetBSD */
416	copy_statvfs_info(abp, mp);
417
418	/* not actually sure which we really must set, but
419	* pretty sure of the right values (and in 40, none touched by
420	* the above convenience function) */
421	abp->f_bsize = mp->osi_vfs_bsize;
422	abp->f_frsize = mp->osi_vfs_bsize;
423	abp->f_iosize = mp->osi_vfs_bsize;
424
425	abp->f_blocks = abp->f_bfree = abp->f_bavail = abp->f_files =
426	abp->f_ffree = AFS_VFS_FAKEFREE;
427
428	return (0);
429	}
430
431	int
432	afs_sync(struct mount *mp, int waitfor, kauth_cred_t cred)
433	{
434	AFS_STATCNT(afs_sync);
435	#if defined(AFS_DISCON_ENV)
436	/* Can't do this in OpenBSD 2.7, it faults when called from apm_suspend() */
437	store_dirty_vcaches();
438	#endif
439	return 0;
440	}
441
442	void
443	afs_init(void)
444	{
445	osi_Init();
446	return;
447	}
448
449	void
450	afs_reinit(void)
451	{
452	return;
453	}
454
455	#ifndef AFS_NBSD60_ENV
456	/* LKM */
457
458	/*
459	* declare the filesystem
460	*/
461	MOD_VFS("afs", -1, &afs_vfsops);
462
463	static int
464	afs_vfs_load(struct lkm_table *lkmtp, int cmd)
465	{
466	lkmid = lkmtp->id;
467	if (sysent[AFS_SYSCALL].sy_call != sys_lkmnosys) {
468	printf("LKM afs_vfs_load(): AFS3 syscall %d already used\n",
469	AFS_SYSCALL);
470	/* return EEXIST; */
471	}
472
473	old_sysent = sysent[AFS_SYSCALL];
474	sysent[AFS_SYSCALL] = afs_sysent;
475	old_setgroups = sysent[SYS_setgroups];
476	sysent[SYS_setgroups].sy_call = Afs_xsetgroups;
477	#if NOTYET
478	old_ioctl = sysent[SYS_ioctl];
479	sysent[SYS_ioctl].sy_call = afs_xioctl;
480	#endif
481
482	aprint_verbose("OpenAFS loaded\n");
483
484	return (0);
485	}
486
487	static int
488	afs_vfs_unload(struct lkm_table *lktmp, int cmd)
489	{
490	if (afs_globalVp)
491	return EBUSY;
492
493	if (sysent[AFS_SYSCALL].sy_call != afs_sysent.sy_call) {
494	printf("LKM afs_vfs_load(): AFS3 syscall %d already used\n",
495	AFS_SYSCALL);
496	return EEXIST;
497	}
498
499	sysent[AFS_SYSCALL] = old_sysent;
500	sysent[SYS_setgroups] = old_setgroups;
501	#if NOTYET
502	sysent[SYS_ioctl] = old_ioctl;
503	#endif
504	printf("OpenAFS unloaded\n");
505
506	return (0);
507	}
508
509	int libafs_lkmentry(struct lkm_table *, int, int);
510
511	int
512	libafs_lkmentry(struct lkm_table *lkmtp, int cmd, int ver)
513	{
514	if (cmd == LKM_E_LOAD) {
515	if (sysent[AFS_SYSCALL].sy_call == afs3_syscall
516	\|\| sysent[AFS_SYSCALL].sy_call == afs_badcall) {
517	printf("AFS already loaded\n");
518	return EINVAL;
519	}
520	}
521
522	DISPATCH(lkmtp, cmd, ver, afs_vfs_load, afs_vfs_unload, lkm_nofunc);
523	}
524	#endif