4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
21 /* Portions Copyright 2007 Shivakumar GN */
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
27 * Copyright (c) 2017 by Delphix. All rights reserved.
30 #include <sys/types.h>
31 #include <sys/cmn_err.h>
32 #include <sys/debug.h>
33 #include <sys/dirent.h>
36 #include <sys/mutex.h>
37 #include <sys/sysmacros.h>
38 #include <sys/systm.h>
39 #include <sys/sunddi.h>
41 #include <sys/vmsystm.h>
43 #include <sys/vnode.h>
46 #include <vm/seg_vn.h>
51 * Generic pseudo-filesystem routines.
53 * There are significant similarities between the implementation of certain file
54 * system entry points across different filesystems. While one could attempt to
55 * "choke up on the bat" and incorporate common functionality into a VOP
56 * preamble or postamble, such an approach is limited in the benefit it can
57 * provide. In this file we instead define a toolkit of routines which can be
58 * called from a filesystem (with in-kernel pseudo-filesystems being the focus
59 * of the exercise) in a more component-like fashion.
61 * There are three basic classes of routines:
63 * 1) Lowlevel support routines
65 * These routines are designed to play a support role for existing
66 * pseudo-filesystems (such as procfs). They simplify common tasks,
67 * without forcing the filesystem to hand over management to GFS. The
68 * routines covered are:
77 * 2) Complete GFS management
79 * These routines take a more active role in management of the
80 * pseudo-filesystem. They handle the relationship between vnode private
81 * data and VFS data, as well as the relationship between vnodes in the
82 * directory hierarchy.
84 * In order to use these interfaces, the first member of every private
85 * v_data must be a gfs_file_t or a gfs_dir_t. This hands over all control
102 * 3) Single File pseudo-filesystems
104 * This routine creates a rooted file to be overlayed ontop of another
105 * file in the physical filespace.
107 * Note that the parent is NULL (actually the vfs), but there is nothing
108 * technically keeping such a file from utilizing the "Complete GFS
109 * management" set of routines.
111 * gfs_root_create_file()
115 * gfs_make_opsvec: take an array of vnode type definitions and create
116 * their vnodeops_t structures
118 * This routine takes an array of gfs_opsvec_t's. It could
119 * alternatively take an array of gfs_opsvec_t*'s, which would allow
120 * vnode types to be completely defined in files external to the caller
121 * of gfs_make_opsvec(). As it stands, much more sharing takes place --
122 * both the caller and the vnode type provider need to access gfsv_ops
123 * and gfsv_template, and the caller also needs to know gfsv_name.
126 gfs_make_opsvec(gfs_opsvec_t
*vec
)
131 if (vec
[i
].gfsv_name
== NULL
)
133 error
= vn_make_ops(vec
[i
].gfsv_name
, vec
[i
].gfsv_template
,
139 cmn_err(CE_WARN
, "gfs_make_opsvec: bad vnode ops template for '%s'",
141 for (i
--; i
>= 0; i
--) {
142 vn_freevnodeops(*vec
[i
].gfsv_ops
);
143 *vec
[i
].gfsv_ops
= NULL
;
149 * Low level directory routines
151 * These routines provide some simple abstractions for reading directories.
152 * They are designed to be used by existing pseudo filesystems (namely procfs)
153 * that already have a complicated management infrastructure.
157 * gfs_get_parent_ino: used to obtain a parent inode number and the
158 * inode number of the given vnode in preparation for calling gfs_readdir_init.
161 gfs_get_parent_ino(vnode_t
*dvp
, cred_t
*cr
, caller_context_t
*ct
,
162 ino64_t
*pino
, ino64_t
*ino
)
165 gfs_dir_t
*dp
= dvp
->v_data
;
168 *ino
= dp
->gfsd_file
.gfs_ino
;
169 parent
= dp
->gfsd_file
.gfs_parent
;
171 if (parent
== NULL
) {
172 *pino
= *ino
; /* root of filesystem */
173 } else if (dvp
->v_flag
& V_XATTRDIR
) {
176 va
.va_mask
= AT_NODEID
;
177 error
= VOP_GETATTR(parent
, &va
, 0, cr
, ct
);
180 *pino
= va
.va_nodeid
;
182 *pino
= ((gfs_file_t
*)(parent
->v_data
))->gfs_ino
;
189 * gfs_readdir_init: initiate a generic readdir
190 * st - a pointer to an uninitialized gfs_readdir_state_t structure
191 * name_max - the directory's maximum file name length
192 * ureclen - the exported file-space record length (1 for non-legacy FSs)
193 * uiop - the uiop passed to readdir
194 * parent - the parent directory's inode
195 * self - this directory's inode
196 * flags - flags from VOP_READDIR
198 * Returns 0 or a non-zero errno.
200 * Typical VOP_READDIR usage of gfs_readdir_*:
202 * if ((error = gfs_readdir_init(...)) != 0)
205 * while ((error = gfs_readdir_pred(..., &voffset)) != 0) {
206 * if (!consumer_entry_at(voffset))
207 * voffset = consumer_next_entry(voffset);
208 * if (consumer_eof(voffset)) {
212 * if ((error = gfs_readdir_emit(..., voffset,
213 * consumer_ino(voffset), consumer_name(voffset))) != 0)
216 * return (gfs_readdir_fini(..., error, eofp, eof));
218 * As you can see, a zero result from gfs_readdir_pred() or
219 * gfs_readdir_emit() indicates that processing should continue,
220 * whereas a non-zero result indicates that the loop should terminate.
221 * Most consumers need do nothing more than let gfs_readdir_fini()
222 * determine what the cause of failure was and return the appropriate
226 gfs_readdir_init(gfs_readdir_state_t
*st
, int name_max
, int ureclen
,
227 uio_t
*uiop
, ino64_t parent
, ino64_t self
, int flags
)
231 if (uiop
->uio_loffset
< 0 || uiop
->uio_resid
<= 0 ||
232 (uiop
->uio_loffset
% ureclen
) != 0)
235 st
->grd_ureclen
= ureclen
;
236 st
->grd_oresid
= uiop
->uio_resid
;
237 st
->grd_namlen
= name_max
;
238 if (flags
& V_RDDIR_ENTFLAGS
)
239 dirent_size
= EDIRENT_RECLEN(st
->grd_namlen
);
241 dirent_size
= DIRENT64_RECLEN(st
->grd_namlen
);
242 st
->grd_dirent
= kmem_zalloc(dirent_size
, KM_SLEEP
);
243 st
->grd_parent
= parent
;
245 st
->grd_flags
= flags
;
251 * gfs_readdir_emit_int: internal routine to emit directory entry
253 * st - the current readdir state, which must have d_ino/ed_ino
254 * and d_name/ed_name set
255 * uiop - caller-supplied uio pointer
256 * next - the offset of the next entry
259 gfs_readdir_emit_int(gfs_readdir_state_t
*st
, uio_t
*uiop
, offset_t next
)
265 if (st
->grd_flags
& V_RDDIR_ENTFLAGS
) {
266 edp
= st
->grd_dirent
;
267 reclen
= EDIRENT_RECLEN(strlen(edp
->ed_name
));
270 reclen
= DIRENT64_RECLEN(strlen(dp
->d_name
));
273 if (reclen
> uiop
->uio_resid
) {
275 * Error if no entries were returned yet
277 if (uiop
->uio_resid
== st
->grd_oresid
)
282 if (st
->grd_flags
& V_RDDIR_ENTFLAGS
) {
284 edp
->ed_reclen
= (ushort_t
)reclen
;
287 dp
->d_reclen
= (ushort_t
)reclen
;
290 if (uiomove((caddr_t
)st
->grd_dirent
, reclen
, UIO_READ
, uiop
))
293 uiop
->uio_loffset
= next
;
299 * gfs_readdir_emit: emit a directory entry
300 * voff - the virtual offset (obtained from gfs_readdir_pred)
301 * ino - the entry's inode
302 * name - the entry's name
303 * eflags - value for ed_eflags (if processing edirent_t)
305 * Returns a 0 on success, a non-zero errno on failure, or -1 if the
306 * readdir loop should terminate. A non-zero result (either errno or
307 * -1) from this function is typically passed directly to
308 * gfs_readdir_fini().
311 gfs_readdir_emit(gfs_readdir_state_t
*st
, uio_t
*uiop
, offset_t voff
,
312 ino64_t ino
, const char *name
, int eflags
)
314 offset_t off
= (voff
+ 2) * st
->grd_ureclen
;
316 if (st
->grd_flags
& V_RDDIR_ENTFLAGS
) {
317 edirent_t
*edp
= st
->grd_dirent
;
320 (void) strncpy(edp
->ed_name
, name
, st
->grd_namlen
);
321 edp
->ed_eflags
= eflags
;
323 dirent64_t
*dp
= st
->grd_dirent
;
326 (void) strncpy(dp
->d_name
, name
, st
->grd_namlen
);
330 * Inter-entry offsets are invalid, so we assume a record size of
331 * grd_ureclen and explicitly set the offset appropriately.
333 return (gfs_readdir_emit_int(st
, uiop
, off
+ st
->grd_ureclen
));
337 * gfs_readdir_emitn: like gfs_readdir_emit(), but takes an integer
338 * instead of a string for the entry's name.
341 gfs_readdir_emitn(gfs_readdir_state_t
*st
, uio_t
*uiop
, offset_t voff
,
342 ino64_t ino
, unsigned long num
)
347 return (gfs_readdir_emit(st
, uiop
, voff
, ino
, buf
, 0));
351 * gfs_readdir_pred: readdir loop predicate
352 * voffp - a pointer in which the next virtual offset should be stored
354 * Returns a 0 on success, a non-zero errno on failure, or -1 if the
355 * readdir loop should terminate. A non-zero result (either errno or
356 * -1) from this function is typically passed directly to
357 * gfs_readdir_fini().
360 gfs_readdir_pred(gfs_readdir_state_t
*st
, uio_t
*uiop
, offset_t
*voffp
)
366 if (uiop
->uio_resid
<= 0)
369 off
= uiop
->uio_loffset
/ st
->grd_ureclen
;
372 if ((error
= gfs_readdir_emit(st
, uiop
, voff
, st
->grd_self
,
375 } else if (off
== 1) {
376 if ((error
= gfs_readdir_emit(st
, uiop
, voff
, st
->grd_parent
,
388 * gfs_readdir_fini: generic readdir cleanup
389 * error - if positive, an error to return
390 * eofp - the eofp passed to readdir
391 * eof - the eof value
393 * Returns a 0 on success, a non-zero errno on failure. This result
394 * should be returned from readdir.
397 gfs_readdir_fini(gfs_readdir_state_t
*st
, int error
, int *eofp
, int eof
)
401 if (st
->grd_flags
& V_RDDIR_ENTFLAGS
)
402 dirent_size
= EDIRENT_RECLEN(st
->grd_namlen
);
404 dirent_size
= DIRENT64_RECLEN(st
->grd_namlen
);
405 kmem_free(st
->grd_dirent
, dirent_size
);
416 * Performs a basic check for "." and ".." directory entries.
419 gfs_lookup_dot(vnode_t
**vpp
, vnode_t
*dvp
, vnode_t
*pvp
, const char *nm
)
421 if (*nm
== '\0' || strcmp(nm
, ".") == 0) {
425 } else if (strcmp(nm
, "..") == 0) {
427 ASSERT(dvp
->v_flag
& VROOT
);
441 * gfs_file_create(): create a new GFS file
443 * size - size of private data structure (v_data)
444 * pvp - parent vnode (GFS directory)
445 * ops - vnode operations vector
447 * In order to use this interface, the parent vnode must have been created by
448 * gfs_dir_create(), and the private data stored in v_data must have a
449 * 'gfs_file_t' as its first field.
451 * Given these constraints, this routine will automatically:
453 * - Allocate v_data for the vnode
454 * - Initialize necessary fields in the vnode
458 gfs_file_create(size_t size
, vnode_t
*pvp
, vnodeops_t
*ops
)
464 * Allocate vnode and internal data structure
466 fp
= kmem_zalloc(size
, KM_SLEEP
);
467 vp
= vn_alloc(KM_SLEEP
);
470 * Set up various pointers
473 fp
->gfs_parent
= pvp
;
476 fp
->gfs_type
= GFS_FILE
;
479 * Initialize vnode and hold parent.
483 VN_SET_VFS_TYPE_DEV(vp
, pvp
->v_vfsp
, VREG
, 0);
491 * gfs_dir_create: creates a new directory in the parent
493 * size - size of private data structure (v_data)
494 * pvp - parent vnode (GFS directory)
495 * ops - vnode operations vector
496 * entries - NULL-terminated list of static entries (if any)
497 * maxlen - maximum length of a directory entry
498 * readdir_cb - readdir callback (see gfs_dir_readdir)
499 * inode_cb - inode callback (see gfs_dir_readdir)
500 * lookup_cb - lookup callback (see gfs_dir_lookup)
502 * In order to use this function, the first member of the private vnode
503 * structure (v_data) must be a gfs_dir_t. For each directory, there are
504 * static entries, defined when the structure is initialized, and dynamic
505 * entries, retrieved through callbacks.
507 * If a directory has static entries, then it must supply a inode callback,
508 * which will compute the inode number based on the parent and the index.
509 * For a directory with dynamic entries, the caller must supply a readdir
510 * callback and a lookup callback. If a static lookup fails, we fall back to
511 * the supplied lookup callback, if any.
513 * This function also performs the same initialization as gfs_file_create().
516 gfs_dir_create(size_t struct_size
, vnode_t
*pvp
, vnodeops_t
*ops
,
517 gfs_dirent_t
*entries
, gfs_inode_cb inode_cb
, int maxlen
,
518 gfs_readdir_cb readdir_cb
, gfs_lookup_cb lookup_cb
)
524 vp
= gfs_file_create(struct_size
, pvp
, ops
);
528 dp
->gfsd_file
.gfs_type
= GFS_DIR
;
529 dp
->gfsd_maxlen
= maxlen
;
531 if (entries
!= NULL
) {
532 for (de
= entries
; de
->gfse_name
!= NULL
; de
++)
535 dp
->gfsd_static
= kmem_alloc(
536 dp
->gfsd_nstatic
* sizeof (gfs_dirent_t
), KM_SLEEP
);
537 bcopy(entries
, dp
->gfsd_static
,
538 dp
->gfsd_nstatic
* sizeof (gfs_dirent_t
));
541 dp
->gfsd_readdir
= readdir_cb
;
542 dp
->gfsd_lookup
= lookup_cb
;
543 dp
->gfsd_inode
= inode_cb
;
545 mutex_init(&dp
->gfsd_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
551 * gfs_root_create(): create a root vnode for a GFS filesystem
553 * Similar to gfs_dir_create(), this creates a root vnode for a filesystem. The
554 * only difference is that it takes a vfs_t instead of a vnode_t as its parent.
557 gfs_root_create(size_t size
, vfs_t
*vfsp
, vnodeops_t
*ops
, ino64_t ino
,
558 gfs_dirent_t
*entries
, gfs_inode_cb inode_cb
, int maxlen
,
559 gfs_readdir_cb readdir_cb
, gfs_lookup_cb lookup_cb
)
561 vnode_t
*vp
= gfs_dir_create(size
, NULL
, ops
, entries
, inode_cb
,
562 maxlen
, readdir_cb
, lookup_cb
);
564 /* Manually set the inode */
565 ((gfs_file_t
*)vp
->v_data
)->gfs_ino
= ino
;
568 VN_SET_VFS_TYPE_DEV(vp
, vfsp
, VDIR
, 0);
569 vp
->v_flag
|= VROOT
| VNOCACHE
| VNOMAP
| VNOSWAP
| VNOMOUNT
;
575 * gfs_root_create_file(): create a root vnode for a GFS file as a filesystem
577 * Similar to gfs_root_create(), this creates a root vnode for a file to
578 * be the pseudo-filesystem.
581 gfs_root_create_file(size_t size
, vfs_t
*vfsp
, vnodeops_t
*ops
, ino64_t ino
)
583 vnode_t
*vp
= gfs_file_create(size
, NULL
, ops
);
585 ((gfs_file_t
*)vp
->v_data
)->gfs_ino
= ino
;
588 VN_SET_VFS_TYPE_DEV(vp
, vfsp
, VREG
, 0);
589 vp
->v_flag
|= VROOT
| VNOCACHE
| VNOMAP
| VNOSWAP
| VNOMOUNT
;
595 * gfs_file_inactive()
597 * Called from the VOP_INACTIVE() routine. If necessary, this routine will
598 * remove the given vnode from the parent directory and clean up any references
601 * If the vnode was not removed (due to a race with vget), then NULL is
602 * returned. Otherwise, a pointer to the private data is returned.
605 gfs_file_inactive(vnode_t
*vp
)
608 gfs_dirent_t
*ge
= NULL
;
609 gfs_file_t
*fp
= vp
->v_data
;
610 gfs_dir_t
*dp
= NULL
;
613 if (fp
->gfs_parent
== NULL
|| (vp
->v_flag
& V_XATTRDIR
))
616 dp
= fp
->gfs_parent
->v_data
;
619 * First, see if this vnode is cached in the parent.
624 * Find it in the set of static entries.
626 for (i
= 0; i
< dp
->gfsd_nstatic
; i
++) {
627 ge
= &dp
->gfsd_static
[i
];
629 if (ge
->gfse_vnode
== vp
)
634 * If 'ge' is NULL, then it is a dynamic entry.
639 if (vp
->v_flag
& V_XATTRDIR
) {
640 mutex_enter(&fp
->gfs_parent
->v_lock
);
642 mutex_enter(&vp
->v_lock
);
643 if (vp
->v_count
== 1) {
645 * Really remove this vnode
650 * If this was a statically cached entry, simply set the
651 * cached vnode to NULL.
653 ge
->gfse_vnode
= NULL
;
655 if (vp
->v_flag
& V_XATTRDIR
) {
656 fp
->gfs_parent
->v_xattrdir
= NULL
;
657 mutex_exit(&fp
->gfs_parent
->v_lock
);
659 mutex_exit(&vp
->v_lock
);
662 * Free vnode and release parent
664 if (fp
->gfs_parent
) {
668 VN_RELE(fp
->gfs_parent
);
670 ASSERT(vp
->v_vfsp
!= NULL
);
671 VFS_RELE(vp
->v_vfsp
);
677 mutex_exit(&vp
->v_lock
);
678 if (vp
->v_flag
& V_XATTRDIR
) {
679 mutex_exit(&fp
->gfs_parent
->v_lock
);
691 * Same as above, but for directories.
694 gfs_dir_inactive(vnode_t
*vp
)
698 ASSERT(vp
->v_type
== VDIR
);
700 if ((dp
= gfs_file_inactive(vp
)) != NULL
) {
701 mutex_destroy(&dp
->gfsd_lock
);
702 if (dp
->gfsd_nstatic
)
703 kmem_free(dp
->gfsd_static
,
704 dp
->gfsd_nstatic
* sizeof (gfs_dirent_t
));
711 * gfs_dir_lookup_dynamic()
713 * This routine looks up the provided name amongst the dynamic entries
714 * in the gfs directory and returns the corresponding vnode, if found.
716 * The gfs directory is expected to be locked by the caller prior to
717 * calling this function. The directory will be unlocked during the
718 * execution of this function, but will be locked upon return from the
719 * function. This function returns 0 on success, non-zero on error.
721 * The dynamic lookups are performed by invoking the lookup
722 * callback, which is passed to this function as the first argument.
723 * The arguments to the callback are:
725 * int gfs_lookup_cb(vnode_t *pvp, const char *nm, vnode_t **vpp, cred_t *cr,
726 * int flags, int *deflgs, pathname_t *rpnp);
730 * vpp - pointer to resulting vnode
731 * cr - pointer to cred
732 * flags - flags value from lookup request
733 * ignored here; currently only used to request
734 * insensitive lookups
735 * direntflgs - output parameter, directory entry flags
736 * ignored here; currently only used to indicate a lookup
737 * has more than one possible match when case is not considered
738 * realpnp - output parameter, real pathname
739 * ignored here; when lookup was performed case-insensitively,
740 * this field contains the "real" name of the file.
742 * Returns 0 on success, non-zero on error.
745 gfs_dir_lookup_dynamic(gfs_lookup_cb callback
, gfs_dir_t
*dp
,
746 const char *nm
, vnode_t
*dvp
, vnode_t
**vpp
, cred_t
*cr
, int flags
,
747 int *direntflags
, pathname_t
*realpnp
)
753 ASSERT(GFS_DIR_LOCKED(dp
));
756 * Drop the directory lock, as the lookup routine
757 * will need to allocate memory, or otherwise deadlock on this
761 ret
= callback(dvp
, nm
, vpp
, &ino
, cr
, flags
, direntflags
, realpnp
);
765 * The callback for extended attributes returns a vnode
766 * with v_data from an underlying fs.
768 if (ret
== 0 && !IS_XATTRDIR(dvp
)) {
769 fp
= (gfs_file_t
*)((*vpp
)->v_data
);
778 * gfs_dir_lookup_static()
780 * This routine looks up the provided name amongst the static entries
781 * in the gfs directory and returns the corresponding vnode, if found.
782 * The first argument to the function is a pointer to the comparison
783 * function this function should use to decide if names are a match.
785 * If a match is found, and GFS_CACHE_VNODE is set and the vnode
786 * exists, we simply return the existing vnode. Otherwise, we call
787 * the static entry's callback routine, caching the result if
788 * necessary. If the idx pointer argument is non-NULL, we use it to
789 * return the index of the matching static entry.
791 * The gfs directory is expected to be locked by the caller prior to calling
792 * this function. The directory may be unlocked during the execution of
793 * this function, but will be locked upon return from the function.
795 * This function returns 0 if a match is found, ENOENT if not.
798 gfs_dir_lookup_static(int (*compare
)(const char *, const char *),
799 gfs_dir_t
*dp
, const char *nm
, vnode_t
*dvp
, int *idx
,
800 vnode_t
**vpp
, pathname_t
*rpnp
)
806 ASSERT(GFS_DIR_LOCKED(dp
));
809 * Search static entries.
811 for (i
= 0; i
< dp
->gfsd_nstatic
; i
++) {
812 ge
= &dp
->gfsd_static
[i
];
814 if (compare(ge
->gfse_name
, nm
) == 0) {
816 (void) strlcpy(rpnp
->pn_buf
, ge
->gfse_name
,
819 if (ge
->gfse_vnode
) {
820 ASSERT(ge
->gfse_flags
& GFS_CACHE_VNODE
);
827 * We drop the directory lock, as the constructor will
828 * need to do KM_SLEEP allocations. If we return from
829 * the constructor only to find that a parallel
830 * operation has completed, and GFS_CACHE_VNODE is set
831 * for this entry, we discard the result in favor of
835 vp
= ge
->gfse_ctor(dvp
);
838 ((gfs_file_t
*)vp
->v_data
)->gfs_index
= i
;
840 /* Set the inode according to the callback. */
841 ((gfs_file_t
*)vp
->v_data
)->gfs_ino
=
842 dp
->gfsd_inode(dvp
, i
);
844 if (ge
->gfse_flags
& GFS_CACHE_VNODE
) {
845 if (ge
->gfse_vnode
== NULL
) {
849 * A parallel constructor beat us to it;
850 * return existing vnode. We have to be
851 * careful because we can't release the
852 * current vnode while holding the
853 * directory lock; its inactive routine
854 * will try to lock this directory.
880 * Looks up the given name in the directory and returns the corresponding
883 * First, we search statically defined entries, if any, with a call to
884 * gfs_dir_lookup_static(). If no static entry is found, and we have
885 * a callback function we try a dynamic lookup via gfs_dir_lookup_dynamic().
887 * This function returns 0 on success, non-zero on error.
890 gfs_dir_lookup(vnode_t
*dvp
, const char *nm
, vnode_t
**vpp
, cred_t
*cr
,
891 int flags
, int *direntflags
, pathname_t
*realpnp
)
893 gfs_dir_t
*dp
= dvp
->v_data
;
895 vnode_t
*dynvp
= NULL
;
897 int (*compare
)(const char *, const char *);
900 ASSERT(dvp
->v_type
== VDIR
);
902 if (gfs_lookup_dot(vpp
, dvp
, dp
->gfsd_file
.gfs_parent
, nm
) == 0)
905 casecheck
= (flags
& FIGNORECASE
) != 0 && direntflags
!= NULL
;
906 if (vfs_has_feature(dvp
->v_vfsp
, VFSFT_NOCASESENSITIVE
) ||
907 (flags
& FIGNORECASE
))
908 compare
= strcasecmp
;
914 error
= gfs_dir_lookup_static(compare
, dp
, nm
, dvp
, &idx
, &vp
, realpnp
);
916 if (vp
&& casecheck
) {
920 for (i
= idx
+ 1; i
< dp
->gfsd_nstatic
; i
++) {
921 ge
= &dp
->gfsd_static
[i
];
923 if (strcasecmp(ge
->gfse_name
, nm
) == 0) {
924 *direntflags
|= ED_CASE_CONFLICT
;
930 if ((error
|| casecheck
) && dp
->gfsd_lookup
)
931 error
= gfs_dir_lookup_dynamic(dp
->gfsd_lookup
, dp
, nm
, dvp
,
932 &dynvp
, cr
, flags
, direntflags
, vp
? NULL
: realpnp
);
935 /* static and dynamic entries are case-insensitive conflict */
937 *direntflags
|= ED_CASE_CONFLICT
;
939 } else if (vp
== NULL
) {
941 } else if (error
== ENOENT
) {
956 * gfs_dir_readdir: does a readdir() on the given directory
958 * dvp - directory vnode
959 * uiop - uio structure
961 * data - arbitrary data passed to readdir callback
963 * This routine does all the readdir() dirty work. Even so, the caller must
964 * supply two callbacks in order to get full compatibility.
966 * If the directory contains static entries, an inode callback must be
967 * specified. This avoids having to create every vnode and call VOP_GETATTR()
968 * when reading the directory. This function has the following arguments:
970 * ino_t gfs_inode_cb(vnode_t *vp, int index);
972 * vp - vnode for the directory
973 * index - index in original gfs_dirent_t array
975 * Returns the inode number for the given entry.
977 * For directories with dynamic entries, a readdir callback must be provided.
978 * This is significantly more complex, thanks to the particulars of
981 * int gfs_readdir_cb(vnode_t *vp, void *dp, int *eofp,
982 * offset_t *off, offset_t *nextoff, void *data, int flags)
984 * vp - directory vnode
985 * dp - directory entry, sized according to maxlen given to
986 * gfs_dir_create(). callback must fill in d_name and
987 * d_ino (if a dirent64_t), or ed_name, ed_ino, and ed_eflags
988 * (if an edirent_t). edirent_t is used if V_RDDIR_ENTFLAGS
990 * eofp - callback must set to 1 when EOF has been reached
991 * off - on entry, the last offset read from the directory. Callback
992 * must set to the offset of the current entry, typically left
994 * nextoff - callback must set to offset of next entry. Typically
996 * data - caller-supplied data
997 * flags - VOP_READDIR flags
999 * Return 0 on success, or error on failure.
1002 gfs_dir_readdir(vnode_t
*dvp
, uio_t
*uiop
, int *eofp
, void *data
, cred_t
*cr
,
1003 caller_context_t
*ct
, int flags
)
1005 gfs_readdir_state_t gstate
;
1009 gfs_dir_t
*dp
= dvp
->v_data
;
1011 error
= gfs_get_parent_ino(dvp
, cr
, ct
, &pino
, &ino
);
1015 if ((error
= gfs_readdir_init(&gstate
, dp
->gfsd_maxlen
, 1, uiop
,
1016 pino
, ino
, flags
)) != 0)
1019 while ((error
= gfs_readdir_pred(&gstate
, uiop
, &off
)) == 0 &&
1022 if (off
>= 0 && off
< dp
->gfsd_nstatic
) {
1023 ino
= dp
->gfsd_inode(dvp
, off
);
1025 if ((error
= gfs_readdir_emit(&gstate
, uiop
,
1026 off
, ino
, dp
->gfsd_static
[off
].gfse_name
, 0))
1030 } else if (dp
->gfsd_readdir
) {
1031 off
-= dp
->gfsd_nstatic
;
1033 if ((error
= dp
->gfsd_readdir(dvp
,
1034 gstate
.grd_dirent
, &eof
, &off
, &next
,
1035 data
, flags
)) != 0 || eof
)
1038 off
+= dp
->gfsd_nstatic
+ 2;
1039 next
+= dp
->gfsd_nstatic
+ 2;
1041 if ((error
= gfs_readdir_emit_int(&gstate
, uiop
,
1046 * Offset is beyond the end of the static entries, and
1047 * we have no dynamic entries. Set EOF.
1053 return (gfs_readdir_fini(&gstate
, error
, eofp
, eof
));
1058 * gfs_vop_lookup: VOP_LOOKUP() entry point
1060 * For use directly in vnode ops table. Given a GFS directory, calls
1061 * gfs_dir_lookup() as necessary.
1065 gfs_vop_lookup(vnode_t
*dvp
, char *nm
, vnode_t
**vpp
, pathname_t
*pnp
,
1066 int flags
, vnode_t
*rdir
, cred_t
*cr
, caller_context_t
*ct
,
1067 int *direntflags
, pathname_t
*realpnp
)
1069 return (gfs_dir_lookup(dvp
, nm
, vpp
, cr
, flags
, direntflags
, realpnp
));
1073 * gfs_vop_readdir: VOP_READDIR() entry point
1075 * For use directly in vnode ops table. Given a GFS directory, calls
1076 * gfs_dir_readdir() as necessary.
1080 gfs_vop_readdir(vnode_t
*vp
, uio_t
*uiop
, cred_t
*cr
, int *eofp
,
1081 caller_context_t
*ct
, int flags
)
1083 return (gfs_dir_readdir(vp
, uiop
, eofp
, NULL
, cr
, ct
, flags
));
1088 * gfs_vop_map: VOP_MAP() entry point
1090 * Convenient routine for handling pseudo-files that wish to allow mmap() calls.
1091 * This function only works for readonly files, and uses the read function for
1092 * the vnode to fill in the data. The mapped data is immediately faulted in and
1093 * filled with the necessary data during this call; there are no getpage() or
1094 * putpage() routines.
1098 gfs_vop_map(vnode_t
*vp
, offset_t off
, struct as
*as
, caddr_t
*addrp
,
1099 size_t len
, uchar_t prot
, uchar_t maxprot
, uint_t flags
, cred_t
*cred
,
1100 caller_context_t
*ct
)
1103 ssize_t resid
= len
;
1106 * Check for bad parameters
1112 if (vp
->v_flag
& VNOMAP
)
1116 if ((long)off
< 0 || (long)(off
+ len
) < 0)
1118 if (vp
->v_type
!= VREG
)
1120 if ((prot
& (PROT_EXEC
| PROT_WRITE
)) != 0)
1124 * Find appropriate address if needed, otherwise clear address range.
1127 rv
= choose_addr(as
, addrp
, len
, off
, ADDR_VACALIGN
, flags
);
1136 rv
= as_map(as
, *addrp
, len
, segvn_create
, zfod_argsp
);
1142 * Fill with data from read()
1144 rv
= vn_rdwr(UIO_READ
, vp
, *addrp
, len
, off
, UIO_USERSPACE
,
1145 0, (rlim64_t
)0, cred
, &resid
);
1147 if (rv
== 0 && resid
!= 0)
1152 (void) as_unmap(as
, *addrp
, len
);
1160 * gfs_vop_inactive: VOP_INACTIVE() entry point
1162 * Given a vnode that is a GFS file or directory, call gfs_file_inactive() or
1163 * gfs_dir_inactive() as necessary, and kmem_free()s associated private data.
1167 gfs_vop_inactive(vnode_t
*vp
, cred_t
*cr
, caller_context_t
*ct
)
1169 gfs_file_t
*fp
= vp
->v_data
;
1172 if (fp
->gfs_type
== GFS_DIR
)
1173 data
= gfs_dir_inactive(vp
);
1175 data
= gfs_file_inactive(vp
);
1178 kmem_free(data
, fp
->gfs_size
);