static int
zfs_ioctl_compat_put_nvlist(zfs_cmd_t *zc, nvlist_t *nvl)
{
char *packed = NULL;
int error = 0;
size_t size;
VERIFY(nvlist_size(nvl, &size, NV_ENCODE_NATIVE) == 0);
#ifdef _KERNEL
packed = kmem_alloc(size, KM_SLEEP);
VERIFY(nvlist_pack(nvl, &packed, &size, NV_ENCODE_NATIVE,
KM_SLEEP) == 0);
if (ddi_copyout(packed,
(void *)(uintptr_t)zc->zc_nvlist_dst, size, zc->zc_iflags) != 0)
error = EFAULT;
kmem_free(packed, size);
#else
packed = (void *)(uintptr_t)zc->zc_nvlist_dst;
VERIFY(nvlist_pack(nvl, &packed, &size, NV_ENCODE_NATIVE,
0) == 0);
#endif
zc->zc_nvlist_dst_size = size;
return (error);
}
size_t
fnvlist_size(nvlist_t *nvl)
{
size_t size;
VERIFY0(nvlist_size(nvl, &size, NV_ENCODE_NATIVE));
return (size);
}
/*
* Set an extended attribute.
* This transaction must have called udmu_xattr_declare_set() first.
*
* Returns 0 on success or a negative error number on failure.
*
* No locking is done here.
*/
static int
__osd_sa_xattr_update(const struct lu_env *env, struct osd_object *obj,
struct osd_thandle *oh)
{
struct osd_device *osd = osd_obj2dev(obj);
udmu_objset_t *uos = &osd->od_objset;
char *dxattr;
size_t sa_size;
int rc;
ENTRY;
LASSERT(obj->oo_sa_hdl);
LASSERT(obj->oo_sa_xattr);
/* Update the SA for additions, modifications, and removals. */
rc = -nvlist_size(obj->oo_sa_xattr, &sa_size, NV_ENCODE_XDR);
if (rc)
return rc;
dxattr = sa_spill_alloc(KM_SLEEP);
if (dxattr == NULL)
RETURN(-ENOMEM);
rc = -nvlist_pack(obj->oo_sa_xattr, &dxattr, &sa_size,
NV_ENCODE_XDR, KM_SLEEP);
if (rc)
GOTO(out_free, rc);
rc = osd_object_sa_update(obj, SA_ZPL_DXATTR(uos), dxattr, sa_size, oh);
out_free:
sa_spill_free(dxattr);
RETURN(rc);
}
int __osd_sa_xattr_update(const struct lu_env *env, struct osd_object *obj,
struct osd_thandle *oh)
{
struct lu_buf *lb = &osd_oti_get(env)->oti_xattr_lbuf;
struct osd_device *osd = osd_obj2dev(obj);
char *dxattr;
size_t size;
int rc;
obj->oo_late_xattr = 0;
/* Update the SA for additions, modifications, and removals. */
rc = -nvlist_size(obj->oo_sa_xattr, &size, NV_ENCODE_XDR);
if (rc)
return rc;
lu_buf_check_and_alloc(lb, size);
if (lb->lb_buf == NULL) {
CERROR("%s: can't allocate buffer for xattr update\n",
osd->od_svname);
return -ENOMEM;
}
dxattr = lb->lb_buf;
rc = -nvlist_pack(obj->oo_sa_xattr, &dxattr, &size,
NV_ENCODE_XDR, KM_SLEEP);
if (rc)
return rc;
LASSERT(dxattr == lb->lb_buf);
sa_update(obj->oo_sa_hdl, SA_ZPL_DXATTR(osd), dxattr, size, oh->ot_tx);
return 0;
}
static int
zpl_xattr_set_sa(struct inode *ip, const char *name, const void *value,
size_t size, int flags, cred_t *cr)
{
znode_t *zp = ITOZ(ip);
nvlist_t *nvl;
size_t sa_size;
int error = 0;
mutex_enter(&zp->z_lock);
if (zp->z_xattr_cached == NULL)
error = -zfs_sa_get_xattr(zp);
mutex_exit(&zp->z_lock);
if (error)
return (error);
ASSERT(zp->z_xattr_cached);
nvl = zp->z_xattr_cached;
if (value == NULL) {
error = -nvlist_remove(nvl, name, DATA_TYPE_BYTE_ARRAY);
if (error == -ENOENT)
error = zpl_xattr_set_dir(ip, name, NULL, 0, flags, cr);
} else {
/* Limited to 32k to keep nvpair memory allocations small */
if (size > DXATTR_MAX_ENTRY_SIZE)
return (-EFBIG);
/* Prevent the DXATTR SA from consuming the entire SA region */
error = -nvlist_size(nvl, &sa_size, NV_ENCODE_XDR);
if (error)
return (error);
if (sa_size > DXATTR_MAX_SA_SIZE)
return (-EFBIG);
error = -nvlist_add_byte_array(nvl, name,
(uchar_t *)value, size);
}
/*
* Update the SA for additions, modifications, and removals. On
* error drop the inconsistent cached version of the nvlist, it
* will be reconstructed from the ARC when next accessed.
*/
if (error == 0)
error = -zfs_sa_set_xattr(zp);
if (error) {
nvlist_free(nvl);
zp->z_xattr_cached = NULL;
}
ASSERT3S(error, <=, 0);
return (error);
}
/**
* Open the given zpool
* @param p_libzfshd: the libzfs handle
* @param psz_zpool: the zpool name
* @param ppsz_error: the error message if any
* @return the zpool handle or NULL in case of error
*/
zpool_handle_t *libzfs_zpool_open_canfail(libzfs_handle_t *p_libzfshd, const char* psz_zpool, const char **ppsz_error)
{
zpool_handle_t *p_zpool;
nvlist_t *pnv_config;
int i_error;
/* Check the zpool name */
if(libzfs_zpool_name_valid(psz_zpool, ppsz_error))
return NULL;
if((p_zpool = calloc(1, sizeof(zpool_handle_t))) == NULL)
{
*ppsz_error = "no memory";
return NULL;
}
p_zpool->zpool_hdl = p_libzfshd;
strlcpy(p_zpool->zpool_name, psz_zpool, sizeof(p_zpool->zpool_name));
i_error = spa_get_stats(psz_zpool, &pnv_config, NULL, 0);
if(!pnv_config)
{
free(p_zpool);
*ppsz_error = "unable to get the statistics of the zpool";
return NULL;
}
assert(nvlist_size(pnv_config, &p_zpool->zpool_config_size, NV_ENCODE_NATIVE) == 0);
if(p_zpool->zpool_config)
{
uint64_t oldtxg, newtxg;
assert(nvlist_lookup_uint64(p_zpool->zpool_config, ZPOOL_CONFIG_POOL_TXG, &oldtxg) == 0);
assert(nvlist_lookup_uint64(pnv_config, ZPOOL_CONFIG_POOL_TXG, &newtxg) == 0);
if(p_zpool->zpool_old_config)
nvlist_free(p_zpool->zpool_old_config);
if(oldtxg != newtxg)
{
nvlist_free(p_zpool->zpool_config);
p_zpool->zpool_old_config = NULL;
}
else
p_zpool->zpool_old_config = p_zpool->zpool_config;
}
p_zpool->zpool_config = pnv_config;
if(i_error)
p_zpool->zpool_state = POOL_STATE_UNAVAIL;
else
p_zpool->zpool_state = POOL_STATE_ACTIVE;
return p_zpool;
}
/*
* Handles the door command IPMGMT_CMD_GETADDR. It retrieves the persisted
* address for a given `gargp->ia_aobjname'. If it is not defined then it
* retrieves all the addresses configured on `gargp->ia_ifname'. The
* "ipadm show-addr addrobj" or "ipadm show-addr <ifname>/\*" will call this
* handler through library.
*/
static void
ipmgmt_getaddr_handler(void *argp)
{
size_t buflen, onvlsize;
char *buf, *onvlbuf;
ipmgmt_getaddr_arg_t *gargp = argp;
ipmgmt_getaddr_cbarg_t cbarg;
ipmgmt_get_rval_t rval, *rvalp = &rval;
int err = 0;
cbarg.cb_ifname = gargp->ia_ifname;
cbarg.cb_aobjname = gargp->ia_aobjname;
cbarg.cb_ocnt = 0;
if (nvlist_alloc(&cbarg.cb_onvl, NV_UNIQUE_NAME, 0) != 0)
goto fail;
err = ipmgmt_db_walk(ipmgmt_db_getaddr, &cbarg, IPADM_DB_READ);
if (err == ENOENT && cbarg.cb_ocnt > 0) {
/*
* If there is atleast one entry in the nvlist,
* do not return error.
*/
err = 0;
}
if (err != 0)
goto fail;
if ((err = nvlist_size(cbarg.cb_onvl, &onvlsize,
NV_ENCODE_NATIVE)) != 0) {
goto fail;
}
buflen = onvlsize + sizeof (ipmgmt_get_rval_t);
/*
* We cannot use malloc() here because door_return never returns, and
* memory allocated by malloc() would get leaked. Use alloca() instead.
*/
buf = alloca(buflen);
onvlbuf = buf + sizeof (ipmgmt_get_rval_t);
if ((err = nvlist_pack(cbarg.cb_onvl, &onvlbuf, &onvlsize,
NV_ENCODE_NATIVE, 0)) != 0) {
goto fail;
}
nvlist_free(cbarg.cb_onvl);
rvalp = (ipmgmt_get_rval_t *)(void *)buf;
rvalp->ir_err = 0;
rvalp->ir_nvlsize = onvlsize;
(void) door_return(buf, buflen, NULL, 0);
return;
fail:
nvlist_free(cbarg.cb_onvl);
rvalp->ir_err = err;
(void) door_return((char *)rvalp, sizeof (*rvalp), NULL, 0);
}
static int
spa_config_write(spa_config_dirent_t *dp, nvlist_t *nvl)
{
size_t buflen;
char *buf;
vnode_t *vp;
int oflags = FWRITE | FTRUNC | FCREAT | FOFFMAX;
char *temp;
int err;
/*
* If the nvlist is empty (NULL), then remove the old cachefile.
*/
if (nvl == NULL) {
err = vn_remove(dp->scd_path, UIO_SYSSPACE, RMFILE);
return (err);
}
/*
* Pack the configuration into a buffer.
*/
VERIFY(nvlist_size(nvl, &buflen, NV_ENCODE_XDR) == 0);
buf = kmem_alloc(buflen, KM_SLEEP);
temp = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
VERIFY(nvlist_pack(nvl, &buf, &buflen, NV_ENCODE_XDR,
KM_SLEEP) == 0);
/*
* Write the configuration to disk. We need to do the traditional
* 'write to temporary file, sync, move over original' to make sure we
* always have a consistent view of the data.
*/
(void) snprintf(temp, MAXPATHLEN, "%s.tmp", dp->scd_path);
err = vn_open(temp, UIO_SYSSPACE, oflags, 0644, &vp, CRCREAT, 0);
if (err == 0) {
err = vn_rdwr(UIO_WRITE, vp, buf, buflen, 0, UIO_SYSSPACE,
0, RLIM64_INFINITY, kcred, NULL);
if (err == 0)
err = VOP_FSYNC(vp, FSYNC, kcred, NULL);
if (err == 0)
err = vn_rename(temp, dp->scd_path, UIO_SYSSPACE);
(void) VOP_CLOSE(vp, oflags, 1, 0, kcred, NULL);
}
(void) vn_remove(temp, UIO_SYSSPACE, RMFILE);
kmem_free(buf, buflen);
kmem_free(temp, MAXPATHLEN);
return (err);
}
static void
fmd_ckpt_save_nvlist(fmd_ckpt_t *ckp, nvlist_t *nvl)
{
fcf_nvl_t *fcfn = (void *)ckp->ckp_ptr;
char *nvbuf = (char *)ckp->ckp_ptr + sizeof (fcf_nvl_t);
size_t nvsize = 0;
(void) nvlist_size(nvl, &nvsize, NV_ENCODE_NATIVE);
fcfn->fcfn_size = (uint64_t)nvsize;
(void) nvlist_pack(nvl, &nvbuf, &nvsize, NV_ENCODE_NATIVE, 0);
ckp->ckp_ptr += sizeof (fcf_nvl_t) + nvsize;
ckp->ckp_ptr = (uchar_t *)
P2ROUNDUP((uintptr_t)ckp->ckp_ptr, sizeof (uint64_t));
}
static int
zpl_xattr_set_sa(struct inode *ip, const char *name, const void *value,
size_t size, int flags, cred_t *cr)
{
znode_t *zp = ITOZ(ip);
nvlist_t *nvl;
size_t sa_size;
int error;
ASSERT(zp->z_xattr_cached);
nvl = zp->z_xattr_cached;
if (value == NULL) {
error = -nvlist_remove(nvl, name, DATA_TYPE_BYTE_ARRAY);
if (error == -ENOENT)
error = zpl_xattr_set_dir(ip, name, NULL, 0, flags, cr);
} else {
/* Do not allow SA xattrs in symlinks (issue #1648) */
if (S_ISLNK(ip->i_mode))
return (-EMLINK);
/* Limited to 32k to keep nvpair memory allocations small */
if (size > DXATTR_MAX_ENTRY_SIZE)
return (-EFBIG);
/* Prevent the DXATTR SA from consuming the entire SA region */
error = -nvlist_size(nvl, &sa_size, NV_ENCODE_XDR);
if (error)
return (error);
if (sa_size > DXATTR_MAX_SA_SIZE)
return (-EFBIG);
error = -nvlist_add_byte_array(nvl, name,
(uchar_t *)value, size);
if (error)
return (error);
}
/* Update the SA for additions, modifications, and removals. */
if (!error)
error = -zfs_sa_set_xattr(zp);
ASSERT3S(error, <=, 0);
return (error);
}
int
zfs_sa_set_xattr(znode_t *zp)
{
zfs_sb_t *zsb = ZTOZSB(zp);
dmu_tx_t *tx;
char *obj;
size_t size;
int error;
ASSERT(RW_WRITE_HELD(&zp->z_xattr_lock));
ASSERT(zp->z_xattr_cached);
ASSERT(zp->z_is_sa);
error = nvlist_size(zp->z_xattr_cached, &size, NV_ENCODE_XDR);
if (error)
goto out;
obj = zio_buf_alloc(size);
error = nvlist_pack(zp->z_xattr_cached, &obj, &size,
NV_ENCODE_XDR, KM_SLEEP);
if (error)
goto out_free;
tx = dmu_tx_create(zsb->z_os);
dmu_tx_hold_sa_create(tx, size);
dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
error = dmu_tx_assign(tx, TXG_WAIT);
if (error) {
dmu_tx_abort(tx);
} else {
error = sa_update(zp->z_sa_hdl, SA_ZPL_DXATTR(zsb),
obj, size, tx);
if (error)
dmu_tx_abort(tx);
else
dmu_tx_commit(tx);
}
out_free:
zio_buf_free(obj, size);
out:
return (error);
}
/* ARGSUSED */
static int
xattr_file_read(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr,
caller_context_t *ct)
{
xattr_file_t *np = vp->v_data;
xattr_view_t xattr_view = np->xattr_view;
char *buf;
size_t filesize;
nvlist_t *nvl;
int error;
/*
* Validate file offset and fasttrack empty reads
*/
if (uiop->uio_loffset < (offset_t)0)
return (EINVAL);
if (uiop->uio_resid == 0)
return (0);
if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP))
return (ENOMEM);
if (xattr_fill_nvlist(vp, xattr_view, nvl, cr, ct)) {
nvlist_free(nvl);
return (EFAULT);
}
VERIFY(nvlist_size(nvl, &filesize, NV_ENCODE_XDR) == 0);
if (uiop->uio_loffset >= filesize) {
nvlist_free(nvl);
return (0);
}
buf = kmem_alloc(filesize, KM_SLEEP);
VERIFY(nvlist_pack(nvl, &buf, &filesize, NV_ENCODE_XDR,
KM_SLEEP) == 0);
error = uiomove((caddr_t)buf, filesize, UIO_READ, uiop);
kmem_free(buf, filesize);
nvlist_free(nvl);
return (error);
}
/*
* The size of a sysattr file is the size of the nvlist that will be
* returned by xattr_file_read(). A call to xattr_file_write() could
* change the size of that nvlist. That size is not stored persistently
* so xattr_fill_nvlist() calls VOP_GETATTR so that it can be calculated.
*/
static int
xattr_file_size(vnode_t *vp, xattr_view_t xattr_view, size_t *size,
cred_t *cr, caller_context_t *ct)
{
nvlist_t *nvl;
if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP)) {
return (ENOMEM);
}
if (xattr_fill_nvlist(vp, xattr_view, nvl, cr, ct)) {
nvlist_free(nvl);
return (EFAULT);
}
VERIFY(nvlist_size(nvl, size, NV_ENCODE_XDR) == 0);
nvlist_free(nvl);
return (0);
}
int
zfs_sa_set_xattr(znode_t *zp)
{
zfsvfs_t *zfsvfs = ZTOZSB(zp);
dmu_tx_t *tx;
char *obj;
size_t size;
int error;
ASSERT(RW_WRITE_HELD(&zp->z_xattr_lock));
ASSERT(zp->z_xattr_cached);
ASSERT(zp->z_is_sa);
error = nvlist_size(zp->z_xattr_cached, &size, NV_ENCODE_XDR);
if ((error == 0) && (size > SA_ATTR_MAX_LEN))
error = EFBIG;
if (error)
goto out;
obj = vmem_alloc(size, KM_SLEEP);
error = nvlist_pack(zp->z_xattr_cached, &obj, &size,
NV_ENCODE_XDR, KM_SLEEP);
if (error)
goto out_free;
tx = dmu_tx_create(zfsvfs->z_os);
dmu_tx_hold_sa_create(tx, size);
dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
error = dmu_tx_assign(tx, TXG_WAIT);
if (error) {
dmu_tx_abort(tx);
} else {
VERIFY0(sa_update(zp->z_sa_hdl, SA_ZPL_DXATTR(zfsvfs),
obj, size, tx));
dmu_tx_commit(tx);
}
out_free:
vmem_free(obj, size);
out:
return (error);
}
int
zcmd_write_src_nvlist(libzfs_handle_t *hdl, zfs_cmd_t *zc, nvlist_t *nvl,
size_t *size)
{
char *packed;
size_t len;
verify(nvlist_size(nvl, &len, NV_ENCODE_NATIVE) == 0);
if ((packed = zfs_alloc(hdl, len)) == NULL)
return (-1);
verify(nvlist_pack(nvl, &packed, &len, NV_ENCODE_NATIVE, 0) == 0);
zc->zc_nvlist_src = (uint64_t)(uintptr_t)packed;
zc->zc_nvlist_src_size = len;
if (size)
*size = len;
return (0);
}
static PyObject *
py_set_fsacl(PyObject *self, PyObject *args)
{
int un;
size_t nvsz;
zfs_cmd_t zc = { 0 };
char *name, *nvbuf;
PyObject *dict, *file;
nvlist_t *nvl;
int err;
if (!PyArg_ParseTuple(args, "siO!", &name, &un,
&PyDict_Type, &dict))
return (NULL);
nvl = dict2nvl(dict);
if (nvl == NULL)
return (NULL);
err = nvlist_size(nvl, &nvsz, NV_ENCODE_NATIVE);
assert(err == 0);
nvbuf = malloc(nvsz);
err = nvlist_pack(nvl, &nvbuf, &nvsz, NV_ENCODE_NATIVE, 0);
assert(err == 0);
(void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));
zc.zc_nvlist_src_size = nvsz;
zc.zc_nvlist_src = (uintptr_t)nvbuf;
zc.zc_perm_action = un;
err = ioctl_with_cmdstr(ZFS_IOC_SET_FSACL, &zc);
free(nvbuf);
if (err) {
seterr(_("cannot set permissions on %s"), name);
return (NULL);
}
Py_RETURN_NONE;
}
static void
fmd_ckpt_resv_case(fmd_ckpt_t *ckp, fmd_case_t *cp)
{
fmd_case_impl_t *cip = (fmd_case_impl_t *)cp;
fmd_case_susp_t *cis;
uint_t n;
if (cip->ci_xprt != NULL)
return; /* do not checkpoint cases from remote transports */
n = fmd_buf_hash_count(&cip->ci_bufs);
fmd_buf_hash_apply(&cip->ci_bufs, (fmd_buf_f *)fmd_ckpt_resv_buf, ckp);
fmd_ckpt_resv(ckp, sizeof (fcf_buf_t) * n, sizeof (uint32_t));
if (cip->ci_principal != NULL)
fmd_ckpt_resv(ckp, sizeof (fcf_event_t), sizeof (uint64_t));
fmd_ckpt_resv(ckp,
sizeof (fcf_event_t) * cip->ci_nitems, sizeof (uint64_t));
if (cip->ci_nsuspects != 0)
ckp->ckp_size = P2ROUNDUP(ckp->ckp_size, sizeof (uint64_t));
cip->ci_nvsz = 0; /* compute size of packed suspect nvlist array */
for (cis = cip->ci_suspects; cis != NULL; cis = cis->cis_next) {
size_t nvsize = 0;
(void) nvlist_size(cis->cis_nvl, &nvsize, NV_ENCODE_NATIVE);
cip->ci_nvsz += sizeof (fcf_nvl_t) + nvsize;
cip->ci_nvsz = P2ROUNDUP(cip->ci_nvsz, sizeof (uint64_t));
}
fmd_ckpt_resv(ckp, cip->ci_nvsz, sizeof (uint64_t));
fmd_ckpt_resv(ckp, sizeof (fcf_case_t), sizeof (uint32_t));
ckp->ckp_strn += strlen(cip->ci_uuid) + 1;
}
void *
nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
{
unsigned char *buf, *ptr;
size_t left, size;
nvpair_t *nvp;
NVLIST_ASSERT(nvl);
if (nvl->nvl_error != 0) {
errno = nvl->nvl_error;
return (NULL);
}
size = nvlist_size(nvl);
buf = malloc(size);
if (buf == NULL)
return (NULL);
ptr = buf;
left = size;
ptr = nvlist_pack_header(nvl, ptr, &left);
for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
nvp = nvlist_next_nvpair(nvl, nvp)) {
ptr = nvpair_pack(nvp, ptr, fdidxp, &left);
if (ptr == NULL) {
free(buf);
return (NULL);
}
}
if (sizep != NULL)
*sizep = size;
return (buf);
}
/*ARGSUSED*/
static void
spa_history_log_sync(void *arg1, void *arg2, dmu_tx_t *tx)
{
spa_t *spa = arg1;
history_arg_t *hap = arg2;
const char *history_str = hap->ha_history_str;
objset_t *mos = spa->spa_meta_objset;
dmu_buf_t *dbp;
spa_history_phys_t *shpp;
size_t reclen;
uint64_t le_len;
nvlist_t *nvrecord;
char *record_packed = NULL;
int ret;
/*
* If we have an older pool that doesn't have a command
* history object, create it now.
*/
mutex_enter(&spa->spa_history_lock);
if (!spa->spa_history)
spa_history_create_obj(spa, tx);
mutex_exit(&spa->spa_history_lock);
/*
* Get the offset of where we need to write via the bonus buffer.
* Update the offset when the write completes.
*/
VERIFY(0 == dmu_bonus_hold(mos, spa->spa_history, FTAG, &dbp));
shpp = dbp->db_data;
dmu_buf_will_dirty(dbp, tx);
#ifdef ZFS_DEBUG
{
dmu_object_info_t doi;
dmu_object_info_from_db(dbp, &doi);
ASSERT3U(doi.doi_bonus_type, ==, DMU_OT_SPA_HISTORY_OFFSETS);
}
#endif
VERIFY(nvlist_alloc(&nvrecord, NV_UNIQUE_NAME, KM_SLEEP) == 0);
VERIFY(nvlist_add_uint64(nvrecord, ZPOOL_HIST_TIME,
gethrestime_sec()) == 0);
VERIFY(nvlist_add_uint64(nvrecord, ZPOOL_HIST_WHO, hap->ha_uid) == 0);
if (hap->ha_zone != NULL)
VERIFY(nvlist_add_string(nvrecord, ZPOOL_HIST_ZONE,
hap->ha_zone) == 0);
#ifdef _KERNEL
VERIFY(nvlist_add_string(nvrecord, ZPOOL_HIST_HOST,
utsname.nodename) == 0);
#endif
if (hap->ha_log_type == LOG_CMD_POOL_CREATE ||
hap->ha_log_type == LOG_CMD_NORMAL) {
VERIFY(nvlist_add_string(nvrecord, ZPOOL_HIST_CMD,
history_str) == 0);
zfs_dbgmsg("command: %s", history_str);
} else {
VERIFY(nvlist_add_uint64(nvrecord, ZPOOL_HIST_INT_EVENT,
hap->ha_event) == 0);
VERIFY(nvlist_add_uint64(nvrecord, ZPOOL_HIST_TXG,
tx->tx_txg) == 0);
VERIFY(nvlist_add_string(nvrecord, ZPOOL_HIST_INT_STR,
history_str) == 0);
zfs_dbgmsg("internal %s pool:%s txg:%llu %s",
zfs_history_event_names[hap->ha_event], spa_name(spa),
(longlong_t)tx->tx_txg, history_str);
}
VERIFY(nvlist_size(nvrecord, &reclen, NV_ENCODE_XDR) == 0);
record_packed = kmem_alloc(reclen, KM_SLEEP);
VERIFY(nvlist_pack(nvrecord, &record_packed, &reclen,
NV_ENCODE_XDR, KM_SLEEP) == 0);
mutex_enter(&spa->spa_history_lock);
if (hap->ha_log_type == LOG_CMD_POOL_CREATE)
VERIFY(shpp->sh_eof == shpp->sh_pool_create_len);
/* write out the packed length as little endian */
le_len = LE_64((uint64_t)reclen);
ret = spa_history_write(spa, &le_len, sizeof (le_len), shpp, tx);
if (!ret)
ret = spa_history_write(spa, record_packed, reclen, shpp, tx);
if (!ret && hap->ha_log_type == LOG_CMD_POOL_CREATE) {
shpp->sh_pool_create_len += sizeof (le_len) + reclen;
shpp->sh_bof = shpp->sh_pool_create_len;
}
mutex_exit(&spa->spa_history_lock);
nvlist_free(nvrecord);
kmem_free(record_packed, reclen);
dmu_buf_rele(dbp, FTAG);
strfree(hap->ha_history_str);
if (hap->ha_zone != NULL)
strfree(hap->ha_zone);
kmem_free(hap, sizeof (history_arg_t));
}
/*
* Attach new_disk (fully described by nvroot) to old_disk.
* If 'replacing' is specified, tne new disk will replace the old one.
*/
int
zpool_vdev_attach(zpool_handle_t *zhp,
const char *old_disk, const char *new_disk, nvlist_t *nvroot, int replacing)
{
zfs_cmd_t zc = { 0 };
char msg[1024];
char *packed;
int ret;
size_t len;
nvlist_t *tgt;
boolean_t avail_spare;
uint64_t val;
char *path;
nvlist_t **child;
uint_t children;
nvlist_t *config_root;
libzfs_handle_t *hdl = zhp->zpool_hdl;
if (replacing)
(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
"cannot replace %s with %s"), old_disk, new_disk);
else
(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
"cannot attach %s to %s"), new_disk, old_disk);
(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
if ((tgt = zpool_find_vdev(zhp, old_disk, &avail_spare)) == 0)
return (zfs_error(hdl, EZFS_NODEVICE, msg));
if (avail_spare)
return (zfs_error(hdl, EZFS_ISSPARE, msg));
verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);
zc.zc_cookie = replacing;
if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
&child, &children) != 0 || children != 1) {
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"new device must be a single disk"));
return (zfs_error(hdl, EZFS_INVALCONFIG, msg));
}
verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
ZPOOL_CONFIG_VDEV_TREE, &config_root) == 0);
/*
* If the target is a hot spare that has been swapped in, we can only
* replace it with another hot spare.
*/
if (replacing &&
nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_IS_SPARE, &val) == 0 &&
nvlist_lookup_string(child[0], ZPOOL_CONFIG_PATH, &path) == 0 &&
(zpool_find_vdev(zhp, path, &avail_spare) == NULL ||
!avail_spare) && is_replacing_spare(config_root, tgt, 1)) {
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"can only be replaced by another hot spare"));
return (zfs_error(hdl, EZFS_BADTARGET, msg));
}
/*
* If we are attempting to replace a spare, it canot be applied to an
* already spared device.
*/
if (replacing &&
nvlist_lookup_string(child[0], ZPOOL_CONFIG_PATH, &path) == 0 &&
zpool_find_vdev(zhp, path, &avail_spare) != NULL && avail_spare &&
is_replacing_spare(config_root, tgt, 0)) {
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"device has already been replaced with a spare"));
return (zfs_error(hdl, EZFS_BADTARGET, msg));
}
verify(nvlist_size(nvroot, &len, NV_ENCODE_NATIVE) == 0);
if ((packed = zfs_alloc(zhp->zpool_hdl, len)) == NULL)
return (-1);
verify(nvlist_pack(nvroot, &packed, &len, NV_ENCODE_NATIVE, 0) == 0);
zc.zc_config_src = (uint64_t)(uintptr_t)packed;
zc.zc_config_src_size = len;
ret = ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_VDEV_ATTACH, &zc);
free(packed);
if (ret == 0)
return (0);
switch (errno) {
case ENOTSUP:
/*
* Can't attach to or replace this type of vdev.
*/
if (replacing)
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"cannot replace a replacing device"));
else
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"can only attach to mirrors and top-level "
"disks"));
(void) zfs_error(hdl, EZFS_BADTARGET, msg);
break;
case EINVAL:
/*
* The new device must be a single disk.
*/
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"new device must be a single disk"));
(void) zfs_error(hdl, EZFS_INVALCONFIG, msg);
break;
case EBUSY:
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "%s is busy"),
new_disk);
(void) zfs_error(hdl, EZFS_BADDEV, msg);
break;
case EOVERFLOW:
/*
* The new device is too small.
*/
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"device is too small"));
(void) zfs_error(hdl, EZFS_BADDEV, msg);
break;
case EDOM:
/*
* The new device has a different alignment requirement.
*/
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"devices have different sector alignment"));
(void) zfs_error(hdl, EZFS_BADDEV, msg);
break;
case ENAMETOOLONG:
/*
* The resulting top-level vdev spec won't fit in the label.
*/
(void) zfs_error(hdl, EZFS_DEVOVERFLOW, msg);
break;
default:
(void) zpool_standard_error(hdl, errno, msg);
}
return (-1);
}
/*
* Import the given pool using the known configuration. The configuration
* should have come from zpool_find_import(). The 'newname' and 'altroot'
* parameters control whether the pool is imported with a different name or with
* an alternate root, respectively.
*/
int
zpool_import(libzfs_handle_t *hdl, nvlist_t *config, const char *newname,
const char *altroot)
{
zfs_cmd_t zc;
char *packed;
size_t len;
char *thename;
char *origname;
int ret;
verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
&origname) == 0);
if (newname != NULL) {
if (!zpool_name_valid(hdl, B_FALSE, newname))
return (zfs_error(hdl, EZFS_INVALIDNAME,
dgettext(TEXT_DOMAIN, "cannot import '%s'"),
newname));
thename = (char *)newname;
} else {
thename = origname;
}
if (altroot != NULL && altroot[0] != '/')
return (zfs_error(hdl, EZFS_BADPATH,
dgettext(TEXT_DOMAIN, "bad alternate root '%s'"),
altroot));
(void) strlcpy(zc.zc_name, thename, sizeof (zc.zc_name));
if (altroot != NULL)
(void) strlcpy(zc.zc_root, altroot, sizeof (zc.zc_root));
else
zc.zc_root[0] = '\0';
verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
&zc.zc_guid) == 0);
verify(nvlist_size(config, &len, NV_ENCODE_NATIVE) == 0);
if ((packed = zfs_alloc(hdl, len)) == NULL)
return (-1);
verify(nvlist_pack(config, &packed, &len, NV_ENCODE_NATIVE, 0) == 0);
zc.zc_config_src = (uint64_t)(uintptr_t)packed;
zc.zc_config_src_size = len;
ret = 0;
if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_IMPORT, &zc) != 0) {
char desc[1024];
if (newname == NULL)
(void) snprintf(desc, sizeof (desc),
dgettext(TEXT_DOMAIN, "cannot import '%s'"),
thename);
else
(void) snprintf(desc, sizeof (desc),
dgettext(TEXT_DOMAIN, "cannot import '%s' as '%s'"),
origname, thename);
switch (errno) {
case ENOTSUP:
/*
* Unsupported version.
*/
(void) zfs_error(hdl, EZFS_BADVERSION, desc);
break;
case EINVAL:
(void) zfs_error(hdl, EZFS_INVALCONFIG, desc);
break;
default:
(void) zpool_standard_error(hdl, errno, desc);
}
ret = -1;
} else {
zpool_handle_t *zhp;
/*
* This should never fail, but play it safe anyway.
*/
if (zpool_open_silent(hdl, thename, &zhp) != 0) {
ret = -1;
} else if (zhp != NULL) {
ret = zpool_create_zvol_links(zhp);
zpool_close(zhp);
}
}
free(packed);
return (ret);
}
/*
* Add the given vdevs to the pool. The caller must have already performed the
* necessary verification to ensure that the vdev specification is well-formed.
*/
int
zpool_add(zpool_handle_t *zhp, nvlist_t *nvroot)
{
char *packed;
size_t len;
zfs_cmd_t zc;
int ret;
libzfs_handle_t *hdl = zhp->zpool_hdl;
char msg[1024];
nvlist_t **spares;
uint_t nspares;
(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
"cannot add to '%s'"), zhp->zpool_name);
if (zpool_get_version(zhp) < ZFS_VERSION_SPARES &&
nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
&spares, &nspares) == 0) {
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool must be "
"upgraded to add hot spares"));
return (zfs_error(hdl, EZFS_BADVERSION, msg));
}
verify(nvlist_size(nvroot, &len, NV_ENCODE_NATIVE) == 0);
if ((packed = zfs_alloc(zhp->zpool_hdl, len)) == NULL)
return (-1);
verify(nvlist_pack(nvroot, &packed, &len, NV_ENCODE_NATIVE, 0) == 0);
(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
zc.zc_config_src = (uint64_t)(uintptr_t)packed;
zc.zc_config_src_size = len;
if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_VDEV_ADD, &zc) != 0) {
switch (errno) {
case EBUSY:
/*
* This can happen if the user has specified the same
* device multiple times. We can't reliably detect this
* until we try to add it and see we already have a
* label.
*/
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"one or more vdevs refer to the same device"));
(void) zfs_error(hdl, EZFS_BADDEV, msg);
break;
case EOVERFLOW:
/*
* This occurrs when one of the devices is below
* SPA_MINDEVSIZE. Unfortunately, we can't detect which
* device was the problem device since there's no
* reliable way to determine device size from userland.
*/
{
char buf[64];
zfs_nicenum(SPA_MINDEVSIZE, buf, sizeof (buf));
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"device is less than the minimum "
"size (%s)"), buf);
}
(void) zfs_error(hdl, EZFS_BADDEV, msg);
break;
case ENOTSUP:
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"pool must be upgraded to add raidz2 vdevs"));
(void) zfs_error(hdl, EZFS_BADVERSION, msg);
break;
default:
(void) zpool_standard_error(hdl, errno, msg);
}
ret = -1;
} else {
ret = 0;
}
free(packed);
return (ret);
}
/*
* Create the named pool, using the provided vdev list. It is assumed
* that the consumer has already validated the contents of the nvlist, so we
* don't have to worry about error semantics.
*/
int
zpool_create(libzfs_handle_t *hdl, const char *pool, nvlist_t *nvroot,
const char *altroot)
{
zfs_cmd_t zc = { 0 };
char *packed;
size_t len;
char msg[1024];
(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
"cannot create '%s'"), pool);
if (!zpool_name_valid(hdl, B_FALSE, pool))
return (zfs_error(hdl, EZFS_INVALIDNAME, msg));
if (altroot != NULL && altroot[0] != '/')
return (zfs_error(hdl, EZFS_BADPATH,
dgettext(TEXT_DOMAIN, "bad alternate root '%s'"), altroot));
if (nvlist_size(nvroot, &len, NV_ENCODE_NATIVE) != 0)
return (no_memory(hdl));
if ((packed = zfs_alloc(hdl, len)) == NULL)
return (-1);
if (nvlist_pack(nvroot, &packed, &len,
NV_ENCODE_NATIVE, 0) != 0) {
free(packed);
return (no_memory(hdl));
}
(void) strlcpy(zc.zc_name, pool, sizeof (zc.zc_name));
zc.zc_config_src = (uint64_t)(uintptr_t)packed;
zc.zc_config_src_size = len;
if (altroot != NULL)
(void) strlcpy(zc.zc_root, altroot, sizeof (zc.zc_root));
if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_CREATE, &zc) != 0) {
free(packed);
switch (errno) {
case EBUSY:
/*
* This can happen if the user has specified the same
* device multiple times. We can't reliably detect this
* until we try to add it and see we already have a
* label.
*/
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"one or more vdevs refer to the same device"));
return (zfs_error(hdl, EZFS_BADDEV, msg));
case EOVERFLOW:
/*
* This occurs when one of the devices is below
* SPA_MINDEVSIZE. Unfortunately, we can't detect which
* device was the problem device since there's no
* reliable way to determine device size from userland.
*/
{
char buf[64];
zfs_nicenum(SPA_MINDEVSIZE, buf, sizeof (buf));
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"one or more devices is less than the "
"minimum size (%s)"), buf);
}
return (zfs_error(hdl, EZFS_BADDEV, msg));
case ENOSPC:
zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
"one or more devices is out of space"));
return (zfs_error(hdl, EZFS_BADDEV, msg));
default:
return (zpool_standard_error(hdl, errno, msg));
}
}
free(packed);
/*
* If this is an alternate root pool, then we automatically set the
* moutnpoint of the root dataset to be '/'.
*/
if (altroot != NULL) {
zfs_handle_t *zhp;
verify((zhp = zfs_open(hdl, pool, ZFS_TYPE_ANY)) != NULL);
verify(zfs_prop_set(zhp, ZFS_PROP_MOUNTPOINT, "/") == 0);
zfs_close(zhp);
}
return (0);
}
int __osd_sa_xattr_set(const struct lu_env *env, struct osd_object *obj,
const struct lu_buf *buf, const char *name, int fl,
struct osd_thandle *oh)
{
dmu_buf_impl_t *db;
uchar_t *nv_value;
size_t size;
int nv_size;
int rc;
int too_big = 0;
LASSERT(obj->oo_sa_hdl);
if (obj->oo_sa_xattr == NULL) {
rc = __osd_xattr_cache(env, obj);
if (rc)
return rc;
}
LASSERT(obj->oo_sa_xattr);
/* Limited to 32k to keep nvpair memory allocations small */
if (buf->lb_len > DXATTR_MAX_ENTRY_SIZE) {
too_big = 1;
} else {
/* Prevent the DXATTR SA from consuming the entire SA
* region */
rc = -nvlist_size(obj->oo_sa_xattr, &size, NV_ENCODE_XDR);
if (rc)
return rc;
if (size + buf->lb_len > DXATTR_MAX_SA_SIZE)
too_big = 1;
}
/* even in case of -EFBIG we must lookup xattr and check can we
* rewrite it then delete from SA */
rc = -nvlist_lookup_byte_array(obj->oo_sa_xattr, name, &nv_value,
&nv_size);
if (rc == 0) {
if (fl & LU_XATTR_CREATE) {
return -EEXIST;
} else if (too_big) {
rc = -nvlist_remove(obj->oo_sa_xattr, name,
DATA_TYPE_BYTE_ARRAY);
if (rc < 0)
return rc;
rc = __osd_sa_xattr_schedule_update(env, obj, oh);
return rc == 0 ? -EFBIG : rc;
}
} else if (rc == -ENOENT) {
if (fl & LU_XATTR_REPLACE)
return -ENODATA;
else if (too_big)
return -EFBIG;
} else {
return rc;
}
/* Ensure xattr doesn't exist in ZAP */
if (obj->oo_xattr != ZFS_NO_OBJECT) {
struct osd_device *osd = osd_obj2dev(obj);
uint64_t objid;
rc = -zap_lookup(osd->od_os, obj->oo_xattr,
name, 8, 1, &objid);
if (rc == 0) {
rc = -dmu_object_free(osd->od_os, objid, oh->ot_tx);
if (rc == 0)
zap_remove(osd->od_os, obj->oo_xattr,
name, oh->ot_tx);
}
}
rc = -nvlist_add_byte_array(obj->oo_sa_xattr, name,
(uchar_t *)buf->lb_buf, buf->lb_len);
if (rc)
return rc;
/* batch updates only for just created dnodes where we
* used to set number of EAs in a single transaction */
db = (dmu_buf_impl_t *)obj->oo_db;
if (DB_DNODE(db)->dn_allocated_txg == oh->ot_tx->tx_txg)
rc = __osd_sa_xattr_schedule_update(env, obj, oh);
else
rc = __osd_sa_xattr_update(env, obj, oh);
return rc;
}
int __osd_sa_xattr_set(const struct lu_env *env, struct osd_object *obj,
const struct lu_buf *buf, const char *name, int fl,
struct osd_thandle *oh)
{
uchar_t *nv_value;
size_t size;
int nv_size;
int rc;
int too_big = 0;
LASSERT(obj->oo_sa_hdl);
if (obj->oo_sa_xattr == NULL) {
rc = __osd_xattr_cache(env, obj);
if (rc)
return rc;
}
LASSERT(obj->oo_sa_xattr);
/* Limited to 32k to keep nvpair memory allocations small */
if (buf->lb_len > DXATTR_MAX_ENTRY_SIZE) {
too_big = 1;
} else {
/* Prevent the DXATTR SA from consuming the entire SA
* region */
rc = -nvlist_size(obj->oo_sa_xattr, &size, NV_ENCODE_XDR);
if (rc)
return rc;
if (size + buf->lb_len > DXATTR_MAX_SA_SIZE)
too_big = 1;
}
/* even in case of -EFBIG we must lookup xattr and check can we
* rewrite it then delete from SA */
rc = -nvlist_lookup_byte_array(obj->oo_sa_xattr, name, &nv_value,
&nv_size);
if (rc == 0) {
if (fl & LU_XATTR_CREATE) {
return -EEXIST;
} else if (too_big) {
rc = -nvlist_remove(obj->oo_sa_xattr, name,
DATA_TYPE_BYTE_ARRAY);
if (rc < 0)
return rc;
rc = __osd_sa_xattr_update(env, obj, oh);
return rc == 0 ? -EFBIG : rc;
}
} else if (rc == -ENOENT) {
if (fl & LU_XATTR_REPLACE)
return -ENODATA;
else if (too_big)
return -EFBIG;
} else {
return rc;
}
rc = -nvlist_add_byte_array(obj->oo_sa_xattr, name,
(uchar_t *)buf->lb_buf, buf->lb_len);
if (rc)
return rc;
rc = __osd_sa_xattr_update(env, obj, oh);
return rc;
}
static void
spa_config_write(spa_config_dirent_t *dp, nvlist_t *nvl)
{
size_t buflen;
char *buf;
vnode_t *vp;
int oflags = FWRITE | FTRUNC | FCREAT | FOFFMAX;
int error;
char *temp;
/*
* If the nvlist is empty (NULL), then remove the old cachefile.
*/
if (nvl == NULL) {
(void) vn_remove(dp->scd_path, UIO_SYSSPACE, RMFILE);
return;
}
/*
* Pack the configuration into a buffer.
*/
VERIFY(nvlist_size(nvl, &buflen, NV_ENCODE_XDR) == 0);
buf = vmem_alloc(buflen, KM_SLEEP);
temp = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
VERIFY(nvlist_pack(nvl, &buf, &buflen, NV_ENCODE_XDR,
KM_SLEEP) == 0);
#if defined(__linux__) && defined(_KERNEL)
/*
* Write the configuration to disk. Due to the complexity involved
* in performing a rename from within the kernel the file is truncated
* and overwritten in place. In the event of an error the file is
* unlinked to make sure we always have a consistent view of the data.
*/
error = vn_open(dp->scd_path, UIO_SYSSPACE, oflags, 0644, &vp, 0, 0);
if (error == 0) {
error = vn_rdwr(UIO_WRITE, vp, buf, buflen, 0,
UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, NULL);
if (error == 0)
error = VOP_FSYNC(vp, FSYNC, kcred, NULL);
(void) VOP_CLOSE(vp, oflags, 1, 0, kcred, NULL);
if (error)
(void) vn_remove(dp->scd_path, UIO_SYSSPACE, RMFILE);
}
#else
/*
* Write the configuration to disk. We need to do the traditional
* 'write to temporary file, sync, move over original' to make sure we
* always have a consistent view of the data.
*/
(void) snprintf(temp, MAXPATHLEN, "%s.tmp", dp->scd_path);
error = vn_open(temp, UIO_SYSSPACE, oflags, 0644, &vp, CRCREAT, 0);
if (error == 0) {
if (vn_rdwr(UIO_WRITE, vp, buf, buflen, 0, UIO_SYSSPACE,
0, RLIM64_INFINITY, kcred, NULL) == 0 &&
VOP_FSYNC(vp, FSYNC, kcred, NULL) == 0) {
(void) vn_rename(temp, dp->scd_path, UIO_SYSSPACE);
}
(void) VOP_CLOSE(vp, oflags, 1, 0, kcred, NULL);
}
(void) vn_remove(temp, UIO_SYSSPACE, RMFILE);
#endif
vmem_free(buf, buflen);
kmem_free(temp, MAXPATHLEN);
}
static void *
nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
{
unsigned char *buf, *ptr;
size_t left, size;
const nvlist_t *tmpnvl;
nvpair_t *nvp, *tmpnvp;
void *cookie;
NVLIST_ASSERT(nvl);
if (nvl->nvl_error != 0) {
ERRNO_SET(nvl->nvl_error);
return (NULL);
}
size = nvlist_size(nvl);
buf = nv_malloc(size);
if (buf == NULL)
return (NULL);
ptr = buf;
left = size;
ptr = nvlist_pack_header(nvl, ptr, &left);
nvp = nvlist_first_nvpair(nvl);
while (nvp != NULL) {
NVPAIR_ASSERT(nvp);
nvpair_init_datasize(nvp);
ptr = nvpair_pack_header(nvp, ptr, &left);
if (ptr == NULL) {
nv_free(buf);
return (NULL);
}
switch (nvpair_type(nvp)) {
case NV_TYPE_NULL:
ptr = nvpair_pack_null(nvp, ptr, &left);
break;
case NV_TYPE_BOOL:
ptr = nvpair_pack_bool(nvp, ptr, &left);
break;
case NV_TYPE_NUMBER:
ptr = nvpair_pack_number(nvp, ptr, &left);
break;
case NV_TYPE_STRING:
ptr = nvpair_pack_string(nvp, ptr, &left);
break;
case NV_TYPE_NVLIST:
tmpnvl = nvpair_get_nvlist(nvp);
ptr = nvlist_pack_header(tmpnvl, ptr, &left);
if (ptr == NULL)
goto out;
tmpnvp = nvlist_first_nvpair(tmpnvl);
if (tmpnvp != NULL) {
nvl = tmpnvl;
nvp = tmpnvp;
continue;
}
ptr = nvpair_pack_nvlist_up(ptr, &left);
break;
#ifndef _KERNEL
case NV_TYPE_DESCRIPTOR:
ptr = nvpair_pack_descriptor(nvp, ptr, fdidxp, &left);
break;
#endif
case NV_TYPE_BINARY:
ptr = nvpair_pack_binary(nvp, ptr, &left);
break;
default:
PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
}
if (ptr == NULL) {
nv_free(buf);
return (NULL);
}
while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
cookie = NULL;
nvl = nvlist_get_parent(nvl, &cookie);
if (nvl == NULL)
goto out;
nvp = cookie;
ptr = nvpair_pack_nvlist_up(ptr, &left);
if (ptr == NULL)
goto out;
}
}
out:
if (sizep != NULL)
*sizep = size;
return (buf);
}
/*
* Synchronize all pools to disk. This must be called with the namespace lock
* held.
*/
void
spa_config_sync(void)
{
spa_t *spa = NULL;
nvlist_t *config;
size_t buflen;
char *buf;
vnode_t *vp;
int oflags = FWRITE | FTRUNC | FCREAT | FOFFMAX;
char pathname[128];
char pathname2[128];
ASSERT(MUTEX_HELD(&spa_namespace_lock));
VERIFY(nvlist_alloc(&config, NV_UNIQUE_NAME, KM_SLEEP) == 0);
/*
* Add all known pools to the configuration list, ignoring those with
* alternate root paths.
*/
spa = NULL;
while ((spa = spa_next(spa)) != NULL) {
mutex_enter(&spa->spa_config_cache_lock);
if (spa->spa_config && spa->spa_name && spa->spa_root == NULL)
VERIFY(nvlist_add_nvlist(config, spa->spa_name,
spa->spa_config) == 0);
mutex_exit(&spa->spa_config_cache_lock);
}
/*
* Pack the configuration into a buffer.
*/
VERIFY(nvlist_size(config, &buflen, NV_ENCODE_XDR) == 0);
buf = kmem_alloc(buflen, KM_SLEEP);
VERIFY(nvlist_pack(config, &buf, &buflen, NV_ENCODE_XDR,
KM_SLEEP) == 0);
/*
* Write the configuration to disk. We need to do the traditional
* 'write to temporary file, sync, move over original' to make sure we
* always have a consistent view of the data.
*/
(void) snprintf(pathname, sizeof (pathname), "%s/%s", spa_config_dir,
ZPOOL_CACHE_TMP);
if (vn_open(pathname, UIO_SYSSPACE, oflags, 0644, &vp, CRCREAT, 0) != 0)
goto out;
if (vn_rdwr(UIO_WRITE, vp, buf, buflen, 0, UIO_SYSSPACE,
0, RLIM64_INFINITY, kcred, NULL) == 0 &&
VOP_FSYNC(vp, FSYNC, kcred) == 0) {
(void) snprintf(pathname2, sizeof (pathname2), "%s/%s",
spa_config_dir, ZPOOL_CACHE_FILE);
(void) vn_rename(pathname, pathname2, UIO_SYSSPACE);
}
(void) VOP_CLOSE(vp, oflags, 1, 0, kcred);
VN_RELE(vp);
out:
(void) vn_remove(pathname, UIO_SYSSPACE, RMFILE);
spa_config_generation++;
kmem_free(buf, buflen);
nvlist_free(config);
}
static
#endif
int
zfs_fuid_find_by_domain(zfsvfs_t *zfsvfs, const char *domain, char **retdomain,
dmu_tx_t *tx)
{
fuid_domain_t searchnode, *findnode;
avl_index_t loc;
/*
* If the dummy "nobody" domain then return an index of 0
* to cause the created FUID to be a standard POSIX id
* for the user nobody.
*/
if (domain[0] == '\0') {
*retdomain = "";
return (0);
}
searchnode.f_ksid = ksid_lookupdomain(domain);
if (retdomain) {
*retdomain = searchnode.f_ksid->kd_name;
}
if (!zfsvfs->z_fuid_loaded)
zfs_fuid_init(zfsvfs, tx);
rw_enter(&zfsvfs->z_fuid_lock, RW_READER);
findnode = avl_find(&zfsvfs->z_fuid_domain, &searchnode, &loc);
rw_exit(&zfsvfs->z_fuid_lock);
if (findnode) {
ksiddomain_rele(searchnode.f_ksid);
return (findnode->f_idx);
} else {
fuid_domain_t *domnode;
nvlist_t *nvp;
nvlist_t **fuids;
uint64_t retidx;
size_t nvsize = 0;
char *packed;
dmu_buf_t *db;
int i = 0;
domnode = kmem_alloc(sizeof (fuid_domain_t), KM_SLEEP);
domnode->f_ksid = searchnode.f_ksid;
rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER);
retidx = domnode->f_idx = avl_numnodes(&zfsvfs->z_fuid_idx) + 1;
avl_add(&zfsvfs->z_fuid_domain, domnode);
avl_add(&zfsvfs->z_fuid_idx, domnode);
/*
* Now resync the on-disk nvlist.
*/
VERIFY(nvlist_alloc(&nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);
domnode = avl_first(&zfsvfs->z_fuid_domain);
fuids = kmem_alloc(retidx * sizeof (void *), KM_SLEEP);
while (domnode) {
VERIFY(nvlist_alloc(&fuids[i],
NV_UNIQUE_NAME, KM_SLEEP) == 0);
VERIFY(nvlist_add_uint64(fuids[i], FUID_IDX,
domnode->f_idx) == 0);
VERIFY(nvlist_add_uint64(fuids[i],
FUID_OFFSET, 0) == 0);
VERIFY(nvlist_add_string(fuids[i++], FUID_DOMAIN,
domnode->f_ksid->kd_name) == 0);
domnode = AVL_NEXT(&zfsvfs->z_fuid_domain, domnode);
}
VERIFY(nvlist_add_nvlist_array(nvp, FUID_NVP_ARRAY,
fuids, retidx) == 0);
for (i = 0; i != retidx; i++)
nvlist_free(fuids[i]);
kmem_free(fuids, retidx * sizeof (void *));
VERIFY(nvlist_size(nvp, &nvsize, NV_ENCODE_XDR) == 0);
packed = kmem_alloc(nvsize, KM_SLEEP);
VERIFY(nvlist_pack(nvp, &packed, &nvsize,
NV_ENCODE_XDR, KM_SLEEP) == 0);
nvlist_free(nvp);
zfsvfs->z_fuid_size = nvsize;
dmu_write(zfsvfs->z_os, zfsvfs->z_fuid_obj, 0,
zfsvfs->z_fuid_size, packed, tx);
kmem_free(packed, zfsvfs->z_fuid_size);
VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, zfsvfs->z_fuid_obj,
FTAG, &db));
dmu_buf_will_dirty(db, tx);
*(uint64_t *)db->db_data = zfsvfs->z_fuid_size;
dmu_buf_rele(db, FTAG);
rw_exit(&zfsvfs->z_fuid_lock);
return (retidx);
}
}
/*
* sync out AVL trees to persistent storage.
*/
void
zfs_fuid_sync(zfsvfs_t *zfsvfs, dmu_tx_t *tx)
{
#ifdef HAVE_ZPL
nvlist_t *nvp;
nvlist_t **fuids;
size_t nvsize = 0;
char *packed;
dmu_buf_t *db;
fuid_domain_t *domnode;
int numnodes;
int i;
if (!zfsvfs->z_fuid_dirty) {
return;
}
rw_enter(&zfsvfs->z_fuid_lock, RW_WRITER);
/*
* First see if table needs to be created?
*/
if (zfsvfs->z_fuid_obj == 0) {
zfsvfs->z_fuid_obj = dmu_object_alloc(zfsvfs->z_os,
DMU_OT_FUID, 1 << 14, DMU_OT_FUID_SIZE,
sizeof (uint64_t), tx);
VERIFY(zap_add(zfsvfs->z_os, MASTER_NODE_OBJ,
ZFS_FUID_TABLES, sizeof (uint64_t), 1,
&zfsvfs->z_fuid_obj, tx) == 0);
}
VERIFY(nvlist_alloc(&nvp, NV_UNIQUE_NAME, KM_SLEEP) == 0);
numnodes = avl_numnodes(&zfsvfs->z_fuid_idx);
fuids = kmem_alloc(numnodes * sizeof (void *), KM_SLEEP);
for (i = 0, domnode = avl_first(&zfsvfs->z_fuid_domain); domnode; i++,
domnode = AVL_NEXT(&zfsvfs->z_fuid_domain, domnode)) {
VERIFY(nvlist_alloc(&fuids[i], NV_UNIQUE_NAME, KM_SLEEP) == 0);
VERIFY(nvlist_add_uint64(fuids[i], FUID_IDX,
domnode->f_idx) == 0);
VERIFY(nvlist_add_uint64(fuids[i], FUID_OFFSET, 0) == 0);
VERIFY(nvlist_add_string(fuids[i], FUID_DOMAIN,
domnode->f_ksid->kd_name) == 0);
}
VERIFY(nvlist_add_nvlist_array(nvp, FUID_NVP_ARRAY,
fuids, numnodes) == 0);
for (i = 0; i != numnodes; i++)
nvlist_free(fuids[i]);
kmem_free(fuids, numnodes * sizeof (void *));
VERIFY(nvlist_size(nvp, &nvsize, NV_ENCODE_XDR) == 0);
packed = kmem_alloc(nvsize, KM_SLEEP);
VERIFY(nvlist_pack(nvp, &packed, &nvsize,
NV_ENCODE_XDR, KM_SLEEP) == 0);
nvlist_free(nvp);
zfsvfs->z_fuid_size = nvsize;
dmu_write(zfsvfs->z_os, zfsvfs->z_fuid_obj, 0,
zfsvfs->z_fuid_size, packed, tx);
kmem_free(packed, zfsvfs->z_fuid_size);
VERIFY(0 == dmu_bonus_hold(zfsvfs->z_os, zfsvfs->z_fuid_obj,
FTAG, &db));
dmu_buf_will_dirty(db, tx);
*(uint64_t *)db->db_data = zfsvfs->z_fuid_size;
dmu_buf_rele(db, FTAG);
zfsvfs->z_fuid_dirty = B_FALSE;
rw_exit(&zfsvfs->z_fuid_lock);
#endif /* HAVE_ZPL */
}
