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

intxfs_readlink_by_handle(	struct file		*parfilp,	xfs_fsop_handlereq_t	*hreq){	struct dentry		*dentry;	__u32			olen;	int			error;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	dentry = xfs_handlereq_to_dentry(parfilp, hreq);	if (IS_ERR(dentry))		return PTR_ERR(dentry);	/* Restrict this handle operation to symlinks only. */	if (!d_is_symlink(dentry)) {		error = -EINVAL;		goto out_dput;	}	if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {		error = -EFAULT;		goto out_dput;	}	error = vfs_readlink(dentry, hreq->ohandle, olen); out_dput:	dput(dentry);	return error;}

STATIC intxfs_attrlist_by_handle(	struct file		*parfilp,	void			__user *arg){	int			error = -ENOMEM;	attrlist_cursor_kern_t	*cursor;	struct xfs_fsop_attrlist_handlereq __user	*p = arg;	xfs_fsop_attrlist_handlereq_t al_hreq;	struct dentry		*dentry;	char			*kbuf;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))		return -EFAULT;	if (al_hreq.buflen < sizeof(struct attrlist) ||	    al_hreq.buflen > XFS_XATTR_LIST_MAX)		return -EINVAL;	/*	 * Reject flags, only allow namespaces.	 */	if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))		return -EINVAL;	dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);	if (IS_ERR(dentry))		return PTR_ERR(dentry);	kbuf = kmem_zalloc_large(al_hreq.buflen, KM_SLEEP);	if (!kbuf)		goto out_dput;	cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;	error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen,					al_hreq.flags, cursor);	if (error)		goto out_kfree;	if (copy_to_user(&p->pos, cursor, sizeof(attrlist_cursor_kern_t))) {		error = -EFAULT;		goto out_kfree;	}	if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))		error = -EFAULT;out_kfree:	kmem_free(kbuf);out_dput:	dput(dentry);	return error;}

STATIC intxfs_attrlist_by_handle(	struct file		*parfilp,	void			__user *arg){	int			error = -ENOMEM;	attrlist_cursor_kern_t	*cursor;	xfs_fsop_attrlist_handlereq_t al_hreq;	struct dentry		*dentry;	char			*kbuf;	if (!capable(CAP_SYS_ADMIN))		return -XFS_ERROR(EPERM);	if (copy_from_user(&al_hreq, arg, sizeof(xfs_fsop_attrlist_handlereq_t)))		return -XFS_ERROR(EFAULT);	if (al_hreq.buflen < sizeof(struct attrlist) ||	    al_hreq.buflen > XATTR_LIST_MAX)		return -XFS_ERROR(EINVAL);	/*	 * Reject flags, only allow namespaces.	 */	if (al_hreq.flags & ~(ATTR_ROOT | ATTR_SECURE))		return -XFS_ERROR(EINVAL);	dentry = xfs_handlereq_to_dentry(parfilp, &al_hreq.hreq);	if (IS_ERR(dentry))		return PTR_ERR(dentry);	kbuf = kmem_zalloc(al_hreq.buflen, KM_SLEEP | KM_MAYFAIL);	if (!kbuf) {		kbuf = kmem_zalloc_large(al_hreq.buflen);		if (!kbuf)			goto out_dput;	}	cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;	error = -xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen,					al_hreq.flags, cursor);	if (error)		goto out_kfree;	if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))		error = -EFAULT; out_kfree:	if (is_vmalloc_addr(kbuf))		kmem_free_large(kbuf);	else		kmem_free(kbuf); out_dput:	dput(dentry);	return error;}

intxfs_readlink_by_handle(	struct file		*parfilp,	xfs_fsop_handlereq_t	*hreq){	struct dentry		*dentry;	__u32			olen;	void			*link;	int			error;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	dentry = xfs_handlereq_to_dentry(parfilp, hreq);	if (IS_ERR(dentry))		return PTR_ERR(dentry);	/* Restrict this handle operation to symlinks only. */	if (!d_is_symlink(dentry)) {		error = -EINVAL;		goto out_dput;	}	if (copy_from_user(&olen, hreq->ohandlen, sizeof(__u32))) {		error = -EFAULT;		goto out_dput;	}	link = kmalloc(MAXPATHLEN+1, GFP_KERNEL);	if (!link) {		error = -ENOMEM;		goto out_dput;	}	error = xfs_readlink(XFS_I(d_inode(dentry)), link);	if (error)		goto out_kfree;	error = readlink_copy(hreq->ohandle, olen, link);	if (error)		goto out_kfree; out_kfree:	kfree(link); out_dput:	dput(dentry);	return error;}

STATIC intxfs_fssetdm_by_handle(	struct file		*parfilp,	void			__user *arg){	int			error;	struct fsdmidata	fsd;	xfs_fsop_setdm_handlereq_t dmhreq;	struct dentry		*dentry;	if (!capable(CAP_MKNOD))		return -EPERM;	if (copy_from_user(&dmhreq, arg, sizeof(xfs_fsop_setdm_handlereq_t)))		return -EFAULT;	error = mnt_want_write_file(parfilp);	if (error)		return error;	dentry = xfs_handlereq_to_dentry(parfilp, &dmhreq.hreq);	if (IS_ERR(dentry)) {		mnt_drop_write_file(parfilp);		return PTR_ERR(dentry);	}	if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) {		error = -EPERM;		goto out;	}	if (copy_from_user(&fsd, dmhreq.data, sizeof(fsd))) {		error = -EFAULT;		goto out;	}	error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask,				 fsd.fsd_dmstate); out:	mnt_drop_write_file(parfilp);	dput(dentry);	return error;}

STATIC intxfs_attrmulti_by_handle(	struct file		*parfilp,	void			__user *arg){	int			error;	xfs_attr_multiop_t	*ops;	xfs_fsop_attrmulti_handlereq_t am_hreq;	struct dentry		*dentry;	unsigned int		i, size;	unsigned char		*attr_name;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	if (copy_from_user(&am_hreq, arg, sizeof(xfs_fsop_attrmulti_handlereq_t)))		return -EFAULT;	/* overflow check */	if (am_hreq.opcount >= INT_MAX / sizeof(xfs_attr_multiop_t))		return -E2BIG;	dentry = xfs_handlereq_to_dentry(parfilp, &am_hreq.hreq);	if (IS_ERR(dentry))		return PTR_ERR(dentry);	error = -E2BIG;	size = am_hreq.opcount * sizeof(xfs_attr_multiop_t);	if (!size || size > 16 * PAGE_SIZE)		goto out_dput;	ops = memdup_user(am_hreq.ops, size);	if (IS_ERR(ops)) {		error = PTR_ERR(ops);		goto out_dput;	}	error = -ENOMEM;	attr_name = kmalloc(MAXNAMELEN, GFP_KERNEL);	if (!attr_name)		goto out_kfree_ops;	error = 0;	for (i = 0; i < am_hreq.opcount; i++) {		ops[i].am_error = strncpy_from_user((char *)attr_name,				ops[i].am_attrname, MAXNAMELEN);		if (ops[i].am_error == 0 || ops[i].am_error == MAXNAMELEN)			error = -ERANGE;		if (ops[i].am_error < 0)			break;		switch (ops[i].am_opcode) {		case ATTR_OP_GET:			ops[i].am_error = xfs_attrmulti_attr_get(					d_inode(dentry), attr_name,					ops[i].am_attrvalue, &ops[i].am_length,					ops[i].am_flags);			break;		case ATTR_OP_SET:			ops[i].am_error = mnt_want_write_file(parfilp);			if (ops[i].am_error)				break;			ops[i].am_error = xfs_attrmulti_attr_set(					d_inode(dentry), attr_name,					ops[i].am_attrvalue, ops[i].am_length,					ops[i].am_flags);			mnt_drop_write_file(parfilp);			break;		case ATTR_OP_REMOVE:			ops[i].am_error = mnt_want_write_file(parfilp);			if (ops[i].am_error)				break;			ops[i].am_error = xfs_attrmulti_attr_remove(					d_inode(dentry), attr_name,					ops[i].am_flags);			mnt_drop_write_file(parfilp);			break;		default:			ops[i].am_error = -EINVAL;		}	}	if (copy_to_user(am_hreq.ops, ops, size))		error = -EFAULT;	kfree(attr_name); out_kfree_ops:	kfree(ops); out_dput:	dput(dentry);	return error;}

intxfs_open_by_handle(	struct file		*parfilp,	xfs_fsop_handlereq_t	*hreq){	const struct cred	*cred = current_cred();	int			error;	int			fd;	int			permflag;	struct file		*filp;	struct inode		*inode;	struct dentry		*dentry;	fmode_t			fmode;	struct path		path;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	dentry = xfs_handlereq_to_dentry(parfilp, hreq);	if (IS_ERR(dentry))		return PTR_ERR(dentry);	inode = d_inode(dentry);	/* Restrict xfs_open_by_handle to directories & regular files. */	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {		error = -EPERM;		goto out_dput;	}#if BITS_PER_LONG != 32	hreq->oflags |= O_LARGEFILE;#endif	permflag = hreq->oflags;	fmode = OPEN_FMODE(permflag);	if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&	    (fmode & FMODE_WRITE) && IS_APPEND(inode)) {		error = -EPERM;		goto out_dput;	}	if ((fmode & FMODE_WRITE) && IS_IMMUTABLE(inode)) {		error = -EACCES;		goto out_dput;	}	/* Can't write directories. */	if (S_ISDIR(inode->i_mode) && (fmode & FMODE_WRITE)) {		error = -EISDIR;		goto out_dput;	}	fd = get_unused_fd_flags(0);	if (fd < 0) {		error = fd;		goto out_dput;	}	path.mnt = parfilp->f_path.mnt;	path.dentry = dentry;	filp = dentry_open(&path, hreq->oflags, cred);	dput(dentry);	if (IS_ERR(filp)) {		put_unused_fd(fd);		return PTR_ERR(filp);	}	if (S_ISREG(inode->i_mode)) {		filp->f_flags |= O_NOATIME;		filp->f_mode |= FMODE_NOCMTIME;	}	fd_install(fd, filp);	return fd; out_dput:	dput(dentry);	return error;}

intxfs_open_by_handle(	struct file		*parfilp,	xfs_fsop_handlereq_t	*hreq){	const struct cred	*cred = current_cred();	int			error;	int			fd;	int			permflag;	struct file		*filp;	struct inode		*inode;	struct dentry		*dentry;	if (!capable(CAP_SYS_ADMIN))		return -XFS_ERROR(EPERM);	dentry = xfs_handlereq_to_dentry(parfilp, hreq);	if (IS_ERR(dentry))		return PTR_ERR(dentry);	inode = dentry->d_inode;	/* Restrict xfs_open_by_handle to directories & regular files. */	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) {		error = -XFS_ERROR(EPERM);		goto out_dput;	}#if BITS_PER_LONG != 32	hreq->oflags |= O_LARGEFILE;#endif	/* Put open permission in namei format. */	permflag = hreq->oflags;	if ((permflag+1) & O_ACCMODE)		permflag++;	if (permflag & O_TRUNC)		permflag |= 2;	if ((!(permflag & O_APPEND) || (permflag & O_TRUNC)) &&	    (permflag & FMODE_WRITE) && IS_APPEND(inode)) {		error = -XFS_ERROR(EPERM);		goto out_dput;	}	if ((permflag & FMODE_WRITE) && IS_IMMUTABLE(inode)) {		error = -XFS_ERROR(EACCES);		goto out_dput;	}	/* Can't write directories. */	if (S_ISDIR(inode->i_mode) && (permflag & FMODE_WRITE)) {		error = -XFS_ERROR(EISDIR);		goto out_dput;	}	fd = get_unused_fd();	if (fd < 0) {		error = fd;		goto out_dput;	}	filp = dentry_open(dentry, mntget(parfilp->f_path.mnt),			   hreq->oflags, cred);	if (IS_ERR(filp)) {		put_unused_fd(fd);		return PTR_ERR(filp);	}	if (inode->i_mode & S_IFREG) {		filp->f_flags |= O_NOATIME;		filp->f_mode |= FMODE_NOCMTIME;	}	fd_install(fd, filp);	return fd; out_dput:	dput(dentry);	return error;}