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

voidxfs_qm_vop_create_dqattach(	struct xfs_trans	*tp,	struct xfs_inode	*ip,	struct xfs_dquot	*udqp,	struct xfs_dquot	*gdqp){	struct xfs_mount	*mp = tp->t_mountp;	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))		return;	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));	ASSERT(XFS_IS_QUOTA_RUNNING(mp));	if (udqp) {		ASSERT(ip->i_udquot == NULL);		ASSERT(XFS_IS_UQUOTA_ON(mp));		ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));		ip->i_udquot = xfs_qm_dqhold(udqp);		xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);	}	if (gdqp) {		ASSERT(ip->i_gdquot == NULL);		ASSERT(XFS_IS_OQUOTA_ON(mp));		ASSERT((XFS_IS_GQUOTA_ON(mp) ?			ip->i_d.di_gid : xfs_get_projid(ip)) ==				be32_to_cpu(gdqp->q_core.d_id));		ip->i_gdquot = xfs_qm_dqhold(gdqp);		xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);	}}

static intxfs_ioctl_setattr_check_projid(	struct xfs_inode	*ip,	struct fsxattr		*fa){	/* Disallow 32bit project ids if projid32bit feature is not enabled. */	if (fa->fsx_projid > (__uint16_t)-1 &&	    !xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))		return -EINVAL;	/*	 * Project Quota ID state is only allowed to change from within the init	 * namespace. Enforce that restriction only if we are trying to change	 * the quota ID state. Everything else is allowed in user namespaces.	 */	if (current_user_ns() == &init_user_ns)		return 0;	if (xfs_get_projid(ip) != fa->fsx_projid)		return -EINVAL;	if ((fa->fsx_xflags & XFS_XFLAG_PROJINHERIT) !=	    (ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT))		return -EINVAL;	return 0;}

/* * Directory tree accounting is implemented using project quotas, where * the project identifier is inherited from parent directories. * A statvfs (df, etc.) of a directory that is using project quota should * return a statvfs of the project, not the entire filesystem. * This makes such trees appear as if they are filesystems in themselves. */voidxfs_qm_statvfs(	xfs_inode_t		*ip,	struct kstatfs		*statp){	xfs_mount_t		*mp = ip->i_mount;	xfs_dquot_t		*dqp;	if (!xfs_qm_dqget(mp, NULL, xfs_get_projid(ip), XFS_DQ_PROJ, 0, &dqp)) {		xfs_fill_statvfs_from_dquot(statp, dqp);		xfs_qm_dqput(dqp);	}}

/* * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON * into account. * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed. * Inode may get unlocked and relocked in here, and the caller must deal with * the consequences. */intxfs_qm_dqattach_locked(	xfs_inode_t	*ip,	uint		flags){	xfs_mount_t	*mp = ip->i_mount;	int		error = 0;	if (!xfs_qm_need_dqattach(ip))		return 0;	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));	if (XFS_IS_UQUOTA_ON(mp) && !ip->i_udquot) {		error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,						flags & XFS_QMOPT_DQALLOC,						&ip->i_udquot);		if (error)			goto done;		ASSERT(ip->i_udquot);	}	if (XFS_IS_GQUOTA_ON(mp) && !ip->i_gdquot) {		error = xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,						flags & XFS_QMOPT_DQALLOC,						&ip->i_gdquot);		if (error)			goto done;		ASSERT(ip->i_gdquot);	}	if (XFS_IS_PQUOTA_ON(mp) && !ip->i_pdquot) {		error = xfs_qm_dqattach_one(ip, xfs_get_projid(ip), XFS_DQ_PROJ,						flags & XFS_QMOPT_DQALLOC,						&ip->i_pdquot);		if (error)			goto done;		ASSERT(ip->i_pdquot);	}done:	/*	 * Don't worry about the dquots that we may have attached before any	 * error - they'll get detached later if it has not already been done.	 */	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));	return error;}

/* Return the quota id for a given inode and type. */xfs_dqid_txfs_qm_id_for_quotatype(	struct xfs_inode	*ip,	uint			type){	switch (type) {	case XFS_DQ_USER:		return ip->i_d.di_uid;	case XFS_DQ_GROUP:		return ip->i_d.di_gid;	case XFS_DQ_PROJ:		return xfs_get_projid(ip);	}	ASSERT(0);	return 0;}

/* * A union-based inode filtering algorithm. Process the inode if any of the * criteria match. This is for global/internal scans only. */STATIC intxfs_inode_match_id_union(	struct xfs_inode	*ip,	struct xfs_eofblocks	*eofb){	if ((eofb->eof_flags & XFS_EOF_FLAGS_UID) &&	    uid_eq(VFS_I(ip)->i_uid, eofb->eof_uid))		return 1;	if ((eofb->eof_flags & XFS_EOF_FLAGS_GID) &&	    gid_eq(VFS_I(ip)->i_gid, eofb->eof_gid))		return 1;	if ((eofb->eof_flags & XFS_EOF_FLAGS_PRID) &&	    xfs_get_projid(ip) == eofb->eof_prid)		return 1;	return 0;}

STATIC intxfs_ioc_fsgetxattr(	xfs_inode_t		*ip,	int			attr,	void			__user *arg){	struct fsxattr		fa;	memset(&fa, 0, sizeof(struct fsxattr));	xfs_ilock(ip, XFS_ILOCK_SHARED);	fa.fsx_xflags = xfs_ip2xflags(ip);	fa.fsx_extsize = ip->i_d.di_extsize << ip->i_mount->m_sb.sb_blocklog;	fa.fsx_projid = xfs_get_projid(ip);	if (attr) {		if (ip->i_afp) {			if (ip->i_afp->if_flags & XFS_IFEXTENTS)				fa.fsx_nextents = ip->i_afp->if_bytes /							sizeof(xfs_bmbt_rec_t);			else				fa.fsx_nextents = ip->i_d.di_anextents;		} else			fa.fsx_nextents = 0;	} else {		if (ip->i_df.if_flags & XFS_IFEXTENTS)			fa.fsx_nextents = ip->i_df.if_bytes /						sizeof(xfs_bmbt_rec_t);		else			fa.fsx_nextents = ip->i_d.di_nextents;	}	xfs_iunlock(ip, XFS_ILOCK_SHARED);	if (copy_to_user(arg, &fa, sizeof(fa)))		return -EFAULT;	return 0;}

intxfs_setattr_nonsize(	struct xfs_inode	*ip,	struct iattr		*iattr,	int			flags){	xfs_mount_t		*mp = ip->i_mount;	struct inode		*inode = VFS_I(ip);	int			mask = iattr->ia_valid;	xfs_trans_t		*tp;	int			error;	kuid_t			uid = GLOBAL_ROOT_UID, iuid = GLOBAL_ROOT_UID;	kgid_t			gid = GLOBAL_ROOT_GID, igid = GLOBAL_ROOT_GID;	struct xfs_dquot	*udqp = NULL, *gdqp = NULL;	struct xfs_dquot	*olddquot1 = NULL, *olddquot2 = NULL;	trace_xfs_setattr(ip);	/* If acls are being inherited, we already have this checked */	if (!(flags & XFS_ATTR_NOACL)) {		if (mp->m_flags & XFS_MOUNT_RDONLY)			return XFS_ERROR(EROFS);		if (XFS_FORCED_SHUTDOWN(mp))			return XFS_ERROR(EIO);		error = -inode_change_ok(inode, iattr);		if (error)			return XFS_ERROR(error);	}	ASSERT((mask & ATTR_SIZE) == 0);	/*	 * If disk quotas is on, we make sure that the dquots do exist on disk,	 * before we start any other transactions. Trying to do this later	 * is messy. We don't care to take a readlock to look at the ids	 * in inode here, because we can't hold it across the trans_reserve.	 * If the IDs do change before we take the ilock, we're covered	 * because the i_*dquot fields will get updated anyway.	 */	if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {		uint	qflags = 0;		if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {			uid = iattr->ia_uid;			qflags |= XFS_QMOPT_UQUOTA;		} else {			uid = inode->i_uid;		}		if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {			gid = iattr->ia_gid;			qflags |= XFS_QMOPT_GQUOTA;		}  else {			gid = inode->i_gid;		}		/*		 * We take a reference when we initialize udqp and gdqp,		 * so it is important that we never blindly double trip on		 * the same variable. See xfs_create() for an example.		 */		ASSERT(udqp == NULL);		ASSERT(gdqp == NULL);		error = xfs_qm_vop_dqalloc(ip, xfs_kuid_to_uid(uid),					   xfs_kgid_to_gid(gid),					   xfs_get_projid(ip),					   qflags, &udqp, &gdqp, NULL);		if (error)			return error;	}	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ichange, 0, 0);	if (error)		goto out_dqrele;	xfs_ilock(ip, XFS_ILOCK_EXCL);	/*	 * Change file ownership.  Must be the owner or privileged.	 */	if (mask & (ATTR_UID|ATTR_GID)) {		/*		 * These IDs could have changed since we last looked at them.		 * But, we're assured that if the ownership did change		 * while we didn't have the inode locked, inode's dquot(s)		 * would have changed also.		 */		iuid = inode->i_uid;		igid = inode->i_gid;		gid = (mask & ATTR_GID) ? iattr->ia_gid : igid;		uid = (mask & ATTR_UID) ? iattr->ia_uid : iuid;		/*		 * Do a quota reservation only if uid/gid is actually		 * going to change.		 */		if (XFS_IS_QUOTA_RUNNING(mp) &&		    ((XFS_IS_UQUOTA_ON(mp) && !uid_eq(iuid, uid)) ||//.........这里部分代码省略.........

STATIC intxfs_ioctl_setattr(	xfs_inode_t		*ip,	struct fsxattr		*fa,	int			mask){	struct xfs_mount	*mp = ip->i_mount;	struct xfs_trans	*tp;	unsigned int		lock_flags = 0;	struct xfs_dquot	*udqp = NULL;	struct xfs_dquot	*gdqp = NULL;	struct xfs_dquot	*olddquot = NULL;	int			code;	trace_xfs_ioctl_setattr(ip);	if (mp->m_flags & XFS_MOUNT_RDONLY)		return XFS_ERROR(EROFS);	if (XFS_FORCED_SHUTDOWN(mp))		return XFS_ERROR(EIO);	/*	 * Disallow 32bit project ids when projid32bit feature is not enabled.	 */	if ((mask & FSX_PROJID) && (fa->fsx_projid > (__uint16_t)-1) &&			!xfs_sb_version_hasprojid32bit(&ip->i_mount->m_sb))		return XFS_ERROR(EINVAL);	/*	 * If disk quotas is on, we make sure that the dquots do exist on disk,	 * before we start any other transactions. Trying to do this later	 * is messy. We don't care to take a readlock to look at the ids	 * in inode here, because we can't hold it across the trans_reserve.	 * If the IDs do change before we take the ilock, we're covered	 * because the i_*dquot fields will get updated anyway.	 */	if (XFS_IS_QUOTA_ON(mp) && (mask & FSX_PROJID)) {		code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,					 ip->i_d.di_gid, fa->fsx_projid,					 XFS_QMOPT_PQUOTA, &udqp, &gdqp);		if (code)			return code;	}	/*	 * For the other attributes, we acquire the inode lock and	 * first do an error checking pass.	 */	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);	code = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);	if (code)		goto error_return;	lock_flags = XFS_ILOCK_EXCL;	xfs_ilock(ip, lock_flags);	/*	 * CAP_FOWNER overrides the following restrictions:	 *	 * The user ID of the calling process must be equal	 * to the file owner ID, except in cases where the	 * CAP_FSETID capability is applicable.	 */	if (current_fsuid() != ip->i_d.di_uid && !capable(CAP_FOWNER)) {		code = XFS_ERROR(EPERM);		goto error_return;	}	/*	 * Do a quota reservation only if projid is actually going to change.	 */	if (mask & FSX_PROJID) {		if (XFS_IS_QUOTA_RUNNING(mp) &&		    XFS_IS_PQUOTA_ON(mp) &&		    xfs_get_projid(ip) != fa->fsx_projid) {			ASSERT(tp);			code = xfs_qm_vop_chown_reserve(tp, ip, udqp, gdqp,						capable(CAP_FOWNER) ?						XFS_QMOPT_FORCE_RES : 0);			if (code)	/* out of quota */				goto error_return;		}	}	if (mask & FSX_EXTSIZE) {		/*		 * Can't change extent size if any extents are allocated.		 */		if (ip->i_d.di_nextents &&		    ((ip->i_d.di_extsize << mp->m_sb.sb_blocklog) !=		     fa->fsx_extsize)) {			code = XFS_ERROR(EINVAL);	/* EFBIG? */			goto error_return;		}		/*		 * Extent size must be a multiple of the appropriate block		 * size, if set at all. It must also be smaller than the		 * maximum extent size supported by the filesystem.		 *//.........这里部分代码省略.........

/* * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON * into account. * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed. * Inode may get unlocked and relocked in here, and the caller must deal with * the consequences. */intxfs_qm_dqattach_locked(	xfs_inode_t	*ip,	uint		flags){	xfs_mount_t	*mp = ip->i_mount;	uint		nquotas = 0;	int		error = 0;	if (!xfs_qm_need_dqattach(ip))		return 0;	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));	if (XFS_IS_UQUOTA_ON(mp)) {		error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,						flags & XFS_QMOPT_DQALLOC,						NULL, &ip->i_udquot);		if (error)			goto done;		nquotas++;	}	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));	if (XFS_IS_OQUOTA_ON(mp)) {		error = XFS_IS_GQUOTA_ON(mp) ?			xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,						flags & XFS_QMOPT_DQALLOC,						ip->i_udquot, &ip->i_gdquot) :			xfs_qm_dqattach_one(ip, xfs_get_projid(ip), XFS_DQ_PROJ,						flags & XFS_QMOPT_DQALLOC,						ip->i_udquot, &ip->i_gdquot);		/*		 * Don't worry about the udquot that we may have		 * attached above. It'll get detached, if not already.		 */		if (error)			goto done;		nquotas++;	}	/*	 * Attach this group quota to the user quota as a hint.	 * This WON'T, in general, result in a thrash.	 */	if (nquotas == 2) {		ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));		ASSERT(ip->i_udquot);		ASSERT(ip->i_gdquot);		/*		 * We do not have i_udquot locked at this point, but this check		 * is OK since we don't depend on the i_gdquot to be accurate		 * 100% all the time. It is just a hint, and this will		 * succeed in general.		 */		if (ip->i_udquot->q_gdquot != ip->i_gdquot)			xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot);	} done:#ifdef DEBUG	if (!error) {		if (XFS_IS_UQUOTA_ON(mp))			ASSERT(ip->i_udquot);		if (XFS_IS_OQUOTA_ON(mp))			ASSERT(ip->i_gdquot);	}	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));#endif	return error;}

intxfs_setattr_nonsize(	struct xfs_inode	*ip,	struct iattr		*iattr,	int			flags){	xfs_mount_t		*mp = ip->i_mount;	struct inode		*inode = VFS_I(ip);	int			mask = iattr->ia_valid;	xfs_trans_t		*tp;	int			error;	uid_t			uid = 0, iuid = 0;	gid_t			gid = 0, igid = 0;	struct xfs_dquot	*udqp = NULL, *gdqp = NULL;	struct xfs_dquot	*olddquot1 = NULL, *olddquot2 = NULL;	trace_xfs_setattr(ip);	if (mp->m_flags & XFS_MOUNT_RDONLY)		return XFS_ERROR(EROFS);	if (XFS_FORCED_SHUTDOWN(mp))		return XFS_ERROR(EIO);	error = -inode_change_ok(inode, iattr);	if (error)		return XFS_ERROR(error);	ASSERT((mask & ATTR_SIZE) == 0);	if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {		uint	qflags = 0;		if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {			uid = iattr->ia_uid;			qflags |= XFS_QMOPT_UQUOTA;		} else {			uid = ip->i_d.di_uid;		}		if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {			gid = iattr->ia_gid;			qflags |= XFS_QMOPT_GQUOTA;		}  else {			gid = ip->i_d.di_gid;		}		ASSERT(udqp == NULL);		ASSERT(gdqp == NULL);		error = xfs_qm_vop_dqalloc(ip, uid, gid, xfs_get_projid(ip),					 qflags, &udqp, &gdqp);		if (error)			return error;	}	tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);	error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0);	if (error)		goto out_dqrele;	xfs_ilock(ip, XFS_ILOCK_EXCL);	if (mask & (ATTR_UID|ATTR_GID)) {		iuid = ip->i_d.di_uid;		igid = ip->i_d.di_gid;		gid = (mask & ATTR_GID) ? iattr->ia_gid : igid;		uid = (mask & ATTR_UID) ? iattr->ia_uid : iuid;		if (XFS_IS_QUOTA_RUNNING(mp) &&		    ((XFS_IS_UQUOTA_ON(mp) && iuid != uid) ||		     (XFS_IS_GQUOTA_ON(mp) && igid != gid))) {			ASSERT(tp);			error = xfs_qm_vop_chown_reserve(tp, ip, udqp, gdqp,						capable(CAP_FOWNER) ?						XFS_QMOPT_FORCE_RES : 0);			if (error)					goto out_trans_cancel;		}	}	xfs_trans_ijoin(tp, ip, 0);	if (mask & (ATTR_UID|ATTR_GID)) {		if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&		    !capable(CAP_FSETID))			ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);		if (iuid != uid) {			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_UQUOTA_ON(mp)) {				ASSERT(mask & ATTR_UID);				ASSERT(udqp);				olddquot1 = xfs_qm_vop_chown(tp, ip,							&ip->i_udquot, udqp);			}			ip->i_d.di_uid = uid;			inode->i_uid = uid;		}		if (igid != gid) {			if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_GQUOTA_ON(mp)) {				ASSERT(!XFS_IS_PQUOTA_ON(mp));				ASSERT(mask & ATTR_GID);//.........这里部分代码省略.........

/* * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID). */intxfs_qm_vop_chown_reserve(	xfs_trans_t	*tp,	xfs_inode_t	*ip,	xfs_dquot_t	*udqp,	xfs_dquot_t	*gdqp,	uint		flags){	xfs_mount_t	*mp = ip->i_mount;	uint		delblks, blkflags, prjflags = 0;	xfs_dquot_t	*unresudq, *unresgdq, *delblksudq, *delblksgdq;	int		error;	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));	ASSERT(XFS_IS_QUOTA_RUNNING(mp));	delblks = ip->i_delayed_blks;	delblksudq = delblksgdq = unresudq = unresgdq = NULL;	blkflags = XFS_IS_REALTIME_INODE(ip) ?			XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;	if (XFS_IS_UQUOTA_ON(mp) && udqp &&	    ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {		delblksudq = udqp;		/*		 * If there are delayed allocation blocks, then we have to		 * unreserve those from the old dquot, and add them to the		 * new dquot.		 */		if (delblks) {			ASSERT(ip->i_udquot);			unresudq = ip->i_udquot;		}	}	if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {		if (XFS_IS_PQUOTA_ON(ip->i_mount) &&		     xfs_get_projid(ip) != be32_to_cpu(gdqp->q_core.d_id))			prjflags = XFS_QMOPT_ENOSPC;		if (prjflags ||		    (XFS_IS_GQUOTA_ON(ip->i_mount) &&		     ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {			delblksgdq = gdqp;			if (delblks) {				ASSERT(ip->i_gdquot);				unresgdq = ip->i_gdquot;			}		}	}	if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,				delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,				flags | blkflags | prjflags)))		return (error);	/*	 * Do the delayed blks reservations/unreservations now. Since, these	 * are done without the help of a transaction, if a reservation fails	 * its previous reservations won't be automatically undone by trans	 * code. So, we have to do it manually here.	 */	if (delblks) {		/*		 * Do the reservations first. Unreservation can't fail.		 */		ASSERT(delblksudq || delblksgdq);		ASSERT(unresudq || unresgdq);		if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,				delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,				flags | blkflags | prjflags)))			return (error);		xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,				unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,				blkflags);	}	return (0);}

//.........这里部分代码省略.........	 */	if (XFS_NOT_DQATTACHED(mp, ip)) {		error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);		if (error) {			xfs_iunlock(ip, lockflags);			return error;		}	}	uq = gq = NULL;	if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {		if (ip->i_d.di_uid != uid) {			/*			 * What we need is the dquot that has this uid, and			 * if we send the inode to dqget, the uid of the inode			 * takes priority over what's sent in the uid argument.			 * We must unlock inode here before calling dqget if			 * we're not sending the inode, because otherwise			 * we'll deadlock by doing trans_reserve while			 * holding ilock.			 */			xfs_iunlock(ip, lockflags);			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,						 XFS_DQ_USER,						 XFS_QMOPT_DQALLOC |						 XFS_QMOPT_DOWARN,						 &uq))) {				ASSERT(error != ENOENT);				return error;			}			/*			 * Get the ilock in the right order.			 */			xfs_dqunlock(uq);			lockflags = XFS_ILOCK_SHARED;			xfs_ilock(ip, lockflags);		} else {			/*			 * Take an extra reference, because we'll return			 * this to caller			 */			ASSERT(ip->i_udquot);			uq = xfs_qm_dqhold(ip->i_udquot);		}	}	if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {		if (ip->i_d.di_gid != gid) {			xfs_iunlock(ip, lockflags);			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,						 XFS_DQ_GROUP,						 XFS_QMOPT_DQALLOC |						 XFS_QMOPT_DOWARN,						 &gq))) {				if (uq)					xfs_qm_dqrele(uq);				ASSERT(error != ENOENT);				return error;			}			xfs_dqunlock(gq);			lockflags = XFS_ILOCK_SHARED;			xfs_ilock(ip, lockflags);		} else {			ASSERT(ip->i_gdquot);			gq = xfs_qm_dqhold(ip->i_gdquot);		}	} else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {		if (xfs_get_projid(ip) != prid) {			xfs_iunlock(ip, lockflags);			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,						 XFS_DQ_PROJ,						 XFS_QMOPT_DQALLOC |						 XFS_QMOPT_DOWARN,						 &gq))) {				if (uq)					xfs_qm_dqrele(uq);				ASSERT(error != ENOENT);				return (error);			}			xfs_dqunlock(gq);			lockflags = XFS_ILOCK_SHARED;			xfs_ilock(ip, lockflags);		} else {			ASSERT(ip->i_gdquot);			gq = xfs_qm_dqhold(ip->i_gdquot);		}	}	if (uq)		trace_xfs_dquot_dqalloc(ip);	xfs_iunlock(ip, lockflags);	if (O_udqpp)		*O_udqpp = uq;	else if (uq)		xfs_qm_dqrele(uq);	if (O_gdqpp)		*O_gdqpp = gq;	else if (gq)		xfs_qm_dqrele(gq);	return 0;}

/* * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID). */intxfs_qm_vop_chown_reserve(	struct xfs_trans	*tp,	struct xfs_inode	*ip,	struct xfs_dquot	*udqp,	struct xfs_dquot	*gdqp,	struct xfs_dquot	*pdqp,	uint			flags){	struct xfs_mount	*mp = ip->i_mount;	uint			delblks, blkflags, prjflags = 0;	struct xfs_dquot	*udq_unres = NULL;	struct xfs_dquot	*gdq_unres = NULL;	struct xfs_dquot	*pdq_unres = NULL;	struct xfs_dquot	*udq_delblks = NULL;	struct xfs_dquot	*gdq_delblks = NULL;	struct xfs_dquot	*pdq_delblks = NULL;	int			error;	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));	ASSERT(XFS_IS_QUOTA_RUNNING(mp));	delblks = ip->i_delayed_blks;	blkflags = XFS_IS_REALTIME_INODE(ip) ?			XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;	if (XFS_IS_UQUOTA_ON(mp) && udqp &&	    ip->i_d.di_uid != be32_to_cpu(udqp->q_core.d_id)) {		udq_delblks = udqp;		/*		 * If there are delayed allocation blocks, then we have to		 * unreserve those from the old dquot, and add them to the		 * new dquot.		 */		if (delblks) {			ASSERT(ip->i_udquot);			udq_unres = ip->i_udquot;		}	}	if (XFS_IS_GQUOTA_ON(ip->i_mount) && gdqp &&	    ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id)) {		gdq_delblks = gdqp;		if (delblks) {			ASSERT(ip->i_gdquot);			gdq_unres = ip->i_gdquot;		}	}	if (XFS_IS_PQUOTA_ON(ip->i_mount) && pdqp &&	    xfs_get_projid(ip) != be32_to_cpu(pdqp->q_core.d_id)) {		prjflags = XFS_QMOPT_ENOSPC;		pdq_delblks = pdqp;		if (delblks) {			ASSERT(ip->i_pdquot);			pdq_unres = ip->i_pdquot;		}	}	error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,				udq_delblks, gdq_delblks, pdq_delblks,				ip->i_d.di_nblocks, 1,				flags | blkflags | prjflags);	if (error)		return error;	/*	 * Do the delayed blks reservations/unreservations now. Since, these	 * are done without the help of a transaction, if a reservation fails	 * its previous reservations won't be automatically undone by trans	 * code. So, we have to do it manually here.	 */	if (delblks) {		/*		 * Do the reservations first. Unreservation can't fail.		 */		ASSERT(udq_delblks || gdq_delblks || pdq_delblks);		ASSERT(udq_unres || gdq_unres || pdq_unres);		error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,			    udq_delblks, gdq_delblks, pdq_delblks,			    (xfs_qcnt_t)delblks, 0,			    flags | blkflags | prjflags);		if (error)			return error;		xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,				udq_unres, gdq_unres, pdq_unres,				-((xfs_qcnt_t)delblks), 0, blkflags);	}	return 0;}

STATIC intxfs_ioctl_setattr(	xfs_inode_t		*ip,	struct fsxattr		*fa){	struct xfs_mount	*mp = ip->i_mount;	struct xfs_trans	*tp;	struct xfs_dquot	*udqp = NULL;	struct xfs_dquot	*pdqp = NULL;	struct xfs_dquot	*olddquot = NULL;	int			code;	trace_xfs_ioctl_setattr(ip);	code = xfs_ioctl_setattr_check_projid(ip, fa);	if (code)		return code;	/*	 * If disk quotas is on, we make sure that the dquots do exist on disk,	 * before we start any other transactions. Trying to do this later	 * is messy. We don't care to take a readlock to look at the ids	 * in inode here, because we can't hold it across the trans_reserve.	 * If the IDs do change before we take the ilock, we're covered	 * because the i_*dquot fields will get updated anyway.	 */	if (XFS_IS_QUOTA_ON(mp)) {		code = xfs_qm_vop_dqalloc(ip, ip->i_d.di_uid,					 ip->i_d.di_gid, fa->fsx_projid,					 XFS_QMOPT_PQUOTA, &udqp, NULL, &pdqp);		if (code)			return code;	}	tp = xfs_ioctl_setattr_get_trans(ip);	if (IS_ERR(tp)) {		code = PTR_ERR(tp);		goto error_free_dquots;	}	if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp) &&	    xfs_get_projid(ip) != fa->fsx_projid) {		code = xfs_qm_vop_chown_reserve(tp, ip, udqp, NULL, pdqp,				capable(CAP_FOWNER) ?  XFS_QMOPT_FORCE_RES : 0);		if (code)	/* out of quota */			goto error_trans_cancel;	}	code = xfs_ioctl_setattr_check_extsize(ip, fa);	if (code)		goto error_trans_cancel;	code = xfs_ioctl_setattr_xflags(tp, ip, fa);	if (code)		goto error_trans_cancel;	/*	 * Change file ownership.  Must be the owner or privileged.  CAP_FSETID	 * overrides the following restrictions:	 *	 * The set-user-ID and set-group-ID bits of a file will be cleared upon	 * successful return from chown()	 */	if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&	    !capable_wrt_inode_uidgid(VFS_I(ip), CAP_FSETID))		ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);	/* Change the ownerships and register project quota modifications */	if (xfs_get_projid(ip) != fa->fsx_projid) {		if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_PQUOTA_ON(mp)) {			olddquot = xfs_qm_vop_chown(tp, ip,						&ip->i_pdquot, pdqp);		}		ASSERT(ip->i_d.di_version > 1);		xfs_set_projid(ip, fa->fsx_projid);	}	/*	 * Only set the extent size hint if we've already determined that the	 * extent size hint should be set on the inode. If no extent size flags	 * are set on the inode then unconditionally clear the extent size hint.	 */	if (ip->i_d.di_flags & (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))		ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;	else

intxfs_symlink(	struct xfs_inode	*dp,	struct xfs_name		*link_name,	const char		*target_path,	umode_t			mode,	struct xfs_inode	**ipp){	struct xfs_mount	*mp = dp->i_mount;	struct xfs_trans	*tp = NULL;	struct xfs_inode	*ip = NULL;	int			error = 0;	int			pathlen;	struct xfs_bmap_free	free_list;	xfs_fsblock_t		first_block;	bool			unlock_dp_on_error = false;	uint			cancel_flags;	int			committed;	xfs_fileoff_t		first_fsb;	xfs_filblks_t		fs_blocks;	int			nmaps;	struct xfs_bmbt_irec	mval[XFS_SYMLINK_MAPS];	xfs_daddr_t		d;	const char		*cur_chunk;	int			byte_cnt;	int			n;	xfs_buf_t		*bp;	prid_t			prid;	struct xfs_dquot	*udqp = NULL;	struct xfs_dquot	*gdqp = NULL;	struct xfs_dquot	*pdqp = NULL;	uint			resblks;	*ipp = NULL;	trace_xfs_symlink(dp, link_name);	if (XFS_FORCED_SHUTDOWN(mp))		return XFS_ERROR(EIO);	/*	 * Check component lengths of the target path name.	 */	pathlen = strlen(target_path);	if (pathlen >= MAXPATHLEN)      /* total string too long */		return XFS_ERROR(ENAMETOOLONG);	udqp = gdqp = NULL;	if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)		prid = xfs_get_projid(dp);	else		prid = XFS_PROJID_DEFAULT;	/*	 * Make sure that we have allocated dquot(s) on disk.	 */	error = xfs_qm_vop_dqalloc(dp,			xfs_kuid_to_uid(current_fsuid()),			xfs_kgid_to_gid(current_fsgid()), prid,			XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT,			&udqp, &gdqp, &pdqp);	if (error)		goto std_return;	tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);	cancel_flags = XFS_TRANS_RELEASE_LOG_RES;	/*	 * The symlink will fit into the inode data fork?	 * There can't be any attributes so we get the whole variable part.	 */	if (pathlen <= XFS_LITINO(mp, dp->i_d.di_version))		fs_blocks = 0;	else		fs_blocks = xfs_symlink_blocks(mp, pathlen);	resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, resblks, 0);	if (error == ENOSPC && fs_blocks == 0) {		resblks = 0;		error = xfs_trans_reserve(tp, &M_RES(mp)->tr_symlink, 0, 0);	}	if (error) {		cancel_flags = 0;		goto error_return;	}	xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);	unlock_dp_on_error = true;	/*	 * Check whether the directory allows new symlinks or not.	 */	if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {		error = XFS_ERROR(EPERM);		goto error_return;	}	/*	 * Reserve disk quota : blocks and inode.	 */	error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp,//.........这里部分代码省略.........

/* ARGSUSED */STATIC intxfs_qm_dqusage_adjust(	xfs_mount_t	*mp,		/* mount point for filesystem */	xfs_ino_t	ino,		/* inode number to get data for */	void		__user *buffer,	/* not used */	int		ubsize,		/* not used */	int		*ubused,	/* not used */	int		*res)		/* result code value */{	xfs_inode_t	*ip;	xfs_qcnt_t	nblks, rtblks = 0;	int		error;	ASSERT(XFS_IS_QUOTA_RUNNING(mp));	/*	 * rootino must have its resources accounted for, not so with the quota	 * inodes.	 */	if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {		*res = BULKSTAT_RV_NOTHING;		return XFS_ERROR(EINVAL);	}	/*	 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget	 * interface expects the inode to be exclusively locked because that's	 * the case in all other instances. It's OK that we do this because	 * quotacheck is done only at mount time.	 */	error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip);	if (error) {		*res = BULKSTAT_RV_NOTHING;		return error;	}	ASSERT(ip->i_delayed_blks == 0);	if (XFS_IS_REALTIME_INODE(ip)) {		/*		 * Walk thru the extent list and count the realtime blocks.		 */		error = xfs_qm_get_rtblks(ip, &rtblks);		if (error)			goto error0;	}	nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;	/*	 * Add the (disk blocks and inode) resources occupied by this	 * inode to its dquots. We do this adjustment in the incore dquot,	 * and also copy the changes to its buffer.	 * We don't care about putting these changes in a transaction	 * envelope because if we crash in the middle of a 'quotacheck'	 * we have to start from the beginning anyway.	 * Once we're done, we'll log all the dquot bufs.	 *	 * The *QUOTA_ON checks below may look pretty racy, but quotachecks	 * and quotaoffs don't race. (Quotachecks happen at mount time only).	 */	if (XFS_IS_UQUOTA_ON(mp)) {		error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_uid,						   XFS_DQ_USER, nblks, rtblks);		if (error)			goto error0;	}	if (XFS_IS_GQUOTA_ON(mp)) {		error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_gid,						   XFS_DQ_GROUP, nblks, rtblks);		if (error)			goto error0;	}	if (XFS_IS_PQUOTA_ON(mp)) {		error = xfs_qm_quotacheck_dqadjust(ip, xfs_get_projid(ip),						   XFS_DQ_PROJ, nblks, rtblks);		if (error)			goto error0;	}	xfs_iunlock(ip, XFS_ILOCK_EXCL);	IRELE(ip);	*res = BULKSTAT_RV_DIDONE;	return 0;error0:	xfs_iunlock(ip, XFS_ILOCK_EXCL);	IRELE(ip);	*res = BULKSTAT_RV_GIVEUP;	return error;}

/* * xfs_rename */intxfs_rename(	xfs_inode_t	*src_dp,	struct xfs_name	*src_name,	xfs_inode_t	*src_ip,	xfs_inode_t	*target_dp,	struct xfs_name	*target_name,	xfs_inode_t	*target_ip){	xfs_trans_t	*tp = NULL;	xfs_mount_t	*mp = src_dp->i_mount;	int		new_parent;		/* moving to a new dir */	int		src_is_directory;	/* src_name is a directory */	int		error;	xfs_bmap_free_t free_list;	xfs_fsblock_t   first_block;	int		cancel_flags;	int		committed;	xfs_inode_t	*inodes[4];	int		spaceres;	int		num_inodes;	trace_xfs_rename(src_dp, target_dp, src_name, target_name);	new_parent = (src_dp != target_dp);	src_is_directory = S_ISDIR(src_ip->i_d.di_mode);	xfs_sort_for_rename(src_dp, target_dp, src_ip, target_ip,				inodes, &num_inodes);	xfs_bmap_init(&free_list, &first_block);	tp = xfs_trans_alloc(mp, XFS_TRANS_RENAME);	cancel_flags = XFS_TRANS_RELEASE_LOG_RES;	spaceres = XFS_RENAME_SPACE_RES(mp, target_name->len);	error = xfs_trans_reserve(tp, spaceres, XFS_RENAME_LOG_RES(mp), 0,			XFS_TRANS_PERM_LOG_RES, XFS_RENAME_LOG_COUNT);	if (error == ENOSPC) {		spaceres = 0;		error = xfs_trans_reserve(tp, 0, XFS_RENAME_LOG_RES(mp), 0,				XFS_TRANS_PERM_LOG_RES, XFS_RENAME_LOG_COUNT);	}	if (error) {		xfs_trans_cancel(tp, 0);		goto std_return;	}	/*	 * Attach the dquots to the inodes	 */	error = xfs_qm_vop_rename_dqattach(inodes);	if (error) {		xfs_trans_cancel(tp, cancel_flags);		goto std_return;	}	/*	 * Lock all the participating inodes. Depending upon whether	 * the target_name exists in the target directory, and	 * whether the target directory is the same as the source	 * directory, we can lock from 2 to 4 inodes.	 */	xfs_lock_inodes(inodes, num_inodes, XFS_ILOCK_EXCL);	/*	 * Join all the inodes to the transaction. From this point on,	 * we can rely on either trans_commit or trans_cancel to unlock	 * them.	 */	xfs_trans_ijoin(tp, src_dp, XFS_ILOCK_EXCL);	if (new_parent)		xfs_trans_ijoin(tp, target_dp, XFS_ILOCK_EXCL);	xfs_trans_ijoin(tp, src_ip, XFS_ILOCK_EXCL);	if (target_ip)		xfs_trans_ijoin(tp, target_ip, XFS_ILOCK_EXCL);	/*	 * If we are using project inheritance, we only allow renames	 * into our tree when the project IDs are the same; else the	 * tree quota mechanism would be circumvented.	 */	if (unlikely((target_dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&		     (xfs_get_projid(target_dp) != xfs_get_projid(src_ip)))) {		error = XFS_ERROR(EXDEV);		goto error_return;	}	/*	 * Set up the target.	 */	if (target_ip == NULL) {		/*		 * If there's no space reservation, check the entry will		 * fit before actually inserting it.		 */		error = xfs_dir_canenter(tp, target_dp, target_name, spaceres);		if (error)			goto error_return;//.........这里部分代码省略.........