[linux-2.6-block.git] / fs / ceph / quota.c

// SPDX-License-Identifier: GPL-2.0
/*
 * quota.c - CephFS quota
 *
 * Copyright (C) 2017-2018 SUSE
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/statfs.h>

#include "super.h"
#include "mds_client.h"

void ceph_adjust_quota_realms_count(struct inode *inode, bool inc)
{
	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	if (inc)
		atomic64_inc(&mdsc->quotarealms_count);
	else
		atomic64_dec(&mdsc->quotarealms_count);
}

static inline bool ceph_has_realms_with_quotas(struct inode *inode)
{
	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	return atomic64_read(&mdsc->quotarealms_count) > 0;
}

void ceph_handle_quota(struct ceph_mds_client *mdsc,
		       struct ceph_mds_session *session,
		       struct ceph_msg *msg)
{
	struct super_block *sb = mdsc->fsc->sb;
	struct ceph_mds_quota *h = msg->front.iov_base;
	struct ceph_vino vino;
	struct inode *inode;
	struct ceph_inode_info *ci;

	if (msg->front.iov_len < sizeof(*h)) {
		pr_err("%s corrupt message mds%d len %d\n", __func__,
		       session->s_mds, (int)msg->front.iov_len);
		ceph_msg_dump(msg);
		return;
	}

	/* increment msg sequence number */
	mutex_lock(&session->s_mutex);
	session->s_seq++;
	mutex_unlock(&session->s_mutex);

	/* lookup inode */
	vino.ino = le64_to_cpu(h->ino);
	vino.snap = CEPH_NOSNAP;
	inode = ceph_find_inode(sb, vino);
	if (!inode) {
		pr_warn("Failed to find inode %llu\n", vino.ino);
		return;
	}
	ci = ceph_inode(inode);

	spin_lock(&ci->i_ceph_lock);
	ci->i_rbytes = le64_to_cpu(h->rbytes);
	ci->i_rfiles = le64_to_cpu(h->rfiles);
	ci->i_rsubdirs = le64_to_cpu(h->rsubdirs);
	__ceph_update_quota(ci, le64_to_cpu(h->max_bytes),
		            le64_to_cpu(h->max_files));
	spin_unlock(&ci->i_ceph_lock);

	iput(inode);
}

/*
 * This function walks through the snaprealm for an inode and returns the
 * ceph_snap_realm for the first snaprealm that has quotas set (either max_files
 * or max_bytes).  If the root is reached, return the root ceph_snap_realm
 * instead.
 *
 * Note that the caller is responsible for calling ceph_put_snap_realm() on the
 * returned realm.
 */
static struct ceph_snap_realm *get_quota_realm(struct ceph_mds_client *mdsc,
					       struct inode *inode)
{
	struct ceph_inode_info *ci = NULL;
	struct ceph_snap_realm *realm, *next;
	struct inode *in;
	bool has_quota;

	if (ceph_snap(inode) != CEPH_NOSNAP)
		return NULL;

	realm = ceph_inode(inode)->i_snap_realm;
	if (realm)
		ceph_get_snap_realm(mdsc, realm);
	else
		pr_err_ratelimited("get_quota_realm: ino (%llx.%llx) "
				   "null i_snap_realm\n", ceph_vinop(inode));
	while (realm) {
		spin_lock(&realm->inodes_with_caps_lock);
		in = realm->inode ? igrab(realm->inode) : NULL;
		spin_unlock(&realm->inodes_with_caps_lock);
		if (!in)
			break;

		ci = ceph_inode(in);
		has_quota = __ceph_has_any_quota(ci);
		iput(in);

		next = realm->parent;
		if (has_quota || !next)
		       return realm;

		ceph_get_snap_realm(mdsc, next);
		ceph_put_snap_realm(mdsc, realm);
		realm = next;
	}
	if (realm)
		ceph_put_snap_realm(mdsc, realm);

	return NULL;
}

bool ceph_quota_is_same_realm(struct inode *old, struct inode *new)
{
	struct ceph_mds_client *mdsc = ceph_inode_to_client(old)->mdsc;
	struct ceph_snap_realm *old_realm, *new_realm;
	bool is_same;

	down_read(&mdsc->snap_rwsem);
	old_realm = get_quota_realm(mdsc, old);
	new_realm = get_quota_realm(mdsc, new);
	is_same = (old_realm == new_realm);
	up_read(&mdsc->snap_rwsem);

	if (old_realm)
		ceph_put_snap_realm(mdsc, old_realm);
	if (new_realm)
		ceph_put_snap_realm(mdsc, new_realm);

	return is_same;
}

enum quota_check_op {
	QUOTA_CHECK_MAX_FILES_OP,	/* check quota max_files limit */
	QUOTA_CHECK_MAX_BYTES_OP,	/* check quota max_files limit */
	QUOTA_CHECK_MAX_BYTES_APPROACHING_OP	/* check if quota max_files
						   limit is approaching */
};

/*
 * check_quota_exceeded() will walk up the snaprealm hierarchy and, for each
 * realm, it will execute quota check operation defined by the 'op' parameter.
 * The snaprealm walk is interrupted if the quota check detects that the quota
 * is exceeded or if the root inode is reached.
 */
static bool check_quota_exceeded(struct inode *inode, enum quota_check_op op,
				 loff_t delta)
{
	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	struct ceph_inode_info *ci;
	struct ceph_snap_realm *realm, *next;
	struct inode *in;
	u64 max, rvalue;
	bool exceeded = false;

	if (ceph_snap(inode) != CEPH_NOSNAP)
		return false;

	down_read(&mdsc->snap_rwsem);
	realm = ceph_inode(inode)->i_snap_realm;
	if (realm)
		ceph_get_snap_realm(mdsc, realm);
	else
		pr_err_ratelimited("check_quota_exceeded: ino (%llx.%llx) "
				   "null i_snap_realm\n", ceph_vinop(inode));
	while (realm) {
		spin_lock(&realm->inodes_with_caps_lock);
		in = realm->inode ? igrab(realm->inode) : NULL;
		spin_unlock(&realm->inodes_with_caps_lock);
		if (!in)
			break;

		ci = ceph_inode(in);
		spin_lock(&ci->i_ceph_lock);
		if (op == QUOTA_CHECK_MAX_FILES_OP) {
			max = ci->i_max_files;
			rvalue = ci->i_rfiles + ci->i_rsubdirs;
		} else {
			max = ci->i_max_bytes;
			rvalue = ci->i_rbytes;
		}
		spin_unlock(&ci->i_ceph_lock);
		switch (op) {
		case QUOTA_CHECK_MAX_FILES_OP:
			exceeded = (max && (rvalue >= max));
			break;
		case QUOTA_CHECK_MAX_BYTES_OP:
			exceeded = (max && (rvalue + delta > max));
			break;
		case QUOTA_CHECK_MAX_BYTES_APPROACHING_OP:
			if (max) {
				if (rvalue >= max)
					exceeded = true;
				else {
					/*
					 * when we're writing more that 1/16th
					 * of the available space
					 */
					exceeded =
						(((max - rvalue) >> 4) < delta);
				}
			}
			break;
		default:
			/* Shouldn't happen */
			pr_warn("Invalid quota check op (%d)\n", op);
			exceeded = true; /* Just break the loop */
		}
		iput(in);

		next = realm->parent;
		if (exceeded || !next)
			break;
		ceph_get_snap_realm(mdsc, next);
		ceph_put_snap_realm(mdsc, realm);
		realm = next;
	}
	ceph_put_snap_realm(mdsc, realm);
	up_read(&mdsc->snap_rwsem);

	return exceeded;
}

/*
 * ceph_quota_is_max_files_exceeded - check if we can create a new file
 * @inode:	directory where a new file is being created
 *
 * This functions returns true is max_files quota allows a new file to be
 * created.  It is necessary to walk through the snaprealm hierarchy (until the
 * FS root) to check all realms with quotas set.
 */
bool ceph_quota_is_max_files_exceeded(struct inode *inode)
{
	if (!ceph_has_realms_with_quotas(inode))
		return false;

	WARN_ON(!S_ISDIR(inode->i_mode));

	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_FILES_OP, 0);
}

/*
 * ceph_quota_is_max_bytes_exceeded - check if we can write to a file
 * @inode:	inode being written
 * @newsize:	new size if write succeeds
 *
 * This functions returns true is max_bytes quota allows a file size to reach
 * @newsize; it returns false otherwise.
 */
bool ceph_quota_is_max_bytes_exceeded(struct inode *inode, loff_t newsize)
{
	loff_t size = i_size_read(inode);

	if (!ceph_has_realms_with_quotas(inode))
		return false;

	/* return immediately if we're decreasing file size */
	if (newsize <= size)
		return false;

	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_OP, (newsize - size));
}

/*
 * ceph_quota_is_max_bytes_approaching - check if we're reaching max_bytes
 * @inode:	inode being written
 * @newsize:	new size if write succeeds
 *
 * This function returns true if the new file size @newsize will be consuming
 * more than 1/16th of the available quota space; it returns false otherwise.
 */
bool ceph_quota_is_max_bytes_approaching(struct inode *inode, loff_t newsize)
{
	loff_t size = ceph_inode(inode)->i_reported_size;

	if (!ceph_has_realms_with_quotas(inode))
		return false;

	/* return immediately if we're decreasing file size */
	if (newsize <= size)
		return false;

	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_APPROACHING_OP,
				    (newsize - size));
}

/*
 * ceph_quota_update_statfs - if root has quota update statfs with quota status
 * @fsc:	filesystem client instance
 * @buf:	statfs to update
 *
 * If the mounted filesystem root has max_bytes quota set, update the filesystem
 * statistics with the quota status.
 *
 * This function returns true if the stats have been updated, false otherwise.
 */
bool ceph_quota_update_statfs(struct ceph_fs_client *fsc, struct kstatfs *buf)
{
	struct ceph_mds_client *mdsc = fsc->mdsc;
	struct ceph_inode_info *ci;
	struct ceph_snap_realm *realm;
	struct inode *in;
	u64 total = 0, used, free;
	bool is_updated = false;

	down_read(&mdsc->snap_rwsem);
	realm = get_quota_realm(mdsc, d_inode(fsc->sb->s_root));
	up_read(&mdsc->snap_rwsem);
	if (!realm)
		return false;

	spin_lock(&realm->inodes_with_caps_lock);
	in = realm->inode ? igrab(realm->inode) : NULL;
	spin_unlock(&realm->inodes_with_caps_lock);
	if (in) {
		ci = ceph_inode(in);
		spin_lock(&ci->i_ceph_lock);
		if (ci->i_max_bytes) {
			total = ci->i_max_bytes >> CEPH_BLOCK_SHIFT;
			used = ci->i_rbytes >> CEPH_BLOCK_SHIFT;
			/* It is possible for a quota to be exceeded.
			 * Report 'zero' in that case
			 */
			free = total > used ? total - used : 0;
		}
		spin_unlock(&ci->i_ceph_lock);
		if (total) {
			buf->f_blocks = total;
			buf->f_bfree = free;
			buf->f_bavail = free;
			is_updated = true;
		}
		iput(in);
	}
	ceph_put_snap_realm(mdsc, realm);

	return is_updated;
}
Commit	Line	Data
fb18a575 LH	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* quota.c - CephFS quota
	4	*
	5	* Copyright (C) 2017-2018 SUSE
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License
	9	* as published by the Free Software Foundation; either version 2
	10	* of the License, or (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
9122eed5 LH	21	#include <linux/statfs.h>
9122eed5 LH	22
fb18a575 LH	23	#include "super.h"
	24	#include "mds_client.h"
	25
d557c48d	26	void ceph_adjust_quota_realms_count(struct inode *inode, bool inc)
cafe21a4	27	{
d557c48d LH	28	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	29	if (inc)
	30	atomic64_inc(&mdsc->quotarealms_count);
	31	else
	32	atomic64_dec(&mdsc->quotarealms_count);
	33	}
	34
	35	static inline bool ceph_has_realms_with_quotas(struct inode *inode)
	36	{
	37	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	38	return atomic64_read(&mdsc->quotarealms_count) > 0;
cafe21a4 LH	39	}
cafe21a4 LH	40
fb18a575 LH	41	void ceph_handle_quota(struct ceph_mds_client *mdsc,
	42	struct ceph_mds_session *session,
	43	struct ceph_msg *msg)
	44	{
	45	struct super_block *sb = mdsc->fsc->sb;
	46	struct ceph_mds_quota *h = msg->front.iov_base;
	47	struct ceph_vino vino;
	48	struct inode *inode;
	49	struct ceph_inode_info *ci;
	50
0fcf6c02	51	if (msg->front.iov_len < sizeof(*h)) {
fb18a575 LH	52	pr_err("%s corrupt message mds%d len %d\n", __func__,
	53	session->s_mds, (int)msg->front.iov_len);
	54	ceph_msg_dump(msg);
	55	return;
	56	}
	57
	58	/* increment msg sequence number */
	59	mutex_lock(&session->s_mutex);
	60	session->s_seq++;
	61	mutex_unlock(&session->s_mutex);
	62
	63	/* lookup inode */
	64	vino.ino = le64_to_cpu(h->ino);
	65	vino.snap = CEPH_NOSNAP;
	66	inode = ceph_find_inode(sb, vino);
	67	if (!inode) {
	68	pr_warn("Failed to find inode %llu\n", vino.ino);
	69	return;
	70	}
	71	ci = ceph_inode(inode);
	72
	73	spin_lock(&ci->i_ceph_lock);
	74	ci->i_rbytes = le64_to_cpu(h->rbytes);
	75	ci->i_rfiles = le64_to_cpu(h->rfiles);
	76	ci->i_rsubdirs = le64_to_cpu(h->rsubdirs);
d557c48d LH	77	__ceph_update_quota(ci, le64_to_cpu(h->max_bytes),
d557c48d LH	78	le64_to_cpu(h->max_files));
fb18a575 LH	79	spin_unlock(&ci->i_ceph_lock);
	80
	81	iput(inode);
	82	}
b7a29217	83
cafe21a4 LH	84	/*
	85	* This function walks through the snaprealm for an inode and returns the
	86	* ceph_snap_realm for the first snaprealm that has quotas set (either max_files
	87	* or max_bytes). If the root is reached, return the root ceph_snap_realm
	88	* instead.
	89	*
	90	* Note that the caller is responsible for calling ceph_put_snap_realm() on the
	91	* returned realm.
	92	*/
	93	static struct ceph_snap_realm get_quota_realm(struct ceph_mds_client mdsc,
	94	struct inode *inode)
	95	{
	96	struct ceph_inode_info *ci = NULL;
	97	struct ceph_snap_realm realm, next;
cafe21a4	98	struct inode *in;
0eb6bbe4	99	bool has_quota;
cafe21a4	100
25963669 YZ	101	if (ceph_snap(inode) != CEPH_NOSNAP)
	102	return NULL;
	103
cafe21a4	104	realm = ceph_inode(inode)->i_snap_realm;
25963669 YZ	105	if (realm)
	106	ceph_get_snap_realm(mdsc, realm);
	107	else
	108	pr_err_ratelimited("get_quota_realm: ino (%llx.%llx) "
	109	"null i_snap_realm\n", ceph_vinop(inode));
cafe21a4	110	while (realm) {
e3161f17 LH	111	spin_lock(&realm->inodes_with_caps_lock);
	112	in = realm->inode ? igrab(realm->inode) : NULL;
	113	spin_unlock(&realm->inodes_with_caps_lock);
	114	if (!in)
cafe21a4	115	break;
e3161f17	116
cafe21a4	117	ci = ceph_inode(in);
d557c48d	118	has_quota = __ceph_has_any_quota(ci);
cafe21a4	119	iput(in);
0eb6bbe4	120
cafe21a4	121	next = realm->parent;
0eb6bbe4 YZ	122	if (has_quota \|\| !next)
	123	return realm;
	124
cafe21a4 LH	125	ceph_get_snap_realm(mdsc, next);
	126	ceph_put_snap_realm(mdsc, realm);
	127	realm = next;
	128	}
	129	if (realm)
	130	ceph_put_snap_realm(mdsc, realm);
	131
	132	return NULL;
	133	}
	134
	135	bool ceph_quota_is_same_realm(struct inode old, struct inode new)
	136	{
	137	struct ceph_mds_client *mdsc = ceph_inode_to_client(old)->mdsc;
	138	struct ceph_snap_realm old_realm, new_realm;
	139	bool is_same;
	140
	141	down_read(&mdsc->snap_rwsem);
	142	old_realm = get_quota_realm(mdsc, old);
	143	new_realm = get_quota_realm(mdsc, new);
	144	is_same = (old_realm == new_realm);
	145	up_read(&mdsc->snap_rwsem);
	146
	147	if (old_realm)
	148	ceph_put_snap_realm(mdsc, old_realm);
	149	if (new_realm)
	150	ceph_put_snap_realm(mdsc, new_realm);
	151
	152	return is_same;
	153	}
	154
b7a29217	155	enum quota_check_op {
2b83845f	156	QUOTA_CHECK_MAX_FILES_OP, /* check quota max_files limit */
1ab302a0 LH	157	QUOTA_CHECK_MAX_BYTES_OP, /* check quota max_files limit */
	158	QUOTA_CHECK_MAX_BYTES_APPROACHING_OP /* check if quota max_files
	159	limit is approaching */
b7a29217 LH	160	};
	161
	162	/*
	163	* check_quota_exceeded() will walk up the snaprealm hierarchy and, for each
	164	* realm, it will execute quota check operation defined by the 'op' parameter.
	165	* The snaprealm walk is interrupted if the quota check detects that the quota
	166	* is exceeded or if the root inode is reached.
	167	*/
	168	static bool check_quota_exceeded(struct inode *inode, enum quota_check_op op,
	169	loff_t delta)
	170	{
	171	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	172	struct ceph_inode_info *ci;
	173	struct ceph_snap_realm realm, next;
b7a29217 LH	174	struct inode *in;
b7a29217 LH	175	u64 max, rvalue;
b7a29217 LH	176	bool exceeded = false;
b7a29217 LH	177
25963669 YZ	178	if (ceph_snap(inode) != CEPH_NOSNAP)
	179	return false;
	180
b7a29217 LH	181	down_read(&mdsc->snap_rwsem);
b7a29217 LH	182	realm = ceph_inode(inode)->i_snap_realm;
25963669 YZ	183	if (realm)
	184	ceph_get_snap_realm(mdsc, realm);
	185	else
	186	pr_err_ratelimited("check_quota_exceeded: ino (%llx.%llx) "
	187	"null i_snap_realm\n", ceph_vinop(inode));
b7a29217	188	while (realm) {
e3161f17 LH	189	spin_lock(&realm->inodes_with_caps_lock);
	190	in = realm->inode ? igrab(realm->inode) : NULL;
	191	spin_unlock(&realm->inodes_with_caps_lock);
	192	if (!in)
b7a29217	193	break;
e3161f17	194
b7a29217 LH	195	ci = ceph_inode(in);
	196	spin_lock(&ci->i_ceph_lock);
	197	if (op == QUOTA_CHECK_MAX_FILES_OP) {
	198	max = ci->i_max_files;
	199	rvalue = ci->i_rfiles + ci->i_rsubdirs;
2b83845f LH	200	} else {
	201	max = ci->i_max_bytes;
	202	rvalue = ci->i_rbytes;
b7a29217	203	}
b7a29217 LH	204	spin_unlock(&ci->i_ceph_lock);
	205	switch (op) {
	206	case QUOTA_CHECK_MAX_FILES_OP:
	207	exceeded = (max && (rvalue >= max));
	208	break;
2b83845f LH	209	case QUOTA_CHECK_MAX_BYTES_OP:
	210	exceeded = (max && (rvalue + delta > max));
	211	break;
1ab302a0 LH	212	case QUOTA_CHECK_MAX_BYTES_APPROACHING_OP:
	213	if (max) {
	214	if (rvalue >= max)
	215	exceeded = true;
	216	else {
	217	/*
	218	* when we're writing more that 1/16th
	219	* of the available space
	220	*/
	221	exceeded =
	222	(((max - rvalue) >> 4) < delta);
	223	}
	224	}
	225	break;
b7a29217 LH	226	default:
	227	/* Shouldn't happen */
	228	pr_warn("Invalid quota check op (%d)\n", op);
	229	exceeded = true; /* Just break the loop */
	230	}
	231	iput(in);
	232
b7a29217	233	next = realm->parent;
0eb6bbe4 YZ	234	if (exceeded \|\| !next)
0eb6bbe4 YZ	235	break;
b7a29217 LH	236	ceph_get_snap_realm(mdsc, next);
	237	ceph_put_snap_realm(mdsc, realm);
	238	realm = next;
	239	}
	240	ceph_put_snap_realm(mdsc, realm);
	241	up_read(&mdsc->snap_rwsem);
	242
	243	return exceeded;
	244	}
	245
	246	/*
	247	* ceph_quota_is_max_files_exceeded - check if we can create a new file
	248	* @inode: directory where a new file is being created
	249	*
	250	* This functions returns true is max_files quota allows a new file to be
	251	* created. It is necessary to walk through the snaprealm hierarchy (until the
	252	* FS root) to check all realms with quotas set.
	253	*/
	254	bool ceph_quota_is_max_files_exceeded(struct inode *inode)
	255	{
d557c48d LH	256	if (!ceph_has_realms_with_quotas(inode))
	257	return false;
	258
b7a29217 LH	259	WARN_ON(!S_ISDIR(inode->i_mode));
	260
	261	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_FILES_OP, 0);
	262	}
2b83845f LH	263
	264	/*
	265	* ceph_quota_is_max_bytes_exceeded - check if we can write to a file
	266	* @inode: inode being written
	267	* @newsize: new size if write succeeds
	268	*
	269	* This functions returns true is max_bytes quota allows a file size to reach
	270	* @newsize; it returns false otherwise.
	271	*/
	272	bool ceph_quota_is_max_bytes_exceeded(struct inode *inode, loff_t newsize)
	273	{
	274	loff_t size = i_size_read(inode);
	275
d557c48d LH	276	if (!ceph_has_realms_with_quotas(inode))
	277	return false;
	278
2b83845f LH	279	/* return immediately if we're decreasing file size */
	280	if (newsize <= size)
	281	return false;
	282
	283	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_OP, (newsize - size));
	284	}
1ab302a0 LH	285
	286	/*
	287	* ceph_quota_is_max_bytes_approaching - check if we're reaching max_bytes
	288	* @inode: inode being written
	289	* @newsize: new size if write succeeds
	290	*
	291	* This function returns true if the new file size @newsize will be consuming
	292	* more than 1/16th of the available quota space; it returns false otherwise.
	293	*/
	294	bool ceph_quota_is_max_bytes_approaching(struct inode *inode, loff_t newsize)
	295	{
	296	loff_t size = ceph_inode(inode)->i_reported_size;
	297
d557c48d LH	298	if (!ceph_has_realms_with_quotas(inode))
	299	return false;
	300
1ab302a0 LH	301	/* return immediately if we're decreasing file size */
	302	if (newsize <= size)
	303	return false;
	304
	305	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_APPROACHING_OP,
	306	(newsize - size));
	307	}
9122eed5 LH	308
	309	/*
	310	* ceph_quota_update_statfs - if root has quota update statfs with quota status
	311	* @fsc: filesystem client instance
	312	* @buf: statfs to update
	313	*
	314	* If the mounted filesystem root has max_bytes quota set, update the filesystem
	315	* statistics with the quota status.
	316	*
	317	* This function returns true if the stats have been updated, false otherwise.
	318	*/
	319	bool ceph_quota_update_statfs(struct ceph_fs_client fsc, struct kstatfs buf)
	320	{
	321	struct ceph_mds_client *mdsc = fsc->mdsc;
	322	struct ceph_inode_info *ci;
	323	struct ceph_snap_realm *realm;
	324	struct inode *in;
	325	u64 total = 0, used, free;
	326	bool is_updated = false;
	327
	328	down_read(&mdsc->snap_rwsem);
	329	realm = get_quota_realm(mdsc, d_inode(fsc->sb->s_root));
	330	up_read(&mdsc->snap_rwsem);
	331	if (!realm)
	332	return false;
	333
	334	spin_lock(&realm->inodes_with_caps_lock);
	335	in = realm->inode ? igrab(realm->inode) : NULL;
	336	spin_unlock(&realm->inodes_with_caps_lock);
	337	if (in) {
	338	ci = ceph_inode(in);
	339	spin_lock(&ci->i_ceph_lock);
	340	if (ci->i_max_bytes) {
	341	total = ci->i_max_bytes >> CEPH_BLOCK_SHIFT;
	342	used = ci->i_rbytes >> CEPH_BLOCK_SHIFT;
	343	/* It is possible for a quota to be exceeded.
	344	* Report 'zero' in that case
	345	*/
	346	free = total > used ? total - used : 0;
	347	}
	348	spin_unlock(&ci->i_ceph_lock);
	349	if (total) {
	350	buf->f_blocks = total;
	351	buf->f_bfree = free;
	352	buf->f_bavail = free;
	353	is_updated = true;
	354	}
	355	iput(in);
	356	}
	357	ceph_put_snap_realm(mdsc, realm);
	358
	359	return is_updated;
	360	}
	361