c/mirror_zfs
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_zfs.git synced 2025-06-13 17:24:57 +03:00
Code Issues Packages Projects Releases Wiki Activity

Allocate zap_attribute_t from kmem instead of stack

Browse Source 
This patch is preparatory work for long name feature. It changes all
users of zap_attribute_t to allocate it from kmem instead of stack. It
also make zap_attribute_t and zap_name_t structure variable length.

Reviewed-by: Tony Hutter <hutter2@llnl.gov>
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Reviewed-by: Alexander Motin <mav@FreeBSD.org>
Signed-off-by: Chunwei Chen <david.chen@nutanix.com>
Closes #15921
This commit is contained in:
Sanjeev Bagewadi 2021-02-02 13:54:15 +00:00 committed by Brian Behlendorf
parent 141368a4b6
commit 3cf2bfa570
35 changed files with 513 additions and 365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
cmd/zdb/zdb.c
View File

@ -1117,7 +1117,7 @@ dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
{ {
(void) data, (void) size; (void) data, (void) size;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t attr; zap_attribute_t *attrp = zap_attribute_alloc();
void *prop; void *prop;
unsigned i; unsigned i;
@ -1125,53 +1125,54 @@ dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
(void) printf("\n"); (void) printf("\n");
for (zap_cursor_init(&zc, os, object); for (zap_cursor_init(&zc, os, object);
zap_cursor_retrieve(&zc, &attr) == 0; zap_cursor_retrieve(&zc, attrp) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
boolean_t key64 = boolean_t key64 =
!!(zap_getflags(zc.zc_zap) & ZAP_FLAG_UINT64_KEY); !!(zap_getflags(zc.zc_zap) & ZAP_FLAG_UINT64_KEY);
if (key64) if (key64)
(void) printf("\t\t0x%010lx = ", (void) printf("\t\t0x%010lx = ",
*(uint64_t *)attr.za_name); *(uint64_t *)attrp->za_name);
else else
(void) printf("\t\t%s = ", attr.za_name); (void) printf("\t\t%s = ", attrp->za_name);
if (attr.za_num_integers == 0) { if (attrp->za_num_integers == 0) {
(void) printf("\n"); (void) printf("\n");
continue; continue;
} }
prop = umem_zalloc(attr.za_num_integers * prop = umem_zalloc(attrp->za_num_integers *
attr.za_integer_length, UMEM_NOFAIL); attrp->za_integer_length, UMEM_NOFAIL);
if (key64) if (key64)
(void) zap_lookup_uint64(os, object, (void) zap_lookup_uint64(os, object,
(const uint64_t *)attr.za_name, 1, (const uint64_t *)attrp->za_name, 1,
attr.za_integer_length, attr.za_num_integers, attrp->za_integer_length, attrp->za_num_integers,
prop); prop);
else else
(void) zap_lookup(os, object, attr.za_name, (void) zap_lookup(os, object, attrp->za_name,
attr.za_integer_length, attr.za_num_integers, attrp->za_integer_length, attrp->za_num_integers,
prop); prop);
if (attr.za_integer_length == 1 && !key64) { if (attrp->za_integer_length == 1 && !key64) {
if (strcmp(attr.za_name, if (strcmp(attrp->za_name,
DSL_CRYPTO_KEY_MASTER_KEY) == 0 || DSL_CRYPTO_KEY_MASTER_KEY) == 0 ||
strcmp(attr.za_name, strcmp(attrp->za_name,
DSL_CRYPTO_KEY_HMAC_KEY) == 0 || DSL_CRYPTO_KEY_HMAC_KEY) == 0 ||
strcmp(attr.za_name, DSL_CRYPTO_KEY_IV) == 0 || strcmp(attrp->za_name, DSL_CRYPTO_KEY_IV) == 0 ||
strcmp(attr.za_name, DSL_CRYPTO_KEY_MAC) == 0 || strcmp(attrp->za_name, DSL_CRYPTO_KEY_MAC) == 0 ||
strcmp(attr.za_name, DMU_POOL_CHECKSUM_SALT) == 0) { strcmp(attrp->za_name,
DMU_POOL_CHECKSUM_SALT) == 0) {
uint8_t *u8 = prop; uint8_t *u8 = prop;
for (i = 0; i < attr.za_num_integers; i++) { for (i = 0; i < attrp->za_num_integers; i++) {
(void) printf("%02x", u8[i]); (void) printf("%02x", u8[i]);
} }
} else { } else {
(void) printf("%s", (char *)prop); (void) printf("%s", (char *)prop);
} }
} else { } else {
for (i = 0; i < attr.za_num_integers; i++) { for (i = 0; i < attrp->za_num_integers; i++) {
switch (attr.za_integer_length) { switch (attrp->za_integer_length) {
case 1: case 1:
(void) printf("%u ", (void) printf("%u ",
((uint8_t *)prop)[i]); ((uint8_t *)prop)[i]);
@ -1192,9 +1193,11 @@ dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
} }
} }
(void) printf("\n"); (void) printf("\n");
umem_free(prop, attr.za_num_integers * attr.za_integer_length); umem_free(prop,
attrp->za_num_integers * attrp->za_integer_length);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(attrp);
} }
static void static void
@ -1295,26 +1298,27 @@ dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
{ {
(void) data, (void) size; (void) data, (void) size;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t attr; zap_attribute_t *attrp = zap_attribute_alloc();
dump_zap_stats(os, object); dump_zap_stats(os, object);
(void) printf("\n"); (void) printf("\n");
for (zap_cursor_init(&zc, os, object); for (zap_cursor_init(&zc, os, object);
zap_cursor_retrieve(&zc, &attr) == 0; zap_cursor_retrieve(&zc, attrp) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
(void) printf("\t\t%s = ", attr.za_name); (void) printf("\t\t%s = ", attrp->za_name);
if (attr.za_num_integers == 0) { if (attrp->za_num_integers == 0) {
(void) printf("\n"); (void) printf("\n");
continue; continue;
} }
(void) printf(" %llx : [%d:%d:%d]\n", (void) printf(" %llx : [%d:%d:%d]\n",
(u_longlong_t)attr.za_first_integer, (u_longlong_t)attrp->za_first_integer,
(int)ATTR_LENGTH(attr.za_first_integer), (int)ATTR_LENGTH(attrp->za_first_integer),
(int)ATTR_BSWAP(attr.za_first_integer), (int)ATTR_BSWAP(attrp->za_first_integer),
(int)ATTR_NUM(attr.za_first_integer)); (int)ATTR_NUM(attrp->za_first_integer));
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(attrp);
} }
static void static void
@ -1322,7 +1326,7 @@ dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
{ {
(void) data, (void) size; (void) data, (void) size;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t attr; zap_attribute_t *attrp = zap_attribute_alloc();
uint16_t *layout_attrs; uint16_t *layout_attrs;
unsigned i; unsigned i;
@ -1330,29 +1334,30 @@ dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
(void) printf("\n"); (void) printf("\n");
for (zap_cursor_init(&zc, os, object); for (zap_cursor_init(&zc, os, object);
zap_cursor_retrieve(&zc, &attr) == 0; zap_cursor_retrieve(&zc, attrp) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
(void) printf("\t\t%s = [", attr.za_name); (void) printf("\t\t%s = [", attrp->za_name);
if (attr.za_num_integers == 0) { if (attrp->za_num_integers == 0) {
(void) printf("\n"); (void) printf("\n");
continue; continue;
} }
VERIFY(attr.za_integer_length == 2); VERIFY(attrp->za_integer_length == 2);
layout_attrs = umem_zalloc(attr.za_num_integers * layout_attrs = umem_zalloc(attrp->za_num_integers *
attr.za_integer_length, UMEM_NOFAIL); attrp->za_integer_length, UMEM_NOFAIL);
VERIFY(zap_lookup(os, object, attr.za_name, VERIFY(zap_lookup(os, object, attrp->za_name,
attr.za_integer_length, attrp->za_integer_length,
attr.za_num_integers, layout_attrs) == 0); attrp->za_num_integers, layout_attrs) == 0);
for (i = 0; i != attr.za_num_integers; i++) for (i = 0; i != attrp->za_num_integers; i++)
(void) printf(" %d ", (int)layout_attrs[i]); (void) printf(" %d ", (int)layout_attrs[i]);
(void) printf("]\n"); (void) printf("]\n");
umem_free(layout_attrs, umem_free(layout_attrs,
attr.za_num_integers * attr.za_integer_length); attrp->za_num_integers * attrp->za_integer_length);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(attrp);
} }
static void static void
@ -1360,7 +1365,7 @@ dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
{ {
(void) data, (void) size; (void) data, (void) size;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t attr; zap_attribute_t *attrp = zap_attribute_alloc();
const char *typenames[] = { const char *typenames[] = {
/* 0 */ "not specified", /* 0 */ "not specified",
/* 1 */ "FIFO", /* 1 */ "FIFO",
@ -1384,13 +1389,14 @@ dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
(void) printf("\n"); (void) printf("\n");
for (zap_cursor_init(&zc, os, object); for (zap_cursor_init(&zc, os, object);
zap_cursor_retrieve(&zc, &attr) == 0; zap_cursor_retrieve(&zc, attrp) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
(void) printf("\t\t%s = %lld (type: %s)\n", (void) printf("\t\t%s = %lld (type: %s)\n",
attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer), attrp->za_name, ZFS_DIRENT_OBJ(attrp->za_first_integer),
typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]); typenames[ZFS_DIRENT_TYPE(attrp->za_first_integer)]);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(attrp);
} }
static int static int
@ -2155,23 +2161,25 @@ dump_brt(spa_t *spa)
continue; continue;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, brt->brt_mos, brtvd->bv_mos_entries); for (zap_cursor_init(&zc, brt->brt_mos, brtvd->bv_mos_entries);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
uint64_t refcnt; uint64_t refcnt;
VERIFY0(zap_lookup_uint64(brt->brt_mos, VERIFY0(zap_lookup_uint64(brt->brt_mos,
brtvd->bv_mos_entries, brtvd->bv_mos_entries,
(const uint64_t *)za.za_name, 1, (const uint64_t *)za->za_name, 1,
za.za_integer_length, za.za_num_integers, &refcnt)); za->za_integer_length, za->za_num_integers,
&refcnt));
uint64_t offset = *(const uint64_t *)za.za_name; uint64_t offset = *(const uint64_t *)za->za_name;
snprintf(dva, sizeof (dva), "%" PRIu64 ":%llx", vdevid, snprintf(dva, sizeof (dva), "%" PRIu64 ":%llx", vdevid,
(u_longlong_t)offset); (u_longlong_t)offset);
printf("%-16s %-10llu\n", dva, (u_longlong_t)refcnt); printf("%-16s %-10llu\n", dva, (u_longlong_t)refcnt);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
} }
@ -2953,28 +2961,30 @@ static void
dump_bookmarks(objset_t *os, int verbosity) dump_bookmarks(objset_t *os, int verbosity)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t attr; zap_attribute_t *attrp;
dsl_dataset_t *ds = dmu_objset_ds(os); dsl_dataset_t *ds = dmu_objset_ds(os);
dsl_pool_t *dp = spa_get_dsl(os->os_spa); dsl_pool_t *dp = spa_get_dsl(os->os_spa);
objset_t *mos = os->os_spa->spa_meta_objset; objset_t *mos = os->os_spa->spa_meta_objset;
if (verbosity < 4) if (verbosity < 4)
return; return;
attrp = zap_attribute_alloc();
dsl_pool_config_enter(dp, FTAG); dsl_pool_config_enter(dp, FTAG);
for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj); for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj);
zap_cursor_retrieve(&zc, &attr) == 0; zap_cursor_retrieve(&zc, attrp) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
char osname[ZFS_MAX_DATASET_NAME_LEN]; char osname[ZFS_MAX_DATASET_NAME_LEN];
char buf[ZFS_MAX_DATASET_NAME_LEN]; char buf[ZFS_MAX_DATASET_NAME_LEN];
int len; int len;
dmu_objset_name(os, osname); dmu_objset_name(os, osname);
len = snprintf(buf, sizeof (buf), "%s#%s", osname, len = snprintf(buf, sizeof (buf), "%s#%s", osname,
attr.za_name); attrp->za_name);
VERIFY3S(len, <, ZFS_MAX_DATASET_NAME_LEN); VERIFY3S(len, <, ZFS_MAX_DATASET_NAME_LEN);
(void) dump_bookmark(dp, buf, verbosity >= 5, verbosity >= 6); (void) dump_bookmark(dp, buf, verbosity >= 5, verbosity >= 6);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
dsl_pool_config_exit(dp, FTAG); dsl_pool_config_exit(dp, FTAG);
zap_attribute_free(attrp);
} }
static void static void
@ -6857,18 +6867,19 @@ iterate_deleted_livelists(spa_t *spa, ll_iter_t func, void *arg)
ASSERT0(err); ASSERT0(err);
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t attr; zap_attribute_t *attrp = zap_attribute_alloc();
dsl_deadlist_t ll; dsl_deadlist_t ll;
/* NULL out os prior to dsl_deadlist_open in case it's garbage */ /* NULL out os prior to dsl_deadlist_open in case it's garbage */
ll.dl_os = NULL; ll.dl_os = NULL;
for (zap_cursor_init(&zc, mos, zap_obj); for (zap_cursor_init(&zc, mos, zap_obj);
zap_cursor_retrieve(&zc, &attr) == 0; zap_cursor_retrieve(&zc, attrp) == 0;
(void) zap_cursor_advance(&zc)) { (void) zap_cursor_advance(&zc)) {
dsl_deadlist_open(&ll, mos, attr.za_first_integer); dsl_deadlist_open(&ll, mos, attrp->za_first_integer);
func(&ll, arg); func(&ll, arg);
dsl_deadlist_close(&ll); dsl_deadlist_close(&ll);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(attrp);
} }
static int static int
@ -8082,13 +8093,14 @@ static void
errorlog_count_refd(objset_t *mos, uint64_t errlog) errorlog_count_refd(objset_t *mos, uint64_t errlog)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, mos, errlog); for (zap_cursor_init(&zc, mos, errlog);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
mos_obj_refd(za.za_first_integer); mos_obj_refd(za->za_first_integer);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
static int static int

17
cmd/zhack.c
View File

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

12
include/sys/zap.h
View File

@ -376,9 +376,19 @@ typedef struct {
boolean_t za_normalization_conflict; boolean_t za_normalization_conflict;
uint64_t za_num_integers; uint64_t za_num_integers;
uint64_t za_first_integer; /* no sign extension for <8byte ints */ uint64_t za_first_integer; /* no sign extension for <8byte ints */
char za_name[ZAP_MAXNAMELEN]; uint32_t za_name_len;
char za_name[];
} zap_attribute_t; } zap_attribute_t;
void zap_init(void);
void zap_fini(void);
/*
* Alloc and free zap_attribute_t.
*/
zap_attribute_t *zap_attribute_alloc(void);
void zap_attribute_free(zap_attribute_t *attrp);
/* /*
* The interface for listing all the attributes of a zapobj can be * The interface for listing all the attributes of a zapobj can be
* thought of as cursor moving down a list of the attributes one by * thought of as cursor moving down a list of the attributes one by

3
include/sys/zap_impl.h
View File

@ -191,7 +191,8 @@ typedef struct zap_name {
uint64_t zn_hash; uint64_t zn_hash;
matchtype_t zn_matchtype; matchtype_t zn_matchtype;
int zn_normflags; int zn_normflags;
char zn_normbuf[ZAP_MAXNAMELEN]; int zn_normbuf_len;
char zn_normbuf[];
} zap_name_t; } zap_name_t;
#define zap_f zap_u.zap_fat #define zap_f zap_u.zap_fat

22
module/os/freebsd/zfs/zfs_dir.c
View File

@ -287,7 +287,7 @@ void
zfs_unlinked_drain(zfsvfs_t *zfsvfs) zfs_unlinked_drain(zfsvfs_t *zfsvfs)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t zap; zap_attribute_t *zap;
dmu_object_info_t doi; dmu_object_info_t doi;
znode_t *zp; znode_t *zp;
dmu_tx_t *tx; dmu_tx_t *tx;
@ -296,8 +296,9 @@ zfs_unlinked_drain(zfsvfs_t *zfsvfs)
/* /*
* Iterate over the contents of the unlinked set. * Iterate over the contents of the unlinked set.
*/ */
zap = zap_attribute_alloc();
for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_unlinkedobj); for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_unlinkedobj);
zap_cursor_retrieve(&zc, &zap) == 0; zap_cursor_retrieve(&zc, zap) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
/* /*
@ -305,7 +306,7 @@ zfs_unlinked_drain(zfsvfs_t *zfsvfs)
*/ */
error = dmu_object_info(zfsvfs->z_os, error = dmu_object_info(zfsvfs->z_os,
zap.za_first_integer, &doi); zap->za_first_integer, &doi);
if (error != 0) if (error != 0)
continue; continue;
@ -315,7 +316,7 @@ zfs_unlinked_drain(zfsvfs_t *zfsvfs)
* We need to re-mark these list entries for deletion, * We need to re-mark these list entries for deletion,
* so we pull them back into core and set zp->z_unlinked. * so we pull them back into core and set zp->z_unlinked.
*/ */
error = zfs_zget(zfsvfs, zap.za_first_integer, &zp); error = zfs_zget(zfsvfs, zap->za_first_integer, &zp);
/* /*
* We may pick up znodes that are already marked for deletion. * We may pick up znodes that are already marked for deletion.
@ -351,6 +352,7 @@ zfs_unlinked_drain(zfsvfs_t *zfsvfs)
vput(ZTOV(zp)); vput(ZTOV(zp));
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(zap);
} }
/* /*
@ -368,18 +370,19 @@ static int
zfs_purgedir(znode_t *dzp) zfs_purgedir(znode_t *dzp)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t zap; zap_attribute_t *zap;
znode_t *xzp; znode_t *xzp;
dmu_tx_t *tx; dmu_tx_t *tx;
zfsvfs_t *zfsvfs = dzp->z_zfsvfs; zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
int skipped = 0; int skipped = 0;
int error; int error;
zap = zap_attribute_alloc();
for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id); for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);
(error = zap_cursor_retrieve(&zc, &zap)) == 0; (error = zap_cursor_retrieve(&zc, zap)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
error = zfs_zget(zfsvfs, error = zfs_zget(zfsvfs,
ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp); ZFS_DIRENT_OBJ(zap->za_first_integer), &xzp);
if (error) { if (error) {
skipped += 1; skipped += 1;
continue; continue;
@ -391,7 +394,7 @@ zfs_purgedir(znode_t *dzp)
tx = dmu_tx_create(zfsvfs->z_os); tx = dmu_tx_create(zfsvfs->z_os);
dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE); 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_zap(tx, dzp->z_id, FALSE, zap->za_name);
dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE); dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL); dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
/* Is this really needed ? */ /* Is this really needed ? */
@ -405,7 +408,7 @@ zfs_purgedir(znode_t *dzp)
continue; continue;
} }
error = zfs_link_destroy(dzp, zap.za_name, xzp, tx, 0, NULL); error = zfs_link_destroy(dzp, zap->za_name, xzp, tx, 0, NULL);
if (error) if (error)
skipped += 1; skipped += 1;
dmu_tx_commit(tx); dmu_tx_commit(tx);
@ -413,6 +416,7 @@ zfs_purgedir(znode_t *dzp)
vput(ZTOV(xzp)); vput(ZTOV(xzp));
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(zap);
if (error != ENOENT) if (error != ENOENT)
skipped += 1; skipped += 1;
return (skipped); return (skipped);

32
module/os/freebsd/zfs/zfs_vnops_os.c
View File

@ -1568,7 +1568,7 @@ zfs_readdir(vnode_t *vp, zfs_uio_t *uio, cred_t *cr, int *eofp,
caddr_t outbuf; caddr_t outbuf;
size_t bufsize; size_t bufsize;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t zap; zap_attribute_t *zap;
uint_t bytes_wanted; uint_t bytes_wanted;
uint64_t offset; /* must be unsigned; checks for < 1 */ uint64_t offset; /* must be unsigned; checks for < 1 */
uint64_t parent; uint64_t parent;
@ -1616,6 +1616,7 @@ zfs_readdir(vnode_t *vp, zfs_uio_t *uio, cred_t *cr, int *eofp,
os = zfsvfs->z_os; os = zfsvfs->z_os;
offset = zfs_uio_offset(uio); offset = zfs_uio_offset(uio);
prefetch = zp->z_zn_prefetch; prefetch = zp->z_zn_prefetch;
zap = zap_attribute_alloc();
/* /*
* Initialize the iterator cursor. * Initialize the iterator cursor.
@ -1671,33 +1672,33 @@ zfs_readdir(vnode_t *vp, zfs_uio_t *uio, cred_t *cr, int *eofp,
* Special case `.', `..', and `.zfs'. * Special case `.', `..', and `.zfs'.
*/ */
if (offset == 0) { if (offset == 0) {
(void) strcpy(zap.za_name, "."); (void) strcpy(zap->za_name, ".");
zap.za_normalization_conflict = 0; zap->za_normalization_conflict = 0;
objnum = zp->z_id; objnum = zp->z_id;
type = DT_DIR; type = DT_DIR;
} else if (offset == 1) { } else if (offset == 1) {
(void) strcpy(zap.za_name, ".."); (void) strcpy(zap->za_name, "..");
zap.za_normalization_conflict = 0; zap->za_normalization_conflict = 0;
objnum = parent; objnum = parent;
type = DT_DIR; type = DT_DIR;
} else if (offset == 2 && zfs_show_ctldir(zp)) { } else if (offset == 2 && zfs_show_ctldir(zp)) {
(void) strcpy(zap.za_name, ZFS_CTLDIR_NAME); (void) strcpy(zap->za_name, ZFS_CTLDIR_NAME);
zap.za_normalization_conflict = 0; zap->za_normalization_conflict = 0;
objnum = ZFSCTL_INO_ROOT; objnum = ZFSCTL_INO_ROOT;
type = DT_DIR; type = DT_DIR;
} else { } else {
/* /*
* Grab next entry. * Grab next entry.
*/ */
if ((error = zap_cursor_retrieve(&zc, &zap))) { if ((error = zap_cursor_retrieve(&zc, zap))) {
if ((*eofp = (error == ENOENT)) != 0) if ((*eofp = (error == ENOENT)) != 0)
break; break;
else else
goto update; goto update;
} }
if (zap.za_integer_length != 8 || if (zap->za_integer_length != 8 ||
zap.za_num_integers != 1) { zap->za_num_integers != 1) {
cmn_err(CE_WARN, "zap_readdir: bad directory " cmn_err(CE_WARN, "zap_readdir: bad directory "
"entry, obj = %lld, offset = %lld\n", "entry, obj = %lld, offset = %lld\n",
(u_longlong_t)zp->z_id, (u_longlong_t)zp->z_id,
@ -1706,15 +1707,15 @@ zfs_readdir(vnode_t *vp, zfs_uio_t *uio, cred_t *cr, int *eofp,
goto update; goto update;
} }
objnum = ZFS_DIRENT_OBJ(zap.za_first_integer); objnum = ZFS_DIRENT_OBJ(zap->za_first_integer);
/* /*
* MacOS X can extract the object type here such as: * MacOS X can extract the object type here such as:
* uint8_t type = ZFS_DIRENT_TYPE(zap.za_first_integer); * uint8_t type = ZFS_DIRENT_TYPE(zap.za_first_integer);
*/ */
type = ZFS_DIRENT_TYPE(zap.za_first_integer); type = ZFS_DIRENT_TYPE(zap->za_first_integer);
} }
reclen = DIRENT64_RECLEN(strlen(zap.za_name)); reclen = DIRENT64_RECLEN(strlen(zap->za_name));
/* /*
* Will this entry fit in the buffer? * Will this entry fit in the buffer?
@ -1734,10 +1735,10 @@ zfs_readdir(vnode_t *vp, zfs_uio_t *uio, cred_t *cr, int *eofp,
*/ */
odp->d_ino = objnum; odp->d_ino = objnum;
odp->d_reclen = reclen; odp->d_reclen = reclen;
odp->d_namlen = strlen(zap.za_name); odp->d_namlen = strlen(zap->za_name);
/* NOTE: d_off is the offset for the *next* entry. */ /* NOTE: d_off is the offset for the *next* entry. */
next = &odp->d_off; next = &odp->d_off;
strlcpy(odp->d_name, zap.za_name, odp->d_namlen + 1); strlcpy(odp->d_name, zap->za_name, odp->d_namlen + 1);
odp->d_type = type; odp->d_type = type;
dirent_terminate(odp); dirent_terminate(odp);
odp = (dirent64_t *)((intptr_t)odp + reclen); odp = (dirent64_t *)((intptr_t)odp + reclen);
@ -1788,6 +1789,7 @@ zfs_readdir(vnode_t *vp, zfs_uio_t *uio, cred_t *cr, int *eofp,
update: update:
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(zap);
if (zfs_uio_segflg(uio) != UIO_SYSSPACE || zfs_uio_iovcnt(uio) != 1) if (zfs_uio_segflg(uio) != UIO_SYSSPACE || zfs_uio_iovcnt(uio) != 1)
kmem_free(outbuf, bufsize); kmem_free(outbuf, bufsize);

20
module/os/linux/zfs/zfs_dir.c
View File

@ -476,7 +476,7 @@ zfs_unlinked_drain_task(void *arg)
{ {
zfsvfs_t *zfsvfs = arg; zfsvfs_t *zfsvfs = arg;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t zap; zap_attribute_t *zap = zap_attribute_alloc();
dmu_object_info_t doi; dmu_object_info_t doi;
znode_t *zp; znode_t *zp;
int error; int error;
@ -487,7 +487,7 @@ zfs_unlinked_drain_task(void *arg)
* Iterate over the contents of the unlinked set. * Iterate over the contents of the unlinked set.
*/ */
for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_unlinkedobj); for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_unlinkedobj);
zap_cursor_retrieve(&zc, &zap) == 0 && !zfsvfs->z_drain_cancel; zap_cursor_retrieve(&zc, zap) == 0 && !zfsvfs->z_drain_cancel;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
/* /*
@ -495,7 +495,7 @@ zfs_unlinked_drain_task(void *arg)
*/ */
error = dmu_object_info(zfsvfs->z_os, error = dmu_object_info(zfsvfs->z_os,
zap.za_first_integer, &doi); zap->za_first_integer, &doi);
if (error != 0) if (error != 0)
continue; continue;
@ -505,7 +505,7 @@ zfs_unlinked_drain_task(void *arg)
* We need to re-mark these list entries for deletion, * We need to re-mark these list entries for deletion,
* so we pull them back into core and set zp->z_unlinked. * so we pull them back into core and set zp->z_unlinked.
*/ */
error = zfs_zget(zfsvfs, zap.za_first_integer, &zp); error = zfs_zget(zfsvfs, zap->za_first_integer, &zp);
/* /*
* We may pick up znodes that are already marked for deletion. * We may pick up znodes that are already marked for deletion.
@ -532,6 +532,7 @@ zfs_unlinked_drain_task(void *arg)
zfsvfs->z_draining = B_FALSE; zfsvfs->z_draining = B_FALSE;
zfsvfs->z_drain_task = TASKQID_INVALID; zfsvfs->z_drain_task = TASKQID_INVALID;
zap_attribute_free(zap);
} }
/* /*
@ -589,7 +590,7 @@ static int
zfs_purgedir(znode_t *dzp) zfs_purgedir(znode_t *dzp)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t zap; zap_attribute_t *zap = zap_attribute_alloc();
znode_t *xzp; znode_t *xzp;
dmu_tx_t *tx; dmu_tx_t *tx;
zfsvfs_t *zfsvfs = ZTOZSB(dzp); zfsvfs_t *zfsvfs = ZTOZSB(dzp);
@ -598,10 +599,10 @@ zfs_purgedir(znode_t *dzp)
int error; int error;
for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id); for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);
(error = zap_cursor_retrieve(&zc, &zap)) == 0; (error = zap_cursor_retrieve(&zc, zap)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
error = zfs_zget(zfsvfs, error = zfs_zget(zfsvfs,
ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp); ZFS_DIRENT_OBJ(zap->za_first_integer), &xzp);
if (error) { if (error) {
skipped += 1; skipped += 1;
continue; continue;
@ -612,7 +613,7 @@ zfs_purgedir(znode_t *dzp)
tx = dmu_tx_create(zfsvfs->z_os); tx = dmu_tx_create(zfsvfs->z_os);
dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE); 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_zap(tx, dzp->z_id, FALSE, zap->za_name);
dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE); dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL); dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
/* Is this really needed ? */ /* Is this really needed ? */
@ -627,7 +628,7 @@ zfs_purgedir(znode_t *dzp)
} }
memset(&dl, 0, sizeof (dl)); memset(&dl, 0, sizeof (dl));
dl.dl_dzp = dzp; dl.dl_dzp = dzp;
dl.dl_name = zap.za_name; dl.dl_name = zap->za_name;
error = zfs_link_destroy(&dl, xzp, tx, 0, NULL); error = zfs_link_destroy(&dl, xzp, tx, 0, NULL);
if (error) if (error)
@ -637,6 +638,7 @@ zfs_purgedir(znode_t *dzp)
zfs_zrele_async(xzp); zfs_zrele_async(xzp);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(zap);
if (error != ENOENT) if (error != ENOENT)
skipped += 1; skipped += 1;
return (skipped); return (skipped);

42
module/os/linux/zfs/zfs_vnops_os.c
View File

@ -1523,7 +1523,7 @@ zfs_readdir(struct inode *ip, struct dir_context *ctx, cred_t *cr)
zfsvfs_t *zfsvfs = ITOZSB(ip); zfsvfs_t *zfsvfs = ITOZSB(ip);
objset_t *os; objset_t *os;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t zap; zap_attribute_t *zap;
int error; int error;
uint8_t prefetch; uint8_t prefetch;
uint8_t type; uint8_t type;
@ -1548,6 +1548,7 @@ zfs_readdir(struct inode *ip, struct dir_context *ctx, cred_t *cr)
os = zfsvfs->z_os; os = zfsvfs->z_os;
offset = ctx->pos; offset = ctx->pos;
prefetch = zp->z_zn_prefetch; prefetch = zp->z_zn_prefetch;
zap = zap_attribute_alloc();
/* /*
* Initialize the iterator cursor. * Initialize the iterator cursor.
@ -1573,25 +1574,25 @@ zfs_readdir(struct inode *ip, struct dir_context *ctx, cred_t *cr)
* Special case `.', `..', and `.zfs'. * Special case `.', `..', and `.zfs'.
*/ */
if (offset == 0) { if (offset == 0) {
(void) strcpy(zap.za_name, "."); (void) strcpy(zap->za_name, ".");
zap.za_normalization_conflict = 0; zap->za_normalization_conflict = 0;
objnum = zp->z_id; objnum = zp->z_id;
type = DT_DIR; type = DT_DIR;
} else if (offset == 1) { } else if (offset == 1) {
(void) strcpy(zap.za_name, ".."); (void) strcpy(zap->za_name, "..");
zap.za_normalization_conflict = 0; zap->za_normalization_conflict = 0;
objnum = parent; objnum = parent;
type = DT_DIR; type = DT_DIR;
} else if (offset == 2 && zfs_show_ctldir(zp)) { } else if (offset == 2 && zfs_show_ctldir(zp)) {
(void) strcpy(zap.za_name, ZFS_CTLDIR_NAME); (void) strcpy(zap->za_name, ZFS_CTLDIR_NAME);
zap.za_normalization_conflict = 0; zap->za_normalization_conflict = 0;
objnum = ZFSCTL_INO_ROOT; objnum = ZFSCTL_INO_ROOT;
type = DT_DIR; type = DT_DIR;
} else { } else {
/* /*
* Grab next entry. * Grab next entry.
*/ */
if ((error = zap_cursor_retrieve(&zc, &zap))) { if ((error = zap_cursor_retrieve(&zc, zap))) {
if (error == ENOENT) if (error == ENOENT)
break; break;
else else
@ -1605,24 +1606,24 @@ zfs_readdir(struct inode *ip, struct dir_context *ctx, cred_t *cr)
* *
* XXX: This should be a feature flag for compatibility * XXX: This should be a feature flag for compatibility
*/ */
if (zap.za_integer_length != 8 || if (zap->za_integer_length != 8 ||
zap.za_num_integers == 0) { zap->za_num_integers == 0) {
cmn_err(CE_WARN, "zap_readdir: bad directory " cmn_err(CE_WARN, "zap_readdir: bad directory "
"entry, obj = %lld, offset = %lld, " "entry, obj = %lld, offset = %lld, "
"length = %d, num = %lld\n", "length = %d, num = %lld\n",
(u_longlong_t)zp->z_id, (u_longlong_t)zp->z_id,
(u_longlong_t)offset, (u_longlong_t)offset,
zap.za_integer_length, zap->za_integer_length,
(u_longlong_t)zap.za_num_integers); (u_longlong_t)zap->za_num_integers);
error = SET_ERROR(ENXIO); error = SET_ERROR(ENXIO);
goto update; goto update;
} }
objnum = ZFS_DIRENT_OBJ(zap.za_first_integer); objnum = ZFS_DIRENT_OBJ(zap->za_first_integer);
type = ZFS_DIRENT_TYPE(zap.za_first_integer); type = ZFS_DIRENT_TYPE(zap->za_first_integer);
} }
done = !dir_emit(ctx, zap.za_name, strlen(zap.za_name), done = !dir_emit(ctx, zap->za_name, strlen(zap->za_name),
objnum, type); objnum, type);
if (done) if (done)
break; break;
@ -1645,6 +1646,7 @@ zfs_readdir(struct inode *ip, struct dir_context *ctx, cred_t *cr)
update: update:
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(zap);
if (error == ENOENT) if (error == ENOENT)
error = 0; error = 0;
out: out:
@ -1743,7 +1745,7 @@ zfs_setattr_dir(znode_t *dzp)
zfsvfs_t *zfsvfs = ZTOZSB(dzp); zfsvfs_t *zfsvfs = ZTOZSB(dzp);
objset_t *os = zfsvfs->z_os; objset_t *os = zfsvfs->z_os;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t zap; zap_attribute_t *zap;
zfs_dirlock_t *dl; zfs_dirlock_t *dl;
znode_t *zp = NULL; znode_t *zp = NULL;
dmu_tx_t *tx = NULL; dmu_tx_t *tx = NULL;
@ -1752,15 +1754,16 @@ zfs_setattr_dir(znode_t *dzp)
int count; int count;
int err; int err;
zap = zap_attribute_alloc();
zap_cursor_init(&zc, os, dzp->z_id); zap_cursor_init(&zc, os, dzp->z_id);
while ((err = zap_cursor_retrieve(&zc, &zap)) == 0) { while ((err = zap_cursor_retrieve(&zc, zap)) == 0) {
count = 0; count = 0;
if (zap.za_integer_length != 8 || zap.za_num_integers != 1) { if (zap->za_integer_length != 8 || zap->za_num_integers != 1) {
err = ENXIO; err = ENXIO;
break; break;
} }
err = zfs_dirent_lock(&dl, dzp, (char *)zap.za_name, &zp, err = zfs_dirent_lock(&dl, dzp, (char *)zap->za_name, &zp,
ZEXISTS, NULL, NULL); ZEXISTS, NULL, NULL);
if (err == ENOENT) if (err == ENOENT)
goto next; goto next;
@ -1852,6 +1855,7 @@ next:
zfs_dirent_unlock(dl); zfs_dirent_unlock(dl);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(zap);
return (err == ENOENT ? 0 : err); return (err == ENOENT ? 0 : err);
} }

10
module/os/linux/zfs/zpl_xattr.c
View File

@ -153,19 +153,20 @@ static int
zpl_xattr_readdir(struct inode *dxip, xattr_filldir_t *xf) zpl_xattr_readdir(struct inode *dxip, xattr_filldir_t *xf)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t zap; zap_attribute_t *zap = zap_attribute_alloc();
int error; int error;
zap_cursor_init(&zc, ITOZSB(dxip)->z_os, ITOZ(dxip)->z_id); zap_cursor_init(&zc, ITOZSB(dxip)->z_os, ITOZ(dxip)->z_id);
while ((error = -zap_cursor_retrieve(&zc, &zap)) == 0) { while ((error = -zap_cursor_retrieve(&zc, zap)) == 0) {
if (zap.za_integer_length != 8 || zap.za_num_integers != 1) { if (zap->za_integer_length != 8 || zap->za_num_integers != 1) {
error = -ENXIO; error = -ENXIO;
break; break;
} }
error = zpl_xattr_filldir(xf, zap.za_name, strlen(zap.za_name)); error = zpl_xattr_filldir(xf, zap->za_name,
strlen(zap->za_name));
if (error) if (error)
break; break;
@ -173,6 +174,7 @@ zpl_xattr_readdir(struct inode *dxip, xattr_filldir_t *xf)
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(zap);
if (error == -ENOENT) if (error == -ENOENT)
error = 0; error = 0;

14
module/zfs/ddt_zap.c
View File

@ -196,9 +196,10 @@ ddt_zap_walk(objset_t *os, uint64_t object, uint64_t *walk, ddt_key_t *ddk,
void *phys, size_t psize) void *phys, size_t psize)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
int error; int error;
za = zap_attribute_alloc();
if (*walk == 0) { if (*walk == 0) {
/* /*
* We don't want to prefetch the entire ZAP object, because * We don't want to prefetch the entire ZAP object, because
@ -211,20 +212,20 @@ ddt_zap_walk(objset_t *os, uint64_t object, uint64_t *walk, ddt_key_t *ddk,
} else { } else {
zap_cursor_init_serialized(&zc, os, object, *walk); zap_cursor_init_serialized(&zc, os, object, *walk);
} }
if ((error = zap_cursor_retrieve(&zc, &za)) == 0) { if ((error = zap_cursor_retrieve(&zc, za)) == 0) {
uint64_t csize = za.za_num_integers; uint64_t csize = za->za_num_integers;
ASSERT3U(za.za_integer_length, ==, 1); ASSERT3U(za->za_integer_length, ==, 1);
ASSERT3U(csize, <=, psize + 1); ASSERT3U(csize, <=, psize + 1);
uchar_t *cbuf = kmem_alloc(csize, KM_SLEEP); uchar_t *cbuf = kmem_alloc(csize, KM_SLEEP);
error = zap_lookup_uint64(os, object, (uint64_t *)za.za_name, error = zap_lookup_uint64(os, object, (uint64_t *)za->za_name,
DDT_KEY_WORDS, 1, csize, cbuf); DDT_KEY_WORDS, 1, csize, cbuf);
ASSERT0(error); ASSERT0(error);
if (error == 0) { if (error == 0) {
ddt_zap_decompress(cbuf, phys, csize, psize); ddt_zap_decompress(cbuf, phys, csize, psize);
*ddk = *(ddt_key_t *)za.za_name; *ddk = *(ddt_key_t *)za->za_name;
} }
kmem_free(cbuf, csize); kmem_free(cbuf, csize);
@ -233,6 +234,7 @@ ddt_zap_walk(objset_t *os, uint64_t object, uint64_t *walk, ddt_key_t *ddk,
*walk = zap_cursor_serialize(&zc); *walk = zap_cursor_serialize(&zc);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
return (error); return (error);
} }

40
module/zfs/dmu_objset.c
View File

@ -2621,35 +2621,39 @@ dmu_snapshot_list_next(objset_t *os, int namelen, char *name,
{ {
dsl_dataset_t *ds = os->os_dsl_dataset; dsl_dataset_t *ds = os->os_dsl_dataset;
zap_cursor_t cursor; zap_cursor_t cursor;
zap_attribute_t attr; zap_attribute_t *attr;
ASSERT(dsl_pool_config_held(dmu_objset_pool(os))); ASSERT(dsl_pool_config_held(dmu_objset_pool(os)));
if (dsl_dataset_phys(ds)->ds_snapnames_zapobj == 0) if (dsl_dataset_phys(ds)->ds_snapnames_zapobj == 0)
return (SET_ERROR(ENOENT)); return (SET_ERROR(ENOENT));
attr = zap_attribute_alloc();
zap_cursor_init_serialized(&cursor, zap_cursor_init_serialized(&cursor,
ds->ds_dir->dd_pool->dp_meta_objset, ds->ds_dir->dd_pool->dp_meta_objset,
dsl_dataset_phys(ds)->ds_snapnames_zapobj, *offp); dsl_dataset_phys(ds)->ds_snapnames_zapobj, *offp);
if (zap_cursor_retrieve(&cursor, &attr) != 0) { if (zap_cursor_retrieve(&cursor, attr) != 0) {
zap_cursor_fini(&cursor); zap_cursor_fini(&cursor);
zap_attribute_free(attr);
return (SET_ERROR(ENOENT)); return (SET_ERROR(ENOENT));
} }
if (strlen(attr.za_name) + 1 > namelen) { if (strlen(attr->za_name) + 1 > namelen) {
zap_cursor_fini(&cursor); zap_cursor_fini(&cursor);
zap_attribute_free(attr);
return (SET_ERROR(ENAMETOOLONG)); return (SET_ERROR(ENAMETOOLONG));
} }
(void) strlcpy(name, attr.za_name, namelen); (void) strlcpy(name, attr->za_name, namelen);
if (idp) if (idp)
*idp = attr.za_first_integer; *idp = attr->za_first_integer;
if (case_conflict) if (case_conflict)
*case_conflict = attr.za_normalization_conflict; *case_conflict = attr->za_normalization_conflict;
zap_cursor_advance(&cursor); zap_cursor_advance(&cursor);
*offp = zap_cursor_serialize(&cursor); *offp = zap_cursor_serialize(&cursor);
zap_cursor_fini(&cursor); zap_cursor_fini(&cursor);
zap_attribute_free(attr);
return (0); return (0);
} }
@ -2666,33 +2670,37 @@ dmu_dir_list_next(objset_t *os, int namelen, char *name,
{ {
dsl_dir_t *dd = os->os_dsl_dataset->ds_dir; dsl_dir_t *dd = os->os_dsl_dataset->ds_dir;
zap_cursor_t cursor; zap_cursor_t cursor;
zap_attribute_t attr; zap_attribute_t *attr;
/* there is no next dir on a snapshot! */ /* there is no next dir on a snapshot! */
if (os->os_dsl_dataset->ds_object != if (os->os_dsl_dataset->ds_object !=
dsl_dir_phys(dd)->dd_head_dataset_obj) dsl_dir_phys(dd)->dd_head_dataset_obj)
return (SET_ERROR(ENOENT)); return (SET_ERROR(ENOENT));
attr = zap_attribute_alloc();
zap_cursor_init_serialized(&cursor, zap_cursor_init_serialized(&cursor,
dd->dd_pool->dp_meta_objset, dd->dd_pool->dp_meta_objset,
dsl_dir_phys(dd)->dd_child_dir_zapobj, *offp); dsl_dir_phys(dd)->dd_child_dir_zapobj, *offp);
if (zap_cursor_retrieve(&cursor, &attr) != 0) { if (zap_cursor_retrieve(&cursor, attr) != 0) {
zap_cursor_fini(&cursor); zap_cursor_fini(&cursor);
zap_attribute_free(attr);
return (SET_ERROR(ENOENT)); return (SET_ERROR(ENOENT));
} }
if (strlen(attr.za_name) + 1 > namelen) { if (strlen(attr->za_name) + 1 > namelen) {
zap_cursor_fini(&cursor); zap_cursor_fini(&cursor);
zap_attribute_free(attr);
return (SET_ERROR(ENAMETOOLONG)); return (SET_ERROR(ENAMETOOLONG));
} }
(void) strlcpy(name, attr.za_name, namelen); (void) strlcpy(name, attr->za_name, namelen);
if (idp) if (idp)
*idp = attr.za_first_integer; *idp = attr->za_first_integer;
zap_cursor_advance(&cursor); zap_cursor_advance(&cursor);
*offp = zap_cursor_serialize(&cursor); *offp = zap_cursor_serialize(&cursor);
zap_cursor_fini(&cursor); zap_cursor_fini(&cursor);
zap_attribute_free(attr);
return (0); return (0);
} }
@ -2740,7 +2748,7 @@ dmu_objset_find_dp_impl(dmu_objset_find_ctx_t *dcp)
} }
thisobj = dsl_dir_phys(dd)->dd_head_dataset_obj; thisobj = dsl_dir_phys(dd)->dd_head_dataset_obj;
attr = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); attr = zap_attribute_alloc();
/* /*
* Iterate over all children. * Iterate over all children.
@ -2801,7 +2809,7 @@ dmu_objset_find_dp_impl(dmu_objset_find_ctx_t *dcp)
} }
} }
kmem_free(attr, sizeof (zap_attribute_t)); zap_attribute_free(attr);
if (err != 0) { if (err != 0) {
dsl_dir_rele(dd, FTAG); dsl_dir_rele(dd, FTAG);
@ -2975,7 +2983,7 @@ dmu_objset_find_impl(spa_t *spa, const char *name,
} }
thisobj = dsl_dir_phys(dd)->dd_head_dataset_obj; thisobj = dsl_dir_phys(dd)->dd_head_dataset_obj;
attr = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); attr = zap_attribute_alloc();
/* /*
* Iterate over all children. * Iterate over all children.
@ -3003,7 +3011,7 @@ dmu_objset_find_impl(spa_t *spa, const char *name,
if (err != 0) { if (err != 0) {
dsl_dir_rele(dd, FTAG); dsl_dir_rele(dd, FTAG);
dsl_pool_config_exit(dp, FTAG); dsl_pool_config_exit(dp, FTAG);
kmem_free(attr, sizeof (zap_attribute_t)); zap_attribute_free(attr);
return (err); return (err);
} }
} }
@ -3041,7 +3049,7 @@ dmu_objset_find_impl(spa_t *spa, const char *name,
} }
dsl_dir_rele(dd, FTAG); dsl_dir_rele(dd, FTAG);
kmem_free(attr, sizeof (zap_attribute_t)); zap_attribute_free(attr);
dsl_pool_config_exit(dp, FTAG); dsl_pool_config_exit(dp, FTAG);
if (err != 0) if (err != 0)

8
module/zfs/dmu_redact.c
View File

@ -189,7 +189,7 @@ zfs_get_deleteq(objset_t *os)
objlist_t *deleteq_objlist = objlist_create(); objlist_t *deleteq_objlist = objlist_create();
uint64_t deleteq_obj; uint64_t deleteq_obj;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
dmu_object_info_t doi; dmu_object_info_t doi;
ASSERT3U(os->os_phys->os_type, ==, DMU_OST_ZFS); ASSERT3U(os->os_phys->os_type, ==, DMU_OST_ZFS);
@ -208,13 +208,15 @@ zfs_get_deleteq(objset_t *os)
avl_create(&at, objnode_compare, sizeof (struct objnode), avl_create(&at, objnode_compare, sizeof (struct objnode),
offsetof(struct objnode, node)); offsetof(struct objnode, node));
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, os, deleteq_obj); for (zap_cursor_init(&zc, os, deleteq_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_advance(&zc)) { zap_cursor_retrieve(&zc, za) == 0; zap_cursor_advance(&zc)) {
struct objnode *obj = kmem_zalloc(sizeof (*obj), KM_SLEEP); struct objnode *obj = kmem_zalloc(sizeof (*obj), KM_SLEEP);
obj->obj = za.za_first_integer; obj->obj = za->za_first_integer;
avl_add(&at, obj); avl_add(&at, obj);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
struct objnode *next, *found = avl_first(&at); struct objnode *next, *found = avl_first(&at);
while (found != NULL) { while (found != NULL) {

8
module/zfs/dsl_bookmark.c
View File

@ -870,13 +870,14 @@ dsl_bookmark_init_ds(dsl_dataset_t *ds)
int err = 0; int err = 0;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t attr; zap_attribute_t *attr;
attr = zap_attribute_alloc();
for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj); for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj);
(err = zap_cursor_retrieve(&zc, &attr)) == 0; (err = zap_cursor_retrieve(&zc, attr)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
dsl_bookmark_node_t *dbn = dsl_bookmark_node_t *dbn =
dsl_bookmark_node_alloc(attr.za_name); dsl_bookmark_node_alloc(attr->za_name);
err = dsl_bookmark_lookup_impl(ds, err = dsl_bookmark_lookup_impl(ds,
dbn->dbn_name, &dbn->dbn_phys); dbn->dbn_name, &dbn->dbn_phys);
@ -888,6 +889,7 @@ dsl_bookmark_init_ds(dsl_dataset_t *ds)
avl_add(&ds->ds_bookmarks, dbn); avl_add(&ds->ds_bookmarks, dbn);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(attr);
if (err == ENOENT) if (err == ENOENT)
err = 0; err = 0;
return (err); return (err);

4
module/zfs/dsl_crypt.c
View File

@ -1497,7 +1497,7 @@ spa_keystore_change_key_sync_impl(uint64_t rddobj, uint64_t ddobj,
} }
zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP); zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);
za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); za = zap_attribute_alloc();
/* Recurse into all child dsl dirs. */ /* Recurse into all child dsl dirs. */
for (zap_cursor_init(zc, dp->dp_meta_objset, for (zap_cursor_init(zc, dp->dp_meta_objset,
@ -1529,7 +1529,7 @@ spa_keystore_change_key_sync_impl(uint64_t rddobj, uint64_t ddobj,
} }
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(za, sizeof (zap_attribute_t)); zap_attribute_free(za);
kmem_free(zc, sizeof (zap_cursor_t)); kmem_free(zc, sizeof (zap_cursor_t));
dsl_dir_rele(dd, FTAG); dsl_dir_rele(dd, FTAG);

18
module/zfs/dsl_dataset.c
View File

@ -2290,7 +2290,7 @@ get_clones_stat_impl(dsl_dataset_t *ds, nvlist_t *val)
uint64_t count = 0; uint64_t count = 0;
objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset; objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool)); ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
@ -2306,19 +2306,22 @@ get_clones_stat_impl(dsl_dataset_t *ds, nvlist_t *val)
if (count != dsl_dataset_phys(ds)->ds_num_children - 1) { if (count != dsl_dataset_phys(ds)->ds_num_children - 1) {
return (SET_ERROR(ENOENT)); return (SET_ERROR(ENOENT));
} }
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, mos, for (zap_cursor_init(&zc, mos,
dsl_dataset_phys(ds)->ds_next_clones_obj); dsl_dataset_phys(ds)->ds_next_clones_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
dsl_dataset_t *clone; dsl_dataset_t *clone;
char buf[ZFS_MAX_DATASET_NAME_LEN]; char buf[ZFS_MAX_DATASET_NAME_LEN];
VERIFY0(dsl_dataset_hold_obj(ds->ds_dir->dd_pool, VERIFY0(dsl_dataset_hold_obj(ds->ds_dir->dd_pool,
za.za_first_integer, FTAG, &clone)); za->za_first_integer, FTAG, &clone));
dsl_dir_name(clone->ds_dir, buf); dsl_dir_name(clone->ds_dir, buf);
fnvlist_add_boolean(val, buf); fnvlist_add_boolean(val, buf);
dsl_dataset_rele(clone, FTAG); dsl_dataset_rele(clone, FTAG);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
return (0); return (0);
} }
@ -3646,16 +3649,16 @@ dsl_dataset_promote_sync(void *arg, dmu_tx_t *tx)
if (dsl_dataset_phys(ds)->ds_next_clones_obj && if (dsl_dataset_phys(ds)->ds_next_clones_obj &&
spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) { spa_version(dp->dp_spa) >= SPA_VERSION_DIR_CLONES) {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, dp->dp_meta_objset, for (zap_cursor_init(&zc, dp->dp_meta_objset,
dsl_dataset_phys(ds)->ds_next_clones_obj); dsl_dataset_phys(ds)->ds_next_clones_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
dsl_dataset_t *cnds; dsl_dataset_t *cnds;
uint64_t o; uint64_t o;
if (za.za_first_integer == oldnext_obj) { if (za->za_first_integer == oldnext_obj) {
/* /*
* We've already moved the * We've already moved the
* origin's reference. * origin's reference.
@ -3664,7 +3667,7 @@ dsl_dataset_promote_sync(void *arg, dmu_tx_t *tx)
} }
VERIFY0(dsl_dataset_hold_obj(dp, VERIFY0(dsl_dataset_hold_obj(dp,
za.za_first_integer, FTAG, &cnds)); za->za_first_integer, FTAG, &cnds));
o = dsl_dir_phys(cnds->ds_dir)-> o = dsl_dir_phys(cnds->ds_dir)->
dd_head_dataset_obj; dd_head_dataset_obj;
@ -3675,6 +3678,7 @@ dsl_dataset_promote_sync(void *arg, dmu_tx_t *tx)
dsl_dataset_rele(cnds, FTAG); dsl_dataset_rele(cnds, FTAG);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
ASSERT(!dsl_prop_hascb(ds)); ASSERT(!dsl_prop_hascb(ds));

38
module/zfs/dsl_deadlist.c
View File

@ -133,7 +133,7 @@ static void
dsl_deadlist_load_tree(dsl_deadlist_t *dl) dsl_deadlist_load_tree(dsl_deadlist_t *dl)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
int error; int error;
ASSERT(MUTEX_HELD(&dl->dl_lock)); ASSERT(MUTEX_HELD(&dl->dl_lock));
@ -159,20 +159,21 @@ dsl_deadlist_load_tree(dsl_deadlist_t *dl)
if (dl->dl_havetree) if (dl->dl_havetree)
return; return;
za = zap_attribute_alloc();
avl_create(&dl->dl_tree, dsl_deadlist_compare, avl_create(&dl->dl_tree, dsl_deadlist_compare,
sizeof (dsl_deadlist_entry_t), sizeof (dsl_deadlist_entry_t),
offsetof(dsl_deadlist_entry_t, dle_node)); offsetof(dsl_deadlist_entry_t, dle_node));
for (zap_cursor_init(&zc, dl->dl_os, dl->dl_object); for (zap_cursor_init(&zc, dl->dl_os, dl->dl_object);
(error = zap_cursor_retrieve(&zc, &za)) == 0; (error = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
dsl_deadlist_entry_t *dle = kmem_alloc(sizeof (*dle), KM_SLEEP); dsl_deadlist_entry_t *dle = kmem_alloc(sizeof (*dle), KM_SLEEP);
dle->dle_mintxg = zfs_strtonum(za.za_name, NULL); dle->dle_mintxg = zfs_strtonum(za->za_name, NULL);
/* /*
* Prefetch all the bpobj's so that we do that i/o * Prefetch all the bpobj's so that we do that i/o
* in parallel. Then open them all in a second pass. * in parallel. Then open them all in a second pass.
*/ */
dle->dle_bpobj.bpo_object = za.za_first_integer; dle->dle_bpobj.bpo_object = za->za_first_integer;
dmu_prefetch_dnode(dl->dl_os, dle->dle_bpobj.bpo_object, dmu_prefetch_dnode(dl->dl_os, dle->dle_bpobj.bpo_object,
ZIO_PRIORITY_SYNC_READ); ZIO_PRIORITY_SYNC_READ);
@ -180,6 +181,7 @@ dsl_deadlist_load_tree(dsl_deadlist_t *dl)
} }
VERIFY3U(error, ==, ENOENT); VERIFY3U(error, ==, ENOENT);
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
for (dsl_deadlist_entry_t *dle = avl_first(&dl->dl_tree); for (dsl_deadlist_entry_t *dle = avl_first(&dl->dl_tree);
dle != NULL; dle = AVL_NEXT(&dl->dl_tree, dle)) { dle != NULL; dle = AVL_NEXT(&dl->dl_tree, dle)) {
@ -207,7 +209,7 @@ static void
dsl_deadlist_load_cache(dsl_deadlist_t *dl) dsl_deadlist_load_cache(dsl_deadlist_t *dl)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
int error; int error;
ASSERT(MUTEX_HELD(&dl->dl_lock)); ASSERT(MUTEX_HELD(&dl->dl_lock));
@ -221,26 +223,28 @@ dsl_deadlist_load_cache(dsl_deadlist_t *dl)
avl_create(&dl->dl_cache, dsl_deadlist_cache_compare, avl_create(&dl->dl_cache, dsl_deadlist_cache_compare,
sizeof (dsl_deadlist_cache_entry_t), sizeof (dsl_deadlist_cache_entry_t),
offsetof(dsl_deadlist_cache_entry_t, dlce_node)); offsetof(dsl_deadlist_cache_entry_t, dlce_node));
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, dl->dl_os, dl->dl_object); for (zap_cursor_init(&zc, dl->dl_os, dl->dl_object);
(error = zap_cursor_retrieve(&zc, &za)) == 0; (error = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
if (za.za_first_integer == empty_bpobj) if (za->za_first_integer == empty_bpobj)
continue; continue;
dsl_deadlist_cache_entry_t *dlce = dsl_deadlist_cache_entry_t *dlce =
kmem_zalloc(sizeof (*dlce), KM_SLEEP); kmem_zalloc(sizeof (*dlce), KM_SLEEP);
dlce->dlce_mintxg = zfs_strtonum(za.za_name, NULL); dlce->dlce_mintxg = zfs_strtonum(za->za_name, NULL);
/* /*
* Prefetch all the bpobj's so that we do that i/o * Prefetch all the bpobj's so that we do that i/o
* in parallel. Then open them all in a second pass. * in parallel. Then open them all in a second pass.
*/ */
dlce->dlce_bpobj = za.za_first_integer; dlce->dlce_bpobj = za->za_first_integer;
dmu_prefetch_dnode(dl->dl_os, dlce->dlce_bpobj, dmu_prefetch_dnode(dl->dl_os, dlce->dlce_bpobj,
ZIO_PRIORITY_SYNC_READ); ZIO_PRIORITY_SYNC_READ);
avl_add(&dl->dl_cache, dlce); avl_add(&dl->dl_cache, dlce);
} }
VERIFY3U(error, ==, ENOENT); VERIFY3U(error, ==, ENOENT);
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
for (dsl_deadlist_cache_entry_t *dlce = avl_first(&dl->dl_cache); for (dsl_deadlist_cache_entry_t *dlce = avl_first(&dl->dl_cache);
dlce != NULL; dlce = AVL_NEXT(&dl->dl_cache, dlce)) { dlce != NULL; dlce = AVL_NEXT(&dl->dl_cache, dlce)) {
@ -381,7 +385,7 @@ dsl_deadlist_free(objset_t *os, uint64_t dlobj, dmu_tx_t *tx)
{ {
dmu_object_info_t doi; dmu_object_info_t doi;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
int error; int error;
VERIFY0(dmu_object_info(os, dlobj, &doi)); VERIFY0(dmu_object_info(os, dlobj, &doi));
@ -390,10 +394,11 @@ dsl_deadlist_free(objset_t *os, uint64_t dlobj, dmu_tx_t *tx)
return; return;
} }
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, os, dlobj); for (zap_cursor_init(&zc, os, dlobj);
(error = zap_cursor_retrieve(&zc, &za)) == 0; (error = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
uint64_t obj = za.za_first_integer; uint64_t obj = za->za_first_integer;
if (obj == dmu_objset_pool(os)->dp_empty_bpobj) if (obj == dmu_objset_pool(os)->dp_empty_bpobj)
bpobj_decr_empty(os, tx); bpobj_decr_empty(os, tx);
else else
@ -401,6 +406,7 @@ dsl_deadlist_free(objset_t *os, uint64_t dlobj, dmu_tx_t *tx)
} }
VERIFY3U(error, ==, ENOENT); VERIFY3U(error, ==, ENOENT);
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
VERIFY0(dmu_object_free(os, dlobj, tx)); VERIFY0(dmu_object_free(os, dlobj, tx));
} }
@ -875,8 +881,8 @@ dsl_deadlist_merge(dsl_deadlist_t *dl, uint64_t obj, dmu_tx_t *tx)
return; return;
} }
za = kmem_alloc(sizeof (*za), KM_SLEEP); za = zap_attribute_alloc();
pza = kmem_alloc(sizeof (*pza), KM_SLEEP); pza = zap_attribute_alloc();
mutex_enter(&dl->dl_lock); mutex_enter(&dl->dl_lock);
/* /*
@ -913,8 +919,8 @@ dsl_deadlist_merge(dsl_deadlist_t *dl, uint64_t obj, dmu_tx_t *tx)
dmu_buf_rele(bonus, FTAG); dmu_buf_rele(bonus, FTAG);
mutex_exit(&dl->dl_lock); mutex_exit(&dl->dl_lock);
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
kmem_free(pza, sizeof (*pza)); zap_attribute_free(pza);
} }
/* /*

36
module/zfs/dsl_deleg.c
View File

@ -327,9 +327,9 @@ dsl_deleg_get(const char *ddname, nvlist_t **nvp)
mos = dp->dp_meta_objset; mos = dp->dp_meta_objset;
zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP); zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);
za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); za = zap_attribute_alloc();
basezc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP); basezc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);
baseza = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); baseza = zap_attribute_alloc();
source = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP); source = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0); VERIFY(nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);
@ -371,9 +371,9 @@ dsl_deleg_get(const char *ddname, nvlist_t **nvp)
} }
kmem_free(source, ZFS_MAX_DATASET_NAME_LEN); kmem_free(source, ZFS_MAX_DATASET_NAME_LEN);
kmem_free(baseza, sizeof (zap_attribute_t)); zap_attribute_free(baseza);
kmem_free(basezc, sizeof (zap_cursor_t)); kmem_free(basezc, sizeof (zap_cursor_t));
kmem_free(za, sizeof (zap_attribute_t)); zap_attribute_free(za);
kmem_free(zc, sizeof (zap_cursor_t)); kmem_free(zc, sizeof (zap_cursor_t));
dsl_dir_rele(startdd, FTAG); dsl_dir_rele(startdd, FTAG);
@ -482,7 +482,7 @@ dsl_load_sets(objset_t *mos, uint64_t zapobj,
char type, char checkflag, void *valp, avl_tree_t *avl) char type, char checkflag, void *valp, avl_tree_t *avl)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
perm_set_t *permnode; perm_set_t *permnode;
avl_index_t idx; avl_index_t idx;
uint64_t jumpobj; uint64_t jumpobj;
@ -495,11 +495,12 @@ dsl_load_sets(objset_t *mos, uint64_t zapobj,
if (error != 0) if (error != 0)
return (error); return (error);
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, mos, jumpobj); for (zap_cursor_init(&zc, mos, jumpobj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
permnode = kmem_alloc(sizeof (perm_set_t), KM_SLEEP); permnode = kmem_alloc(sizeof (perm_set_t), KM_SLEEP);
(void) strlcpy(permnode->p_setname, za.za_name, (void) strlcpy(permnode->p_setname, za->za_name,
sizeof (permnode->p_setname)); sizeof (permnode->p_setname));
permnode->p_matched = B_FALSE; permnode->p_matched = B_FALSE;
@ -510,6 +511,7 @@ dsl_load_sets(objset_t *mos, uint64_t zapobj,
} }
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
return (0); return (0);
} }
@ -683,7 +685,7 @@ copy_create_perms(dsl_dir_t *dd, uint64_t pzapobj,
uint64_t jumpobj, pjumpobj; uint64_t jumpobj, pjumpobj;
uint64_t zapobj = dsl_dir_phys(dd)->dd_deleg_zapobj; uint64_t zapobj = dsl_dir_phys(dd)->dd_deleg_zapobj;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
char whokey[ZFS_MAX_DELEG_NAME]; char whokey[ZFS_MAX_DELEG_NAME];
zfs_deleg_whokey(whokey, zfs_deleg_whokey(whokey,
@ -706,16 +708,18 @@ copy_create_perms(dsl_dir_t *dd, uint64_t pzapobj,
VERIFY(zap_add(mos, zapobj, whokey, 8, 1, &jumpobj, tx) == 0); VERIFY(zap_add(mos, zapobj, whokey, 8, 1, &jumpobj, tx) == 0);
} }
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, mos, pjumpobj); for (zap_cursor_init(&zc, mos, pjumpobj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
uint64_t zero = 0; uint64_t zero = 0;
ASSERT(za.za_integer_length == 8 && za.za_num_integers == 1); ASSERT(za->za_integer_length == 8 && za->za_num_integers == 1);
VERIFY(zap_update(mos, jumpobj, za.za_name, VERIFY(zap_update(mos, jumpobj, za->za_name,
8, 1, &zero, tx) == 0); 8, 1, &zero, tx) == 0);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
/* /*
@ -746,19 +750,21 @@ int
dsl_deleg_destroy(objset_t *mos, uint64_t zapobj, dmu_tx_t *tx) dsl_deleg_destroy(objset_t *mos, uint64_t zapobj, dmu_tx_t *tx)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
if (zapobj == 0) if (zapobj == 0)
return (0); return (0);
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, mos, zapobj); for (zap_cursor_init(&zc, mos, zapobj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
ASSERT(za.za_integer_length == 8 && za.za_num_integers == 1); ASSERT(za->za_integer_length == 8 && za->za_num_integers == 1);
VERIFY(0 == zap_destroy(mos, za.za_first_integer, tx)); VERIFY(0 == zap_destroy(mos, za->za_first_integer, tx));
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
VERIFY(0 == zap_destroy(mos, zapobj, tx)); VERIFY(0 == zap_destroy(mos, zapobj, tx));
zap_attribute_free(za);
return (0); return (0);
} }

4
module/zfs/dsl_destroy.c
View File

@ -216,7 +216,7 @@ dsl_dir_remove_clones_key_impl(dsl_dir_t *dd, uint64_t mintxg, dmu_tx_t *tx,
return; return;
zap_cursor_t *zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP); zap_cursor_t *zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);
zap_attribute_t *za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(zc, mos, dsl_dir_phys(dd)->dd_clones); for (zap_cursor_init(zc, mos, dsl_dir_phys(dd)->dd_clones);
zap_cursor_retrieve(zc, za) == 0; zap_cursor_retrieve(zc, za) == 0;
@ -242,7 +242,7 @@ dsl_dir_remove_clones_key_impl(dsl_dir_t *dd, uint64_t mintxg, dmu_tx_t *tx,
} }
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(za, sizeof (zap_attribute_t)); zap_attribute_free(za);
kmem_free(zc, sizeof (zap_cursor_t)); kmem_free(zc, sizeof (zap_cursor_t));
} }

4
module/zfs/dsl_dir.c
View File

@ -586,7 +586,7 @@ dsl_dir_init_fs_ss_count(dsl_dir_t *dd, dmu_tx_t *tx)
return; return;
zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP); zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);
za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); za = zap_attribute_alloc();
/* Iterate my child dirs */ /* Iterate my child dirs */
for (zap_cursor_init(zc, os, dsl_dir_phys(dd)->dd_child_dir_zapobj); for (zap_cursor_init(zc, os, dsl_dir_phys(dd)->dd_child_dir_zapobj);
@ -635,7 +635,7 @@ dsl_dir_init_fs_ss_count(dsl_dir_t *dd, dmu_tx_t *tx)
dsl_dataset_rele(ds, FTAG); dsl_dataset_rele(ds, FTAG);
kmem_free(zc, sizeof (zap_cursor_t)); kmem_free(zc, sizeof (zap_cursor_t));
kmem_free(za, sizeof (zap_attribute_t)); zap_attribute_free(za);
/* we're in a sync task, update counts */ /* we're in a sync task, update counts */
dmu_buf_will_dirty(dd->dd_dbuf, tx); dmu_buf_will_dirty(dd->dd_dbuf, tx);

12
module/zfs/dsl_pool.c
View File

@ -1196,7 +1196,7 @@ dsl_pool_unlinked_drain_taskq(dsl_pool_t *dp)
void void
dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp) dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp)
{ {
zap_attribute_t za; zap_attribute_t *za;
zap_cursor_t zc; zap_cursor_t zc;
objset_t *mos = dp->dp_meta_objset; objset_t *mos = dp->dp_meta_objset;
uint64_t zapobj = dp->dp_tmp_userrefs_obj; uint64_t zapobj = dp->dp_tmp_userrefs_obj;
@ -1208,19 +1208,20 @@ dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp)
holds = fnvlist_alloc(); holds = fnvlist_alloc();
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, mos, zapobj); for (zap_cursor_init(&zc, mos, zapobj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
char *htag; char *htag;
nvlist_t *tags; nvlist_t *tags;
htag = strchr(za.za_name, '-'); htag = strchr(za->za_name, '-');
*htag = '\0'; *htag = '\0';
++htag; ++htag;
if (nvlist_lookup_nvlist(holds, za.za_name, &tags) != 0) { if (nvlist_lookup_nvlist(holds, za->za_name, &tags) != 0) {
tags = fnvlist_alloc(); tags = fnvlist_alloc();
fnvlist_add_boolean(tags, htag); fnvlist_add_boolean(tags, htag);
fnvlist_add_nvlist(holds, za.za_name, tags); fnvlist_add_nvlist(holds, za->za_name, tags);
fnvlist_free(tags); fnvlist_free(tags);
} else { } else {
fnvlist_add_boolean(tags, htag); fnvlist_add_boolean(tags, htag);
@ -1229,6 +1230,7 @@ dsl_pool_clean_tmp_userrefs(dsl_pool_t *dp)
dsl_dataset_user_release_tmp(dp, holds); dsl_dataset_user_release_tmp(dp, holds);
fnvlist_free(holds); fnvlist_free(holds);
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
/* /*

37
module/zfs/dsl_prop.c
View File

@ -662,7 +662,7 @@ dsl_prop_changed_notify(dsl_pool_t *dp, uint64_t ddobj,
} }
mutex_exit(&dd->dd_lock); mutex_exit(&dd->dd_lock);
za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); za = zap_attribute_alloc();
for (zap_cursor_init(&zc, mos, for (zap_cursor_init(&zc, mos,
dsl_dir_phys(dd)->dd_child_dir_zapobj); dsl_dir_phys(dd)->dd_child_dir_zapobj);
zap_cursor_retrieve(&zc, za) == 0; zap_cursor_retrieve(&zc, za) == 0;
@ -670,7 +670,7 @@ dsl_prop_changed_notify(dsl_pool_t *dp, uint64_t ddobj,
dsl_prop_changed_notify(dp, za->za_first_integer, dsl_prop_changed_notify(dp, za->za_first_integer,
propname, value, FALSE); propname, value, FALSE);
} }
kmem_free(za, sizeof (zap_attribute_t)); zap_attribute_free(za);
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
dsl_dir_rele(dd, FTAG); dsl_dir_rele(dd, FTAG);
} }
@ -1061,11 +1061,11 @@ dsl_prop_get_all_impl(objset_t *mos, uint64_t propobj,
const char *setpoint, dsl_prop_getflags_t flags, nvlist_t *nv) const char *setpoint, dsl_prop_getflags_t flags, nvlist_t *nv)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
int err = 0; int err = 0;
for (zap_cursor_init(&zc, mos, propobj); for (zap_cursor_init(&zc, mos, propobj);
(err = zap_cursor_retrieve(&zc, &za)) == 0; (err = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
nvlist_t *propval; nvlist_t *propval;
zfs_prop_t prop; zfs_prop_t prop;
@ -1075,7 +1075,7 @@ dsl_prop_get_all_impl(objset_t *mos, uint64_t propobj,
const char *propname; const char *propname;
const char *source; const char *source;
suffix = strchr(za.za_name, '$'); suffix = strchr(za->za_name, '$');
if (suffix == NULL) { if (suffix == NULL) {
/* /*
@ -1085,7 +1085,7 @@ dsl_prop_get_all_impl(objset_t *mos, uint64_t propobj,
if (flags & DSL_PROP_GET_RECEIVED) if (flags & DSL_PROP_GET_RECEIVED)
continue; continue;
propname = za.za_name; propname = za->za_name;
source = setpoint; source = setpoint;
/* Skip if iuv entries are preset. */ /* Skip if iuv entries are preset. */
@ -1102,8 +1102,8 @@ dsl_prop_get_all_impl(objset_t *mos, uint64_t propobj,
if (flags & DSL_PROP_GET_LOCAL) if (flags & DSL_PROP_GET_LOCAL)
continue; continue;
(void) strlcpy(buf, za.za_name, (void) strlcpy(buf, za->za_name,
MIN(sizeof (buf), suffix - za.za_name + 1)); MIN(sizeof (buf), suffix - za->za_name + 1));
propname = buf; propname = buf;
if (!(flags & DSL_PROP_GET_RECEIVED)) { if (!(flags & DSL_PROP_GET_RECEIVED)) {
@ -1128,14 +1128,14 @@ dsl_prop_get_all_impl(objset_t *mos, uint64_t propobj,
source = ((flags & DSL_PROP_GET_INHERITING) ? source = ((flags & DSL_PROP_GET_INHERITING) ?
setpoint : ZPROP_SOURCE_VAL_RECVD); setpoint : ZPROP_SOURCE_VAL_RECVD);
} else if (strcmp(suffix, ZPROP_IUV_SUFFIX) == 0) { } else if (strcmp(suffix, ZPROP_IUV_SUFFIX) == 0) {
(void) strlcpy(buf, za.za_name, (void) strlcpy(buf, za->za_name,
MIN(sizeof (buf), suffix - za.za_name + 1)); MIN(sizeof (buf), suffix - za->za_name + 1));
propname = buf; propname = buf;
source = setpoint; source = setpoint;
prop = zfs_name_to_prop(propname); prop = zfs_name_to_prop(propname);
if (dsl_prop_known_index(prop, if (dsl_prop_known_index(prop,
za.za_first_integer) != 1) za->za_first_integer) != 1)
continue; continue;
} else { } else {
/* /*
@ -1162,28 +1162,28 @@ dsl_prop_get_all_impl(objset_t *mos, uint64_t propobj,
continue; continue;
VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0); VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0);
if (za.za_integer_length == 1) { if (za->za_integer_length == 1) {
/* /*
* String property * String property
*/ */
char *tmp = kmem_alloc(za.za_num_integers, char *tmp = kmem_alloc(za->za_num_integers,
KM_SLEEP); KM_SLEEP);
err = zap_lookup(mos, propobj, err = zap_lookup(mos, propobj,
za.za_name, 1, za.za_num_integers, tmp); za->za_name, 1, za->za_num_integers, tmp);
if (err != 0) { if (err != 0) {
kmem_free(tmp, za.za_num_integers); kmem_free(tmp, za->za_num_integers);
break; break;
} }
VERIFY(nvlist_add_string(propval, ZPROP_VALUE, VERIFY(nvlist_add_string(propval, ZPROP_VALUE,
tmp) == 0); tmp) == 0);
kmem_free(tmp, za.za_num_integers); kmem_free(tmp, za->za_num_integers);
} else { } else {
/* /*
* Integer property * Integer property
*/ */
ASSERT(za.za_integer_length == 8); ASSERT(za->za_integer_length == 8);
(void) nvlist_add_uint64(propval, ZPROP_VALUE, (void) nvlist_add_uint64(propval, ZPROP_VALUE,
za.za_first_integer); za->za_first_integer);
} }
VERIFY(nvlist_add_string(propval, ZPROP_SOURCE, source) == 0); VERIFY(nvlist_add_string(propval, ZPROP_SOURCE, source) == 0);
@ -1191,6 +1191,7 @@ dsl_prop_get_all_impl(objset_t *mos, uint64_t propobj,
nvlist_free(propval); nvlist_free(propval);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
if (err == ENOENT) if (err == ENOENT)
err = 0; err = 0;
return (err); return (err);

26
module/zfs/dsl_scan.c
View File

@ -617,17 +617,18 @@ dsl_scan_init(dsl_pool_t *dp, uint64_t txg)
/* reload the queue into the in-core state */ /* reload the queue into the in-core state */
if (scn->scn_phys.scn_queue_obj != 0) { if (scn->scn_phys.scn_queue_obj != 0) {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, dp->dp_meta_objset, for (zap_cursor_init(&zc, dp->dp_meta_objset,
scn->scn_phys.scn_queue_obj); scn->scn_phys.scn_queue_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
(void) zap_cursor_advance(&zc)) { (void) zap_cursor_advance(&zc)) {
scan_ds_queue_insert(scn, scan_ds_queue_insert(scn,
zfs_strtonum(za.za_name, NULL), zfs_strtonum(za->za_name, NULL),
za.za_first_integer); za->za_first_integer);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
ddt_walk_init(spa, scn->scn_phys.scn_max_txg); ddt_walk_init(spa, scn->scn_phys.scn_max_txg);
@ -2870,16 +2871,17 @@ dsl_scan_visitds(dsl_scan_t *scn, uint64_t dsobj, dmu_tx_t *tx)
if (usenext) { if (usenext) {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, dp->dp_meta_objset, for (zap_cursor_init(&zc, dp->dp_meta_objset,
dsl_dataset_phys(ds)->ds_next_clones_obj); dsl_dataset_phys(ds)->ds_next_clones_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
(void) zap_cursor_advance(&zc)) { (void) zap_cursor_advance(&zc)) {
scan_ds_queue_insert(scn, scan_ds_queue_insert(scn,
zfs_strtonum(za.za_name, NULL), zfs_strtonum(za->za_name, NULL),
dsl_dataset_phys(ds)->ds_creation_txg); dsl_dataset_phys(ds)->ds_creation_txg);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} else { } else {
VERIFY0(dmu_objset_find_dp(dp, dp->dp_root_dir_obj, VERIFY0(dmu_objset_find_dp(dp, dp->dp_root_dir_obj,
enqueue_clones_cb, &ds->ds_object, enqueue_clones_cb, &ds->ds_object,
@ -4174,7 +4176,7 @@ dsl_errorscrub_sync(dsl_pool_t *dp, dmu_tx_t *tx)
zbookmark_phys_t *zb; zbookmark_phys_t *zb;
boolean_t limit_exceeded = B_FALSE; boolean_t limit_exceeded = B_FALSE;
za = kmem_zalloc(sizeof (zap_attribute_t), KM_SLEEP); za = zap_attribute_alloc();
zb = kmem_zalloc(sizeof (zbookmark_phys_t), KM_SLEEP); zb = kmem_zalloc(sizeof (zbookmark_phys_t), KM_SLEEP);
if (!spa_feature_is_enabled(spa, SPA_FEATURE_HEAD_ERRLOG)) { if (!spa_feature_is_enabled(spa, SPA_FEATURE_HEAD_ERRLOG)) {
@ -4205,7 +4207,7 @@ dsl_errorscrub_sync(dsl_pool_t *dp, dmu_tx_t *tx)
dsl_errorscrub_done(scn, B_TRUE, tx); dsl_errorscrub_done(scn, B_TRUE, tx);
dsl_errorscrub_sync_state(scn, tx); dsl_errorscrub_sync_state(scn, tx);
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
kmem_free(zb, sizeof (*zb)); kmem_free(zb, sizeof (*zb));
return; return;
} }
@ -4219,7 +4221,7 @@ dsl_errorscrub_sync(dsl_pool_t *dp, dmu_tx_t *tx)
zbookmark_err_phys_t head_ds_block; zbookmark_err_phys_t head_ds_block;
head_ds_cursor = kmem_zalloc(sizeof (zap_cursor_t), KM_SLEEP); head_ds_cursor = kmem_zalloc(sizeof (zap_cursor_t), KM_SLEEP);
head_ds_attr = kmem_zalloc(sizeof (zap_attribute_t), KM_SLEEP); head_ds_attr = zap_attribute_alloc();
uint64_t head_ds_err_obj = za->za_first_integer; uint64_t head_ds_err_obj = za->za_first_integer;
uint64_t head_ds; uint64_t head_ds;
@ -4258,13 +4260,13 @@ dsl_errorscrub_sync(dsl_pool_t *dp, dmu_tx_t *tx)
zap_cursor_fini(head_ds_cursor); zap_cursor_fini(head_ds_cursor);
kmem_free(head_ds_cursor, sizeof (*head_ds_cursor)); kmem_free(head_ds_cursor, sizeof (*head_ds_cursor));
kmem_free(head_ds_attr, sizeof (*head_ds_attr)); zap_attribute_free(head_ds_attr);
if (config_held) if (config_held)
dsl_pool_config_exit(dp, FTAG); dsl_pool_config_exit(dp, FTAG);
} }
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
kmem_free(zb, sizeof (*zb)); kmem_free(zb, sizeof (*zb));
if (!limit_exceeded) if (!limit_exceeded)
dsl_errorscrub_done(scn, B_TRUE, tx); dsl_errorscrub_done(scn, B_TRUE, tx);

4
module/zfs/dsl_userhold.c
View File

@ -674,7 +674,7 @@ dsl_dataset_get_holds(const char *dsname, nvlist_t *nvl)
zap_attribute_t *za; zap_attribute_t *za;
zap_cursor_t zc; zap_cursor_t zc;
za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); za = zap_attribute_alloc();
for (zap_cursor_init(&zc, ds->ds_dir->dd_pool->dp_meta_objset, for (zap_cursor_init(&zc, ds->ds_dir->dd_pool->dp_meta_objset,
dsl_dataset_phys(ds)->ds_userrefs_obj); dsl_dataset_phys(ds)->ds_userrefs_obj);
zap_cursor_retrieve(&zc, za) == 0; zap_cursor_retrieve(&zc, za) == 0;
@ -683,7 +683,7 @@ dsl_dataset_get_holds(const char *dsname, nvlist_t *nvl)
za->za_first_integer); za->za_first_integer);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
kmem_free(za, sizeof (zap_attribute_t)); zap_attribute_free(za);
} }
dsl_dataset_rele(ds, FTAG); dsl_dataset_rele(ds, FTAG);
dsl_pool_rele(dp, FTAG); dsl_pool_rele(dp, FTAG);

34
module/zfs/sa.c
View File

@ -840,7 +840,7 @@ sa_attr_table_setup(objset_t *os, const sa_attr_reg_t *reg_attrs, int count)
uint64_t attr_value; uint64_t attr_value;
sa_attr_table_t *tb; sa_attr_table_t *tb;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
int registered_count = 0; int registered_count = 0;
int i; int i;
dmu_objset_type_t ostype = dmu_objset_type(os); dmu_objset_type_t ostype = dmu_objset_type(os);
@ -914,11 +914,12 @@ sa_attr_table_setup(objset_t *os, const sa_attr_reg_t *reg_attrs, int count)
*/ */
if (sa->sa_reg_attr_obj) { if (sa->sa_reg_attr_obj) {
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, os, sa->sa_reg_attr_obj); for (zap_cursor_init(&zc, os, sa->sa_reg_attr_obj);
(error = zap_cursor_retrieve(&zc, &za)) == 0; (error = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
uint64_t value; uint64_t value;
value = za.za_first_integer; value = za->za_first_integer;
registered_count++; registered_count++;
tb[ATTR_NUM(value)].sa_attr = ATTR_NUM(value); tb[ATTR_NUM(value)].sa_attr = ATTR_NUM(value);
@ -930,11 +931,12 @@ sa_attr_table_setup(objset_t *os, const sa_attr_reg_t *reg_attrs, int count)
continue; continue;
} }
tb[ATTR_NUM(value)].sa_name = tb[ATTR_NUM(value)].sa_name =
kmem_zalloc(strlen(za.za_name) +1, KM_SLEEP); kmem_zalloc(strlen(za->za_name) +1, KM_SLEEP);
(void) strlcpy(tb[ATTR_NUM(value)].sa_name, za.za_name, (void) strlcpy(tb[ATTR_NUM(value)].sa_name, za->za_name,
strlen(za.za_name) +1); strlen(za->za_name) +1);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
/* /*
* Make sure we processed the correct number of registered * Make sure we processed the correct number of registered
* attributes * attributes
@ -996,7 +998,7 @@ sa_setup(objset_t *os, uint64_t sa_obj, const sa_attr_reg_t *reg_attrs,
int count, sa_attr_type_t **user_table) int count, sa_attr_type_t **user_table)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
sa_os_t *sa; sa_os_t *sa;
dmu_objset_type_t ostype = dmu_objset_type(os); dmu_objset_type_t ostype = dmu_objset_type(os);
sa_attr_type_t *tb; sa_attr_type_t *tb;
@ -1053,33 +1055,35 @@ sa_setup(objset_t *os, uint64_t sa_obj, const sa_attr_reg_t *reg_attrs,
goto fail; goto fail;
} }
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, os, sa->sa_layout_attr_obj); for (zap_cursor_init(&zc, os, sa->sa_layout_attr_obj);
(error = zap_cursor_retrieve(&zc, &za)) == 0; (error = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
sa_attr_type_t *lot_attrs; sa_attr_type_t *lot_attrs;
uint64_t lot_num; uint64_t lot_num;
lot_attrs = kmem_zalloc(sizeof (sa_attr_type_t) * lot_attrs = kmem_zalloc(sizeof (sa_attr_type_t) *
za.za_num_integers, KM_SLEEP); za->za_num_integers, KM_SLEEP);
if ((error = (zap_lookup(os, sa->sa_layout_attr_obj, if ((error = (zap_lookup(os, sa->sa_layout_attr_obj,
za.za_name, 2, za.za_num_integers, za->za_name, 2, za->za_num_integers,
lot_attrs))) != 0) { lot_attrs))) != 0) {
kmem_free(lot_attrs, sizeof (sa_attr_type_t) * kmem_free(lot_attrs, sizeof (sa_attr_type_t) *
za.za_num_integers); za->za_num_integers);
break; break;
} }
VERIFY0(ddi_strtoull(za.za_name, NULL, 10, VERIFY0(ddi_strtoull(za->za_name, NULL, 10,
(unsigned long long *)&lot_num)); (unsigned long long *)&lot_num));
(void) sa_add_layout_entry(os, lot_attrs, (void) sa_add_layout_entry(os, lot_attrs,
za.za_num_integers, lot_num, za->za_num_integers, lot_num,
sa_layout_info_hash(lot_attrs, sa_layout_info_hash(lot_attrs,
za.za_num_integers), B_FALSE, NULL); za->za_num_integers), B_FALSE, NULL);
kmem_free(lot_attrs, sizeof (sa_attr_type_t) * kmem_free(lot_attrs, sizeof (sa_attr_type_t) *
za.za_num_integers); za->za_num_integers);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
/* /*
* Make sure layout count matches number of entries added * Make sure layout count matches number of entries added

72
module/zfs/spa.c
View File

@ -542,12 +542,13 @@ spa_prop_get(spa_t *spa, nvlist_t *nv)
{ {
objset_t *mos = spa->spa_meta_objset; objset_t *mos = spa->spa_meta_objset;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
dsl_pool_t *dp; dsl_pool_t *dp;
int err = 0; int err = 0;
dp = spa_get_dsl(spa); dp = spa_get_dsl(spa);
dsl_pool_config_enter(dp, FTAG); dsl_pool_config_enter(dp, FTAG);
za = zap_attribute_alloc();
mutex_enter(&spa->spa_props_lock); mutex_enter(&spa->spa_props_lock);
/* /*
@ -563,21 +564,21 @@ spa_prop_get(spa_t *spa, nvlist_t *nv)
* Get properties from the MOS pool property object. * Get properties from the MOS pool property object.
*/ */
for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object); for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object);
(err = zap_cursor_retrieve(&zc, &za)) == 0; (err = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
uint64_t intval = 0; uint64_t intval = 0;
char *strval = NULL; char *strval = NULL;
zprop_source_t src = ZPROP_SRC_DEFAULT; zprop_source_t src = ZPROP_SRC_DEFAULT;
zpool_prop_t prop; zpool_prop_t prop;
if ((prop = zpool_name_to_prop(za.za_name)) == if ((prop = zpool_name_to_prop(za->za_name)) ==
ZPOOL_PROP_INVAL && !zfs_prop_user(za.za_name)) ZPOOL_PROP_INVAL && !zfs_prop_user(za->za_name))
continue; continue;
switch (za.za_integer_length) { switch (za->za_integer_length) {
case 8: case 8:
/* integer property */ /* integer property */
if (za.za_first_integer != if (za->za_first_integer !=
zpool_prop_default_numeric(prop)) zpool_prop_default_numeric(prop))
src = ZPROP_SRC_LOCAL; src = ZPROP_SRC_LOCAL;
@ -585,7 +586,7 @@ spa_prop_get(spa_t *spa, nvlist_t *nv)
dsl_dataset_t *ds = NULL; dsl_dataset_t *ds = NULL;
err = dsl_dataset_hold_obj(dp, err = dsl_dataset_hold_obj(dp,
za.za_first_integer, FTAG, &ds); za->za_first_integer, FTAG, &ds);
if (err != 0) if (err != 0)
break; break;
@ -595,7 +596,7 @@ spa_prop_get(spa_t *spa, nvlist_t *nv)
dsl_dataset_rele(ds, FTAG); dsl_dataset_rele(ds, FTAG);
} else { } else {
strval = NULL; strval = NULL;
intval = za.za_first_integer; intval = za->za_first_integer;
} }
spa_prop_add_list(nv, prop, strval, intval, src); spa_prop_add_list(nv, prop, strval, intval, src);
@ -607,21 +608,21 @@ spa_prop_get(spa_t *spa, nvlist_t *nv)
case 1: case 1:
/* string property */ /* string property */
strval = kmem_alloc(za.za_num_integers, KM_SLEEP); strval = kmem_alloc(za->za_num_integers, KM_SLEEP);
err = zap_lookup(mos, spa->spa_pool_props_object, err = zap_lookup(mos, spa->spa_pool_props_object,
za.za_name, 1, za.za_num_integers, strval); za->za_name, 1, za->za_num_integers, strval);
if (err) { if (err) {
kmem_free(strval, za.za_num_integers); kmem_free(strval, za->za_num_integers);
break; break;
} }
if (prop != ZPOOL_PROP_INVAL) { if (prop != ZPOOL_PROP_INVAL) {
spa_prop_add_list(nv, prop, strval, 0, src); spa_prop_add_list(nv, prop, strval, 0, src);
} else { } else {
src = ZPROP_SRC_LOCAL; src = ZPROP_SRC_LOCAL;
spa_prop_add_user(nv, za.za_name, strval, spa_prop_add_user(nv, za->za_name, strval,
src); src);
} }
kmem_free(strval, za.za_num_integers); kmem_free(strval, za->za_num_integers);
break; break;
default: default:
@ -632,6 +633,7 @@ spa_prop_get(spa_t *spa, nvlist_t *nv)
out: out:
mutex_exit(&spa->spa_props_lock); mutex_exit(&spa->spa_props_lock);
dsl_pool_config_exit(dp, FTAG); dsl_pool_config_exit(dp, FTAG);
zap_attribute_free(za);
if (err && err != ENOENT) if (err && err != ENOENT)
return (err); return (err);
@ -2972,12 +2974,13 @@ dsl_get_next_livelist_obj(objset_t *os, uint64_t zap_obj, uint64_t *llp)
{ {
int err; int err;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
zap_cursor_init(&zc, os, zap_obj); zap_cursor_init(&zc, os, zap_obj);
err = zap_cursor_retrieve(&zc, &za); err = zap_cursor_retrieve(&zc, za);
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
if (err == 0) if (err == 0)
*llp = za.za_first_integer; *llp = za->za_first_integer;
zap_attribute_free(za);
return (err); return (err);
} }
@ -6048,17 +6051,17 @@ static void
spa_feature_stats_from_disk(spa_t *spa, nvlist_t *features) spa_feature_stats_from_disk(spa_t *spa, nvlist_t *features)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
if (spa->spa_feat_for_read_obj != 0) { if (spa->spa_feat_for_read_obj != 0) {
for (zap_cursor_init(&zc, spa->spa_meta_objset, for (zap_cursor_init(&zc, spa->spa_meta_objset,
spa->spa_feat_for_read_obj); spa->spa_feat_for_read_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
ASSERT(za.za_integer_length == sizeof (uint64_t) && ASSERT(za->za_integer_length == sizeof (uint64_t) &&
za.za_num_integers == 1); za->za_num_integers == 1);
VERIFY0(nvlist_add_uint64(features, za.za_name, VERIFY0(nvlist_add_uint64(features, za->za_name,
za.za_first_integer)); za->za_first_integer));
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
} }
@ -6066,15 +6069,16 @@ spa_feature_stats_from_disk(spa_t *spa, nvlist_t *features)
if (spa->spa_feat_for_write_obj != 0) { if (spa->spa_feat_for_write_obj != 0) {
for (zap_cursor_init(&zc, spa->spa_meta_objset, for (zap_cursor_init(&zc, spa->spa_meta_objset,
spa->spa_feat_for_write_obj); spa->spa_feat_for_write_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
ASSERT(za.za_integer_length == sizeof (uint64_t) && ASSERT(za->za_integer_length == sizeof (uint64_t) &&
za.za_num_integers == 1); za->za_num_integers == 1);
VERIFY0(nvlist_add_uint64(features, za.za_name, VERIFY0(nvlist_add_uint64(features, za->za_name,
za.za_first_integer)); za->za_first_integer));
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
} }
zap_attribute_free(za);
} }
static void static void
@ -9434,13 +9438,13 @@ spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
/* Diff old AVZ with new one */ /* Diff old AVZ with new one */
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, spa->spa_meta_objset, for (zap_cursor_init(&zc, spa->spa_meta_objset,
spa->spa_all_vdev_zaps); spa->spa_all_vdev_zaps);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
uint64_t vdzap = za.za_first_integer; uint64_t vdzap = za->za_first_integer;
if (zap_lookup_int(spa->spa_meta_objset, new_avz, if (zap_lookup_int(spa->spa_meta_objset, new_avz,
vdzap) == ENOENT) { vdzap) == ENOENT) {
/* /*
@ -9453,6 +9457,7 @@ spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
/* Destroy the old AVZ */ /* Destroy the old AVZ */
VERIFY0(zap_destroy(spa->spa_meta_objset, VERIFY0(zap_destroy(spa->spa_meta_objset,
@ -9466,18 +9471,19 @@ spa_sync_config_object(spa_t *spa, dmu_tx_t *tx)
spa->spa_all_vdev_zaps = new_avz; spa->spa_all_vdev_zaps = new_avz;
} else if (spa->spa_avz_action == AVZ_ACTION_DESTROY) { } else if (spa->spa_avz_action == AVZ_ACTION_DESTROY) {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
/* Walk through the AVZ and destroy all listed ZAPs */ /* Walk through the AVZ and destroy all listed ZAPs */
for (zap_cursor_init(&zc, spa->spa_meta_objset, for (zap_cursor_init(&zc, spa->spa_meta_objset,
spa->spa_all_vdev_zaps); spa->spa_all_vdev_zaps);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
uint64_t zap = za.za_first_integer; uint64_t zap = za->za_first_integer;
VERIFY0(zap_destroy(spa->spa_meta_objset, zap, tx)); VERIFY0(zap_destroy(spa->spa_meta_objset, zap, tx));
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
/* Destroy and unlink the AVZ itself */ /* Destroy and unlink the AVZ itself */
VERIFY0(zap_destroy(spa->spa_meta_objset, VERIFY0(zap_destroy(spa->spa_meta_objset,

84
module/zfs/spa_errlog.c
View File

@ -429,7 +429,7 @@ check_filesystem(spa_t *spa, uint64_t head_ds, zbookmark_err_phys_t *zep,
zap_attribute_t *za; zap_attribute_t *za;
zc = kmem_zalloc(sizeof (zap_cursor_t), KM_SLEEP); zc = kmem_zalloc(sizeof (zap_cursor_t), KM_SLEEP);
za = kmem_zalloc(sizeof (zap_attribute_t), KM_SLEEP); za = zap_attribute_alloc();
for (zap_cursor_init(zc, spa->spa_meta_objset, zap_clone); for (zap_cursor_init(zc, spa->spa_meta_objset, zap_clone);
zap_cursor_retrieve(zc, za) == 0; zap_cursor_retrieve(zc, za) == 0;
@ -463,7 +463,7 @@ check_filesystem(spa_t *spa, uint64_t head_ds, zbookmark_err_phys_t *zep,
} }
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
kmem_free(zc, sizeof (*zc)); kmem_free(zc, sizeof (*zc));
out: out:
@ -617,10 +617,10 @@ spa_add_healed_error(spa_t *spa, uint64_t obj, zbookmark_phys_t *healed_zb,
errphys_to_name(&healed_zep, name, sizeof (name)); errphys_to_name(&healed_zep, name, sizeof (name));
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, spa->spa_meta_objset, spa->spa_errlog_last); for (zap_cursor_init(&zc, spa->spa_meta_objset, spa->spa_errlog_last);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_advance(&zc)) { zap_cursor_retrieve(&zc, za) == 0; zap_cursor_advance(&zc)) {
if (zap_contains(spa->spa_meta_objset, za.za_first_integer, if (zap_contains(spa->spa_meta_objset, za->za_first_integer,
name) == 0) { name) == 0) {
if (!MUTEX_HELD(&spa->spa_errlog_lock)) { if (!MUTEX_HELD(&spa->spa_errlog_lock)) {
mutex_enter(&spa->spa_errlog_lock); mutex_enter(&spa->spa_errlog_lock);
@ -657,6 +657,7 @@ spa_add_healed_error(spa_t *spa, uint64_t obj, zbookmark_phys_t *healed_zb,
} }
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
/* /*
@ -704,24 +705,25 @@ spa_remove_healed_errors(spa_t *spa, avl_tree_t *s, avl_tree_t *l, dmu_tx_t *tx)
} else { } else {
errphys_to_name(&se->se_zep, name, sizeof (name)); errphys_to_name(&se->se_zep, name, sizeof (name));
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, spa->spa_meta_objset, for (zap_cursor_init(&zc, spa->spa_meta_objset,
spa->spa_errlog_last); spa->spa_errlog_last);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
zap_remove(spa->spa_meta_objset, zap_remove(spa->spa_meta_objset,
za.za_first_integer, name, tx); za->za_first_integer, name, tx);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
for (zap_cursor_init(&zc, spa->spa_meta_objset, for (zap_cursor_init(&zc, spa->spa_meta_objset,
spa->spa_errlog_scrub); spa->spa_errlog_scrub);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
zap_remove(spa->spa_meta_objset, zap_remove(spa->spa_meta_objset,
za.za_first_integer, name, tx); za->za_first_integer, name, tx);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
kmem_free(se, sizeof (spa_error_entry_t)); kmem_free(se, sizeof (spa_error_entry_t));
} }
@ -746,15 +748,16 @@ approx_errlog_size_impl(spa_t *spa, uint64_t spa_err_obj)
uint64_t total = 0; uint64_t total = 0;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, spa->spa_meta_objset, spa_err_obj); for (zap_cursor_init(&zc, spa->spa_meta_objset, spa_err_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_advance(&zc)) { zap_cursor_retrieve(&zc, za) == 0; zap_cursor_advance(&zc)) {
uint64_t count; uint64_t count;
if (zap_count(spa->spa_meta_objset, za.za_first_integer, if (zap_count(spa->spa_meta_objset, za->za_first_integer,
&count) == 0) &count) == 0)
total += count; total += count;
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
return (total); return (total);
} }
@ -806,7 +809,7 @@ sync_upgrade_errlog(spa_t *spa, uint64_t spa_err_obj, uint64_t *newobj,
dmu_tx_t *tx) dmu_tx_t *tx)
{ {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
zbookmark_phys_t zb; zbookmark_phys_t zb;
uint64_t count; uint64_t count;
@ -822,14 +825,15 @@ sync_upgrade_errlog(spa_t *spa, uint64_t spa_err_obj, uint64_t *newobj,
return; return;
} }
za = zap_attribute_alloc();
for (zap_cursor_init(&zc, spa->spa_meta_objset, spa_err_obj); for (zap_cursor_init(&zc, spa->spa_meta_objset, spa_err_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
if (spa_upgrade_errlog_limit != 0 && if (spa_upgrade_errlog_limit != 0 &&
zc.zc_cd == spa_upgrade_errlog_limit) zc.zc_cd == spa_upgrade_errlog_limit)
break; break;
name_to_bookmark(za.za_name, &zb); name_to_bookmark(za->za_name, &zb);
zbookmark_err_phys_t zep; zbookmark_err_phys_t zep;
zep.zb_object = zb.zb_object; zep.zb_object = zb.zb_object;
@ -909,6 +913,7 @@ sync_upgrade_errlog(spa_t *spa, uint64_t spa_err_obj, uint64_t *newobj,
buf, 1, strlen(name) + 1, name, tx); buf, 1, strlen(name) + 1, name, tx);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
VERIFY0(dmu_object_free(spa->spa_meta_objset, spa_err_obj, tx)); VERIFY0(dmu_object_free(spa->spa_meta_objset, spa_err_obj, tx));
} }
@ -954,7 +959,7 @@ process_error_log(spa_t *spa, uint64_t obj, void *uaddr, uint64_t *count)
zap_attribute_t *za; zap_attribute_t *za;
zc = kmem_zalloc(sizeof (zap_cursor_t), KM_SLEEP); zc = kmem_zalloc(sizeof (zap_cursor_t), KM_SLEEP);
za = kmem_zalloc(sizeof (zap_attribute_t), KM_SLEEP); za = zap_attribute_alloc();
if (!spa_feature_is_enabled(spa, SPA_FEATURE_HEAD_ERRLOG)) { if (!spa_feature_is_enabled(spa, SPA_FEATURE_HEAD_ERRLOG)) {
for (zap_cursor_init(zc, spa->spa_meta_objset, obj); for (zap_cursor_init(zc, spa->spa_meta_objset, obj);
@ -963,7 +968,7 @@ process_error_log(spa_t *spa, uint64_t obj, void *uaddr, uint64_t *count)
if (*count == 0) { if (*count == 0) {
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(zc, sizeof (*zc)); kmem_free(zc, sizeof (*zc));
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
return (SET_ERROR(ENOMEM)); return (SET_ERROR(ENOMEM));
} }
@ -974,13 +979,13 @@ process_error_log(spa_t *spa, uint64_t obj, void *uaddr, uint64_t *count)
if (error != 0) { if (error != 0) {
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(zc, sizeof (*zc)); kmem_free(zc, sizeof (*zc));
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
return (error); return (error);
} }
} }
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(zc, sizeof (*zc)); kmem_free(zc, sizeof (*zc));
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
return (0); return (0);
} }
@ -992,7 +997,7 @@ process_error_log(spa_t *spa, uint64_t obj, void *uaddr, uint64_t *count)
zap_attribute_t *head_ds_attr; zap_attribute_t *head_ds_attr;
head_ds_cursor = kmem_zalloc(sizeof (zap_cursor_t), KM_SLEEP); head_ds_cursor = kmem_zalloc(sizeof (zap_cursor_t), KM_SLEEP);
head_ds_attr = kmem_zalloc(sizeof (zap_attribute_t), KM_SLEEP); head_ds_attr = zap_attribute_alloc();
uint64_t head_ds_err_obj = za->za_first_integer; uint64_t head_ds_err_obj = za->za_first_integer;
uint64_t head_ds; uint64_t head_ds;
@ -1010,20 +1015,20 @@ process_error_log(spa_t *spa, uint64_t obj, void *uaddr, uint64_t *count)
zap_cursor_fini(head_ds_cursor); zap_cursor_fini(head_ds_cursor);
kmem_free(head_ds_cursor, kmem_free(head_ds_cursor,
sizeof (*head_ds_cursor)); sizeof (*head_ds_cursor));
kmem_free(head_ds_attr, sizeof (*head_ds_attr)); zap_attribute_free(head_ds_attr);
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
kmem_free(zc, sizeof (*zc)); kmem_free(zc, sizeof (*zc));
return (error); return (error);
} }
} }
zap_cursor_fini(head_ds_cursor); zap_cursor_fini(head_ds_cursor);
kmem_free(head_ds_cursor, sizeof (*head_ds_cursor)); kmem_free(head_ds_cursor, sizeof (*head_ds_cursor));
kmem_free(head_ds_attr, sizeof (*head_ds_attr)); zap_attribute_free(head_ds_attr);
} }
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
kmem_free(zc, sizeof (*zc)); kmem_free(zc, sizeof (*zc));
return (0); return (0);
} }
@ -1230,14 +1235,15 @@ delete_errlog(spa_t *spa, uint64_t spa_err_obj, dmu_tx_t *tx)
{ {
if (spa_feature_is_enabled(spa, SPA_FEATURE_HEAD_ERRLOG)) { if (spa_feature_is_enabled(spa, SPA_FEATURE_HEAD_ERRLOG)) {
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, spa->spa_meta_objset, spa_err_obj); for (zap_cursor_init(&zc, spa->spa_meta_objset, spa_err_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_retrieve(&zc, za) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
VERIFY0(dmu_object_free(spa->spa_meta_objset, VERIFY0(dmu_object_free(spa->spa_meta_objset,
za.za_first_integer, tx)); za->za_first_integer, tx));
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
VERIFY0(dmu_object_free(spa->spa_meta_objset, spa_err_obj, tx)); VERIFY0(dmu_object_free(spa->spa_meta_objset, spa_err_obj, tx));
} }
@ -1339,20 +1345,21 @@ delete_dataset_errlog(spa_t *spa, uint64_t spa_err_obj, uint64_t ds,
return; return;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, spa->spa_meta_objset, spa_err_obj); for (zap_cursor_init(&zc, spa->spa_meta_objset, spa_err_obj);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_advance(&zc)) { zap_cursor_retrieve(&zc, za) == 0; zap_cursor_advance(&zc)) {
uint64_t head_ds; uint64_t head_ds;
name_to_object(za.za_name, &head_ds); name_to_object(za->za_name, &head_ds);
if (head_ds == ds) { if (head_ds == ds) {
(void) zap_remove(spa->spa_meta_objset, spa_err_obj, (void) zap_remove(spa->spa_meta_objset, spa_err_obj,
za.za_name, tx); za->za_name, tx);
VERIFY0(dmu_object_free(spa->spa_meta_objset, VERIFY0(dmu_object_free(spa->spa_meta_objset,
za.za_first_integer, tx)); za->za_first_integer, tx));
break; break;
} }
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
void void
@ -1435,22 +1442,23 @@ swap_errlog(spa_t *spa, uint64_t spa_err_obj, uint64_t new_head, uint64_t
} }
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
zbookmark_err_phys_t err_block; zbookmark_err_phys_t err_block;
for (zap_cursor_init(&zc, spa->spa_meta_objset, old_head_errlog); for (zap_cursor_init(&zc, spa->spa_meta_objset, old_head_errlog);
zap_cursor_retrieve(&zc, &za) == 0; zap_cursor_advance(&zc)) { zap_cursor_retrieve(&zc, za) == 0; zap_cursor_advance(&zc)) {
const char *name = ""; const char *name = "";
name_to_errphys(za.za_name, &err_block); name_to_errphys(za->za_name, &err_block);
if (err_block.zb_birth < txg) { if (err_block.zb_birth < txg) {
(void) zap_update(spa->spa_meta_objset, new_head_errlog, (void) zap_update(spa->spa_meta_objset, new_head_errlog,
za.za_name, 1, strlen(name) + 1, name, tx); za->za_name, 1, strlen(name) + 1, name, tx);
(void) zap_remove(spa->spa_meta_objset, old_head_errlog, (void) zap_remove(spa->spa_meta_objset, old_head_errlog,
za.za_name, tx); za->za_name, tx);
} }
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
void void

9
module/zfs/spa_log_spacemap.c
View File

@ -1020,16 +1020,17 @@ spa_ld_log_sm_metadata(spa_t *spa)
} }
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, spa_meta_objset(spa), spacemap_zap); for (zap_cursor_init(&zc, spa_meta_objset(spa), spacemap_zap);
(error = zap_cursor_retrieve(&zc, &za)) == 0; (error = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
uint64_t log_txg = zfs_strtonum(za.za_name, NULL); uint64_t log_txg = zfs_strtonum(za->za_name, NULL);
spa_log_sm_t *sls = spa_log_sm_t *sls =
spa_log_sm_alloc(za.za_first_integer, log_txg); spa_log_sm_alloc(za->za_first_integer, log_txg);
avl_add(&spa->spa_sm_logs_by_txg, sls); avl_add(&spa->spa_sm_logs_by_txg, sls);
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
if (error != ENOENT) { if (error != ENOENT) {
spa_load_failed(spa, "spa_ld_log_sm_metadata(): failed at " spa_load_failed(spa, "spa_ld_log_sm_metadata(): failed at "
"zap_cursor_retrieve(spacemap_zap) [error %d]", "zap_cursor_retrieve(spacemap_zap) [error %d]",

2
module/zfs/spa_misc.c
View File

@ -2590,6 +2590,7 @@ spa_init(spa_mode_t mode)
scan_init(); scan_init();
qat_init(); qat_init();
spa_import_progress_init(); spa_import_progress_init();
zap_init();
} }
void void
@ -2616,6 +2617,7 @@ spa_fini(void)
scan_fini(); scan_fini();
qat_fini(); qat_fini();
spa_import_progress_destroy(); spa_import_progress_destroy();
zap_fini();
avl_destroy(&spa_namespace_avl); avl_destroy(&spa_namespace_avl);
avl_destroy(&spa_spare_avl); avl_destroy(&spa_spare_avl);

19
module/zfs/vdev.c
View File

@ -6475,33 +6475,33 @@ vdev_prop_get(vdev_t *vd, nvlist_t *innvl, nvlist_t *outnvl)
* Get all properties from the MOS vdev property object. * Get all properties from the MOS vdev property object.
*/ */
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, mos, objid); for (zap_cursor_init(&zc, mos, objid);
(err = zap_cursor_retrieve(&zc, &za)) == 0; (err = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
intval = 0; intval = 0;
strval = NULL; strval = NULL;
zprop_source_t src = ZPROP_SRC_DEFAULT; zprop_source_t src = ZPROP_SRC_DEFAULT;
propname = za.za_name; propname = za->za_name;
switch (za.za_integer_length) { switch (za->za_integer_length) {
case 8: case 8:
/* We do not allow integer user properties */ /* We do not allow integer user properties */
/* This is likely an internal value */ /* This is likely an internal value */
break; break;
case 1: case 1:
/* string property */ /* string property */
strval = kmem_alloc(za.za_num_integers, strval = kmem_alloc(za->za_num_integers,
KM_SLEEP); KM_SLEEP);
err = zap_lookup(mos, objid, za.za_name, 1, err = zap_lookup(mos, objid, za->za_name, 1,
za.za_num_integers, strval); za->za_num_integers, strval);
if (err) { if (err) {
kmem_free(strval, za.za_num_integers); kmem_free(strval, za->za_num_integers);
break; break;
} }
vdev_prop_add_list(outnvl, propname, strval, 0, vdev_prop_add_list(outnvl, propname, strval, 0,
src); src);
kmem_free(strval, za.za_num_integers); kmem_free(strval, za->za_num_integers);
break; break;
default: default:
@ -6509,6 +6509,7 @@ vdev_prop_get(vdev_t *vd, nvlist_t *innvl, nvlist_t *outnvl)
} }
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
} }
mutex_exit(&spa->spa_props_lock); mutex_exit(&spa->spa_props_lock);

18
module/zfs/zap.c
View File

@ -1110,7 +1110,7 @@ zap_value_search(objset_t *os, uint64_t zapobj, uint64_t value, uint64_t mask,
if (mask == 0) if (mask == 0)
mask = -1ULL; mask = -1ULL;
zap_attribute_t *za = kmem_alloc(sizeof (*za), KM_SLEEP); zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, os, zapobj); for (zap_cursor_init(&zc, os, zapobj);
(err = zap_cursor_retrieve(&zc, za)) == 0; (err = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
@ -1120,7 +1120,7 @@ zap_value_search(objset_t *os, uint64_t zapobj, uint64_t value, uint64_t mask,
} }
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
return (err); return (err);
} }
@ -1130,7 +1130,7 @@ zap_join(objset_t *os, uint64_t fromobj, uint64_t intoobj, dmu_tx_t *tx)
zap_cursor_t zc; zap_cursor_t zc;
int err = 0; int err = 0;
zap_attribute_t *za = kmem_alloc(sizeof (*za), KM_SLEEP); zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, os, fromobj); for (zap_cursor_init(&zc, os, fromobj);
zap_cursor_retrieve(&zc, za) == 0; zap_cursor_retrieve(&zc, za) == 0;
(void) zap_cursor_advance(&zc)) { (void) zap_cursor_advance(&zc)) {
@ -1144,7 +1144,7 @@ zap_join(objset_t *os, uint64_t fromobj, uint64_t intoobj, dmu_tx_t *tx)
break; break;
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
return (err); return (err);
} }
@ -1155,7 +1155,7 @@ zap_join_key(objset_t *os, uint64_t fromobj, uint64_t intoobj,
zap_cursor_t zc; zap_cursor_t zc;
int err = 0; int err = 0;
zap_attribute_t *za = kmem_alloc(sizeof (*za), KM_SLEEP); zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, os, fromobj); for (zap_cursor_init(&zc, os, fromobj);
zap_cursor_retrieve(&zc, za) == 0; zap_cursor_retrieve(&zc, za) == 0;
(void) zap_cursor_advance(&zc)) { (void) zap_cursor_advance(&zc)) {
@ -1169,7 +1169,7 @@ zap_join_key(objset_t *os, uint64_t fromobj, uint64_t intoobj,
break; break;
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
return (err); return (err);
} }
@ -1180,7 +1180,7 @@ zap_join_increment(objset_t *os, uint64_t fromobj, uint64_t intoobj,
zap_cursor_t zc; zap_cursor_t zc;
int err = 0; int err = 0;
zap_attribute_t *za = kmem_alloc(sizeof (*za), KM_SLEEP); zap_attribute_t *za = zap_attribute_alloc();
for (zap_cursor_init(&zc, os, fromobj); for (zap_cursor_init(&zc, os, fromobj);
zap_cursor_retrieve(&zc, za) == 0; zap_cursor_retrieve(&zc, za) == 0;
(void) zap_cursor_advance(&zc)) { (void) zap_cursor_advance(&zc)) {
@ -1200,7 +1200,7 @@ zap_join_increment(objset_t *os, uint64_t fromobj, uint64_t intoobj,
break; break;
} }
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
kmem_free(za, sizeof (*za)); zap_attribute_free(za);
return (err); return (err);
} }
@ -1378,7 +1378,7 @@ again:
ASSERT(err == 0 || err == EOVERFLOW); ASSERT(err == 0 || err == EOVERFLOW);
} }
err = zap_entry_read_name(zap, &zeh, err = zap_entry_read_name(zap, &zeh,
sizeof (za->za_name), za->za_name); za->za_name_len, za->za_name);
ASSERT(err == 0); ASSERT(err == 0);
za->za_normalization_conflict = za->za_normalization_conflict =

50
module/zfs/zap_micro.c
View File

@ -164,10 +164,32 @@ zap_match(zap_name_t *zn, const char *matchname)
} }
} }
static kmem_cache_t *zap_name_cache;
static kmem_cache_t *zap_attr_cache;
void
zap_init(void)
{
zap_name_cache = kmem_cache_create("zap_name",
sizeof (zap_name_t) + ZAP_MAXNAMELEN, 0, NULL, NULL,
NULL, NULL, NULL, 0);
zap_attr_cache = kmem_cache_create("zap_attr_cache",
sizeof (zap_attribute_t) + ZAP_MAXNAMELEN, 0, NULL,
NULL, NULL, NULL, NULL, 0);
}
void
zap_fini(void)
{
kmem_cache_destroy(zap_name_cache);
kmem_cache_destroy(zap_attr_cache);
}
static zap_name_t * static zap_name_t *
zap_name_alloc(zap_t *zap) zap_name_alloc(zap_t *zap)
{ {
zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP); zap_name_t *zn = kmem_cache_alloc(zap_name_cache, KM_SLEEP);
zn->zn_zap = zap; zn->zn_zap = zap;
return (zn); return (zn);
} }
@ -175,7 +197,7 @@ zap_name_alloc(zap_t *zap)
void void
zap_name_free(zap_name_t *zn) zap_name_free(zap_name_t *zn)
{ {
kmem_free(zn, sizeof (zap_name_t)); kmem_cache_free(zap_name_cache, zn);
} }
static int static int
@ -188,6 +210,7 @@ zap_name_init_str(zap_name_t *zn, const char *key, matchtype_t mt)
zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1; zn->zn_key_orig_numints = strlen(zn->zn_key_orig) + 1;
zn->zn_matchtype = mt; zn->zn_matchtype = mt;
zn->zn_normflags = zap->zap_normflags; zn->zn_normflags = zap->zap_normflags;
zn->zn_normbuf_len = ZAP_MAXNAMELEN;
/* /*
* If we're dealing with a case sensitive lookup on a mixed or * If we're dealing with a case sensitive lookup on a mixed or
@ -244,7 +267,7 @@ zap_name_alloc_str(zap_t *zap, const char *key, matchtype_t mt)
static zap_name_t * static zap_name_t *
zap_name_alloc_uint64(zap_t *zap, const uint64_t *key, int numints) zap_name_alloc_uint64(zap_t *zap, const uint64_t *key, int numints)
{ {
zap_name_t *zn = kmem_alloc(sizeof (zap_name_t), KM_SLEEP); zap_name_t *zn = kmem_cache_alloc(zap_name_cache, KM_SLEEP);
ASSERT(zap->zap_normflags == 0); ASSERT(zap->zap_normflags == 0);
zn->zn_zap = zap; zn->zn_zap = zap;
@ -252,6 +275,7 @@ zap_name_alloc_uint64(zap_t *zap, const uint64_t *key, int numints)
zn->zn_key_orig = zn->zn_key_norm = key; zn->zn_key_orig = zn->zn_key_norm = key;
zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints; zn->zn_key_orig_numints = zn->zn_key_norm_numints = numints;
zn->zn_matchtype = 0; zn->zn_matchtype = 0;
zn->zn_normbuf_len = ZAP_MAXNAMELEN;
zn->zn_hash = zap_hash(zn); zn->zn_hash = zap_hash(zn);
return (zn); return (zn);
@ -1600,6 +1624,24 @@ zap_remove_uint64_by_dnode(dnode_t *dn, const uint64_t *key, int key_numints,
return (err); return (err);
} }
zap_attribute_t *
zap_attribute_alloc(void)
{
uint32_t len = ZAP_MAXNAMELEN;
zap_attribute_t *za;
za = kmem_cache_alloc(zap_attr_cache, KM_SLEEP);
za->za_name_len = len;
return (za);
}
void
zap_attribute_free(zap_attribute_t *za)
{
kmem_cache_free(zap_attr_cache, za);
}
/* /*
* Routines for iterating over the attributes. * Routines for iterating over the attributes.
*/ */
@ -1736,7 +1778,7 @@ zap_cursor_retrieve(zap_cursor_t *zc, zap_attribute_t *za)
za->za_num_integers = 1; za->za_num_integers = 1;
za->za_first_integer = mzep->mze_value; za->za_first_integer = mzep->mze_value;
(void) strlcpy(za->za_name, mzep->mze_name, (void) strlcpy(za->za_name, mzep->mze_name,
sizeof (za->za_name)); za->za_name_len);
zc->zc_hash = (uint64_t)mze->mze_hash << 32; zc->zc_hash = (uint64_t)mze->mze_hash << 32;
zc->zc_cd = mze->mze_cd; zc->zc_cd = mze->mze_cd;
err = 0; err = 0;

29
module/zfs/zcp_iter.c
View File

@ -54,7 +54,7 @@ zcp_clones_iter(lua_State *state)
uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2)); uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2));
dsl_pool_t *dp = zcp_run_info(state)->zri_pool; dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
dsl_dataset_t *ds, *clone; dsl_dataset_t *ds, *clone;
zap_attribute_t za; zap_attribute_t *za;
zap_cursor_t zc; zap_cursor_t zc;
err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);
@ -75,9 +75,11 @@ zcp_clones_iter(lua_State *state)
dsl_dataset_phys(ds)->ds_next_clones_obj, cursor); dsl_dataset_phys(ds)->ds_next_clones_obj, cursor);
dsl_dataset_rele(ds, FTAG); dsl_dataset_rele(ds, FTAG);
err = zap_cursor_retrieve(&zc, &za); za = zap_attribute_alloc();
err = zap_cursor_retrieve(&zc, za);
if (err != 0) { if (err != 0) {
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
if (err != ENOENT) { if (err != ENOENT) {
return (luaL_error(state, return (luaL_error(state,
"unexpected error %d from zap_cursor_retrieve()", "unexpected error %d from zap_cursor_retrieve()",
@ -89,7 +91,8 @@ zcp_clones_iter(lua_State *state)
cursor = zap_cursor_serialize(&zc); cursor = zap_cursor_serialize(&zc);
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
err = dsl_dataset_hold_obj(dp, za.za_first_integer, FTAG, &clone); err = dsl_dataset_hold_obj(dp, za->za_first_integer, FTAG, &clone);
zap_attribute_free(za);
if (err != 0) { if (err != 0) {
return (luaL_error(state, return (luaL_error(state,
"unexpected error %d from " "unexpected error %d from "
@ -499,7 +502,7 @@ zcp_bookmarks_iter(lua_State *state)
uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2)); uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2));
dsl_pool_t *dp = zcp_run_info(state)->zri_pool; dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
dsl_dataset_t *ds; dsl_dataset_t *ds;
zap_attribute_t za; zap_attribute_t *za;
zap_cursor_t zc; zap_cursor_t zc;
int err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); int err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);
@ -536,9 +539,11 @@ zcp_bookmarks_iter(lua_State *state)
ds->ds_bookmarks_obj, cursor); ds->ds_bookmarks_obj, cursor);
dsl_dataset_rele(ds, FTAG); dsl_dataset_rele(ds, FTAG);
err = zap_cursor_retrieve(&zc, &za); za = zap_attribute_alloc();
err = zap_cursor_retrieve(&zc, za);
if (err != 0) { if (err != 0) {
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
if (err != ENOENT) { if (err != ENOENT) {
return (luaL_error(state, return (luaL_error(state,
"unexpected error %d from zap_cursor_retrieve()", "unexpected error %d from zap_cursor_retrieve()",
@ -552,7 +557,8 @@ zcp_bookmarks_iter(lua_State *state)
/* Create the full "pool/fs#bookmark" string to return */ /* Create the full "pool/fs#bookmark" string to return */
int n = snprintf(bookmark_name, ZFS_MAX_DATASET_NAME_LEN, "%s#%s", int n = snprintf(bookmark_name, ZFS_MAX_DATASET_NAME_LEN, "%s#%s",
ds_name, za.za_name); ds_name, za->za_name);
zap_attribute_free(za);
if (n >= ZFS_MAX_DATASET_NAME_LEN) { if (n >= ZFS_MAX_DATASET_NAME_LEN) {
return (luaL_error(state, return (luaL_error(state,
"unexpected error %d from snprintf()", ENAMETOOLONG)); "unexpected error %d from snprintf()", ENAMETOOLONG));
@ -610,7 +616,7 @@ zcp_holds_iter(lua_State *state)
uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2)); uint64_t cursor = lua_tonumber(state, lua_upvalueindex(2));
dsl_pool_t *dp = zcp_run_info(state)->zri_pool; dsl_pool_t *dp = zcp_run_info(state)->zri_pool;
dsl_dataset_t *ds; dsl_dataset_t *ds;
zap_attribute_t za; zap_attribute_t *za;
zap_cursor_t zc; zap_cursor_t zc;
int err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds); int err = dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds);
@ -631,9 +637,11 @@ zcp_holds_iter(lua_State *state)
dsl_dataset_phys(ds)->ds_userrefs_obj, cursor); dsl_dataset_phys(ds)->ds_userrefs_obj, cursor);
dsl_dataset_rele(ds, FTAG); dsl_dataset_rele(ds, FTAG);
err = zap_cursor_retrieve(&zc, &za); za = zap_attribute_alloc();
err = zap_cursor_retrieve(&zc, za);
if (err != 0) { if (err != 0) {
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
if (err != ENOENT) { if (err != ENOENT) {
return (luaL_error(state, return (luaL_error(state,
"unexpected error %d from zap_cursor_retrieve()", "unexpected error %d from zap_cursor_retrieve()",
@ -648,8 +656,9 @@ zcp_holds_iter(lua_State *state)
lua_pushnumber(state, cursor); lua_pushnumber(state, cursor);
lua_replace(state, lua_upvalueindex(2)); lua_replace(state, lua_upvalueindex(2));
(void) lua_pushstring(state, za.za_name); (void) lua_pushstring(state, za->za_name);
(void) lua_pushnumber(state, za.za_first_integer); (void) lua_pushnumber(state, za->za_first_integer);
zap_attribute_free(za);
return (2); return (2);
} }

4
module/zfs/zfeature.c
View File

@ -183,7 +183,7 @@ spa_features_check(spa_t *spa, boolean_t for_write,
char *buf; char *buf;
zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP); zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);
za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); za = zap_attribute_alloc();
buf = kmem_alloc(MAXPATHLEN, KM_SLEEP); buf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
supported = B_TRUE; supported = B_TRUE;
@ -217,7 +217,7 @@ spa_features_check(spa_t *spa, boolean_t for_write,
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(buf, MAXPATHLEN); kmem_free(buf, MAXPATHLEN);
kmem_free(za, sizeof (zap_attribute_t)); zap_attribute_free(za);
kmem_free(zc, sizeof (zap_cursor_t)); kmem_free(zc, sizeof (zap_cursor_t));
return (supported); return (supported);

12
module/zfs/zfs_quota.c
View File

@ -165,7 +165,7 @@ zfs_userspace_many(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
{ {
int error; int error;
zap_cursor_t zc; zap_cursor_t zc;
zap_attribute_t za; zap_attribute_t *za;
zfs_useracct_t *buf = vbuf; zfs_useracct_t *buf = vbuf;
uint64_t obj; uint64_t obj;
int offset = 0; int offset = 0;
@ -196,8 +196,9 @@ zfs_userspace_many(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
type == ZFS_PROP_PROJECTOBJUSED) type == ZFS_PROP_PROJECTOBJUSED)
offset = DMU_OBJACCT_PREFIX_LEN; offset = DMU_OBJACCT_PREFIX_LEN;
za = zap_attribute_alloc();
for (zap_cursor_init_serialized(&zc, zfsvfs->z_os, obj, *cookiep); for (zap_cursor_init_serialized(&zc, zfsvfs->z_os, obj, *cookiep);
(error = zap_cursor_retrieve(&zc, &za)) == 0; (error = zap_cursor_retrieve(&zc, za)) == 0;
zap_cursor_advance(&zc)) { zap_cursor_advance(&zc)) {
if ((uintptr_t)buf - (uintptr_t)vbuf + sizeof (zfs_useracct_t) > if ((uintptr_t)buf - (uintptr_t)vbuf + sizeof (zfs_useracct_t) >
*bufsizep) *bufsizep)
@ -207,14 +208,14 @@ zfs_userspace_many(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
* skip object quota (with zap name prefix DMU_OBJACCT_PREFIX) * skip object quota (with zap name prefix DMU_OBJACCT_PREFIX)
* when dealing with block quota and vice versa. * when dealing with block quota and vice versa.
*/ */
if ((offset > 0) != (strncmp(za.za_name, DMU_OBJACCT_PREFIX, if ((offset > 0) != (strncmp(za->za_name, DMU_OBJACCT_PREFIX,
DMU_OBJACCT_PREFIX_LEN) == 0)) DMU_OBJACCT_PREFIX_LEN) == 0))
continue; continue;
fuidstr_to_sid(zfsvfs, za.za_name + offset, fuidstr_to_sid(zfsvfs, za->za_name + offset,
buf->zu_domain, sizeof (buf->zu_domain), &buf->zu_rid); buf->zu_domain, sizeof (buf->zu_domain), &buf->zu_rid);
buf->zu_space = za.za_first_integer; buf->zu_space = za->za_first_integer;
buf++; buf++;
} }
if (error == ENOENT) if (error == ENOENT)
@ -224,6 +225,7 @@ zfs_userspace_many(zfsvfs_t *zfsvfs, zfs_userquota_prop_t type,
*bufsizep = (uintptr_t)buf - (uintptr_t)vbuf; *bufsizep = (uintptr_t)buf - (uintptr_t)vbuf;
*cookiep = zap_cursor_serialize(&zc); *cookiep = zap_cursor_serialize(&zc);
zap_cursor_fini(&zc); zap_cursor_fini(&zc);
zap_attribute_free(za);
return (error); return (error);
} }

4
module/zfs/zvol.c
View File

@ -1034,7 +1034,7 @@ zvol_add_clones(const char *dsname, list_t *minors_list)
goto out; goto out;
zap_cursor_t *zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP); zap_cursor_t *zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);
zap_attribute_t *za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP); zap_attribute_t *za = zap_attribute_alloc();
objset_t *mos = dd->dd_pool->dp_meta_objset; objset_t *mos = dd->dd_pool->dp_meta_objset;
for (zap_cursor_init(zc, mos, dsl_dir_phys(dd)->dd_clones); for (zap_cursor_init(zc, mos, dsl_dir_phys(dd)->dd_clones);
@ -1060,7 +1060,7 @@ zvol_add_clones(const char *dsname, list_t *minors_list)
} }
} }
zap_cursor_fini(zc); zap_cursor_fini(zc);
kmem_free(za, sizeof (zap_attribute_t)); zap_attribute_free(za);
kmem_free(zc, sizeof (zap_cursor_t)); kmem_free(zc, sizeof (zap_cursor_t));
out: out: