File Manager

003 File Manager

Current Path: /usr/src/sys/contrib/openzfs/include/sys

usr / src / sys / contrib / openzfs / include / sys /

📁 ..
📄 Makefile.am(2.18 KB)
📄 abd.h(4.25 KB)
📄 abd_impl.h(4.41 KB)
📄 aggsum.h(1.28 KB)
📄 arc.h(11.19 KB)
📄 arc_impl.h(33.15 KB)
📄 avl.h(9.16 KB)
📄 avl_impl.h(4.8 KB)
📄 bitops.h(3.2 KB)
📄 blkptr.h(914 B)
📄 bplist.h(1.6 KB)
📄 bpobj.h(3.21 KB)
📄 bptree.h(1.89 KB)
📄 bqueue.h(1.23 KB)
📄 btree.h(7.68 KB)
📁 crypto
📄 dataset_kstats.h(2.27 KB)
📄 dbuf.h(13.94 KB)
📄 ddt.h(7.96 KB)
📄 dmu.h(39.06 KB)
📄 dmu_impl.h(6.92 KB)
📄 dmu_objset.h(9.19 KB)
📄 dmu_recv.h(2.75 KB)
📄 dmu_redact.h(1.67 KB)
📄 dmu_send.h(2.54 KB)
📄 dmu_traverse.h(3.02 KB)
📄 dmu_tx.h(4.43 KB)
📄 dmu_zfetch.h(2.23 KB)
📄 dnode.h(22.41 KB)
📄 dsl_bookmark.h(5.05 KB)
📄 dsl_crypt.h(7.76 KB)
📄 dsl_dataset.h(18.62 KB)
📄 dsl_deadlist.h(4.21 KB)
📄 dsl_deleg.h(3.27 KB)
📄 dsl_destroy.h(2.19 KB)
📄 dsl_dir.h(7.67 KB)
📄 dsl_pool.h(6.23 KB)
📄 dsl_prop.h(4.38 KB)
📄 dsl_scan.h(7.11 KB)
📄 dsl_synctask.h(4.06 KB)
📄 dsl_userhold.h(1.84 KB)
📄 edonr.h(2.65 KB)
📄 efi_partition.h(16.28 KB)
📁 fm
📄 frame.h(935 B)
📁 fs
📄 hkdf.h(782 B)
📁 lua
📄 metaslab.h(5.48 KB)
📄 metaslab_impl.h(21.23 KB)
📄 mmp.h(2.37 KB)
📄 mntent.h(5.22 KB)
📄 mod.h(1.26 KB)
📄 multilist.h(3.27 KB)
📄 note.h(1.62 KB)
📄 nvpair.h(14.77 KB)
📄 nvpair_impl.h(2.23 KB)
📄 objlist.h(1.13 KB)
📄 pathname.h(2.12 KB)
📄 qat.h(5.86 KB)
📄 range_tree.h(9.73 KB)
📄 rrwlock.h(3.53 KB)
📄 sa.h(5.14 KB)
📄 sa_impl.h(8.29 KB)
📄 skein.h(6.69 KB)
📄 spa.h(46.07 KB)
📄 spa_boot.h(1.16 KB)
📄 spa_checkpoint.h(1.44 KB)
📄 spa_checksum.h(1.96 KB)
📄 spa_impl.h(18.25 KB)
📄 spa_log_spacemap.h(2.62 KB)
📄 space_map.h(8.7 KB)
📄 space_reftree.h(1.69 KB)
📁 sysevent
📄 sysevent.h(1.07 KB)
📄 txg.h(4.66 KB)
📄 txg_impl.h(4.77 KB)
📄 u8_textprep.h(3.59 KB)
📄 u8_textprep_data.h(1.41 MB)
📄 uberblock.h(1.36 KB)
📄 uberblock_impl.h(5.11 KB)
📄 uio_impl.h(1.58 KB)
📄 unique.h(1.56 KB)
📄 uuid.h(2.85 KB)
📄 vdev.h(8.18 KB)
📄 vdev_disk.h(1.65 KB)
📄 vdev_draid.h(3.43 KB)
📄 vdev_file.h(1.23 KB)
📄 vdev_impl.h(22.53 KB)
📄 vdev_indirect_births.h(2.31 KB)
📄 vdev_indirect_mapping.h(4.38 KB)
📄 vdev_initialize.h(1.39 KB)
📄 vdev_raidz.h(2.04 KB)
📄 vdev_raidz_impl.h(10.54 KB)
📄 vdev_rebuild.h(3.4 KB)
📄 vdev_removal.h(2.63 KB)
📄 vdev_trim.h(1.72 KB)
📄 xvattr.h(13.1 KB)
📄 zap.h(18.63 KB)
📄 zap_impl.h(6.79 KB)
📄 zap_leaf.h(7.84 KB)
📄 zcp.h(4.87 KB)
📄 zcp_global.h(742 B)
📄 zcp_iter.h(1.07 KB)
📄 zcp_prop.h(780 B)
📄 zcp_set.h(929 B)
📄 zfeature.h(2.42 KB)
📄 zfs_acl.h(8.08 KB)
📄 zfs_bootenv.h(1.41 KB)
📄 zfs_context.h(21.23 KB)
📄 zfs_debug.h(3.3 KB)
📄 zfs_delay.h(1.25 KB)
📄 zfs_file.h(2.06 KB)
📄 zfs_fuid.h(4.26 KB)
📄 zfs_ioctl.h(17.63 KB)
📄 zfs_ioctl_impl.h(3.1 KB)
📄 zfs_onexit.h(1.65 KB)
📄 zfs_project.h(2.35 KB)
📄 zfs_quota.h(1.57 KB)
📄 zfs_racct.h(1.12 KB)
📄 zfs_ratelimit.h(1.11 KB)
📄 zfs_refcount.h(4.15 KB)
📄 zfs_rlock.h(2.54 KB)
📄 zfs_sa.h(4.38 KB)
📄 zfs_stat.h(1.45 KB)
📄 zfs_sysfs.h(1.49 KB)
📄 zfs_vfsops.h(1.05 KB)
📄 zfs_vnops.h(2 KB)
📄 zfs_znode.h(10.93 KB)
📄 zil.h(18.27 KB)
📄 zil_impl.h(9.12 KB)
📄 zio.h(21.68 KB)
📄 zio_checksum.h(4.55 KB)
📄 zio_compress.h(5.91 KB)
📄 zio_crypt.h(5.21 KB)
📄 zio_impl.h(8.33 KB)
📄 zio_priority.h(1.2 KB)
📄 zrlock.h(1.7 KB)
📁 zstd
📄 zthr.h(1.23 KB)
📄 zvol.h(2.27 KB)
📄 zvol_impl.h(3.7 KB)

Editing: avl.h

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright (c) 2014 by Delphix. All rights reserved.
 */

#ifndef	_AVL_H
#define	_AVL_H

/*
 * This is a private header file.  Applications should not directly include
 * this file.
 */

#ifdef	__cplusplus
extern "C" {
#endif

#include <sys/types.h>
#include <sys/avl_impl.h>

/*
 * This is a generic implementation of AVL trees for use in the Solaris kernel.
 * The interfaces provide an efficient way of implementing an ordered set of
 * data structures.
 *
 * AVL trees provide an alternative to using an ordered linked list. Using AVL
 * trees will usually be faster, however they requires more storage. An ordered
 * linked list in general requires 2 pointers in each data structure. The
 * AVL tree implementation uses 3 pointers. The following chart gives the
 * approximate performance of operations with the different approaches:
 *
 *	Operation	 Link List	AVL tree
 *	---------	 --------	--------
 *	lookup		   O(n)		O(log(n))
 *
 *	insert 1 node	 constant	constant
 *
 *	delete 1 node	 constant	between constant and O(log(n))
 *
 *	delete all nodes   O(n)		O(n)
 *
 *	visit the next
 *	or prev node	 constant	between constant and O(log(n))
 *
 *
 * The data structure nodes are anchored at an "avl_tree_t" (the equivalent
 * of a list header) and the individual nodes will have a field of
 * type "avl_node_t" (corresponding to list pointers).
 *
 * The type "avl_index_t" is used to indicate a position in the list for
 * certain calls.
 *
 * The usage scenario is generally:
 *
 * 1. Create the list/tree with: avl_create()
 *
 * followed by any mixture of:
 *
 * 2a. Insert nodes with: avl_add(), or avl_find() and avl_insert()
 *
 * 2b. Visited elements with:
 *	 avl_first() - returns the lowest valued node
 *	 avl_last() - returns the highest valued node
 *	 AVL_NEXT() - given a node go to next higher one
 *	 AVL_PREV() - given a node go to previous lower one
 *
 * 2c.  Find the node with the closest value either less than or greater
 *	than a given value with avl_nearest().
 *
 * 2d. Remove individual nodes from the list/tree with avl_remove().
 *
 * and finally when the list is being destroyed
 *
 * 3. Use avl_destroy_nodes() to quickly process/free up any remaining nodes.
 *    Note that once you use avl_destroy_nodes(), you can no longer
 *    use any routine except avl_destroy_nodes() and avl_destroy().
 *
 * 4. Use avl_destroy() to destroy the AVL tree itself.
 *
 * Any locking for multiple thread access is up to the user to provide, just
 * as is needed for any linked list implementation.
 */

/*
 * AVL comparator helpers
 */
#define	TREE_ISIGN(a)	(((a) > 0) - ((a) < 0))
#define	TREE_CMP(a, b)	(((a) > (b)) - ((a) < (b)))
#define	TREE_PCMP(a, b)	\
	(((uintptr_t)(a) > (uintptr_t)(b)) - ((uintptr_t)(a) < (uintptr_t)(b)))

/*
 * Type used for the root of the AVL tree.
 */
typedef struct avl_tree avl_tree_t;

/*
 * The data nodes in the AVL tree must have a field of this type.
 */
typedef struct avl_node avl_node_t;

/*
 * An opaque type used to locate a position in the tree where a node
 * would be inserted.
 */
typedef uintptr_t avl_index_t;

/*
 * Direction constants used for avl_nearest().
 */
#define	AVL_BEFORE	(0)
#define	AVL_AFTER	(1)

/*
 * Prototypes
 *
 * Where not otherwise mentioned, "void *" arguments are a pointer to the
 * user data structure which must contain a field of type avl_node_t.
 *
 * Also assume the user data structures looks like:
 *	struct my_type {
 *		...
 *		avl_node_t	my_link;
 *		...
 *	};
 */

/*
 * Initialize an AVL tree. Arguments are:
 *
 * tree   - the tree to be initialized
 * compar - function to compare two nodes, it must return exactly: -1, 0, or +1
 *          -1 for <, 0 for ==, and +1 for >
 * size   - the value of sizeof(struct my_type)
 * offset - the value of OFFSETOF(struct my_type, my_link)
 */
extern void avl_create(avl_tree_t *tree,
	int (*compar) (const void *, const void *), size_t size, size_t offset);

/*
 * Find a node with a matching value in the tree. Returns the matching node
 * found. If not found, it returns NULL and then if "where" is not NULL it sets
 * "where" for use with avl_insert() or avl_nearest().
 *
 * node   - node that has the value being looked for
 * where  - position for use with avl_nearest() or avl_insert(), may be NULL
 */
extern void *avl_find(avl_tree_t *tree, const void *node, avl_index_t *where);

/*
 * Insert a node into the tree.
 *
 * node   - the node to insert
 * where  - position as returned from avl_find()
 */
extern void avl_insert(avl_tree_t *tree, void *node, avl_index_t where);

/*
 * Insert "new_data" in "tree" in the given "direction" either after
 * or before the data "here".
 *
 * This might be useful for avl clients caching recently accessed
 * data to avoid doing avl_find() again for insertion.
 *
 * new_data	- new data to insert
 * here		- existing node in "tree"
 * direction	- either AVL_AFTER or AVL_BEFORE the data "here".
 */
extern void avl_insert_here(avl_tree_t *tree, void *new_data, void *here,
    int direction);

/*
 * Return the first or last valued node in the tree. Will return NULL
 * if the tree is empty.
 *
 */
extern void *avl_first(avl_tree_t *tree);
extern void *avl_last(avl_tree_t *tree);

/*
 * Return the next or previous valued node in the tree.
 * AVL_NEXT() will return NULL if at the last node.
 * AVL_PREV() will return NULL if at the first node.
 *
 * node   - the node from which the next or previous node is found
 */
#define	AVL_NEXT(tree, node)	avl_walk(tree, node, AVL_AFTER)
#define	AVL_PREV(tree, node)	avl_walk(tree, node, AVL_BEFORE)

/*
 * Find the node with the nearest value either greater or less than
 * the value from a previous avl_find(). Returns the node or NULL if
 * there isn't a matching one.
 *
 * where     - position as returned from avl_find()
 * direction - either AVL_BEFORE or AVL_AFTER
 *
 * EXAMPLE get the greatest node that is less than a given value:
 *
 *	avl_tree_t *tree;
 *	struct my_data look_for_value = {....};
 *	struct my_data *node;
 *	struct my_data *less;
 *	avl_index_t where;
 *
 *	node = avl_find(tree, &look_for_value, &where);
 *	if (node != NULL)
 *		less = AVL_PREV(tree, node);
 *	else
 *		less = avl_nearest(tree, where, AVL_BEFORE);
 */
extern void *avl_nearest(avl_tree_t *tree, avl_index_t where, int direction);

/*
 * Add a single node to the tree.
 * The node must not be in the tree, and it must not
 * compare equal to any other node already in the tree.
 *
 * node   - the node to add
 */
extern void avl_add(avl_tree_t *tree, void *node);

/*
 * Remove a single node from the tree.  The node must be in the tree.
 *
 * node   - the node to remove
 */
extern void avl_remove(avl_tree_t *tree, void *node);

/*
 * Reinsert a node only if its order has changed relative to its nearest
 * neighbors. To optimize performance avl_update_lt() checks only the previous
 * node and avl_update_gt() checks only the next node. Use avl_update_lt() and
 * avl_update_gt() only if you know the direction in which the order of the
 * node may change.
 */
extern boolean_t avl_update(avl_tree_t *, void *);
extern boolean_t avl_update_lt(avl_tree_t *, void *);
extern boolean_t avl_update_gt(avl_tree_t *, void *);

/*
 * Swaps the contents of the two trees.
 */
extern void avl_swap(avl_tree_t *tree1, avl_tree_t *tree2);

/*
 * Return the number of nodes in the tree
 */
extern ulong_t avl_numnodes(avl_tree_t *tree);

/*
 * Return B_TRUE if there are zero nodes in the tree, B_FALSE otherwise.
 */
extern boolean_t avl_is_empty(avl_tree_t *tree);

/*
 * Used to destroy any remaining nodes in a tree. The cookie argument should
 * be initialized to NULL before the first call. Returns a node that has been
 * removed from the tree and may be free()'d. Returns NULL when the tree is
 * empty.
 *
 * Once you call avl_destroy_nodes(), you can only continuing calling it and
 * finally avl_destroy(). No other AVL routines will be valid.
 *
 * cookie - a "void *" used to save state between calls to avl_destroy_nodes()
 *
 * EXAMPLE:
 *	avl_tree_t *tree;
 *	struct my_data *node;
 *	void *cookie;
 *
 *	cookie = NULL;
 *	while ((node = avl_destroy_nodes(tree, &cookie)) != NULL)
 *		free(node);
 *	avl_destroy(tree);
 */
extern void *avl_destroy_nodes(avl_tree_t *tree, void **cookie);

/*
 * Final destroy of an AVL tree. Arguments are:
 *
 * tree   - the empty tree to destroy
 */
extern void avl_destroy(avl_tree_t *tree);

#ifdef	__cplusplus
}
#endif

#endif	/* _AVL_H */

003 File Manager

Editing: avl.h

Upload File

Create Folder