gfs.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/sysmacros.h>
/*
* Generic pseudo-filesystem routines.
*
* There are significant similarities between the implementation of certain file
* system entry points across different filesystems. While one could attempt to
* "choke up on the bat" and incorporate common functionality into a VOP
* preamable or postamble, such an approach is limited in the benefit it can
* provide. In this file we instead define a toolkit of routines which can be
* called from a filesystem (with in-kernel pseudo-filesystems being the focus
* of the exercise) in a more component-like fashion.
*
* There are three basic classes of routines:
*
* 1) Lowlevel support routines
*
* These routines are designed to play a support role for existing
* pseudo-filesystems (such as procfs). They simplif ycommon tasks,
* without enforcing the filesystem to hand over management to GFS. The
* routines covered are:
*
* gfs_readdir_init()
* gfs_readdir_emit()
* gfs_readdir_emitn()
* gfs_readdir_pred()
* gfs_readdir_fini()
* gfs_lookup_dot()
*
* 2) Complete GFS management
*
* These routines take a more active role in management of the
* pseudo-filesystem. They handle the relationship between vnode private
* data and VFS data, as well as the relationship between vnodes in the
* directory heirarchy.
*
* In order to use these interfaces, the first member of every private
* v_data must be a gfs_file_t or a gfs_dir_t. This hands over all control
* to GFS.
*
* gfs_file_create()
* gfs_dir_create()
* gfs_root_create()
*
* gfs_file_inactive()
* gfs_dir_inactive()
* gfs_dir_lookup()
* gfs_dir_readdir()
*
* gfs_vop_inactive()
* gfs_vop_lookup()
* gfs_vop_readdir()
* gfs_vop_map()
*/
/*
* gfs_make_opsvec: take an array of vnode type definitions and create
* their vnodeops_t structures
*
* This routine takes an array of gfs_opsvec_t's. It could
* alternatively take an array of gfs_opsvec_t*'s, which would allow
* vnode types to be completely defined in files external to the caller
* of gfs_make_opsvec(). As it stands, much more sharing takes place --
* both the caller and the vnode type provider need to access gfsv_ops
* and gfsv_template, and the caller also needs to know gfsv_name.
*/
int
{
int error, i;
for (i = 0; ; i++) {
return (0);
if (error)
break;
}
for (i--; i >= 0; i--) {
}
return (error);
}
/*
* Low level directory routines
*
* These routines provide some simple abstractions for reading directories.
* They are designed to be used by existing pseudo filesystems (namely procfs)
* that already have a complicated management infrastructure.
*/
/*
* gfs_readdir_init: initiate a generic readdir
* st - a pointer to an uninitialized gfs_readdir_state_t structure
* name_max - the directory's maximum file name length
* ureclen - the exported file-space record length (1 for non-legacy FSs)
* uiop - the uiop passed to readdir
* parent - the parent directory's inode
* self - this directory's inode
*
* Returns 0 or a non-zero errno.
*
* Typical VOP_READDIR usage of gfs_readdir_*:
*
* if ((error = gfs_readdir_init(...)) != 0)
* return (error);
* eof = 0;
* while ((error = gfs_readdir_pred(..., &voffset)) != 0) {
* if (!consumer_entry_at(voffset))
* voffset = consumer_next_entry(voffset);
* if (consumer_eof(voffset)) {
* eof = 1
* break;
* }
* if ((error = gfs_readdir_emit(..., voffset,
* consumer_ino(voffset), consumer_name(voffset))) != 0)
* break;
* }
* return (gfs_readdir_fini(..., error, eofp, eof));
*
* As you can see, a zero result from gfs_readdir_pred() or
* gfs_readdir_emit() indicates that processing should continue,
* whereas a non-zero result indicates that the loop should terminate.
* Most consumers need do nothing more than let gfs_readdir_fini()
* determine what the cause of failure was and return the appropriate
* value.
*/
int
{
return (EINVAL);
return (0);
}
/*
* gfs_readdir_emit_int: internal routine to emit directory entry
*
* st - the current readdir state, which must have d_ino and d_name
* set
* uiop - caller-supplied uio pointer
* off - the offset of the current entry
* next - the offset of the next entry
*/
static int
{
int reclen;
/*
* Error if no entries were returned yet
*/
return (EINVAL);
return (-1);
}
return (EFAULT);
return (0);
}
/*
* gfs_readdir_emit: emit a directory entry
* voff - the virtual offset (obtained from gfs_readdir_pred)
* ino - the entry's inode
* name - the entry's name
*
* Returns a 0 on success, a non-zero errno on failure, or -1 if the
* readdir loop should terminate. A non-zero result (either errno or
* -1) from this function is typically passed directly to
* gfs_readdir_fini().
*/
int
{
/*
* Inter-entry offsets are invalid, so we assume a record size of
* grd_ureclen and explicitly set the offset appropriately.
*/
}
/*
* gfs_readdir_emitn: like gfs_readdir_emit(), but takes an integer
* instead of a string for the entry's name.
*/
int
{
char buf[40];
}
/*
* gfs_readdir_pred: readdir loop predicate
* voffp - a pointer in which the next virtual offset should be stored
*
* Returns a 0 on success, a non-zero errno on failure, or -1 if the
* readdir loop should terminate. A non-zero result (either errno or
* -1) from this function is typically passed directly to
* gfs_readdir_fini().
*/
int
{
int error;
top:
return (-1);
if (off == 0) {
".")) == 0)
goto top;
} else if (off == 1) {
"..")) == 0)
goto top;
} else {
return (0);
}
return (error);
}
/*
* gfs_readdir_fini: generic readdir cleanup
* error - if positive, an error to return
* eofp - the eofp passed to readdir
* eof - the eof value
*
* Returns a 0 on success, a non-zero errno on failure. This result
* should be returned from readdir.
*/
int
{
if (error > 0)
return (error);
if (eofp)
return (0);
}
/*
* gfs_lookup_dot
*
* Performs a basic check for "." and ".." directory entries.
*/
int
{
return (0);
} else {
}
return (0);
}
return (-1);
}
/*
* gfs_file_create(): create a new GFS file
*
* size - size of private data structure (v_data)
* pvp - parent vnode (GFS directory)
* ops - vnode operations vector
*
* In order to use this interface, the parent vnode must have been created by
* gfs_dir_create(), and the private data stored in v_data must have a
* 'gfs_file_t' as its first field.
*
* Given these constraints, this routine will automatically:
*
* - Allocate v_data for the vnode
* - Initialize necessary fields in the vnode
* - Hold the parent
*/
vnode_t *
{
gfs_file_t *fp;
/*
* Allocate vnode and internal data structure
*/
/*
* Set up various pointers
*/
/*
* Initialize vnode and hold parent.
*/
if (pvp) {
}
return (vp);
}
/*
* gfs_dir_create: creates a new directory in the parent
*
* size - size of private data structure (v_data)
* pvp - parent vnode (GFS directory)
* ops - vnode operations vector
* entries - NULL-terminated list of static entries (if any)
* maxlen - maximum length of a directory entry
* readdir_cb - readdir callback (see gfs_dir_readdir)
* inode_cb - inode callback (see gfs_dir_readdir)
* lookup_cb - lookup callback (see gfs_dir_lookup)
*
* In order to use this function, the first member of the private vnode
* structure (v_data) must be a gfs_dir_t. For each directory, there are
* static entries, defined when the structure is initialized, and dynamic
* entries, retrieved through callbacks.
*
* If a directory has static entries, then it must supply a inode callback,
* which will compute the inode number based on the parent and the index.
* For a directory with dynamic entries, the caller must supply a readdir
* callback and a lookup callback. If a static lookup fails, we fall back to
* the supplied lookup callback, if any.
*
* This function also performs the same initialization as gfs_file_create().
*/
vnode_t *
{
dp->gfsd_nstatic++;
}
return (vp);
}
/*
* gfs_root_create(): create a root vnode for a GFS filesystem
*
* Similar to gfs_dir_create(), this creates a root vnode for a filesystem. The
* only difference is that it takes a vfs_t instead of a vnode_t as its parent.
*/
vnode_t *
{
/* Manually set the inode */
return (vp);
}
/*
* gfs_file_inactive()
*
* Called from the VOP_INACTIVE() routine. If necessary, this routine will
* remove the given vnode from the parent directory and clean up any references
* in the VFS layer.
*
* If the vnode was not removed (due to a race with vget), then NULL is
* returned. Otherwise, a pointer to the private data is returned.
*/
void *
{
int i;
void *data;
goto found;
/*
* First, see if this vnode is cached in the parent.
*/
/*
* Find it in the set of static entries.
*/
for (i = 0; i < dp->gfsd_nstatic; i++) {
goto found;
}
/*
* If 'ge' is NULL, then it is a dynamic entry.
*/
/*
* Really remove this vnode
*/
/*
* If this was a statically cached entry, simply set the
* cached vnode to NULL.
*/
}
/*
* Free vnode and release parent
*/
if (fp->gfs_parent) {
} else {
}
} else {
if (dp)
}
return (data);
}
/*
* gfs_dir_inactive()
*
* Same as above, but for directories.
*/
void *
{
if (dp->gfsd_nstatic)
}
return (dp);
}
/*
* gfs_dir_lookup()
*
* Looks up the given name in the directory and returns the corresponding vnode,
* if found.
*
* First, we search statically defined entries, if any. If a match is found,
* and GFS_CACHE_VNODE is set and the vnode exists, we simply return the
* existing vnode. Otherwise, we call the static entry's callback routine,
* caching the result if necessary.
*
* If no static entry is found, we invoke the lookup callback, if any. The
* arguments to this callback are:
*
* int gfs_lookup_cb(vnode_t *pvp, const char *nm, vnode_t **vpp);
*
* pvp - parent vnode
* nm - name of entry
* vpp - pointer to resulting vnode
*
* Returns 0 on success, non-zero on error.
*/
int
{
int i;
int ret = 0;
return (0);
/*
* Search static entries.
*/
for (i = 0; i < dp->gfsd_nstatic; i++) {
if (ge->gfse_vnode) {
goto out;
}
/*
* We drop the directory lock, as the constuctor will
* need to do KM_SLEEP allocations. If we return from
* the constructor only to find that a parallel
* operation has completed, and GFS_CACHE_VNODE is set
* for this entry, we discard the result in favor of the
* cached vnode.
*/
/* Set the inode according to the callback. */
} else {
/*
* A parallel constructor beat us to it;
* return existing vnode. We have to be
* careful because we can't release the
* current vnode while holding the
* directory lock; its inactive routine
* will try to lock this directory.
*/
}
}
goto out;
}
}
/*
* See if there is a dynamic constructor.
*/
if (dp->gfsd_lookup) {
gfs_file_t *fp;
/*
* Once again, drop the directory lock, as the lookup routine
* will need to allocate memory, or otherwise deadlock on this
* directory.
*/
if (ret != 0)
goto out;
} else {
/*
* No static entry found, and there is no lookup callback, so
* return ENOENT.
*/
}
out:
return (ret);
}
/*
* gfs_dir_readdir: does a readdir() on the given directory
*
* dvp - directory vnode
* uiop - uio structure
* eofp - eof pointer
* data - arbitrary data passed to readdir callback
*
* This routine does all the readdir() dirty work. Even so, the caller must
* supply two callbacks in order to get full compatibility.
*
* If the directory contains static entries, an inode callback must be
* specified. This avoids having to create every vnode and call VOP_GETATTR()
* when reading the directory. This function has the following arguments:
*
* ino_t gfs_inode_cb(vnode_t *vp, int index);
*
* vp - vnode for the directory
* index - index in original gfs_dirent_t array
*
* Returns the inode number for the given entry.
*
* For directories with dynamic entries, a readdir callback must be provided.
* This is significantly more complex, thanks to the particulars of
* VOP_READDIR().
*
* int gfs_readdir_cb(vnode_t *vp, struct dirent64 *dp, int *eofp,
* offset_t *off, offset_t *nextoff, void *data)
*
* vp - directory vnode
* dp - directory entry, sized according to maxlen given to
* gfs_dir_create(). callback must fill in d_name and
* d_ino.
* eofp - callback must set to 1 when EOF has been reached
* off - on entry, the last offset read from the directory. Callback
* must set to the offset of the current entry, typically left
* untouched.
* nextoff - callback must set to offset of next entry. Typically
* (off + 1)
* data - caller-supplied data
*
* Return 0 on success, or error on failure.
*/
int
{
else
pino = ((gfs_file_t *)
return (error);
!eof) {
!= 0)
break;
} else if (dp->gfsd_readdir) {
break;
break;
} else {
/*
* Offset is beyond the end of the static entries, and
* we have no dynamic entries. Set EOF.
*/
eof = 1;
}
}
}
/*
* gfs_vop_lookup: VOP_LOOKUP() entry point
*
* For use directly in vnode ops table. Given a GFS directory, calls
* gfs_dir_lookup() as necessary.
*/
/* ARGSUSED */
int
{
}
/*
* gfs_vop_readdir: VOP_READDIR() entry point
*
* For use directly in vnode ops table. Given a GFS directory, calls
* gfs_dir_readdir() as necessary.
*/
/* ARGSUSED */
int
{
}
/*
* gfs_vop_map: VOP_MAP() entry point
*
* Convenient routine for handling pseudo-files that wish to allow mmap() calls.
* This function only works for readonly files, and uses the read function for
* the vnode to fill in the data. The mapped data is immediately faulted in and
* filled with the necessary data during this call; there are no getpage() or
* putpage() routines.
*/
/* ARGSUSED */
int
{
int rv;
/*
* Check for bad parameters
*/
#ifdef _ILP32
return (ENOMEM);
#endif
return (ENOTSUP);
return (EFBIG);
return (EINVAL);
return (ENODEV);
return (EACCES);
/*
* Find appropriate address if needed, otherwise clear address range.
*/
return (ENOMEM);
}
} else {
}
/*
* Create mapping
*/
if (rv != 0)
return (rv);
/*
* Fill with data from read()
*/
if (rv != 0) {
}
return (rv);
}
/*
* gfs_vop_inactive: VOP_INACTIVE() entry point
*
* Given a vnode that is a GFS file or directory, call gfs_file_inactive() or
* gfs_dir_inactive() as necessary, and kmem_free()s associated private data.
*/
/* ARGSUSED */
void
{
void *data;
else
}