7801 add more by-dnode routines
illumos/illumos-gate@b0c42cd470
b0c42cd470
https://www.illumos.org/issues/7801
Add *_by_dnode() routines for accessing objects given their
dnode_t *, this is more efficient than accessing the object by
(objset_t *, uint64_t object). This change converts some but
not all of the existing consumers. As performance-sensitive
code paths are discovered they should be converted to use
these routines.
Ported from: https://github.com/zfsonlinux/zfs/commit/
0eef1bde31d67091d3deed23fe2394f5a8bf2276
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
Reviewed by: Brian Behlendorf <behlendorf1@llnl.gov>
Reviewed by: Pavel Zakharov <pavel.zakharov@delphix.com>
Approved by: Robert Mustacchi <rm@joyent.com>
Author: bzzz77 <bzzz.tomas@gmail.com>
This commit is contained in:
Andriy Gapon
parent
c9327351e8
commit
fd870ba29a
@ -871,17 +871,12 @@ dmu_free_range(objset_t *os, uint64_t object, uint64_t offset,
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
|
||||
static int
|
||||
dmu_read_impl(dnode_t *dn, uint64_t offset, uint64_t size,
|
||||
void *buf, uint32_t flags)
|
||||
{
|
||||
dnode_t *dn;
|
||||
dmu_buf_t **dbp;
|
||||
int numbufs, err;
|
||||
|
||||
err = dnode_hold(os, object, FTAG, &dn);
|
||||
if (err)
|
||||
return (err);
|
||||
int numbufs, err = 0;
|
||||
|
||||
/*
|
||||
* Deal with odd block sizes, where there can't be data past the first
|
||||
@ -926,22 +921,37 @@ dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
|
||||
}
|
||||
dmu_buf_rele_array(dbp, numbufs, FTAG);
|
||||
}
|
||||
return (err);
|
||||
}
|
||||
|
||||
int
|
||||
dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
|
||||
void *buf, uint32_t flags)
|
||||
{
|
||||
dnode_t *dn;
|
||||
int err;
|
||||
|
||||
err = dnode_hold(os, object, FTAG, &dn);
|
||||
if (err != 0)
|
||||
return (err);
|
||||
|
||||
err = dmu_read_impl(dn, offset, size, buf, flags);
|
||||
dnode_rele(dn, FTAG);
|
||||
return (err);
|
||||
}
|
||||
|
||||
void
|
||||
dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
|
||||
int
|
||||
dmu_read_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size, void *buf,
|
||||
uint32_t flags)
|
||||
{
|
||||
return (dmu_read_impl(dn, offset, size, buf, flags));
|
||||
}
|
||||
|
||||
static void
|
||||
dmu_write_impl(dmu_buf_t **dbp, int numbufs, uint64_t offset, uint64_t size,
|
||||
const void *buf, dmu_tx_t *tx)
|
||||
{
|
||||
dmu_buf_t **dbp;
|
||||
int numbufs, i;
|
||||
|
||||
if (size == 0)
|
||||
return;
|
||||
|
||||
VERIFY(0 == dmu_buf_hold_array(os, object, offset, size,
|
||||
FALSE, FTAG, &numbufs, &dbp));
|
||||
int i;
|
||||
|
||||
for (i = 0; i < numbufs; i++) {
|
||||
int tocpy;
|
||||
@ -969,6 +979,37 @@ dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
|
||||
size -= tocpy;
|
||||
buf = (char *)buf + tocpy;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
|
||||
const void *buf, dmu_tx_t *tx)
|
||||
{
|
||||
dmu_buf_t **dbp;
|
||||
int numbufs;
|
||||
|
||||
if (size == 0)
|
||||
return;
|
||||
|
||||
VERIFY0(dmu_buf_hold_array(os, object, offset, size,
|
||||
FALSE, FTAG, &numbufs, &dbp));
|
||||
dmu_write_impl(dbp, numbufs, offset, size, buf, tx);
|
||||
dmu_buf_rele_array(dbp, numbufs, FTAG);
|
||||
}
|
||||
|
||||
void
|
||||
dmu_write_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size,
|
||||
const void *buf, dmu_tx_t *tx)
|
||||
{
|
||||
dmu_buf_t **dbp;
|
||||
int numbufs;
|
||||
|
||||
if (size == 0)
|
||||
return;
|
||||
|
||||
VERIFY0(dmu_buf_hold_array_by_dnode(dn, offset, size,
|
||||
FALSE, FTAG, &numbufs, &dbp, DMU_READ_PREFETCH));
|
||||
dmu_write_impl(dbp, numbufs, offset, size, buf, tx);
|
||||
dmu_buf_rele_array(dbp, numbufs, FTAG);
|
||||
}
|
||||
|
||||
|
||||
@ -93,11 +93,11 @@ dmu_object_alloc(objset_t *os, dmu_object_type_t ot, int blocksize,
|
||||
}
|
||||
|
||||
dnode_allocate(dn, ot, blocksize, 0, bonustype, bonuslen, tx);
|
||||
dnode_rele(dn, FTAG);
|
||||
|
||||
mutex_exit(&os->os_obj_lock);
|
||||
|
||||
dmu_tx_add_new_object(tx, os, object);
|
||||
dmu_tx_add_new_object(tx, dn);
|
||||
dnode_rele(dn, FTAG);
|
||||
|
||||
return (object);
|
||||
}
|
||||
|
||||
@ -115,9 +115,10 @@ dmu_object_claim(objset_t *os, uint64_t object, dmu_object_type_t ot,
|
||||
if (err)
|
||||
return (err);
|
||||
dnode_allocate(dn, ot, blocksize, 0, bonustype, bonuslen, tx);
|
||||
dmu_tx_add_new_object(tx, dn);
|
||||
|
||||
dnode_rele(dn, FTAG);
|
||||
|
||||
dmu_tx_add_new_object(tx, os, object);
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
||||
@ -93,21 +93,14 @@ dmu_tx_private_ok(dmu_tx_t *tx)
|
||||
}
|
||||
|
||||
static dmu_tx_hold_t *
|
||||
dmu_tx_hold_object_impl(dmu_tx_t *tx, objset_t *os, uint64_t object,
|
||||
enum dmu_tx_hold_type type, uint64_t arg1, uint64_t arg2)
|
||||
dmu_tx_hold_dnode_impl(dmu_tx_t *tx, dnode_t *dn, enum dmu_tx_hold_type type,
|
||||
uint64_t arg1, uint64_t arg2)
|
||||
{
|
||||
dmu_tx_hold_t *txh;
|
||||
dnode_t *dn = NULL;
|
||||
int err;
|
||||
|
||||
if (object != DMU_NEW_OBJECT) {
|
||||
err = dnode_hold(os, object, tx, &dn);
|
||||
if (err) {
|
||||
tx->tx_err = err;
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
if (err == 0 && tx->tx_txg != 0) {
|
||||
if (dn != NULL) {
|
||||
(void) refcount_add(&dn->dn_holds, tx);
|
||||
if (tx->tx_txg != 0) {
|
||||
mutex_enter(&dn->dn_mtx);
|
||||
/*
|
||||
* dn->dn_assigned_txg == tx->tx_txg doesn't pose a
|
||||
@ -134,17 +127,36 @@ dmu_tx_hold_object_impl(dmu_tx_t *tx, objset_t *os, uint64_t object,
|
||||
return (txh);
|
||||
}
|
||||
|
||||
static dmu_tx_hold_t *
|
||||
dmu_tx_hold_object_impl(dmu_tx_t *tx, objset_t *os, uint64_t object,
|
||||
enum dmu_tx_hold_type type, uint64_t arg1, uint64_t arg2)
|
||||
{
|
||||
dnode_t *dn = NULL;
|
||||
dmu_tx_hold_t *txh;
|
||||
int err;
|
||||
|
||||
if (object != DMU_NEW_OBJECT) {
|
||||
err = dnode_hold(os, object, FTAG, &dn);
|
||||
if (err != 0) {
|
||||
tx->tx_err = err;
|
||||
return (NULL);
|
||||
}
|
||||
}
|
||||
txh = dmu_tx_hold_dnode_impl(tx, dn, type, arg1, arg2);
|
||||
if (dn != NULL)
|
||||
dnode_rele(dn, FTAG);
|
||||
return (txh);
|
||||
}
|
||||
|
||||
void
|
||||
dmu_tx_add_new_object(dmu_tx_t *tx, objset_t *os, uint64_t object)
|
||||
dmu_tx_add_new_object(dmu_tx_t *tx, dnode_t *dn)
|
||||
{
|
||||
/*
|
||||
* If we're syncing, they can manipulate any object anyhow, and
|
||||
* the hold on the dnode_t can cause problems.
|
||||
*/
|
||||
if (!dmu_tx_is_syncing(tx)) {
|
||||
(void) dmu_tx_hold_object_impl(tx, os,
|
||||
object, THT_NEWOBJECT, 0, 0);
|
||||
}
|
||||
if (!dmu_tx_is_syncing(tx))
|
||||
(void) dmu_tx_hold_dnode_impl(tx, dn, THT_NEWOBJECT, 0, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -282,11 +294,26 @@ dmu_tx_hold_write(dmu_tx_t *tx, uint64_t object, uint64_t off, int len)
|
||||
|
||||
txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
|
||||
object, THT_WRITE, off, len);
|
||||
if (txh == NULL)
|
||||
return;
|
||||
if (txh != NULL) {
|
||||
dmu_tx_count_write(txh, off, len);
|
||||
dmu_tx_count_dnode(txh);
|
||||
}
|
||||
}
|
||||
|
||||
dmu_tx_count_write(txh, off, len);
|
||||
dmu_tx_count_dnode(txh);
|
||||
void
|
||||
dmu_tx_hold_write_by_dnode(dmu_tx_t *tx, dnode_t *dn, uint64_t off, int len)
|
||||
{
|
||||
dmu_tx_hold_t *txh;
|
||||
|
||||
ASSERT0(tx->tx_txg);
|
||||
ASSERT3U(len, <=, DMU_MAX_ACCESS);
|
||||
ASSERT(len == 0 || UINT64_MAX - off >= len - 1);
|
||||
|
||||
txh = dmu_tx_hold_dnode_impl(tx, dn, THT_WRITE, off, len);
|
||||
if (txh != NULL) {
|
||||
dmu_tx_count_write(txh, off, len);
|
||||
dmu_tx_count_dnode(txh);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@ -303,18 +330,18 @@ dmu_tx_mark_netfree(dmu_tx_t *tx)
|
||||
tx->tx_netfree = B_TRUE;
|
||||
}
|
||||
|
||||
void
|
||||
dmu_tx_hold_free(dmu_tx_t *tx, uint64_t object, uint64_t off, uint64_t len)
|
||||
static void
|
||||
dmu_tx_hold_free_impl(dmu_tx_hold_t *txh, uint64_t off, uint64_t len)
|
||||
{
|
||||
dmu_tx_t *tx;
|
||||
dnode_t *dn;
|
||||
int err;
|
||||
zio_t *zio;
|
||||
|
||||
tx = txh->txh_tx;
|
||||
ASSERT(tx->tx_txg == 0);
|
||||
|
||||
dmu_tx_hold_t *txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
|
||||
object, THT_FREE, off, len);
|
||||
if (txh == NULL)
|
||||
return;
|
||||
dnode_t *dn = txh->txh_dnode;
|
||||
dn = txh->txh_dnode;
|
||||
dmu_tx_count_dnode(txh);
|
||||
|
||||
if (off >= (dn->dn_maxblkid + 1) * dn->dn_datablksz)
|
||||
@ -395,17 +422,36 @@ dmu_tx_hold_free(dmu_tx_t *tx, uint64_t object, uint64_t off, uint64_t len)
|
||||
}
|
||||
|
||||
void
|
||||
dmu_tx_hold_zap(dmu_tx_t *tx, uint64_t object, int add, const char *name)
|
||||
dmu_tx_hold_free(dmu_tx_t *tx, uint64_t object, uint64_t off, uint64_t len)
|
||||
{
|
||||
dmu_tx_hold_t *txh;
|
||||
|
||||
txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
|
||||
object, THT_FREE, off, len);
|
||||
if (txh != NULL)
|
||||
(void) dmu_tx_hold_free_impl(txh, off, len);
|
||||
}
|
||||
|
||||
void
|
||||
dmu_tx_hold_free_by_dnode(dmu_tx_t *tx, dnode_t *dn, uint64_t off, uint64_t len)
|
||||
{
|
||||
dmu_tx_hold_t *txh;
|
||||
|
||||
txh = dmu_tx_hold_dnode_impl(tx, dn, THT_FREE, off, len);
|
||||
if (txh != NULL)
|
||||
(void) dmu_tx_hold_free_impl(txh, off, len);
|
||||
}
|
||||
|
||||
static void
|
||||
dmu_tx_hold_zap_impl(dmu_tx_hold_t *txh, int add, const char *name)
|
||||
{
|
||||
dmu_tx_t *tx = txh->txh_tx;
|
||||
dnode_t *dn;
|
||||
int err;
|
||||
|
||||
ASSERT(tx->tx_txg == 0);
|
||||
|
||||
dmu_tx_hold_t *txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
|
||||
object, THT_ZAP, add, (uintptr_t)name);
|
||||
if (txh == NULL)
|
||||
return;
|
||||
dnode_t *dn = txh->txh_dnode;
|
||||
dn = txh->txh_dnode;
|
||||
|
||||
dmu_tx_count_dnode(txh);
|
||||
|
||||
@ -448,6 +494,32 @@ dmu_tx_hold_zap(dmu_tx_t *tx, uint64_t object, int add, const char *name)
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
dmu_tx_hold_zap(dmu_tx_t *tx, uint64_t object, int add, const char *name)
|
||||
{
|
||||
dmu_tx_hold_t *txh;
|
||||
|
||||
ASSERT0(tx->tx_txg);
|
||||
|
||||
txh = dmu_tx_hold_object_impl(tx, tx->tx_objset,
|
||||
object, THT_ZAP, add, (uintptr_t)name);
|
||||
if (txh != NULL)
|
||||
dmu_tx_hold_zap_impl(txh, add, name);
|
||||
}
|
||||
|
||||
void
|
||||
dmu_tx_hold_zap_by_dnode(dmu_tx_t *tx, dnode_t *dn, int add, const char *name)
|
||||
{
|
||||
dmu_tx_hold_t *txh;
|
||||
|
||||
ASSERT0(tx->tx_txg);
|
||||
ASSERT(dn != NULL);
|
||||
|
||||
txh = dmu_tx_hold_dnode_impl(tx, dn, THT_ZAP, add, (uintptr_t)name);
|
||||
if (txh != NULL)
|
||||
dmu_tx_hold_zap_impl(txh, add, name);
|
||||
}
|
||||
|
||||
void
|
||||
dmu_tx_hold_bonus(dmu_tx_t *tx, uint64_t object)
|
||||
{
|
||||
@ -461,6 +533,18 @@ dmu_tx_hold_bonus(dmu_tx_t *tx, uint64_t object)
|
||||
dmu_tx_count_dnode(txh);
|
||||
}
|
||||
|
||||
void
|
||||
dmu_tx_hold_bonus_by_dnode(dmu_tx_t *tx, dnode_t *dn)
|
||||
{
|
||||
dmu_tx_hold_t *txh;
|
||||
|
||||
ASSERT0(tx->tx_txg);
|
||||
|
||||
txh = dmu_tx_hold_dnode_impl(tx, dn, THT_BONUS, 0, 0);
|
||||
if (txh)
|
||||
dmu_tx_count_dnode(txh);
|
||||
}
|
||||
|
||||
void
|
||||
dmu_tx_hold_space(dmu_tx_t *tx, uint64_t space)
|
||||
{
|
||||
|
||||
@ -667,10 +667,17 @@ void dmu_buf_will_dirty(dmu_buf_t *db, dmu_tx_t *tx);
|
||||
|
||||
dmu_tx_t *dmu_tx_create(objset_t *os);
|
||||
void dmu_tx_hold_write(dmu_tx_t *tx, uint64_t object, uint64_t off, int len);
|
||||
void dmu_tx_hold_write_by_dnode(dmu_tx_t *tx, dnode_t *dn, uint64_t off,
|
||||
int len);
|
||||
void dmu_tx_hold_free(dmu_tx_t *tx, uint64_t object, uint64_t off,
|
||||
uint64_t len);
|
||||
void dmu_tx_hold_free_by_dnode(dmu_tx_t *tx, dnode_t *dn, uint64_t off,
|
||||
uint64_t len);
|
||||
void dmu_tx_hold_zap(dmu_tx_t *tx, uint64_t object, int add, const char *name);
|
||||
void dmu_tx_hold_zap_by_dnode(dmu_tx_t *tx, dnode_t *dn, int add,
|
||||
const char *name);
|
||||
void dmu_tx_hold_bonus(dmu_tx_t *tx, uint64_t object);
|
||||
void dmu_tx_hold_bonus_by_dnode(dmu_tx_t *tx, dnode_t *dn);
|
||||
void dmu_tx_hold_spill(dmu_tx_t *tx, uint64_t object);
|
||||
void dmu_tx_hold_sa(dmu_tx_t *tx, struct sa_handle *hdl, boolean_t may_grow);
|
||||
void dmu_tx_hold_sa_create(dmu_tx_t *tx, int total_size);
|
||||
@ -720,8 +727,12 @@ int dmu_free_long_object(objset_t *os, uint64_t object);
|
||||
#define DMU_READ_NO_PREFETCH 1 /* don't prefetch */
|
||||
int dmu_read(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
|
||||
void *buf, uint32_t flags);
|
||||
int dmu_read_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size, void *buf,
|
||||
uint32_t flags);
|
||||
void dmu_write(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
|
||||
const void *buf, dmu_tx_t *tx);
|
||||
void dmu_write_by_dnode(dnode_t *dn, uint64_t offset, uint64_t size,
|
||||
const void *buf, dmu_tx_t *tx);
|
||||
void dmu_prealloc(objset_t *os, uint64_t object, uint64_t offset, uint64_t size,
|
||||
dmu_tx_t *tx);
|
||||
int dmu_read_uio(objset_t *os, uint64_t object, struct uio *uio, uint64_t size);
|
||||
|
||||
@ -136,7 +136,7 @@ extern dmu_tx_t *dmu_tx_create_assigned(struct dsl_pool *dp, uint64_t txg);
|
||||
dmu_tx_t *dmu_tx_create_dd(dsl_dir_t *dd);
|
||||
int dmu_tx_is_syncing(dmu_tx_t *tx);
|
||||
int dmu_tx_private_ok(dmu_tx_t *tx);
|
||||
void dmu_tx_add_new_object(dmu_tx_t *tx, objset_t *os, uint64_t object);
|
||||
void dmu_tx_add_new_object(dmu_tx_t *tx, dnode_t *dn);
|
||||
void dmu_tx_dirty_buf(dmu_tx_t *tx, struct dmu_buf_impl *db);
|
||||
void dmu_tx_hold_space(dmu_tx_t *tx, uint64_t space);
|
||||
|
||||
|
||||
@ -220,6 +220,9 @@ int zap_count_write_by_dnode(dnode_t *dn, const char *name,
|
||||
int zap_add(objset_t *ds, uint64_t zapobj, const char *key,
|
||||
int integer_size, uint64_t num_integers,
|
||||
const void *val, dmu_tx_t *tx);
|
||||
int zap_add_by_dnode(dnode_t *dn, const char *key,
|
||||
int integer_size, uint64_t num_integers,
|
||||
const void *val, dmu_tx_t *tx);
|
||||
int zap_add_uint64(objset_t *ds, uint64_t zapobj, const uint64_t *key,
|
||||
int key_numints, int integer_size, uint64_t num_integers,
|
||||
const void *val, dmu_tx_t *tx);
|
||||
@ -259,6 +262,7 @@ int zap_length_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key,
|
||||
int zap_remove(objset_t *ds, uint64_t zapobj, const char *name, dmu_tx_t *tx);
|
||||
int zap_remove_norm(objset_t *ds, uint64_t zapobj, const char *name,
|
||||
matchtype_t mt, dmu_tx_t *tx);
|
||||
int zap_remove_by_dnode(dnode_t *dn, const char *name, dmu_tx_t *tx);
|
||||
int zap_remove_uint64(objset_t *os, uint64_t zapobj, const uint64_t *key,
|
||||
int key_numints, dmu_tx_t *tx);
|
||||
|
||||
|
||||
@ -1109,34 +1109,30 @@ mzap_addent(zap_name_t *zn, uint64_t value)
|
||||
ASSERT(!"out of entries!");
|
||||
}
|
||||
|
||||
int
|
||||
zap_add(objset_t *os, uint64_t zapobj, const char *key,
|
||||
static int
|
||||
zap_add_impl(zap_t *zap, const char *key,
|
||||
int integer_size, uint64_t num_integers,
|
||||
const void *val, dmu_tx_t *tx)
|
||||
const void *val, dmu_tx_t *tx, void *tag)
|
||||
{
|
||||
zap_t *zap;
|
||||
int err;
|
||||
int err = 0;
|
||||
mzap_ent_t *mze;
|
||||
const uint64_t *intval = val;
|
||||
zap_name_t *zn;
|
||||
|
||||
err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
|
||||
if (err)
|
||||
return (err);
|
||||
zn = zap_name_alloc(zap, key, 0);
|
||||
if (zn == NULL) {
|
||||
zap_unlockdir(zap, FTAG);
|
||||
zap_unlockdir(zap, tag);
|
||||
return (SET_ERROR(ENOTSUP));
|
||||
}
|
||||
if (!zap->zap_ismicro) {
|
||||
err = fzap_add(zn, integer_size, num_integers, val, FTAG, tx);
|
||||
err = fzap_add(zn, integer_size, num_integers, val, tag, tx);
|
||||
zap = zn->zn_zap; /* fzap_add() may change zap */
|
||||
} else if (integer_size != 8 || num_integers != 1 ||
|
||||
strlen(key) >= MZAP_NAME_LEN) {
|
||||
err = mzap_upgrade(&zn->zn_zap, FTAG, tx, 0);
|
||||
err = mzap_upgrade(&zn->zn_zap, tag, tx, 0);
|
||||
if (err == 0) {
|
||||
err = fzap_add(zn, integer_size, num_integers, val,
|
||||
FTAG, tx);
|
||||
tag, tx);
|
||||
}
|
||||
zap = zn->zn_zap; /* fzap_add() may change zap */
|
||||
} else {
|
||||
@ -1150,7 +1146,39 @@ zap_add(objset_t *os, uint64_t zapobj, const char *key,
|
||||
ASSERT(zap == zn->zn_zap);
|
||||
zap_name_free(zn);
|
||||
if (zap != NULL) /* may be NULL if fzap_add() failed */
|
||||
zap_unlockdir(zap, FTAG);
|
||||
zap_unlockdir(zap, tag);
|
||||
return (err);
|
||||
}
|
||||
|
||||
int
|
||||
zap_add(objset_t *os, uint64_t zapobj, const char *key,
|
||||
int integer_size, uint64_t num_integers,
|
||||
const void *val, dmu_tx_t *tx)
|
||||
{
|
||||
zap_t *zap;
|
||||
int err;
|
||||
|
||||
err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
|
||||
if (err != 0)
|
||||
return (err);
|
||||
err = zap_add_impl(zap, key, integer_size, num_integers, val, tx, FTAG);
|
||||
/* zap_add_impl() calls zap_unlockdir() */
|
||||
return (err);
|
||||
}
|
||||
|
||||
int
|
||||
zap_add_by_dnode(dnode_t *dn, const char *key,
|
||||
int integer_size, uint64_t num_integers,
|
||||
const void *val, dmu_tx_t *tx)
|
||||
{
|
||||
zap_t *zap;
|
||||
int err;
|
||||
|
||||
err = zap_lockdir_by_dnode(dn, tx, RW_WRITER, TRUE, TRUE, FTAG, &zap);
|
||||
if (err != 0)
|
||||
return (err);
|
||||
err = zap_add_impl(zap, key, integer_size, num_integers, val, tx, FTAG);
|
||||
/* zap_add_impl() calls zap_unlockdir() */
|
||||
return (err);
|
||||
}
|
||||
|
||||
@ -1268,23 +1296,17 @@ zap_remove(objset_t *os, uint64_t zapobj, const char *name, dmu_tx_t *tx)
|
||||
return (zap_remove_norm(os, zapobj, name, 0, tx));
|
||||
}
|
||||
|
||||
int
|
||||
zap_remove_norm(objset_t *os, uint64_t zapobj, const char *name,
|
||||
static int
|
||||
zap_remove_impl(zap_t *zap, const char *name,
|
||||
matchtype_t mt, dmu_tx_t *tx)
|
||||
{
|
||||
zap_t *zap;
|
||||
int err;
|
||||
mzap_ent_t *mze;
|
||||
zap_name_t *zn;
|
||||
int err = 0;
|
||||
|
||||
err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap);
|
||||
if (err)
|
||||
return (err);
|
||||
zn = zap_name_alloc(zap, name, mt);
|
||||
if (zn == NULL) {
|
||||
zap_unlockdir(zap, FTAG);
|
||||
if (zn == NULL)
|
||||
return (SET_ERROR(ENOTSUP));
|
||||
}
|
||||
if (!zap->zap_ismicro) {
|
||||
err = fzap_remove(zn, tx);
|
||||
} else {
|
||||
@ -1299,6 +1321,34 @@ zap_remove_norm(objset_t *os, uint64_t zapobj, const char *name,
|
||||
}
|
||||
}
|
||||
zap_name_free(zn);
|
||||
return (err);
|
||||
}
|
||||
|
||||
int
|
||||
zap_remove_norm(objset_t *os, uint64_t zapobj, const char *name,
|
||||
matchtype_t mt, dmu_tx_t *tx)
|
||||
{
|
||||
zap_t *zap;
|
||||
int err;
|
||||
|
||||
err = zap_lockdir(os, zapobj, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap);
|
||||
if (err)
|
||||
return (err);
|
||||
err = zap_remove_impl(zap, name, mt, tx);
|
||||
zap_unlockdir(zap, FTAG);
|
||||
return (err);
|
||||
}
|
||||
|
||||
int
|
||||
zap_remove_by_dnode(dnode_t *dn, const char *name, dmu_tx_t *tx)
|
||||
{
|
||||
zap_t *zap;
|
||||
int err;
|
||||
|
||||
err = zap_lockdir_by_dnode(dn, tx, RW_WRITER, TRUE, FALSE, FTAG, &zap);
|
||||
if (err)
|
||||
return (err);
|
||||
err = zap_remove_impl(zap, name, 0, tx);
|
||||
zap_unlockdir(zap, FTAG);
|
||||
return (err);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user