Linux Audio

Check our new training course

Loading...
v6.9.4
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
  4 * All Rights Reserved.
  5 */
  6#include "xfs.h"
  7#include "xfs_fs.h"
  8#include "xfs_shared.h"
  9#include "xfs_format.h"
 10#include "xfs_log_format.h"
 11#include "xfs_trans_resv.h"
 12#include "xfs_mount.h"
 13#include "xfs_quota.h"
 14#include "xfs_mount.h"
 15#include "xfs_inode.h"
 16#include "xfs_trans.h"
 17#include "xfs_qm.h"
 18
 19
 20STATIC void
 21xfs_fill_statvfs_from_dquot(
 22	struct kstatfs		*statp,
 
 23	struct xfs_dquot	*dqp)
 24{
 
 25	uint64_t		limit;
 26
 27	limit = dqp->q_blk.softlimit ?
 28		dqp->q_blk.softlimit :
 29		dqp->q_blk.hardlimit;
 30	if (limit && statp->f_blocks > limit) {
 31		statp->f_blocks = limit;
 32		statp->f_bfree = statp->f_bavail =
 33			(statp->f_blocks > dqp->q_blk.reserved) ?
 34			 (statp->f_blocks - dqp->q_blk.reserved) : 0;
 
 
 
 
 
 
 
 
 35	}
 36
 37	limit = dqp->q_ino.softlimit ?
 38		dqp->q_ino.softlimit :
 39		dqp->q_ino.hardlimit;
 40	if (limit && statp->f_files > limit) {
 41		statp->f_files = limit;
 42		statp->f_ffree =
 43			(statp->f_files > dqp->q_ino.reserved) ?
 44			 (statp->f_files - dqp->q_ino.reserved) : 0;
 
 
 
 45	}
 46}
 47
 48
 49/*
 50 * Directory tree accounting is implemented using project quotas, where
 51 * the project identifier is inherited from parent directories.
 52 * A statvfs (df, etc.) of a directory that is using project quota should
 53 * return a statvfs of the project, not the entire filesystem.
 54 * This makes such trees appear as if they are filesystems in themselves.
 55 */
 56void
 57xfs_qm_statvfs(
 58	struct xfs_inode	*ip,
 59	struct kstatfs		*statp)
 60{
 61	struct xfs_mount	*mp = ip->i_mount;
 62	struct xfs_dquot	*dqp;
 63
 64	if (!xfs_qm_dqget(mp, ip->i_projid, XFS_DQTYPE_PROJ, false, &dqp)) {
 65		xfs_fill_statvfs_from_dquot(statp, dqp);
 66		xfs_qm_dqput(dqp);
 67	}
 68}
 69
 70int
 71xfs_qm_newmount(
 72	xfs_mount_t	*mp,
 73	uint		*needquotamount,
 74	uint		*quotaflags)
 75{
 76	uint		quotaondisk;
 77	uint		uquotaondisk = 0, gquotaondisk = 0, pquotaondisk = 0;
 78
 79	quotaondisk = xfs_has_quota(mp) &&
 80				(mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT);
 81
 82	if (quotaondisk) {
 83		uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT;
 84		pquotaondisk = mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT;
 85		gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT;
 86	}
 87
 88	/*
 89	 * If the device itself is read-only, we can't allow
 90	 * the user to change the state of quota on the mount -
 91	 * this would generate a transaction on the ro device,
 92	 * which would lead to an I/O error and shutdown
 93	 */
 94
 95	if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) ||
 96	    (!uquotaondisk &&  XFS_IS_UQUOTA_ON(mp)) ||
 97	     (gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) ||
 98	    (!gquotaondisk &&  XFS_IS_GQUOTA_ON(mp)) ||
 99	     (pquotaondisk && !XFS_IS_PQUOTA_ON(mp)) ||
100	    (!pquotaondisk &&  XFS_IS_PQUOTA_ON(mp)))  &&
101	    xfs_dev_is_read_only(mp, "changing quota state")) {
102		xfs_warn(mp, "please mount with%s%s%s%s.",
103			(!quotaondisk ? "out quota" : ""),
104			(uquotaondisk ? " usrquota" : ""),
105			(gquotaondisk ? " grpquota" : ""),
106			(pquotaondisk ? " prjquota" : ""));
107		return -EPERM;
108	}
109
110	if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
111		/*
112		 * Call mount_quotas at this point only if we won't have to do
113		 * a quotacheck.
114		 */
115		if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) {
116			/*
117			 * If an error occurred, qm_mount_quotas code
118			 * has already disabled quotas. So, just finish
119			 * mounting, and get on with the boring life
120			 * without disk quotas.
121			 */
122			xfs_qm_mount_quotas(mp);
123		} else {
124			/*
125			 * Clear the quota flags, but remember them. This
126			 * is so that the quota code doesn't get invoked
127			 * before we're ready. This can happen when an
128			 * inode goes inactive and wants to free blocks,
129			 * or via xfs_log_mount_finish.
130			 */
131			*needquotamount = true;
132			*quotaflags = mp->m_qflags;
133			mp->m_qflags = 0;
134		}
135	}
136
137	return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
138}
v6.13.7
  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
  4 * All Rights Reserved.
  5 */
  6#include "xfs.h"
  7#include "xfs_fs.h"
  8#include "xfs_shared.h"
  9#include "xfs_format.h"
 10#include "xfs_log_format.h"
 11#include "xfs_trans_resv.h"
 12#include "xfs_mount.h"
 13#include "xfs_quota.h"
 
 14#include "xfs_inode.h"
 15#include "xfs_trans.h"
 16#include "xfs_qm.h"
 17
 18
 19STATIC void
 20xfs_fill_statvfs_from_dquot(
 21	struct kstatfs		*statp,
 22	struct xfs_inode	*ip,
 23	struct xfs_dquot	*dqp)
 24{
 25	struct xfs_dquot_res	*blkres = &dqp->q_blk;
 26	uint64_t		limit;
 27
 28	if (XFS_IS_REALTIME_MOUNT(ip->i_mount) &&
 29	    (ip->i_diflags & (XFS_DIFLAG_RTINHERIT | XFS_DIFLAG_REALTIME)))
 30		blkres = &dqp->q_rtb;
 31
 32	limit = blkres->softlimit ?
 33		blkres->softlimit :
 34		blkres->hardlimit;
 35	if (limit) {
 36		uint64_t	remaining = 0;
 37
 38		if (limit > blkres->reserved)
 39			remaining = limit - blkres->reserved;
 40
 41		statp->f_blocks = min(statp->f_blocks, limit);
 42		statp->f_bfree = min(statp->f_bfree, remaining);
 43		statp->f_bavail = min(statp->f_bavail, remaining);
 44	}
 45
 46	limit = dqp->q_ino.softlimit ?
 47		dqp->q_ino.softlimit :
 48		dqp->q_ino.hardlimit;
 49	if (limit) {
 50		uint64_t	remaining = 0;
 51
 52		if (limit > dqp->q_ino.reserved)
 53			remaining = limit - dqp->q_ino.reserved;
 54
 55		statp->f_files = min(statp->f_files, limit);
 56		statp->f_ffree = min(statp->f_ffree, remaining);
 57	}
 58}
 59
 60
 61/*
 62 * Directory tree accounting is implemented using project quotas, where
 63 * the project identifier is inherited from parent directories.
 64 * A statvfs (df, etc.) of a directory that is using project quota should
 65 * return a statvfs of the project, not the entire filesystem.
 66 * This makes such trees appear as if they are filesystems in themselves.
 67 */
 68void
 69xfs_qm_statvfs(
 70	struct xfs_inode	*ip,
 71	struct kstatfs		*statp)
 72{
 73	struct xfs_mount	*mp = ip->i_mount;
 74	struct xfs_dquot	*dqp;
 75
 76	if (!xfs_qm_dqget(mp, ip->i_projid, XFS_DQTYPE_PROJ, false, &dqp)) {
 77		xfs_fill_statvfs_from_dquot(statp, ip, dqp);
 78		xfs_qm_dqput(dqp);
 79	}
 80}
 81
 82int
 83xfs_qm_newmount(
 84	xfs_mount_t	*mp,
 85	uint		*needquotamount,
 86	uint		*quotaflags)
 87{
 88	uint		quotaondisk;
 89	uint		uquotaondisk = 0, gquotaondisk = 0, pquotaondisk = 0;
 90
 91	quotaondisk = xfs_has_quota(mp) &&
 92				(mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT);
 93
 94	if (quotaondisk) {
 95		uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT;
 96		pquotaondisk = mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT;
 97		gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT;
 98	}
 99
100	/*
101	 * If the device itself is read-only, we can't allow
102	 * the user to change the state of quota on the mount -
103	 * this would generate a transaction on the ro device,
104	 * which would lead to an I/O error and shutdown
105	 */
106
107	if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) ||
108	    (!uquotaondisk &&  XFS_IS_UQUOTA_ON(mp)) ||
109	     (gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) ||
110	    (!gquotaondisk &&  XFS_IS_GQUOTA_ON(mp)) ||
111	     (pquotaondisk && !XFS_IS_PQUOTA_ON(mp)) ||
112	    (!pquotaondisk &&  XFS_IS_PQUOTA_ON(mp)))  &&
113	    xfs_dev_is_read_only(mp, "changing quota state")) {
114		xfs_warn(mp, "please mount with%s%s%s%s.",
115			(!quotaondisk ? "out quota" : ""),
116			(uquotaondisk ? " usrquota" : ""),
117			(gquotaondisk ? " grpquota" : ""),
118			(pquotaondisk ? " prjquota" : ""));
119		return -EPERM;
120	}
121
122	if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
123		/*
124		 * Call mount_quotas at this point only if we won't have to do
125		 * a quotacheck.
126		 */
127		if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) {
128			/*
129			 * If an error occurred, qm_mount_quotas code
130			 * has already disabled quotas. So, just finish
131			 * mounting, and get on with the boring life
132			 * without disk quotas.
133			 */
134			xfs_qm_mount_quotas(mp);
135		} else {
136			/*
137			 * Clear the quota flags, but remember them. This
138			 * is so that the quota code doesn't get invoked
139			 * before we're ready. This can happen when an
140			 * inode goes inactive and wants to free blocks,
141			 * or via xfs_log_mount_finish.
142			 */
143			*needquotamount = true;
144			*quotaflags = mp->m_qflags;
145			mp->m_qflags = 0;
146		}
147	}
148
149	return 0;
150}
151
152/*
153 * If the sysadmin didn't provide any quota mount options, restore the quota
154 * accounting and enforcement state from the ondisk superblock.  Only do this
155 * for metadir filesystems because this is a behavior change.
156 */
157void
158xfs_qm_resume_quotaon(
159	struct xfs_mount	*mp)
160{
161	if (!xfs_has_metadir(mp))
162		return;
163	if (xfs_has_norecovery(mp))
164		return;
165
166	mp->m_qflags = mp->m_sb.sb_qflags & (XFS_ALL_QUOTA_ACCT |
167					     XFS_ALL_QUOTA_ENFD);
168}