From b50f2868e54b258b1d74b361d14452c2e01fa4c6 Mon Sep 17 00:00:00 2001 From: avg Date: Fri, 24 Feb 2017 07:53:56 +0000 Subject: [PATCH] zfs: clean up unused files and definitions MFC after: 1 month X-MFC after: r314048 --- .../opensolaris/kern/opensolaris_lookup.c | 52 - sys/cddl/compat/opensolaris/sys/pathname.h | 11 - .../contrib/opensolaris/uts/common/fs/gfs.c | 1246 ----------------- .../contrib/opensolaris/uts/common/sys/gfs.h | 159 --- sys/conf/files | 1 - sys/modules/zfs/Makefile | 1 - 6 files changed, 1470 deletions(-) delete mode 100644 sys/cddl/contrib/opensolaris/uts/common/fs/gfs.c delete mode 100644 sys/cddl/contrib/opensolaris/uts/common/sys/gfs.h diff --git a/sys/cddl/compat/opensolaris/kern/opensolaris_lookup.c b/sys/cddl/compat/opensolaris/kern/opensolaris_lookup.c index 4214ca856d0f..bdc1e16818af 100644 --- a/sys/cddl/compat/opensolaris/kern/opensolaris_lookup.c +++ b/sys/cddl/compat/opensolaris/kern/opensolaris_lookup.c @@ -62,55 +62,3 @@ lookupnameat(char *dirname, enum uio_seg seg, enum symfollow follow, vn_lock(startvp, ltype | LK_RETRY); return (error); } - -int -traverse(vnode_t **cvpp, int lktype) -{ - vnode_t *cvp; - vnode_t *tvp; - vfs_t *vfsp; - int error; - - cvp = *cvpp; - tvp = NULL; - - /* - * If this vnode is mounted on, then we transparently indirect - * to the vnode which is the root of the mounted file system. - * Before we do this we must check that an unmount is not in - * progress on this vnode. - */ - - for (;;) { - /* - * Reached the end of the mount chain? - */ - vfsp = vn_mountedvfs(cvp); - if (vfsp == NULL) - break; - error = vfs_busy(vfsp, 0); - - /* - * tvp is NULL for *cvpp vnode, which we can't unlock. - */ - if (tvp != NULL) - vput(cvp); - else - vrele(cvp); - if (error) - return (error); - - /* - * The read lock must be held across the call to VFS_ROOT() to - * prevent a concurrent unmount from destroying the vfs. - */ - error = VFS_ROOT(vfsp, lktype, &tvp); - vfs_unbusy(vfsp); - if (error != 0) - return (error); - cvp = tvp; - } - - *cvpp = cvp; - return (0); -} diff --git a/sys/cddl/compat/opensolaris/sys/pathname.h b/sys/cddl/compat/opensolaris/sys/pathname.h index 0d396231c65d..43862a6eee05 100644 --- a/sys/cddl/compat/opensolaris/sys/pathname.h +++ b/sys/cddl/compat/opensolaris/sys/pathname.h @@ -34,20 +34,9 @@ #include #include -typedef struct pathname { - char *pn_buf; /* underlying storage */ - char *pn_path; /* remaining pathname */ - size_t pn_pathlen; /* remaining length */ - size_t pn_bufsize; /* total size of pn_buf */ -} pathname_t; - -#define pn_alloc(pnp) panic("pn_alloc() called") -#define pn_free(pnp) panic("pn_free() called") - int lookupname(char *, enum uio_seg, enum symfollow, vnode_t **, vnode_t **); int lookupnameat(char *, enum uio_seg, enum symfollow, vnode_t **, vnode_t **, vnode_t *); -int traverse(vnode_t **, int); #endif /* _KERNEL */ diff --git a/sys/cddl/contrib/opensolaris/uts/common/fs/gfs.c b/sys/cddl/contrib/opensolaris/uts/common/fs/gfs.c deleted file mode 100644 index 27d259d995f6..000000000000 --- a/sys/cddl/contrib/opensolaris/uts/common/fs/gfs.c +++ /dev/null @@ -1,1246 +0,0 @@ -/* - * CDDL HEADER START - * - * The contents of this file are subject to the terms of the - * Common Development and Distribution License (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 - * or http://www.opensolaris.org/os/licensing. - * 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 - */ -/* Portions Copyright 2007 Shivakumar GN */ -/* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved. - * Use is subject to license terms. - */ - -#pragma ident "%Z%%M% %I% %E% SMI" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -/* - * 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 - * preamble 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 simplify common tasks, - * without forcing 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 hierarchy. - * - * 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_reclaim() - * gfs_vop_lookup() - * gfs_vop_readdir() - * gfs_vop_map() - * - * 3) Single File pseudo-filesystems - * - * This routine creates a rooted file to be overlayed ontop of another - * file in the physical filespace. - * - * Note that the parent is NULL (actually the vfs), but there is nothing - * technically keeping such a file from utilizing the "Complete GFS - * management" set of routines. - * - * gfs_root_create_file() - */ - -#ifdef illumos -/* - * 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 -gfs_make_opsvec(gfs_opsvec_t *vec) -{ - int error, i; - - for (i = 0; ; i++) { - if (vec[i].gfsv_name == NULL) - return (0); - error = vn_make_ops(vec[i].gfsv_name, vec[i].gfsv_template, - vec[i].gfsv_ops); - if (error) - break; - } - - cmn_err(CE_WARN, "gfs_make_opsvec: bad vnode ops template for '%s'", - vec[i].gfsv_name); - for (i--; i >= 0; i--) { - vn_freevnodeops(*vec[i].gfsv_ops); - *vec[i].gfsv_ops = NULL; - } - return (error); -} -#endif /* illumos */ - -/* - * 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_get_parent_ino: used to obtain a parent inode number and the - * inode number of the given vnode in preparation for calling gfs_readdir_init. - */ -int -gfs_get_parent_ino(vnode_t *dvp, cred_t *cr, caller_context_t *ct, - ino64_t *pino, ino64_t *ino) -{ - vnode_t *parent; - gfs_dir_t *dp = dvp->v_data; - int error; - - *ino = dp->gfsd_file.gfs_ino; - parent = dp->gfsd_file.gfs_parent; - - if (parent == NULL) { - *pino = *ino; /* root of filesystem */ - } else if (dvp->v_flag & V_XATTRDIR) { -#ifdef TODO - vattr_t va; - - va.va_mask = AT_NODEID; - error = VOP_GETATTR(parent, &va, 0, cr, ct); - if (error) - return (error); - *pino = va.va_nodeid; -#else - panic("%s:%u: not implemented", __func__, __LINE__); -#endif - } else { - *pino = ((gfs_file_t *)(parent->v_data))->gfs_ino; - } - - return (0); -} - -/* - * 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 - * flags - flags from VOP_READDIR - * - * 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 -gfs_readdir_init(gfs_readdir_state_t *st, int name_max, int ureclen, - uio_t *uiop, ino64_t parent, ino64_t self, int flags) -{ - size_t dirent_size; - - if (uiop->uio_loffset < 0 || uiop->uio_resid <= 0 || - (uiop->uio_loffset % ureclen) != 0) - return (EINVAL); - - st->grd_ureclen = ureclen; - st->grd_oresid = uiop->uio_resid; - st->grd_namlen = name_max; - if (flags & V_RDDIR_ENTFLAGS) - dirent_size = EDIRENT_RECLEN(st->grd_namlen); - else - dirent_size = DIRENT64_RECLEN(st->grd_namlen); - st->grd_dirent = kmem_zalloc(dirent_size, KM_SLEEP); - st->grd_parent = parent; - st->grd_self = self; - st->grd_flags = flags; - - return (0); -} - -/* - * gfs_readdir_emit_int: internal routine to emit directory entry - * - * st - the current readdir state, which must have d_ino/ed_ino - * and d_name/ed_name set - * uiop - caller-supplied uio pointer - * next - the offset of the next entry - */ -static int -gfs_readdir_emit_int(gfs_readdir_state_t *st, uio_t *uiop, offset_t next, - int *ncookies, u_long **cookies) -{ - int reclen, namlen; - dirent64_t *dp; - edirent_t *edp; - - if (st->grd_flags & V_RDDIR_ENTFLAGS) { - edp = st->grd_dirent; - namlen = strlen(edp->ed_name); - reclen = EDIRENT_RECLEN(namlen); - } else { - dp = st->grd_dirent; - namlen = strlen(dp->d_name); - reclen = DIRENT64_RECLEN(namlen); - } - - if (reclen > uiop->uio_resid) { - /* - * Error if no entries were returned yet - */ - if (uiop->uio_resid == st->grd_oresid) - return (EINVAL); - return (-1); - } - - if (st->grd_flags & V_RDDIR_ENTFLAGS) { - edp->ed_off = next; - edp->ed_reclen = (ushort_t)reclen; - } else { - /* XXX: This can change in the future. */ - dp->d_reclen = (ushort_t)reclen; - dp->d_type = DT_DIR; - dp->d_namlen = namlen; - } - - if (uiomove((caddr_t)st->grd_dirent, reclen, UIO_READ, uiop)) - return (EFAULT); - - uiop->uio_loffset = next; - if (*cookies != NULL) { - **cookies = next; - (*cookies)++; - (*ncookies)--; - KASSERT(*ncookies >= 0, ("ncookies=%d", *ncookies)); - } - - 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 - * eflags - value for ed_eflags (if processing edirent_t) - * - * 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 -gfs_readdir_emit(gfs_readdir_state_t *st, uio_t *uiop, offset_t voff, - ino64_t ino, const char *name, int eflags, int *ncookies, u_long **cookies) -{ - offset_t off = (voff + 2) * st->grd_ureclen; - - if (st->grd_flags & V_RDDIR_ENTFLAGS) { - edirent_t *edp = st->grd_dirent; - - edp->ed_ino = ino; - (void) strncpy(edp->ed_name, name, st->grd_namlen); - edp->ed_eflags = eflags; - } else { - dirent64_t *dp = st->grd_dirent; - - dp->d_ino = ino; - (void) strncpy(dp->d_name, name, st->grd_namlen); - } - - /* - * Inter-entry offsets are invalid, so we assume a record size of - * grd_ureclen and explicitly set the offset appropriately. - */ - return (gfs_readdir_emit_int(st, uiop, off + st->grd_ureclen, ncookies, - cookies)); -} - -#ifdef illumos -/* - * gfs_readdir_emitn: like gfs_readdir_emit(), but takes an integer - * instead of a string for the entry's name. - */ -int -gfs_readdir_emitn(gfs_readdir_state_t *st, uio_t *uiop, offset_t voff, - ino64_t ino, unsigned long num) -{ - char buf[40]; - - numtos(num, buf); - return (gfs_readdir_emit(st, uiop, voff, ino, buf, 0)); -} -#endif - -/* - * 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 -gfs_readdir_pred(gfs_readdir_state_t *st, uio_t *uiop, offset_t *voffp, - int *ncookies, u_long **cookies) -{ - offset_t off, voff; - int error; - -top: - if (uiop->uio_resid <= 0) - return (-1); - - off = uiop->uio_loffset / st->grd_ureclen; - voff = off - 2; - if (off == 0) { - if ((error = gfs_readdir_emit(st, uiop, voff, st->grd_self, - ".", 0, ncookies, cookies)) == 0) - goto top; - } else if (off == 1) { - if ((error = gfs_readdir_emit(st, uiop, voff, st->grd_parent, - "..", 0, ncookies, cookies)) == 0) - goto top; - } else { - *voffp = voff; - 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 -gfs_readdir_fini(gfs_readdir_state_t *st, int error, int *eofp, int eof) -{ - size_t dirent_size; - - if (st->grd_flags & V_RDDIR_ENTFLAGS) - dirent_size = EDIRENT_RECLEN(st->grd_namlen); - else - dirent_size = DIRENT64_RECLEN(st->grd_namlen); - kmem_free(st->grd_dirent, dirent_size); - if (error > 0) - return (error); - if (eofp) - *eofp = eof; - return (0); -} - -/* - * gfs_lookup_dot - * - * Performs a basic check for "." and ".." directory entries. - */ -int -gfs_lookup_dot(vnode_t **vpp, vnode_t *dvp, vnode_t *pvp, const char *nm) -{ - int ltype; - - if (*nm == '\0' || strcmp(nm, ".") == 0) { - VN_HOLD(dvp); - *vpp = dvp; - return (0); - } else if (strcmp(nm, "..") == 0) { - ASSERT(pvp != NULL); - VN_HOLD(pvp); - *vpp = pvp; - 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_create(size_t size, vnode_t *pvp, vfs_t *vfsp, vnodeops_t *ops) -{ - gfs_file_t *fp; - vnode_t *vp; - int error; - - /* - * Allocate vnode and internal data structure - */ - fp = kmem_zalloc(size, KM_SLEEP); - error = getnewvnode("zfs_gfs", vfsp, ops, &vp); - ASSERT(error == 0); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); - vp->v_data = (caddr_t)fp; - - /* - * Set up various pointers - */ - fp->gfs_vnode = vp; - fp->gfs_parent = pvp; - fp->gfs_size = size; - fp->gfs_type = GFS_FILE; - - vp->v_vflag |= VV_FORCEINSMQ; - error = insmntque(vp, vfsp); - vp->v_vflag &= ~VV_FORCEINSMQ; - KASSERT(error == 0, ("insmntque() failed: error %d", error)); - - /* - * Initialize vnode and hold parent. - */ - if (pvp) - VN_HOLD(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 * -gfs_dir_create(size_t struct_size, vnode_t *pvp, vfs_t *vfsp, vnodeops_t *ops, - gfs_dirent_t *entries, gfs_inode_cb inode_cb, int maxlen, - gfs_readdir_cb readdir_cb, gfs_lookup_cb lookup_cb) -{ - vnode_t *vp; - gfs_dir_t *dp; - gfs_dirent_t *de; - - vp = gfs_file_create(struct_size, pvp, vfsp, ops); - vp->v_type = VDIR; - - dp = vp->v_data; - dp->gfsd_file.gfs_type = GFS_DIR; - dp->gfsd_maxlen = maxlen; - - if (entries != NULL) { - for (de = entries; de->gfse_name != NULL; de++) - dp->gfsd_nstatic++; - - dp->gfsd_static = kmem_alloc( - dp->gfsd_nstatic * sizeof (gfs_dirent_t), KM_SLEEP); - bcopy(entries, dp->gfsd_static, - dp->gfsd_nstatic * sizeof (gfs_dirent_t)); - } - - dp->gfsd_readdir = readdir_cb; - dp->gfsd_lookup = lookup_cb; - dp->gfsd_inode = inode_cb; - - mutex_init(&dp->gfsd_lock, NULL, MUTEX_DEFAULT, NULL); - - 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 * -gfs_root_create(size_t size, vfs_t *vfsp, vnodeops_t *ops, ino64_t ino, - gfs_dirent_t *entries, gfs_inode_cb inode_cb, int maxlen, - gfs_readdir_cb readdir_cb, gfs_lookup_cb lookup_cb) -{ - vnode_t *vp; - -#ifdef illumos - VFS_HOLD(vfsp); -#endif - vp = gfs_dir_create(size, NULL, vfsp, ops, entries, inode_cb, - maxlen, readdir_cb, lookup_cb); - /* Manually set the inode */ - ((gfs_file_t *)vp->v_data)->gfs_ino = ino; - vp->v_flag |= VROOT; - - return (vp); -} - -#ifdef illumos -/* - * gfs_root_create_file(): create a root vnode for a GFS file as a filesystem - * - * Similar to gfs_root_create(), this creates a root vnode for a file to - * be the pseudo-filesystem. - */ -vnode_t * -gfs_root_create_file(size_t size, vfs_t *vfsp, vnodeops_t *ops, ino64_t ino) -{ - vnode_t *vp = gfs_file_create(size, NULL, ops); - - ((gfs_file_t *)vp->v_data)->gfs_ino = ino; - - VFS_HOLD(vfsp); - VN_SET_VFS_TYPE_DEV(vp, vfsp, VREG, 0); - vp->v_flag |= VROOT | VNOCACHE | VNOMAP | VNOSWAP | VNOMOUNT; - - return (vp); -} -#endif /* illumos */ - -/* - * gfs_file_inactive() - * - * Called from the VOP_RECLAIM() 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 * -gfs_file_inactive(vnode_t *vp) -{ - int i; - gfs_dirent_t *ge = NULL; - gfs_file_t *fp = vp->v_data; - gfs_dir_t *dp = NULL; - void *data; - - if (fp->gfs_parent == NULL || (vp->v_flag & V_XATTRDIR)) - goto found; - - /* - * XXX cope with a FreeBSD-specific race wherein the parent's - * snapshot data can be freed before the parent is - */ - if ((dp = fp->gfs_parent->v_data) == NULL) - return (NULL); - - /* - * First, see if this vnode is cached in the parent. - */ - gfs_dir_lock(dp); - - /* - * Find it in the set of static entries. - */ - for (i = 0; i < dp->gfsd_nstatic; i++) { - ge = &dp->gfsd_static[i]; - - if (ge->gfse_vnode == vp) - goto found; - } - - /* - * If 'ge' is NULL, then it is a dynamic entry. - */ - ge = NULL; - -found: -#ifdef TODO - if (vp->v_flag & V_XATTRDIR) - VI_LOCK(fp->gfs_parent); -#endif - VI_LOCK(vp); - /* - * Really remove this vnode - */ - data = vp->v_data; - if (ge != NULL) { - /* - * If this was a statically cached entry, simply set the - * cached vnode to NULL. - */ - ge->gfse_vnode = NULL; - } - VI_UNLOCK(vp); - - /* - * Free vnode and release parent - */ - if (fp->gfs_parent) { - if (dp) - gfs_dir_unlock(dp); - VOP_UNLOCK(vp, 0); - VN_RELE(fp->gfs_parent); - vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); - } else { - ASSERT(vp->v_vfsp != NULL); -#ifdef illumos - VFS_RELE(vp->v_vfsp); -#endif - } -#ifdef TODO - if (vp->v_flag & V_XATTRDIR) - VI_UNLOCK(fp->gfs_parent); -#endif - return (data); -} - -/* - * gfs_dir_inactive() - * - * Same as above, but for directories. - */ -void * -gfs_dir_inactive(vnode_t *vp) -{ - gfs_dir_t *dp; - - ASSERT(vp->v_type == VDIR); - - if ((dp = gfs_file_inactive(vp)) != NULL) { - mutex_destroy(&dp->gfsd_lock); - if (dp->gfsd_nstatic) - kmem_free(dp->gfsd_static, - dp->gfsd_nstatic * sizeof (gfs_dirent_t)); - } - - return (dp); -} - -/* - * gfs_dir_lookup_dynamic() - * - * This routine looks up the provided name amongst the dynamic entries - * in the gfs directory and returns the corresponding vnode, if found. - * - * The gfs directory is expected to be locked by the caller prior to - * calling this function. The directory will be unlocked during the - * execution of this function, but will be locked upon return from the - * function. This function returns 0 on success, non-zero on error. - * - * The dynamic lookups are performed by invoking the lookup - * callback, which is passed to this function as the first argument. - * The arguments to the callback are: - * - * int gfs_lookup_cb(vnode_t *pvp, const char *nm, vnode_t **vpp, cred_t *cr, - * int flags, int *deflgs, pathname_t *rpnp); - * - * pvp - parent vnode - * nm - name of entry - * vpp - pointer to resulting vnode - * cr - pointer to cred - * flags - flags value from lookup request - * ignored here; currently only used to request - * insensitive lookups - * direntflgs - output parameter, directory entry flags - * ignored here; currently only used to indicate a lookup - * has more than one possible match when case is not considered - * realpnp - output parameter, real pathname - * ignored here; when lookup was performed case-insensitively, - * this field contains the "real" name of the file. - * - * Returns 0 on success, non-zero on error. - */ -static int -gfs_dir_lookup_dynamic(gfs_lookup_cb callback, gfs_dir_t *dp, - const char *nm, vnode_t *dvp, vnode_t **vpp, cred_t *cr, int flags, - int *direntflags, pathname_t *realpnp) -{ - gfs_file_t *fp; - ino64_t ino; - int ret; - - ASSERT(GFS_DIR_LOCKED(dp)); - - /* - * Drop the directory lock, as the lookup routine - * will need to allocate memory, or otherwise deadlock on this - * directory. - */ - gfs_dir_unlock(dp); - ret = callback(dvp, nm, vpp, &ino, cr, flags, direntflags, realpnp); - gfs_dir_lock(dp); - - /* - * The callback for extended attributes returns a vnode - * with v_data from an underlying fs. - */ - if (ret == 0 && !IS_XATTRDIR(dvp)) { - fp = (gfs_file_t *)((*vpp)->v_data); - fp->gfs_index = -1; - fp->gfs_ino = ino; - } - - return (ret); -} - -/* - * gfs_dir_lookup_static() - * - * This routine looks up the provided name amongst the static entries - * in the gfs directory and returns the corresponding vnode, if found. - * The first argument to the function is a pointer to the comparison - * function this function should use to decide if names are a match. - * - * 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 the idx pointer argument is non-NULL, we use it to - * return the index of the matching static entry. - * - * The gfs directory is expected to be locked by the caller prior to calling - * this function. The directory may be unlocked during the execution of - * this function, but will be locked upon return from the function. - * - * This function returns 0 if a match is found, ENOENT if not. - */ -static int -gfs_dir_lookup_static(int (*compare)(const char *, const char *), - gfs_dir_t *dp, const char *nm, vnode_t *dvp, int *idx, - vnode_t **vpp, pathname_t *rpnp) -{ - gfs_dirent_t *ge; - vnode_t *vp = NULL; - int i; - - ASSERT(GFS_DIR_LOCKED(dp)); - - /* - * Search static entries. - */ - for (i = 0; i < dp->gfsd_nstatic; i++) { - ge = &dp->gfsd_static[i]; - - if (compare(ge->gfse_name, nm) == 0) { - if (rpnp) - (void) strlcpy(rpnp->pn_buf, ge->gfse_name, - rpnp->pn_bufsize); - - if (ge->gfse_vnode) { - ASSERT(ge->gfse_flags & GFS_CACHE_VNODE); - vp = ge->gfse_vnode; - VN_HOLD(vp); - break; - } - - /* - * We drop the directory lock, as the constructor 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. - */ - gfs_dir_unlock(dp); - vp = ge->gfse_ctor(dvp); - gfs_dir_lock(dp); - - ((gfs_file_t *)vp->v_data)->gfs_index = i; - - /* Set the inode according to the callback. */ - ((gfs_file_t *)vp->v_data)->gfs_ino = - dp->gfsd_inode(dvp, i); - - if (ge->gfse_flags & GFS_CACHE_VNODE) { - if (ge->gfse_vnode == NULL) { - ge->gfse_vnode = vp; - } 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. - */ - vnode_t *oldvp = vp; - vp = ge->gfse_vnode; - VN_HOLD(vp); - - gfs_dir_unlock(dp); - VN_RELE(oldvp); - gfs_dir_lock(dp); - } - } - break; - } - } - - if (vp == NULL) - return (ENOENT); - else if (idx) - *idx = i; - *vpp = vp; - return (0); -} - -/* - * 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, with a call to - * gfs_dir_lookup_static(). If no static entry is found, and we have - * a callback function we try a dynamic lookup via gfs_dir_lookup_dynamic(). - * - * This function returns 0 on success, non-zero on error. - */ -int -gfs_dir_lookup(vnode_t *dvp, const char *nm, vnode_t **vpp, cred_t *cr, - int flags, int *direntflags, pathname_t *realpnp) -{ - gfs_dir_t *dp = dvp->v_data; - boolean_t casecheck; - vnode_t *dynvp = NULL; - vnode_t *vp = NULL; - int (*compare)(const char *, const char *); - int error, idx; - - ASSERT(dvp->v_type == VDIR); - - if (gfs_lookup_dot(vpp, dvp, dp->gfsd_file.gfs_parent, nm) == 0) - return (0); - - casecheck = (flags & FIGNORECASE) != 0 && direntflags != NULL; - if (vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) || - (flags & FIGNORECASE)) - compare = strcasecmp; - else - compare = strcmp; - - gfs_dir_lock(dp); - - error = gfs_dir_lookup_static(compare, dp, nm, dvp, &idx, &vp, realpnp); - - if (vp && casecheck) { - gfs_dirent_t *ge; - int i; - - for (i = idx + 1; i < dp->gfsd_nstatic; i++) { - ge = &dp->gfsd_static[i]; - - if (strcasecmp(ge->gfse_name, nm) == 0) { - *direntflags |= ED_CASE_CONFLICT; - goto out; - } - } - } - - if ((error || casecheck) && dp->gfsd_lookup) - error = gfs_dir_lookup_dynamic(dp->gfsd_lookup, dp, nm, dvp, - &dynvp, cr, flags, direntflags, vp ? NULL : realpnp); - - if (vp && dynvp) { - /* static and dynamic entries are case-insensitive conflict */ - ASSERT(casecheck); - *direntflags |= ED_CASE_CONFLICT; - VN_RELE(dynvp); - } else if (vp == NULL) { - vp = dynvp; - } else if (error == ENOENT) { - error = 0; - } else if (error) { - VN_RELE(vp); - vp = NULL; - } - -out: - gfs_dir_unlock(dp); - - *vpp = vp; - return (error); -} - -/* - * 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, void *dp, int *eofp, - * offset_t *off, offset_t *nextoff, void *data, int flags) - * - * vp - directory vnode - * dp - directory entry, sized according to maxlen given to - * gfs_dir_create(). callback must fill in d_name and - * d_ino (if a dirent64_t), or ed_name, ed_ino, and ed_eflags - * (if an edirent_t). edirent_t is used if V_RDDIR_ENTFLAGS - * is set in 'flags'. - * 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 - * flags - VOP_READDIR flags - * - * Return 0 on success, or error on failure. - */ -int -gfs_dir_readdir(vnode_t *dvp, uio_t *uiop, int *eofp, int *ncookies, - u_long **cookies, void *data, cred_t *cr, int flags) -{ - gfs_readdir_state_t gstate; - int error, eof = 0; - ino64_t ino, pino; - offset_t off, next; - gfs_dir_t *dp = dvp->v_data; - - error = gfs_get_parent_ino(dvp, cr, NULL, &pino, &ino); - if (error) - return (error); - - if ((error = gfs_readdir_init(&gstate, dp->gfsd_maxlen, 1, uiop, - pino, ino, flags)) != 0) - return (error); - - while ((error = gfs_readdir_pred(&gstate, uiop, &off, ncookies, - cookies)) == 0 && !eof) { - - if (off >= 0 && off < dp->gfsd_nstatic) { - ino = dp->gfsd_inode(dvp, off); - - if ((error = gfs_readdir_emit(&gstate, uiop, - off, ino, dp->gfsd_static[off].gfse_name, 0, - ncookies, cookies)) != 0) - break; - - } else if (dp->gfsd_readdir) { - off -= dp->gfsd_nstatic; - - if ((error = dp->gfsd_readdir(dvp, - gstate.grd_dirent, &eof, &off, &next, - data, flags)) != 0 || eof) - break; - - off += dp->gfsd_nstatic + 2; - next += dp->gfsd_nstatic + 2; - - if ((error = gfs_readdir_emit_int(&gstate, uiop, - next, ncookies, cookies)) != 0) - break; - } else { - /* - * Offset is beyond the end of the static entries, and - * we have no dynamic entries. Set EOF. - */ - eof = 1; - } - } - - return (gfs_readdir_fini(&gstate, error, eofp, eof)); -} - - -/* - * 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_lookup(vnode_t *dvp, char *nm, vnode_t **vpp, pathname_t *pnp, - int flags, vnode_t *rdir, cred_t *cr, caller_context_t *ct, - int *direntflags, pathname_t *realpnp) -{ - return (gfs_dir_lookup(dvp, nm, vpp, cr, flags, direntflags, realpnp)); -} - -/* - * 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_readdir(ap) - struct vop_readdir_args /* { - struct vnode *a_vp; - struct uio *a_uio; - struct ucred *a_cred; - int *a_eofflag; - int *ncookies; - u_long **a_cookies; - } */ *ap; -{ - vnode_t *vp = ap->a_vp; - uio_t *uiop = ap->a_uio; - cred_t *cr = ap->a_cred; - int *eofp = ap->a_eofflag; - int ncookies = 0; - u_long *cookies = NULL; - int error; - - if (ap->a_ncookies) { - /* - * Minimum entry size is dirent size and 1 byte for a file name. - */ - ncookies = uiop->uio_resid / (sizeof(struct dirent) - sizeof(((struct dirent *)NULL)->d_name) + 1); - cookies = malloc(ncookies * sizeof(u_long), M_TEMP, M_WAITOK); - *ap->a_cookies = cookies; - *ap->a_ncookies = ncookies; - } - - error = gfs_dir_readdir(vp, uiop, eofp, &ncookies, &cookies, NULL, - cr, 0); - - if (error == 0) { - /* Subtract unused cookies */ - if (ap->a_ncookies) - *ap->a_ncookies -= ncookies; - } else if (ap->a_ncookies) { - free(*ap->a_cookies, M_TEMP); - *ap->a_cookies = NULL; - *ap->a_ncookies = 0; - } - - return (error); -} - - -#ifdef illumos -/* - * 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 -gfs_vop_map(vnode_t *vp, offset_t off, struct as *as, caddr_t *addrp, - size_t len, uchar_t prot, uchar_t maxprot, uint_t flags, cred_t *cred, - caller_context_t *ct) -{ - int rv; - ssize_t resid = len; - - /* - * Check for bad parameters - */ -#ifdef _ILP32 - if (len > MAXOFF_T) - return (ENOMEM); -#endif - if (vp->v_flag & VNOMAP) - return (ENOTSUP); - if (off > MAXOFF_T) - return (EFBIG); - if ((long)off < 0 || (long)(off + len) < 0) - return (EINVAL); - if (vp->v_type != VREG) - return (ENODEV); - if ((prot & (PROT_EXEC | PROT_WRITE)) != 0) - return (EACCES); - - /* - * Find appropriate address if needed, otherwise clear address range. - */ - as_rangelock(as); - rv = choose_addr(as, addrp, len, off, ADDR_VACALIGN, flags); - if (rv != 0) { - as_rangeunlock(as); - return (rv); - } - - /* - * Create mapping - */ - rv = as_map(as, *addrp, len, segvn_create, zfod_argsp); - as_rangeunlock(as); - if (rv != 0) - return (rv); - - /* - * Fill with data from read() - */ - rv = vn_rdwr(UIO_READ, vp, *addrp, len, off, UIO_USERSPACE, - 0, (rlim64_t)0, cred, &resid); - - if (rv == 0 && resid != 0) - rv = ENXIO; - - if (rv != 0) { - as_rangelock(as); - (void) as_unmap(as, *addrp, len); - as_rangeunlock(as); - } - - return (rv); -} -#endif /* illumos */ - -/* - * gfs_vop_reclaim: VOP_RECLAIM() entry point (solaris' VOP_INACTIVE()) - * - * 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 */ -int -gfs_vop_reclaim(ap) - struct vop_reclaim_args /* { - struct vnode *a_vp; - struct thread *a_td; - } */ *ap; -{ - vnode_t *vp = ap->a_vp; - gfs_file_t *fp = vp->v_data; - - if (fp->gfs_type == GFS_DIR) - gfs_dir_inactive(vp); - else - gfs_file_inactive(vp); - - vnode_destroy_vobject(vp); - VI_LOCK(vp); - vp->v_data = NULL; - VI_UNLOCK(vp); - kmem_free(fp, fp->gfs_size); - - return (0); -} diff --git a/sys/cddl/contrib/opensolaris/uts/common/sys/gfs.h b/sys/cddl/contrib/opensolaris/uts/common/sys/gfs.h deleted file mode 100644 index 0409172f81d9..000000000000 --- a/sys/cddl/contrib/opensolaris/uts/common/sys/gfs.h +++ /dev/null @@ -1,159 +0,0 @@ -/* - * CDDL HEADER START - * - * The contents of this file are subject to the terms of the - * Common Development and Distribution License (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 - * or http://www.opensolaris.org/os/licensing. - * 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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. - */ - -/* - * These are Consolidation Private interfaces and are subject to change. - */ - -#ifndef _SYS_GFS_H -#define _SYS_GFS_H - -#include -#include -#include -#include -#include -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -#define GFS_CACHE_VNODE 0x1 - -typedef struct gfs_dirent { - char *gfse_name; /* entry name */ - vnode_t *(*gfse_ctor)(vnode_t *); /* constructor */ - int gfse_flags; /* flags */ - list_node_t gfse_link; /* dynamic list */ - vnode_t *gfse_vnode; /* cached vnode */ -} gfs_dirent_t; - -typedef enum gfs_type { - GFS_DIR, - GFS_FILE -} gfs_type_t; - -typedef struct gfs_file { - vnode_t *gfs_vnode; /* current vnode */ - vnode_t *gfs_parent; /* parent vnode */ - size_t gfs_size; /* size of private data structure */ - gfs_type_t gfs_type; /* type of vnode */ - int gfs_index; /* index in parent dir */ - ino64_t gfs_ino; /* inode for this vnode */ -} gfs_file_t; - -typedef int (*gfs_readdir_cb)(vnode_t *, void *, int *, offset_t *, - offset_t *, void *, int); -typedef int (*gfs_lookup_cb)(vnode_t *, const char *, vnode_t **, ino64_t *, - cred_t *, int, int *, pathname_t *); -typedef ino64_t (*gfs_inode_cb)(vnode_t *, int); - -typedef struct gfs_dir { - gfs_file_t gfsd_file; /* generic file attributes */ - gfs_dirent_t *gfsd_static; /* statically defined entries */ - int gfsd_nstatic; /* # static entries */ - kmutex_t gfsd_lock; /* protects entries */ - int gfsd_maxlen; /* maximum name length */ - gfs_readdir_cb gfsd_readdir; /* readdir() callback */ - gfs_lookup_cb gfsd_lookup; /* lookup() callback */ - gfs_inode_cb gfsd_inode; /* get an inode number */ -} gfs_dir_t; - -struct vfs; - -extern vnode_t *gfs_file_create(size_t, vnode_t *, vfs_t *, vnodeops_t *); -extern vnode_t *gfs_dir_create(size_t, vnode_t *, vfs_t *, vnodeops_t *, - gfs_dirent_t *, gfs_inode_cb, int, gfs_readdir_cb, gfs_lookup_cb); -extern vnode_t *gfs_root_create(size_t, vfs_t *, vnodeops_t *, ino64_t, - gfs_dirent_t *, gfs_inode_cb, int, gfs_readdir_cb, gfs_lookup_cb); -extern vnode_t *gfs_root_create_file(size_t, struct vfs *, vnodeops_t *, - ino64_t); - -extern void *gfs_file_inactive(vnode_t *); -extern void *gfs_dir_inactive(vnode_t *); - -extern int gfs_dir_case_lookup(vnode_t *, const char *, vnode_t **, cred_t *, - int, int *, pathname_t *); -extern int gfs_dir_lookup(vnode_t *, const char *, vnode_t **, cred_t *, - int, int *, pathname_t *); -extern int gfs_vop_lookup(vnode_t *, char *, vnode_t **, pathname_t *, - int, vnode_t *, cred_t *, caller_context_t *, int *, pathname_t *); -extern int gfs_dir_readdir(vnode_t *, uio_t *, int *, int *, u_long **, void *, - cred_t *, int flags); - -#define gfs_dir_lock(gd) mutex_enter(&(gd)->gfsd_lock) -#define gfs_dir_unlock(gd) mutex_exit(&(gd)->gfsd_lock) -#define GFS_DIR_LOCKED(gd) MUTEX_HELD(&(gd)->gfsd_lock) - -#define gfs_file_parent(vp) (((gfs_file_t *)(vp)->v_data)->gfs_parent) - -#define gfs_file_index(vp) (((gfs_file_t *)(vp)->v_data)->gfs_index) -#define gfs_file_set_index(vp, idx) \ - (((gfs_file_t *)(vp)->v_data)->gfs_index = (idx)) - -#define gfs_file_inode(vp) (((gfs_file_t *)(vp)->v_data)->gfs_ino) -#define gfs_file_set_inode(vp, ino) \ - (((gfs_file_t *)(vp)->v_data)->gfs_ino = (ino)) - -typedef struct gfs_readdir_state { - void *grd_dirent; /* directory entry buffer */ - size_t grd_namlen; /* max file name length */ - size_t grd_ureclen; /* exported record size */ - ssize_t grd_oresid; /* original uio_resid */ - ino64_t grd_parent; /* inode of parent */ - ino64_t grd_self; /* inode of self */ - int grd_flags; /* flags from VOP_READDIR */ -} gfs_readdir_state_t; - -extern int gfs_readdir_init(gfs_readdir_state_t *, int, int, uio_t *, ino64_t, - ino64_t, int); -extern int gfs_readdir_emit(gfs_readdir_state_t *, uio_t *, offset_t, ino64_t, - const char *, int, int *, u_long **); -extern int gfs_readdir_pred(gfs_readdir_state_t *, uio_t *, offset_t *, int *, - u_long **); -extern int gfs_readdir_fini(gfs_readdir_state_t *, int, int *, int); -extern int gfs_get_parent_ino(vnode_t *, cred_t *, caller_context_t *, - ino64_t *, ino64_t *); - -/* - * Objects with real extended attributes will get their . and .. - * readdir entries from the real xattr directory. GFS_STATIC_ENTRY_OFFSET - * lets us skip right to the static entries in the GFS directory. - */ -#define GFS_STATIC_ENTRY_OFFSET ((offset_t)2) - -extern int gfs_lookup_dot(vnode_t **, vnode_t *, vnode_t *, const char *); - -extern int gfs_vop_readdir(struct vop_readdir_args *); -extern int gfs_vop_reclaim(struct vop_reclaim_args *); - - -#ifdef __cplusplus -} -#endif - -#endif /* _SYS_GFS_H */ diff --git a/sys/conf/files b/sys/conf/files index f51975976829..33fd16af8bb6 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -158,7 +158,6 @@ cddl/contrib/opensolaris/common/zfs/zfs_namecheck.c optional zfs compile-with cddl/contrib/opensolaris/common/zfs/zfs_prop.c optional zfs compile-with "${ZFS_C}" cddl/contrib/opensolaris/common/zfs/zpool_prop.c optional zfs compile-with "${ZFS_C}" cddl/contrib/opensolaris/common/zfs/zprop_common.c optional zfs compile-with "${ZFS_C}" -cddl/contrib/opensolaris/uts/common/fs/gfs.c optional zfs compile-with "${ZFS_C}" cddl/contrib/opensolaris/uts/common/fs/vnode.c optional zfs compile-with "${ZFS_C}" cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c optional zfs compile-with "${ZFS_C}" cddl/contrib/opensolaris/uts/common/fs/zfs/blkptr.c optional zfs compile-with "${ZFS_C}" diff --git a/sys/modules/zfs/Makefile b/sys/modules/zfs/Makefile index 9c503f96420c..b02254d9c5b6 100644 --- a/sys/modules/zfs/Makefile +++ b/sys/modules/zfs/Makefile @@ -46,7 +46,6 @@ SRCS+= opensolaris_atomic.c .endif .PATH: ${SUNW}/uts/common/fs -SRCS+= gfs.c SRCS+= vnode.c .PATH: ${SUNW}/uts/common/os