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

static intzfs_replay_rename(zfsvfs_t *zfsvfs, lr_rename_t *lr, boolean_t byteswap){	char *sname = (char *)(lr + 1);	/* sname and tname follow lr_rename_t */	char *tname = sname + strlen(sname) + 1;	znode_t *sdzp, *tdzp;	int error;	int vflg = 0;	if (byteswap)		byteswap_uint64_array(lr, sizeof (*lr));	if ((error = zfs_zget(zfsvfs, lr->lr_sdoid, &sdzp)) != 0)		return (error);	if ((error = zfs_zget(zfsvfs, lr->lr_tdoid, &tdzp)) != 0) {		iput(ZTOI(sdzp));		return (error);	}	if (lr->lr_common.lrc_txtype & TX_CI)		vflg |= FIGNORECASE;	error = zfs_rename(ZTOI(sdzp), sname, ZTOI(tdzp), tname, kcred, vflg);	iput(ZTOI(tdzp));	iput(ZTOI(sdzp));	return (error);}

static intzfs_replay_link(zfsvfs_t *zfsvfs, lr_link_t *lr, boolean_t byteswap){	char *name = (char *)(lr + 1);	/* name follows lr_link_t */	znode_t *dzp, *zp;	int error;	int vflg = 0;	if (byteswap)		byteswap_uint64_array(lr, sizeof (*lr));	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)		return (error);	if ((error = zfs_zget(zfsvfs, lr->lr_link_obj, &zp)) != 0) {		iput(ZTOI(dzp));		return (error);	}	if (lr->lr_common.lrc_txtype & TX_CI)		vflg |= FIGNORECASE;	error = zfs_link(ZTOI(dzp), ZTOI(zp), name, kcred, vflg);	iput(ZTOI(zp));	iput(ZTOI(dzp));	return (error);}

static int zfsfuse_rename(fuse_req_t req, fuse_ino_t parent, const char *name, fuse_ino_t newparent, const char *newname){	if(strlen(name) >= MAXNAMELEN)		return ENAMETOOLONG;	if(strlen(newname) >= MAXNAMELEN)		return ENAMETOOLONG;	vfs_t *vfs = (vfs_t *) fuse_req_userdata(req);	zfsvfs_t *zfsvfs = vfs->vfs_data;	ZFS_ENTER(zfsvfs);	znode_t *p_znode, *np_znode;	int error = zfs_zget(zfsvfs, parent, &p_znode, B_FALSE);	if(error) {		ZFS_EXIT(zfsvfs);		/* If the inode we are trying to get was recently deleted		   dnode_hold_impl will return EEXIST instead of ENOENT */		return error == EEXIST ? ENOENT : error;	}	ASSERT(p_znode != NULL);	error = zfs_zget(zfsvfs, newparent, &np_znode, B_FALSE);	if(error) {		VN_RELE(ZTOV(p_znode));		ZFS_EXIT(zfsvfs);		/* If the inode we are trying to get was recently deleted		   dnode_hold_impl will return EEXIST instead of ENOENT */		return error == EEXIST ? ENOENT : error;	}	ASSERT(np_znode != NULL);	vnode_t *p_vp = ZTOV(p_znode);	vnode_t *np_vp = ZTOV(np_znode);	ASSERT(p_vp != NULL);	ASSERT(np_vp != NULL);	cred_t cred;	zfsfuse_getcred(req, &cred);	error = VOP_RENAME(p_vp, (char *) name, np_vp, (char *) newname, &cred, NULL, 0);	VN_RELE(p_vp);	VN_RELE(np_vp);	ZFS_EXIT(zfsvfs);	return error;}

static intzfs_replay_truncate(zfsvfs_t *zfsvfs, lr_truncate_t *lr, boolean_t byteswap){	znode_t *zp;	flock64_t fl;	int error;	if (byteswap)		byteswap_uint64_array(lr, sizeof (*lr));	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)		return (error);	bzero(&fl, sizeof (fl));	fl.l_type = F_WRLCK;	fl.l_whence = 0;	fl.l_start = lr->lr_offset;	fl.l_len = lr->lr_length;	error = zfs_space(ZTOI(zp), F_FREESP, &fl, FWRITE | FOFFMAX,	    lr->lr_offset, kcred);	iput(ZTOI(zp));	return (error);}

static intzfs_replay_remove(zfsvfs_t *zfsvfs, lr_remove_t *lr, boolean_t byteswap){	char *name = (char *)(lr + 1);	/* name follows lr_remove_t */	znode_t *dzp;	int error;	int vflg = 0;	if (byteswap)		byteswap_uint64_array(lr, sizeof (*lr));	if ((error = zfs_zget(zfsvfs, lr->lr_doid, &dzp)) != 0)		return (error);	if (lr->lr_common.lrc_txtype & TX_CI)		vflg |= FIGNORECASE;	switch ((int)lr->lr_common.lrc_txtype) {	case TX_REMOVE:		error = zfs_remove(ZTOI(dzp), name, kcred, vflg);		break;	case TX_RMDIR:		error = zfs_rmdir(ZTOI(dzp), name, NULL, kcred, vflg);		break;	default:		error = SET_ERROR(ENOTSUP);	}	iput(ZTOI(dzp));	return (error);}

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

/* * Look up an entry in a directory. * * NOTE: '.' and '..' are handled as special cases because *	no directory entries are actually stored for them.  If this is *	the root of a filesystem, then '.zfs' is also treated as a *	special pseudo-directory. */intzfs_dirlook(znode_t *dzp, char *name, struct inode **ipp, int flags,            int *deflg, pathname_t *rpnp){    zfs_dirlock_t *dl;    znode_t *zp;    int error = 0;    uint64_t parent;    if (name[0] == 0 || (name[0] == '.' && name[1] == 0)) {        *ipp = ZTOI(dzp);        igrab(*ipp);    } else if (name[0] == '.' && name[1] == '.' && name[2] == 0) {        zfs_sb_t *zsb = ZTOZSB(dzp);        /*         * If we are a snapshot mounted under .zfs, return         * the vp for the snapshot directory.         */        if ((error = sa_lookup(dzp->z_sa_hdl,                               SA_ZPL_PARENT(zsb), &parent, sizeof (parent))) != 0)            return (error);#ifdef HAVE_SNAPSHOT        if (parent == dzp->z_id && zsb->z_parent != zsb) {            error = zfsctl_root_lookup(zsb->z_parent->z_ctldir,                                       "snapshot", ipp, NULL, 0, NULL, kcred,                                       NULL, NULL, NULL);            return (error);        }#endif /* HAVE_SNAPSHOT */        rw_enter(&dzp->z_parent_lock, RW_READER);        error = zfs_zget(zsb, parent, &zp);        if (error == 0)            *ipp = ZTOI(zp);        rw_exit(&dzp->z_parent_lock);#ifdef HAVE_SNAPSHOT    } else if (zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0) {        *ipp = zfsctl_root(dzp);#endif /* HAVE_SNAPSHOT */    } else {        int zf;        zf = ZEXISTS | ZSHARED;        if (flags & FIGNORECASE)            zf |= ZCILOOK;        error = zfs_dirent_lock(&dl, dzp, name, &zp, zf, deflg, rpnp);        if (error == 0) {            *ipp = ZTOI(zp);            zfs_dirent_unlock(dl);            dzp->z_zn_prefetch = B_TRUE; /* enable prefetching */        }        rpnp = NULL;    }    if ((flags & FIGNORECASE) && rpnp && !error)        (void) strlcpy(rpnp->pn_buf, name, rpnp->pn_bufsize);    return (error);}

static int zfsfuse_getattr(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi){	vfs_t *vfs = (vfs_t *) fuse_req_userdata(req);	zfsvfs_t *zfsvfs = vfs->vfs_data;	ZFS_ENTER(zfsvfs);	znode_t *znode;	int error = zfs_zget(zfsvfs, ino, &znode, B_TRUE);	if(error) {		ZFS_EXIT(zfsvfs);		/* If the inode we are trying to get was recently deleted		   dnode_hold_impl will return EEXIST instead of ENOENT */		return error == EEXIST ? ENOENT : error;	}	ASSERT(znode != NULL);	vnode_t *vp = ZTOV(znode);	ASSERT(vp != NULL);	cred_t cred;	zfsfuse_getcred(req, &cred);	struct stat stbuf;	error = zfsfuse_stat(vp, &stbuf, &cred);	VN_RELE(vp);	ZFS_EXIT(zfsvfs);	if(!error)		fuse_reply_attr(req, &stbuf, 0.0);	return error;}

voidzfs_rmnode(znode_t *zp){    zfsvfs_t	*zfsvfs = zp->z_zfsvfs;    objset_t	*os = zfsvfs->z_os;    znode_t		*xzp = NULL;    dmu_tx_t	*tx;    uint64_t	acl_obj;    uint64_t	xattr_obj;    int		error;    ASSERT(zp->z_links == 0);    ASSERT_VOP_ELOCKED(ZTOV(zp), __func__);    /*     * If this is an attribute directory, purge its contents.     */    if (ZTOV(zp) != NULL && ZTOV(zp)->v_type == VDIR &&            (zp->z_pflags & ZFS_XATTR)) {        if (zfs_purgedir(zp) != 0) {            /*             * Not enough space to delete some xattrs.             * Leave it in the unlinked set.             */            zfs_znode_dmu_fini(zp);            zfs_znode_free(zp);            return;        }    } else {        /*         * Free up all the data in the file.  We don't do this for         * XATTR directories because we need truncate and remove to be         * in the same tx, like in zfs_znode_delete(). Otherwise, if         * we crash here we'll end up with an inconsistent truncated         * zap object in the delete queue.  Note a truncated file is         * harmless since it only contains user data.         */        error = dmu_free_long_range(os, zp->z_id, 0, DMU_OBJECT_END);        if (error) {            /*             * Not enough space.  Leave the file in the unlinked             * set.             */            zfs_znode_dmu_fini(zp);            zfs_znode_free(zp);            return;        }    }    /*     * If the file has extended attributes, we're going to unlink     * the xattr dir.     */    error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),                      &xattr_obj, sizeof (xattr_obj));    if (error == 0 && xattr_obj) {        error = zfs_zget(zfsvfs, xattr_obj, &xzp);        ASSERT3S(error, ==, 0);        vn_lock(ZTOV(xzp), LK_EXCLUSIVE | LK_RETRY);    }

static intzfs_replay_write(zfsvfs_t *zsb, lr_write_t *lr, boolean_t byteswap){	char *data = (char *)(lr + 1);	/* data follows lr_write_t */	znode_t	*zp;	int error;	uint64_t eod, offset, length;    ssize_t resid;	if (byteswap)		byteswap_uint64_array(lr, sizeof (*lr));	if ((error = zfs_zget(zsb, lr->lr_foid, &zp)) != 0) {		/*		 * As we can log writes out of order, it's possible the		 * file has been removed. In this case just drop the write		 * and return success.		 */		if (error == ENOENT)			error = 0;		return (error);	}    zfs_znode_wait_vnode(zp);	offset = lr->lr_offset;	length = lr->lr_length;	eod = offset + length;	/* end of data for this write */	/*	 * This may be a write from a dmu_sync() for a whole block,	 * and may extend beyond the current end of the file.	 * We can't just replay what was written for this TX_WRITE as	 * a future TX_WRITE2 may extend the eof and the data for that	 * write needs to be there. So we write the whole block and	 * reduce the eof. This needs to be done within the single dmu	 * transaction created within vn_rdwr -> zfs_write. So a possible	 * new end of file is passed through in zsb->z_replay_eof	 */	zsb->z_replay_eof = 0; /* 0 means don't change end of file */	/* If it's a dmu_sync() block, write the whole block */	if (lr->lr_common.lrc_reclen == sizeof (lr_write_t)) {		uint64_t blocksize = BP_GET_LSIZE(&lr->lr_blkptr);		if (length < blocksize) {			offset -= offset % blocksize;			length = blocksize;		}		if (zp->z_size < eod)			zsb->z_replay_eof = eod;	}    error = vn_rdwr(UIO_WRITE, ZTOV(zp), data, length, offset,                    UIO_SYSSPACE, 0, RLIM64_INFINITY, kcred, &resid);    VN_RELE(ZTOV(zp));	zsb->z_replay_eof = 0;	/* safety */	return (error);}

static int zfsfuse_lookup(fuse_req_t req, fuse_ino_t parent, const char *name){	if(strlen(name) >= MAXNAMELEN)		return ENAMETOOLONG;	vfs_t *vfs = (vfs_t *) fuse_req_userdata(req);	zfsvfs_t *zfsvfs = vfs->vfs_data;	ZFS_ENTER(zfsvfs);	znode_t *znode;	int error = zfs_zget(zfsvfs, parent, &znode, B_TRUE);	if(error) {		ZFS_EXIT(zfsvfs);		/* If the inode we are trying to get was recently deleted		   dnode_hold_impl will return EEXIST instead of ENOENT */		return error == EEXIST ? ENOENT : error;	}	ASSERT(znode != NULL);	vnode_t *dvp = ZTOV(znode);	ASSERT(dvp != NULL);	vnode_t *vp = NULL;	cred_t cred;	zfsfuse_getcred(req, &cred);	error = VOP_LOOKUP(dvp, (char *) name, &vp, NULL, 0, NULL, &cred, NULL, NULL, NULL);	if(error)		goto out;	struct fuse_entry_param e = { 0 };	e.attr_timeout = 0.0;	e.entry_timeout = 0.0;	if(vp == NULL)		goto out;	e.ino = VTOZ(vp)->z_id;	if(e.ino == 3)		e.ino = 1;	e.generation = VTOZ(vp)->z_phys->zp_gen;	error = zfsfuse_stat(vp, &e.attr, &cred);out:	if(vp != NULL)		VN_RELE(vp);	VN_RELE(dvp);	ZFS_EXIT(zfsvfs);	if(!error)		fuse_reply_entry(req, &e);	return error;}

static intzfs_replay_acl_v0(zfsvfs_t *zfsvfs, lr_acl_v0_t *lr, boolean_t byteswap){	ace_t *ace = (ace_t *)(lr + 1);	/* ace array follows lr_acl_t */	vsecattr_t vsa;	znode_t *zp;	int error;	if (byteswap) {		byteswap_uint64_array(lr, sizeof (*lr));		zfs_oldace_byteswap(ace, lr->lr_aclcnt);	}	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)		return (error);	bzero(&vsa, sizeof (vsa));	vsa.vsa_mask = VSA_ACE | VSA_ACECNT;	vsa.vsa_aclcnt = lr->lr_aclcnt;	vsa.vsa_aclentsz = sizeof (ace_t) * vsa.vsa_aclcnt;	vsa.vsa_aclflags = 0;	vsa.vsa_aclentp = ace;	error = zfs_setsecattr(ZTOI(zp), &vsa, 0, kcred);	iput(ZTOI(zp));	return (error);}

static intzfs_replay_acl_v0(zfsvfs_t *zfsvfs, lr_acl_v0_t *lr, boolean_t byteswap){	ace_t *ace = (ace_t *)(lr + 1);	/* ace array follows lr_acl_t */	vsecattr_t vsa;	znode_t *zp;	int error;	if (byteswap) {		byteswap_uint64_array(lr, sizeof (*lr));		zfs_oldace_byteswap(ace, lr->lr_aclcnt);	}	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)		return (error);	bzero(&vsa, sizeof (vsa));	vsa.vsa_mask = VSA_ACE | VSA_ACECNT;	vsa.vsa_aclcnt = lr->lr_aclcnt;	vsa.vsa_aclentsz = sizeof (ace_t) * vsa.vsa_aclcnt;	vsa.vsa_aclflags = 0;	vsa.vsa_aclentp = ace;#ifdef TODO	error = VOP_SETSECATTR(ZTOV(zp), &vsa, 0, kcred, NULL);#else	panic("%s:%u: unsupported condition", __func__, __LINE__);#endif	VN_RELE(ZTOV(zp));	return (error);}

/* ARGSUSED */intzfsctl_shares_lookup(struct inode *dip, char *name, struct inode **ipp,    int flags, cred_t *cr, int *direntflags, pathname_t *realpnp){	zfs_sb_t *zsb = ITOZSB(dip);	struct inode *ip;	znode_t *dzp;	int error;	ZFS_ENTER(zsb);	if (zsb->z_shares_dir == 0) {		ZFS_EXIT(zsb);		return (ENOTSUP);	}	error = zfs_zget(zsb, zsb->z_shares_dir, &dzp);	if (error) {		ZFS_EXIT(zsb);		return (error);	}	error = zfs_lookup(ZTOI(dzp), name, &ip, 0, cr, NULL, NULL);	iput(ZTOI(dzp));	ZFS_EXIT(zsb);	return (error);}

static intzfs_replay_truncate(zfsvfs_t *zfsvfs, lr_truncate_t *lr, boolean_t byteswap){#ifdef sun	znode_t *zp;	flock64_t fl;	int error;	if (byteswap)		byteswap_uint64_array(lr, sizeof (*lr));	if ((error = zfs_zget(zfsvfs, lr->lr_foid, &zp)) != 0)		return (error);	bzero(&fl, sizeof (fl));	fl.l_type = F_WRLCK;	fl.l_whence = 0;	fl.l_start = lr->lr_offset;	fl.l_len = lr->lr_length;	error = VOP_SPACE(ZTOV(zp), F_FREESP, &fl, FWRITE | FOFFMAX,	    lr->lr_offset, kcred, NULL);	VN_RELE(ZTOV(zp));	return (error);#else	/* !sun */	ZFS_LOG(0, "Unexpected code path, report to [email
C++ zgemm_函数代码示例
C++ zfs_strdup函数代码示例