9539 Make zvol operations use _by_dnode routines
Continues what was started in 7801 add more by-dnode routines by fully converting zvols to avoid unnecessary dnode_hold() calls. This saves a small amount of CPU time and slightly improves latencies of operations on zvols. illumos/illumos-gate@8dfe5547fb Reviewed by: Matthew Ahrens <mahrens@delphix.com> Reviewed by: Brian Behlendorf <behlendorf1@llnl.gov> Reviewed by: Rick McNeal <rick.mcneal@nexenta.com> Approved by: Dan McDonald <danmcd@joyent.com> Author: Richard Yao <richard.yao@prophetstor.com>
This commit is contained in:
commit
3f586250d8
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=337181
@ -449,7 +449,7 @@ dmu_spill_hold_by_bonus(dmu_buf_t *bonus, void *tag, dmu_buf_t **dbp)
|
||||
* and can induce severe lock contention when writing to several files
|
||||
* whose dnodes are in the same block.
|
||||
*/
|
||||
static int
|
||||
int
|
||||
dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, uint64_t length,
|
||||
boolean_t read, void *tag, int *numbufsp, dmu_buf_t ***dbpp, uint32_t flags)
|
||||
{
|
||||
@ -1321,7 +1321,7 @@ xuio_stat_wbuf_nocopy(void)
|
||||
}
|
||||
|
||||
#ifdef _KERNEL
|
||||
static int
|
||||
int
|
||||
dmu_read_uio_dnode(dnode_t *dn, uio_t *uio, uint64_t size)
|
||||
{
|
||||
dmu_buf_t **dbp;
|
||||
@ -1437,7 +1437,7 @@ dmu_read_uio(objset_t *os, uint64_t object, uio_t *uio, uint64_t size)
|
||||
return (err);
|
||||
}
|
||||
|
||||
static int
|
||||
int
|
||||
dmu_write_uio_dnode(dnode_t *dn, uio_t *uio, uint64_t size, dmu_tx_t *tx)
|
||||
{
|
||||
dmu_buf_t **dbp;
|
||||
@ -1881,22 +1881,17 @@ dmu_return_arcbuf(arc_buf_t *buf)
|
||||
* dmu_write().
|
||||
*/
|
||||
void
|
||||
dmu_assign_arcbuf(dmu_buf_t *handle, uint64_t offset, arc_buf_t *buf,
|
||||
dmu_assign_arcbuf_dnode(dnode_t *dn, uint64_t offset, arc_buf_t *buf,
|
||||
dmu_tx_t *tx)
|
||||
{
|
||||
dmu_buf_impl_t *dbuf = (dmu_buf_impl_t *)handle;
|
||||
dnode_t *dn;
|
||||
dmu_buf_impl_t *db;
|
||||
uint32_t blksz = (uint32_t)arc_buf_lsize(buf);
|
||||
uint64_t blkid;
|
||||
|
||||
DB_DNODE_ENTER(dbuf);
|
||||
dn = DB_DNODE(dbuf);
|
||||
rw_enter(&dn->dn_struct_rwlock, RW_READER);
|
||||
blkid = dbuf_whichblock(dn, 0, offset);
|
||||
VERIFY((db = dbuf_hold(dn, blkid, FTAG)) != NULL);
|
||||
rw_exit(&dn->dn_struct_rwlock);
|
||||
DB_DNODE_EXIT(dbuf);
|
||||
|
||||
/*
|
||||
* We can only assign if the offset is aligned, the arc buf is the
|
||||
@ -1924,11 +1919,8 @@ dmu_assign_arcbuf(dmu_buf_t *handle, uint64_t offset, arc_buf_t *buf,
|
||||
ASSERT3U(arc_get_compression(buf), ==, ZIO_COMPRESS_OFF);
|
||||
ASSERT(!(buf->b_flags & ARC_BUF_FLAG_COMPRESSED));
|
||||
|
||||
DB_DNODE_ENTER(dbuf);
|
||||
dn = DB_DNODE(dbuf);
|
||||
os = dn->dn_objset;
|
||||
object = dn->dn_object;
|
||||
DB_DNODE_EXIT(dbuf);
|
||||
|
||||
dbuf_rele(db, FTAG);
|
||||
dmu_write(os, object, offset, blksz, buf->b_data, tx);
|
||||
@ -1937,6 +1929,17 @@ dmu_assign_arcbuf(dmu_buf_t *handle, uint64_t offset, arc_buf_t *buf,
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
dmu_assign_arcbuf(dmu_buf_t *handle, uint64_t offset, arc_buf_t *buf,
|
||||
dmu_tx_t *tx)
|
||||
{
|
||||
dmu_buf_impl_t *dbuf = (dmu_buf_impl_t *)handle;
|
||||
|
||||
DB_DNODE_ENTER(dbuf);
|
||||
dmu_assign_arcbuf_dnode(DB_DNODE(dbuf), offset, buf, tx);
|
||||
DB_DNODE_EXIT(dbuf);
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
dbuf_dirty_record_t *dsa_dr;
|
||||
dmu_sync_cb_t *dsa_done;
|
||||
|
@ -519,6 +519,9 @@ uint64_t dmu_buf_refcount(dmu_buf_t *db);
|
||||
int dmu_buf_hold_array_by_bonus(dmu_buf_t *db, uint64_t offset,
|
||||
uint64_t length, boolean_t read, void *tag,
|
||||
int *numbufsp, dmu_buf_t ***dbpp);
|
||||
int dmu_buf_hold_array_by_dnode(dnode_t *dn, uint64_t offset, uint64_t length,
|
||||
boolean_t read, void *tag, int *numbufsp, dmu_buf_t ***dbpp,
|
||||
uint32_t flags);
|
||||
void dmu_buf_rele_array(dmu_buf_t **, int numbufs, void *tag);
|
||||
|
||||
typedef void dmu_buf_evict_func_t(void *user_ptr);
|
||||
@ -757,10 +760,13 @@ 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);
|
||||
int dmu_read_uio_dbuf(dmu_buf_t *zdb, struct uio *uio, uint64_t size);
|
||||
int dmu_read_uio_dnode(dnode_t *dn, struct uio *uio, uint64_t size);
|
||||
int dmu_write_uio(objset_t *os, uint64_t object, struct uio *uio, uint64_t size,
|
||||
dmu_tx_t *tx);
|
||||
int dmu_write_uio_dbuf(dmu_buf_t *zdb, struct uio *uio, uint64_t size,
|
||||
dmu_tx_t *tx);
|
||||
int dmu_write_uio_dnode(dnode_t *dn, struct uio *uio, uint64_t size,
|
||||
dmu_tx_t *tx);
|
||||
#ifdef _KERNEL
|
||||
#ifdef illumos
|
||||
int dmu_write_pages(objset_t *os, uint64_t object, uint64_t offset,
|
||||
@ -774,6 +780,8 @@ int dmu_read_pages(objset_t *os, uint64_t object, vm_page_t *ma, int count,
|
||||
#endif
|
||||
struct arc_buf *dmu_request_arcbuf(dmu_buf_t *handle, int size);
|
||||
void dmu_return_arcbuf(struct arc_buf *buf);
|
||||
void dmu_assign_arcbuf_dnode(dnode_t *handle, uint64_t offset,
|
||||
struct arc_buf *buf, dmu_tx_t *tx);
|
||||
void dmu_assign_arcbuf(dmu_buf_t *handle, uint64_t offset, struct arc_buf *buf,
|
||||
dmu_tx_t *tx);
|
||||
int dmu_xuio_init(struct xuio *uio, int niov);
|
||||
|
@ -174,7 +174,7 @@ typedef struct zvol_state {
|
||||
zilog_t *zv_zilog; /* ZIL handle */
|
||||
list_t zv_extents; /* List of extents for dump */
|
||||
znode_t zv_znode; /* for range locking */
|
||||
dmu_buf_t *zv_dbuf; /* bonus handle */
|
||||
dnode_t *zv_dn; /* dnode hold */
|
||||
#ifndef illumos
|
||||
int zv_state;
|
||||
int zv_volmode; /* Provide GEOM or cdev */
|
||||
@ -868,7 +868,7 @@ zvol_first_open(zvol_state_t *zv)
|
||||
}
|
||||
zv->zv_volblocksize = doi.doi_data_block_size;
|
||||
|
||||
error = dmu_bonus_hold(os, ZVOL_OBJ, zvol_tag, &zv->zv_dbuf);
|
||||
error = dnode_hold(os, ZVOL_OBJ, zvol_tag, &zv->zv_dn);
|
||||
if (error) {
|
||||
dmu_objset_disown(os, zvol_tag);
|
||||
return (error);
|
||||
@ -893,8 +893,8 @@ zvol_last_close(zvol_state_t *zv)
|
||||
zil_close(zv->zv_zilog);
|
||||
zv->zv_zilog = NULL;
|
||||
|
||||
dmu_buf_rele(zv->zv_dbuf, zvol_tag);
|
||||
zv->zv_dbuf = NULL;
|
||||
dnode_rele(zv->zv_dn, zvol_tag);
|
||||
zv->zv_dn = NULL;
|
||||
|
||||
/*
|
||||
* Evict cached data
|
||||
@ -1342,8 +1342,6 @@ static int
|
||||
zvol_get_data(void *arg, lr_write_t *lr, char *buf, struct lwb *lwb, zio_t *zio)
|
||||
{
|
||||
zvol_state_t *zv = arg;
|
||||
objset_t *os = zv->zv_objset;
|
||||
uint64_t object = ZVOL_OBJ;
|
||||
uint64_t offset = lr->lr_offset;
|
||||
uint64_t size = lr->lr_length; /* length of user data */
|
||||
dmu_buf_t *db;
|
||||
@ -1367,7 +1365,7 @@ zvol_get_data(void *arg, lr_write_t *lr, char *buf, struct lwb *lwb, zio_t *zio)
|
||||
if (buf != NULL) { /* immediate write */
|
||||
zgd->zgd_rl = zfs_range_lock(&zv->zv_znode, offset, size,
|
||||
RL_READER);
|
||||
error = dmu_read(os, object, offset, size, buf,
|
||||
error = dmu_read_by_dnode(zv->zv_dn, offset, size, buf,
|
||||
DMU_READ_NO_PREFETCH);
|
||||
} else { /* indirect write */
|
||||
/*
|
||||
@ -1380,7 +1378,7 @@ zvol_get_data(void *arg, lr_write_t *lr, char *buf, struct lwb *lwb, zio_t *zio)
|
||||
offset = P2ALIGN(offset, size);
|
||||
zgd->zgd_rl = zfs_range_lock(&zv->zv_znode, offset, size,
|
||||
RL_READER);
|
||||
error = dmu_buf_hold(os, object, offset, zgd, &db,
|
||||
error = dmu_buf_hold_by_dnode(zv->zv_dn, offset, zgd, &db,
|
||||
DMU_READ_NO_PREFETCH);
|
||||
if (error == 0) {
|
||||
blkptr_t *bp = &lr->lr_blkptr;
|
||||
@ -1451,8 +1449,8 @@ zvol_log_write(zvol_state_t *zv, dmu_tx_t *tx, offset_t off, ssize_t resid,
|
||||
itx = zil_itx_create(TX_WRITE, sizeof (*lr) +
|
||||
(wr_state == WR_COPIED ? len : 0));
|
||||
lr = (lr_write_t *)&itx->itx_lr;
|
||||
if (wr_state == WR_COPIED && dmu_read(zv->zv_objset,
|
||||
ZVOL_OBJ, off, len, lr + 1, DMU_READ_NO_PREFETCH) != 0) {
|
||||
if (wr_state == WR_COPIED && dmu_read_by_dnode(zv->zv_dn,
|
||||
off, len, lr + 1, DMU_READ_NO_PREFETCH) != 0) {
|
||||
zil_itx_destroy(itx);
|
||||
itx = zil_itx_create(TX_WRITE, sizeof (*lr));
|
||||
lr = (lr_write_t *)&itx->itx_lr;
|
||||
@ -1874,7 +1872,7 @@ zvol_read(struct cdev *dev, struct uio *uio, int ioflag)
|
||||
if (bytes > volsize - uio->uio_loffset)
|
||||
bytes = volsize - uio->uio_loffset;
|
||||
|
||||
error = dmu_read_uio_dbuf(zv->zv_dbuf, uio, bytes);
|
||||
error = dmu_read_uio_dnode(zv->zv_dn, uio, bytes);
|
||||
if (error) {
|
||||
/* convert checksum errors into IO errors */
|
||||
if (error == ECKSUM)
|
||||
@ -1946,7 +1944,7 @@ zvol_write(struct cdev *dev, struct uio *uio, int ioflag)
|
||||
dmu_tx_abort(tx);
|
||||
break;
|
||||
}
|
||||
error = dmu_write_uio_dbuf(zv->zv_dbuf, uio, bytes, tx);
|
||||
error = dmu_write_uio_dnode(zv->zv_dn, uio, bytes, tx);
|
||||
if (error == 0)
|
||||
zvol_log_write(zv, tx, off, bytes, sync);
|
||||
dmu_tx_commit(tx);
|
||||
@ -2028,7 +2026,7 @@ zvol_getefi(void *arg, int flag, uint64_t vs, uint8_t bs)
|
||||
int
|
||||
zvol_get_volume_params(minor_t minor, uint64_t *blksize,
|
||||
uint64_t *max_xfer_len, void **minor_hdl, void **objset_hdl, void **zil_hdl,
|
||||
void **rl_hdl, void **bonus_hdl)
|
||||
void **rl_hdl, void **dnode_hdl)
|
||||
{
|
||||
zvol_state_t *zv;
|
||||
|
||||
@ -2039,7 +2037,7 @@ zvol_get_volume_params(minor_t minor, uint64_t *blksize,
|
||||
return (SET_ERROR(ENXIO));
|
||||
|
||||
ASSERT(blksize && max_xfer_len && minor_hdl &&
|
||||
objset_hdl && zil_hdl && rl_hdl && bonus_hdl);
|
||||
objset_hdl && zil_hdl && rl_hdl && dnode_hdl);
|
||||
|
||||
*blksize = zv->zv_volblocksize;
|
||||
*max_xfer_len = (uint64_t)zvol_maxphys;
|
||||
@ -2047,7 +2045,7 @@ zvol_get_volume_params(minor_t minor, uint64_t *blksize,
|
||||
*objset_hdl = zv->zv_objset;
|
||||
*zil_hdl = zv->zv_zilog;
|
||||
*rl_hdl = &zv->zv_znode;
|
||||
*bonus_hdl = zv->zv_dbuf;
|
||||
*dnode_hdl = zv->zv_dn;
|
||||
return (0);
|
||||
}
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user