自学教程：C++ zap_cursor_fini函数代码示例

static intzcp_clones_iter(lua_State *state){	int err;	char clonename[ZFS_MAX_DATASET_NAME_LEN];	uint64_t dsobj = lua_tonumber(state, lua_upvalueindex(1));	uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2));	dsl_pool_t *dp = zcp_run_info(state)->zri_pool;	dsl_dataset_t *ds, *clone;	zap_attribute_t za;	zap_cursor_t zc;	err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);	if (err == ENOENT) {		return (0);	} else if (err != 0) {		return (luaL_error(state,		    "unexpected error %d from dsl_dataset_hold_obj(dsobj)",		    err));	}	if (dsl_dataset_phys(ds)->ds_next_clones_obj == 0) {		dsl_dataset_rele(ds, FTAG);		return (0);	}	zap_cursor_init_serialized(&zc, dp->dp_meta_objset,	    dsl_dataset_phys(ds)->ds_next_clones_obj, cursor);	dsl_dataset_rele(ds, FTAG);	err = zap_cursor_retrieve(&zc, &za);	if (err != 0) {		zap_cursor_fini(&zc);		if (err != ENOENT) {			return (luaL_error(state,			    "unexpected error %d from zap_cursor_retrieve()",			    err));		}		return (0);	}	zap_cursor_advance(&zc);	cursor = zap_cursor_serialize(&zc);	zap_cursor_fini(&zc);	err = dsl_dataset_hold_obj(dp, za.za_first_integer, FTAG, &clone);	if (err != 0) {		return (luaL_error(state,		    "unexpected error %d from "		    "dsl_dataset_hold_obj(za_first_integer)", err));	}	dsl_dir_name(clone->ds_dir, clonename);	dsl_dataset_rele(clone, FTAG);	lua_pushnumber(state, cursor);	lua_replace(state, lua_upvalueindex(2));	(void) lua_pushstring(state, clonename);	return (1);}

static int osd_index_it_load(const struct lu_env *env, const struct dt_it *di,			     __u64 hash){	struct osd_zap_it *it = (struct osd_zap_it *)di;	struct osd_object *obj = it->ozi_obj;	struct osd_device *osd = osd_obj2dev(obj);	zap_attribute_t   *za = &osd_oti_get(env)->oti_za;	int                rc;	ENTRY;	/* close the current cursor */	zap_cursor_fini(it->ozi_zc);	/* create a new one starting at hash */	memset(it->ozi_zc, 0, sizeof(*it->ozi_zc));	zap_cursor_init_serialized(it->ozi_zc, osd->od_objset.os,				   obj->oo_db->db_object, hash);	it->ozi_reset = 0;	rc = -zap_cursor_retrieve(it->ozi_zc, za);	if (rc == 0)		RETURN(+1);	else if (rc == -ENOENT)		RETURN(0);	RETURN(rc);}

static voiddump_obj(objset_t *os, uint64_t obj, const char *name){	zap_cursor_t zc;	zap_attribute_t za;	(void) printf("%s_obj:/n", name);	for (zap_cursor_init(&zc, os, obj);	    zap_cursor_retrieve(&zc, &za) == 0;	    zap_cursor_advance(&zc)) {		if (za.za_integer_length == 8) {			ASSERT(za.za_num_integers == 1);			(void) printf("/t%s = %llu/n",			    za.za_name, (u_longlong_t)za.za_first_integer);		} else {			ASSERT(za.za_integer_length == 1);			char val[1024];			VERIFY(zap_lookup(os, obj, za.za_name,			    1, sizeof (val), val) == 0);			(void) printf("/t%s = %s/n", za.za_name, val);		}	}	zap_cursor_fini(&zc);}

/* * Read as many directory entry names as will fit in to the provided buffer, * or when no buffer is provided calculate the required buffer size. */intzpl_xattr_readdir(struct inode *dxip, xattr_filldir_t *xf){	zap_cursor_t zc;	zap_attribute_t	zap;	int error;	zap_cursor_init(&zc, ITOZSB(dxip)->z_os, ITOZ(dxip)->z_id);	while ((error = -zap_cursor_retrieve(&zc, &zap)) == 0) {		if (zap.za_integer_length != 8 || zap.za_num_integers != 1) {			error = -ENXIO;			break;		}		error = zpl_xattr_filldir(xf, zap.za_name, strlen(zap.za_name));		if (error)			break;		zap_cursor_advance(&zc);	}	zap_cursor_fini(&zc);	if (error == -ENOENT)		error = 0;	return (error);}

static voiddsl_dataset_remove_clones_key(dsl_dataset_t *ds, uint64_t mintxg, dmu_tx_t *tx){	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;	zap_cursor_t zc;	zap_attribute_t za;	/*	 * If it is the old version, dd_clones doesn't exist so we can't	 * find the clones, but dsl_deadlist_remove_key() is a no-op so it	 * doesn't matter.	 */	if (dsl_dir_phys(ds->ds_dir)->dd_clones == 0)		return;	for (zap_cursor_init(&zc, mos, dsl_dir_phys(ds->ds_dir)->dd_clones);	    zap_cursor_retrieve(&zc, &za) == 0;	    zap_cursor_advance(&zc)) {		dsl_dataset_t *clone;		VERIFY0(dsl_dataset_hold_obj(ds->ds_dir->dd_pool,		    za.za_first_integer, FTAG, &clone));		if (clone->ds_dir->dd_origin_txg > mintxg) {			dsl_deadlist_remove_key(&clone->ds_deadlist,			    mintxg, tx);			dsl_dataset_remove_clones_key(clone, mintxg, tx);		}		dsl_dataset_rele(clone, FTAG);	}	zap_cursor_fini(&zc);}

/* * Clean up any znodes that had no links when we either crashed or * (force) umounted the file system. */voidzfs_unlinked_drain(zfs_sb_t *zsb){    zap_cursor_t	zc;    zap_attribute_t zap;    dmu_object_info_t doi;    znode_t		*zp;    int		error;    /*     * Interate over the contents of the unlinked set.     */    for (zap_cursor_init(&zc, zsb->z_os, zsb->z_unlinkedobj);            zap_cursor_retrieve(&zc, &zap) == 0;            zap_cursor_advance(&zc)) {        /*         * See what kind of object we have in list         */        error = dmu_object_info(zsb->z_os, zap.za_first_integer, &doi);        if (error != 0)            continue;        ASSERT((doi.doi_type == DMU_OT_PLAIN_FILE_CONTENTS) ||               (doi.doi_type == DMU_OT_DIRECTORY_CONTENTS));        /*         * We need to re-mark these list entries for deletion,         * so we pull them back into core and set zp->z_unlinked.         */        error = zfs_zget(zsb, zap.za_first_integer, &zp);        /*         * We may pick up znodes that are already marked for deletion.         * This could happen during the purge of an extended attribute         * directory.  All we need to do is skip over them, since they         * are already in the system marked z_unlinked.         */        if (error != 0)            continue;        zp->z_unlinked = B_TRUE;        /*         * If this is an attribute directory, purge its contents.         */        if (S_ISDIR(ZTOI(zp)->i_mode) && (zp->z_pflags & ZFS_XATTR)) {            /*             * We don't need to check the return value of             * zfs_purgedir here, because zfs_rmnode will just             * return this xattr directory to the unlinked set             * until all of its xattrs are gone.             */            (void) zfs_purgedir(zp);        }        iput(ZTOI(zp));    }    zap_cursor_fini(&zc);}

intdsl_dataset_get_holds(const char *dsname, nvlist_t *nvl){	dsl_pool_t *dp;	dsl_dataset_t *ds;	int err;	err = dsl_pool_hold(dsname, FTAG, &dp);	if (err != 0)		return (err);	err = dsl_dataset_hold(dp, dsname, FTAG, &ds);	if (err != 0) {		dsl_pool_rele(dp, FTAG);		return (err);	}	if (ds->ds_phys->ds_userrefs_obj != 0) {		zap_attribute_t *za;		zap_cursor_t zc;		za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP);		for (zap_cursor_init(&zc, ds->ds_dir->dd_pool->dp_meta_objset,		    ds->ds_phys->ds_userrefs_obj);		    zap_cursor_retrieve(&zc, za) == 0;		    zap_cursor_advance(&zc)) {			fnvlist_add_uint64(nvl, za->za_name,			    za->za_first_integer);		}		zap_cursor_fini(&zc);		kmem_free(za, sizeof (zap_attribute_t));	}	dsl_dataset_rele(ds, FTAG);	dsl_pool_rele(dp, FTAG);	return (0);}

/* * Delete the entire contents of a directory.  Return a count * of the number of entries that could not be deleted. If we encounter * an error, return a count of at least one so that the directory stays * in the unlinked set. * * NOTE: this function assumes that the directory is inactive, *	so there is no need to lock its entries before deletion. *	Also, it assumes the directory contents is *only* regular *	files. */static intzfs_purgedir(znode_t *dzp){	zap_cursor_t	zc;	zap_attribute_t	zap;	znode_t		*xzp;	dmu_tx_t	*tx;	zfsvfs_t	*zfsvfs = dzp->z_zfsvfs;	zfs_dirlock_t	dl;	int skipped = 0;	int error;	for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);	    (error = zap_cursor_retrieve(&zc, &zap)) == 0;	    zap_cursor_advance(&zc)) {		error = zfs_zget(zfsvfs,		    ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp);		if (error) {			skipped += 1;			continue;		}/*	    ASSERT((ZTOV(xzp)->v_type == VREG) ||		    (ZTOV(xzp)->v_type == VLNK));*/		tx = dmu_tx_create(zfsvfs->z_os);		dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);		dmu_tx_hold_zap(tx, dzp->z_id, FALSE, zap.za_name);		dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);		dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);		/* Is this really needed ? */		zfs_sa_upgrade_txholds(tx, xzp);		error = dmu_tx_assign(tx, TXG_WAIT);		if (error) {			dmu_tx_abort(tx);			//VN_RELE(ZTOV(xzp)); // async			VN_RELE_ASYNC(ZTOV(xzp), dsl_pool_vnrele_taskq(dmu_objset_pool(zfsvfs->z_os)));			skipped += 1;			continue;		}		bzero(&dl, sizeof (dl));		dl.dl_dzp = dzp;		dl.dl_name = zap.za_name;		error = zfs_link_destroy(&dl, xzp, tx, 0, NULL);		if (error)			skipped += 1;		dmu_tx_commit(tx);		//VN_RELE(ZTOV(xzp)); // async		VN_RELE_ASYNC(ZTOV(xzp), dsl_pool_vnrele_taskq(dmu_objset_pool(zfsvfs->z_os)));	}	zap_cursor_fini(&zc);	if (error != ENOENT)		skipped += 1;	return (skipped);}

intzfs_userspace_many(zfs_sb_t *zsb, zfs_userquota_prop_t type,    uint64_t *cookiep, void *vbuf, uint64_t *bufsizep){	int error;	zap_cursor_t zc;	zap_attribute_t za;	zfs_useracct_t *buf = vbuf;	uint64_t obj;	int offset = 0;	if (!dmu_objset_userspace_present(zsb->z_os))		return (SET_ERROR(ENOTSUP));	if ((type == ZFS_PROP_USEROBJUSED || type == ZFS_PROP_GROUPOBJUSED ||	    type == ZFS_PROP_USEROBJQUOTA || type == ZFS_PROP_GROUPOBJQUOTA) &&	    !dmu_objset_userobjspace_present(zsb->z_os))		return (SET_ERROR(ENOTSUP));	obj = zfs_userquota_prop_to_obj(zsb, type);	if (obj == ZFS_NO_OBJECT) {		*bufsizep = 0;		return (0);	}	if (type == ZFS_PROP_USEROBJUSED || type == ZFS_PROP_GROUPOBJUSED)		offset = DMU_OBJACCT_PREFIX_LEN;	for (zap_cursor_init_serialized(&zc, zsb->z_os, obj, *cookiep);	    (error = zap_cursor_retrieve(&zc, &za)) == 0;	    zap_cursor_advance(&zc)) {		if ((uintptr_t)buf - (uintptr_t)vbuf + sizeof (zfs_useracct_t) >		    *bufsizep)			break;		/*		 * skip object quota (with zap name prefix DMU_OBJACCT_PREFIX)		 * when dealing with block quota and vice versa.		 */		if ((offset > 0) != (strncmp(za.za_name, DMU_OBJACCT_PREFIX,		    DMU_OBJACCT_PREFIX_LEN) == 0))			continue;		fuidstr_to_sid(zsb, za.za_name + offset,		    buf->zu_domain, sizeof (buf->zu_domain), &buf->zu_rid);		buf->zu_space = za.za_first_integer;		buf++;	}	if (error == ENOENT)		error = 0;	ASSERT3U((uintptr_t)buf - (uintptr_t)vbuf, <=, *bufsizep);	*bufsizep = (uintptr_t)buf - (uintptr_t)vbuf;	*cookiep = zap_cursor_serialize(&zc);	zap_cursor_fini(&zc);	return (error);}

/* * Special function to requeue the znodes for deletion that were * in progress when we either crashed or umounted the file system. * * returns 1 if queue was drained. */static intzfs_drain_dq(zfsvfs_t *zfsvfs){	zap_cursor_t	zc;	zap_attribute_t zap;	dmu_object_info_t doi;	znode_t		*zp;	int		error;	/*	 * Interate over the contents of the delete queue.	 */	for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_dqueue);	    zap_cursor_retrieve(&zc, &zap) == 0;	    zap_cursor_advance(&zc)) {		/*		 * Create more threads if necessary to balance the load.		 * quit if the delete threads have been shut down.		 */		if (zfs_delete_thread_target(zfsvfs, -1) != 0)			return (0);		/*		 * See what kind of object we have in queue		 */		error = dmu_object_info(zfsvfs->z_os,		    zap.za_first_integer, &doi);		if (error != 0)			continue;		ASSERT((doi.doi_type == DMU_OT_PLAIN_FILE_CONTENTS) ||		    (doi.doi_type == DMU_OT_DIRECTORY_CONTENTS));		/*		 * We need to re-mark these queue entries for reaping,		 * so we pull them back into core and set zp->z_reap.		 */		error = zfs_zget(zfsvfs, zap.za_first_integer, &zp);		/*		 * We may pick up znodes that are already marked for reaping.		 * This could happen during the purge of an extended attribute		 * directory.  All we need to do is skip over them, since they		 * are already in the system to be processed by the delete		 * thread(s).		 */		if (error != 0) {			continue;		}		zp->z_reap = 1;		VN_RELE(ZTOV(zp));	}	zap_cursor_fini(&zc);	return (1);}

/* * Delete the entire contents of a directory.  Return a count * of the number of entries that could not be deleted. If we encounter * an error, return a count of at least one so that the directory stays * in the unlinked set. * * NOTE: this function assumes that the directory is inactive, *	so there is no need to lock its entries before deletion. *	Also, it assumes the directory contents is *only* regular *	files. */static intzfs_purgedir(znode_t *dzp){	zap_cursor_t	zc;	zap_attribute_t	zap;	znode_t		*xzp;	dmu_tx_t	*tx;	zfsvfs_t	*zfsvfs = ZTOZSB(dzp);	zfs_dirlock_t	dl;	int skipped = 0;	int error;	for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);	    (error = zap_cursor_retrieve(&zc, &zap)) == 0;	    zap_cursor_advance(&zc)) {		error = zfs_zget(zfsvfs,		    ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp);		if (error) {			skipped += 1;			continue;		}		ASSERT(S_ISREG(ZTOI(xzp)->i_mode) ||		    S_ISLNK(ZTOI(xzp)->i_mode));		tx = dmu_tx_create(zfsvfs->z_os);		dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);		dmu_tx_hold_zap(tx, dzp->z_id, FALSE, zap.za_name);		dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);		dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);		/* Is this really needed ? */		zfs_sa_upgrade_txholds(tx, xzp);		dmu_tx_mark_netfree(tx);		error = dmu_tx_assign(tx, TXG_WAIT);		if (error) {			dmu_tx_abort(tx);			zfs_iput_async(ZTOI(xzp));			skipped += 1;			continue;		}		bzero(&dl, sizeof (dl));		dl.dl_dzp = dzp;		dl.dl_name = zap.za_name;		error = zfs_link_destroy(&dl, xzp, tx, 0, NULL);		if (error)			skipped += 1;		dmu_tx_commit(tx);		zfs_iput_async(ZTOI(xzp));	}	zap_cursor_fini(&zc);	if (error != ENOENT)		skipped += 1;	return (skipped);}

/* * Delete the entire contents of a directory.  Return a count * of the number of entries that could not be deleted. If we encounter * an error, return a count of at least one so that the directory stays * in the unlinked set. * * NOTE: this function assumes that the directory is inactive, *	so there is no need to lock its entries before deletion. *	Also, it assumes the directory contents is *only* regular *	files. */static intzfs_purgedir(znode_t *dzp){    zap_cursor_t	zc;    zap_attribute_t	zap;    znode_t		*xzp;    dmu_tx_t	*tx;    zfsvfs_t	*zfsvfs = dzp->z_zfsvfs;    int skipped = 0;    int error;    for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);            (error = zap_cursor_retrieve(&zc, &zap)) == 0;            zap_cursor_advance(&zc)) {        error = zfs_zget(zfsvfs,                         ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp);        if (error) {            skipped += 1;            continue;        }        vn_lock(ZTOV(xzp), LK_EXCLUSIVE | LK_RETRY);        ASSERT((ZTOV(xzp)->v_type == VREG) ||               (ZTOV(xzp)->v_type == VLNK));        tx = dmu_tx_create(zfsvfs->z_os);        dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);        dmu_tx_hold_zap(tx, dzp->z_id, FALSE, zap.za_name);        dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);        dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);        /* Is this really needed ? */        zfs_sa_upgrade_txholds(tx, xzp);        dmu_tx_mark_netfree(tx);        error = dmu_tx_assign(tx, TXG_WAIT);        if (error) {            dmu_tx_abort(tx);            vput(ZTOV(xzp));            skipped += 1;            continue;        }        error = zfs_link_destroy(dzp, zap.za_name, xzp, tx, 0, NULL);        if (error)            skipped += 1;        dmu_tx_commit(tx);        vput(ZTOV(xzp));    }    zap_cursor_fini(&zc);    if (error != ENOENT)        skipped += 1;    return (skipped);}

/* * Delete the entire contents of a directory.  Return a count * of the number of entries that could not be deleted. If we encounter * an error, return a count of at least one so that the directory stays * in the unlinked set. * * NOTE: this function assumes that the directory is inactive, *	so there is no need to lock its entries before deletion. *	Also, it assumes the directory contents is *only* regular *	files. */static intzfs_purgedir(znode_t *dzp){	zap_cursor_t	zc;	zap_attribute_t	zap;	znode_t		*xzp;	dmu_tx_t	*tx;	zfsvfs_t	*zfsvfs = dzp->z_zfsvfs;	zfs_dirlock_t	dl;	int skipped = 0;	int error;	for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);	    (error = zap_cursor_retrieve(&zc, &zap)) == 0;	    zap_cursor_advance(&zc)) {		error = zfs_zget(zfsvfs,		    ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp);		if (error) {			skipped += 1;			continue;		}		ASSERT((ZTOV(xzp)->v_type == VREG) ||		    (ZTOV(xzp)->v_type == VLNK));		tx = dmu_tx_create(zfsvfs->z_os);		dmu_tx_hold_bonus(tx, dzp->z_id);		dmu_tx_hold_zap(tx, dzp->z_id, FALSE, zap.za_name);		dmu_tx_hold_bonus(tx, xzp->z_id);		dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);		error = dmu_tx_assign(tx, TXG_WAIT);		if (error) {			dmu_tx_abort(tx);			VN_RELE(ZTOV(xzp));			skipped += 1;			continue;		}		bzero(&dl, sizeof (dl));		dl.dl_dzp = dzp;		dl.dl_name = zap.za_name;		error = zfs_link_destroy(&dl, xzp, tx, 0, NULL);		if (error)			skipped += 1;		dmu_tx_commit(tx);		VN_RELE(ZTOV(xzp));	}	zap_cursor_fini(&zc);	if (error != ENOENT)		skipped += 1;	return (skipped);}

/* * Checks that the active features in the pool are supported by * this software.  Adds each unsupported feature (name -> description) to * the supplied nvlist. */boolean_tspa_features_check(spa_t *spa, boolean_t for_write,    nvlist_t *unsup_feat, nvlist_t *enabled_feat){	objset_t *os = spa->spa_meta_objset;	boolean_t supported;	zap_cursor_t *zc;	zap_attribute_t *za;	uint64_t obj = for_write ?	    spa->spa_feat_for_write_obj : spa->spa_feat_for_read_obj;	char *buf;	zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);	za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP);	buf = kmem_alloc(MAXPATHLEN, KM_SLEEP);	supported = B_TRUE;	for (zap_cursor_init(zc, os, obj);	    zap_cursor_retrieve(zc, za) == 0;	    zap_cursor_advance(zc)) {		ASSERT(za->za_integer_length == sizeof (uint64_t) &&		    za->za_num_integers == 1);		if (NULL != enabled_feat) {			fnvlist_add_uint64(enabled_feat, za->za_name,			    za->za_first_integer);		}		if (za->za_first_integer != 0 &&		    !zfeature_is_supported(za->za_name)) {			supported = B_FALSE;			if (NULL != unsup_feat) {				char *desc = "";				if (zap_lookup(os, spa->spa_feat_desc_obj,				    za->za_name, 1, MAXPATHLEN, buf) == 0)					desc = buf;				VERIFY(nvlist_add_string(unsup_feat,				    za->za_name, desc) == 0);			}		}	}	zap_cursor_fini(zc);	kmem_free(buf, MAXPATHLEN);	kmem_free(za, sizeof (zap_attribute_t));	kmem_free(zc, sizeof (zap_cursor_t));	return (supported);}

intdsl_get_bookmarks_impl(dsl_dataset_t *ds, nvlist_t *props, nvlist_t *outnvl){	int err = 0;	zap_cursor_t zc;	zap_attribute_t attr;	dsl_pool_t *dp = ds->ds_dir->dd_pool;	uint64_t bmark_zapobj = ds->ds_bookmarks;	if (bmark_zapobj == 0)		return (0);	for (zap_cursor_init(&zc, dp->dp_meta_objset, bmark_zapobj);	    zap_cursor_retrieve(&zc, &attr) == 0;	    zap_cursor_advance(&zc)) {		nvlist_t *out_props;		char *bmark_name = attr.za_name;		zfs_bookmark_phys_t bmark_phys = { 0 };		err = dsl_dataset_bmark_lookup(ds, bmark_name, &bmark_phys);		ASSERT3U(err, !=, ENOENT);		if (err != 0)			break;		out_props = fnvlist_alloc();		if (nvlist_exists(props,		    zfs_prop_to_name(ZFS_PROP_GUID))) {			dsl_prop_nvlist_add_uint64(out_props,			    ZFS_PROP_GUID, bmark_phys.zbm_guid);		}		if (nvlist_exists(props,		    zfs_prop_to_name(ZFS_PROP_CREATETXG))) {			dsl_prop_nvlist_add_uint64(out_props,			    ZFS_PROP_CREATETXG, bmark_phys.zbm_creation_txg);		}		if (nvlist_exists(props,		    zfs_prop_to_name(ZFS_PROP_CREATION))) {			dsl_prop_nvlist_add_uint64(out_props,			    ZFS_PROP_CREATION, bmark_phys.zbm_creation_time);		}		if (nvlist_exists(props,		    zfs_prop_to_name(ZFS_PROP_IVSET_GUID))) {			dsl_prop_nvlist_add_uint64(out_props,			    ZFS_PROP_IVSET_GUID, bmark_phys.zbm_ivset_guid);		}		fnvlist_add_nvlist(outnvl, bmark_name, out_props);		fnvlist_free(out_props);	}	zap_cursor_fini(&zc);	return (err);}

/** Clean up any znodes that had no links when we either crashed or* (force) umounted the file system.*/voidzfs_unlinked_drain(zfsvfs_t *zfsvfs){        zap_cursor_t        zc;        zap_attribute_t zap;        dmu_object_info_t doi;        znode_t                *zp;        int                error;        printf("ZFS: unlinked drain/n");        /*         * Interate over the contents of the unlinked set.         */        for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_unlinkedobj);         zap_cursor_retrieve(&zc, &zap) == 0;         zap_cursor_advance(&zc)) {                /*                 * See what kind of object we have in list                 */                error = dmu_object_info(zfsvfs->z_os,                 zap.za_first_integer, &doi);                if (error != 0)                        continue;                ASSERT((doi.doi_type == DMU_OT_PLAIN_FILE_CONTENTS) ||                 (doi.doi_type == DMU_OT_DIRECTORY_CONTENTS));                /*                 * We need to re-mark these list entries for deletion,                 * so we pull them back into core and set zp->z_unlinked.                 */                error = zfs_zget(zfsvfs, zap.za_first_integer, &zp);                /*                 * We may pick up znodes that are already marked for deletion.                 * This could happen during the purge of an extended attribute                 * directory. All we need to do is skip over them, since they                 * are already in the system marked z_unlinked.                 */                if (error != 0)                        continue;                zp->z_unlinked = B_TRUE;                VN_RELE(ZTOV(zp));        }        zap_cursor_fini(&zc);        printf("ZFS: unlinked drain completed./n");}

intdmu_snapshot_list_next(objset_t *os, int namelen, char *name,    uint64_t *idp, uint64_t *offp, boolean_t *case_conflict){	dsl_dataset_t *ds = os->os->os_dsl_dataset;	zap_cursor_t cursor;	zap_attribute_t attr;	if (ds->ds_phys->ds_snapnames_zapobj == 0)		return (ENOENT);	zap_cursor_init_serialized(&cursor,	    ds->ds_dir->dd_pool->dp_meta_objset,	    ds->ds_phys->ds_snapnames_zapobj, *offp);	if (zap_cursor_retrieve(&cursor, &attr) != 0) {		zap_cursor_fini(&cursor);		return (ENOENT);	}	if (strlen(attr.za_name) + 1 > namelen) {		zap_cursor_fini(&cursor);		return (ENAMETOOLONG);	}	(void) strcpy(name, attr.za_name);	if (idp)		*idp = attr.za_first_integer;	if (case_conflict)		*case_conflict = attr.za_normalization_conflict;	zap_cursor_advance(&cursor);	*offp = zap_cursor_serialize(&cursor);	zap_cursor_fini(&cursor);	return (0);}

intdmu_dir_list_next(objset_t *os, int namelen, char *name,    uint64_t *idp, uint64_t *offp){	dsl_dir_t *dd = os->os->os_dsl_dataset->ds_dir;	zap_cursor_t cursor;	zap_attribute_t attr;	/* there is no next dir on a snapshot! */	if (os->os->os_dsl_dataset->ds_object !=	    dd->dd_phys->dd_head_dataset_obj)		return (ENOENT);	zap_cursor_init_serialized(&cursor,	    dd->dd_pool->dp_meta_objset,	    dd->dd_phys->dd_child_dir_zapobj, *offp);	if (zap_cursor_retrieve(&cursor, &attr) != 0) {		zap_cursor_fini(&cursor);		return (ENOENT);	}	if (strlen(attr.za_name) + 1 > namelen) {		zap_cursor_fini(&cursor);		return (ENAMETOOLONG);	}	(void) strcpy(name, attr.za_name);	if (idp)		*idp = attr.za_first_integer;	zap_cursor_advance(&cursor);	*offp = zap_cursor_serialize(&cursor);	zap_cursor_fini(&cursor);	return (0);}

/* * Checks that the features active in the specified object are supported by * this software.  Adds each unsupported feature (name -> description) to * the supplied nvlist. */boolean_tfeature_is_supported(objset_t *os, uint64_t obj, uint64_t desc_obj,                     nvlist_t *unsup_feat, nvlist_t *enabled_feat){    boolean_t supported;    zap_cursor_t zc;    zap_attribute_t za;    supported = B_TRUE;    for (zap_cursor_init(&zc, os, obj);            zap_cursor_retrieve(&zc, &za) == 0;            zap_cursor_advance(&zc)) {        ASSERT(za.za_integer_length == sizeof (uint64_t) &&               za.za_num_integers == 1);        if (NULL != enabled_feat) {            fnvlist_add_uint64(enabled_feat, za.za_name,                               za.za_first_integer);        }        if (za.za_first_integer != 0 &&                !zfeature_is_supported(za.za_name)) {            supported = B_FALSE;            if (NULL != unsup_feat) {                char *desc = "";                char buf[MAXPATHLEN];                if (zap_lookup(os, desc_obj, za.za_name,                               1, sizeof (buf), buf) == 0)                    desc = buf;                VERIFY(nvlist_add_string(unsup_feat, za.za_name,                                         desc) == 0);            }        }    }    zap_cursor_fini(&zc);    return (supported);}

intzfs_userspace_many(zfs_sb_t *zsb, zfs_userquota_prop_t type,    uint64_t *cookiep, void *vbuf, uint64_t *bufsizep){	int error;	zap_cursor_t zc;	zap_attribute_t za;	zfs_useracct_t *buf = vbuf;	uint64_t obj;	if (!dmu_objset_userspace_present(zsb->z_os))		return (SET_ERROR(ENOTSUP));	obj = zfs_userquota_prop_to_obj(zsb, type);	if (obj == 0) {		*bufsizep = 0;		return (0);	}	for (zap_cursor_init_serialized(&zc, zsb->z_os, obj, *cookiep);	    (error = zap_cursor_retrieve(&zc, &za)) == 0;	    zap_cursor_advance(&zc)) {		if ((uintptr_t)buf - (uintptr_t)vbuf + sizeof (zfs_useracct_t) >		    *bufsizep)			break;		fuidstr_to_sid(zsb, za.za_name,		    buf->zu_domain, sizeof (buf->zu_domain), &buf->zu_rid);		buf->zu_space = za.za_first_integer;		buf++;	}	if (error == ENOENT)		error = 0;	ASSERT3U((uintptr_t)buf - (uintptr_t)vbuf, <=, *bufsizep);	*bufsizep = (uintptr_t)buf - (uintptr_t)vbuf;	*cookiep = zap_cursor_serialize(&zc);	zap_cursor_fini(&zc);	return (error);}

static int osd_index_it_get(const struct lu_env *env, struct dt_it *di,			    const struct dt_key *key){	struct osd_zap_it *it = (struct osd_zap_it *)di;	struct osd_object *obj = it->ozi_obj;	struct osd_device *osd = osd_obj2dev(obj);	ENTRY;	LASSERT(it);	LASSERT(it->ozi_zc);	/*	 * XXX: we need a binary version of zap_cursor_move_to_key()	 *	to implement this API */	if (*((const __u64 *)key) != 0)		CERROR("NOT IMPLEMETED YET (move to %Lx)/n", *((__u64 *)key));	zap_cursor_fini(it->ozi_zc);	memset(it->ozi_zc, 0, sizeof(*it->ozi_zc));	zap_cursor_init(it->ozi_zc, osd->od_objset.os, obj->oo_db->db_object);	it->ozi_reset = 1;	RETURN(+1);}

uint64_tdmu_snapname_to_id(objset_t *os, const char *snapname){	dsl_dataset_t *ds = os->os->os_dsl_dataset;	zap_cursor_t cursor;	zap_attribute_t attr;	if (ds->ds_phys->ds_snapnames_zapobj == 0) {		return (ENOENT);	}	zap_cursor_init(&cursor,					ds->ds_dir->dd_pool->dp_meta_objset,					ds->ds_phys->ds_snapnames_zapobj);	if(!(zap_cursor_move_to_key(&cursor, snapname, MT_EXACT))) {		if (zap_cursor_retrieve(&cursor, &attr) != 0) {			zap_cursor_fini(&cursor); 	/* not returning ENOENT as that might be the id no */           			return 0; // no snapshot by name snapname		}		return attr.za_first_integer;	} else {		return 0; // no snapshot by name snapname        	}}