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

// SPDX-License-Identifier: GPL-2.0
/*
 * quota.c - CephFS quota
 *
 * Copyright (C) 2017-2018 SUSE
 */

#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_sb_to_mdsc(inode->i_sb);
	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 super_block *sb = inode->i_sb;
	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(sb);
	struct inode *root = d_inode(sb->s_root);

	if (atomic64_read(&mdsc->quotarealms_count) > 0)
		return true;
	/* if root is the real CephFS root, we don't have quota realms */
	if (root && ceph_ino(root) == CEPH_INO_ROOT)
		return false;
	/* otherwise, we can't know for sure */
	return true;
}

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);
	inc_session_sequence(session);
	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);
}

static struct ceph_quotarealm_inode *
find_quotarealm_inode(struct ceph_mds_client *mdsc, u64 ino)
{
	struct ceph_quotarealm_inode *qri = NULL;
	struct rb_node **node, *parent = NULL;

	mutex_lock(&mdsc->quotarealms_inodes_mutex);
	node = &(mdsc->quotarealms_inodes.rb_node);
	while (*node) {
		parent = *node;
		qri = container_of(*node, struct ceph_quotarealm_inode, node);

		if (ino < qri->ino)
			node = &((*node)->rb_left);
		else if (ino > qri->ino)
			node = &((*node)->rb_right);
		else
			break;
	}
	if (!qri || (qri->ino != ino)) {
		/* Not found, create a new one and insert it */
		qri = kmalloc(sizeof(*qri), GFP_KERNEL);
		if (qri) {
			qri->ino = ino;
			qri->inode = NULL;
			qri->timeout = 0;
			mutex_init(&qri->mutex);
			rb_link_node(&qri->node, parent, node);
			rb_insert_color(&qri->node, &mdsc->quotarealms_inodes);
		} else
			pr_warn("Failed to alloc quotarealms_inode\n");
	}
	mutex_unlock(&mdsc->quotarealms_inodes_mutex);

	return qri;
}

/*
 * This function will try to lookup a realm inode which isn't visible in the
 * filesystem mountpoint.  A list of these kind of inodes (not visible) is
 * maintained in the mdsc and freed only when the filesystem is umounted.
 *
 * Note that these inodes are kept in this list even if the lookup fails, which
 * allows to prevent useless lookup requests.
 */
static struct inode *lookup_quotarealm_inode(struct ceph_mds_client *mdsc,
					     struct super_block *sb,
					     struct ceph_snap_realm *realm)
{
	struct ceph_quotarealm_inode *qri;
	struct inode *in;

	qri = find_quotarealm_inode(mdsc, realm->ino);
	if (!qri)
		return NULL;

	mutex_lock(&qri->mutex);
	if (qri->inode && ceph_is_any_caps(qri->inode)) {
		/* A request has already returned the inode */
		mutex_unlock(&qri->mutex);
		return qri->inode;
	}
	/* Check if this inode lookup has failed recently */
	if (qri->timeout &&
	    time_before_eq(jiffies, qri->timeout)) {
		mutex_unlock(&qri->mutex);
		return NULL;
	}
	if (qri->inode) {
		/* get caps */
		int ret = __ceph_do_getattr(qri->inode, NULL,
					    CEPH_STAT_CAP_INODE, true);
		if (ret >= 0)
			in = qri->inode;
		else
			in = ERR_PTR(ret);
	}  else {
		in = ceph_lookup_inode(sb, realm->ino);
	}

	if (IS_ERR(in)) {
		dout("Can't lookup inode %llx (err: %ld)\n",
		     realm->ino, PTR_ERR(in));
		qri->timeout = jiffies + msecs_to_jiffies(60 * 1000); /* XXX */
	} else {
		qri->timeout = 0;
		qri->inode = in;
	}
	mutex_unlock(&qri->mutex);

	return in;
}

void ceph_cleanup_quotarealms_inodes(struct ceph_mds_client *mdsc)
{
	struct ceph_quotarealm_inode *qri;
	struct rb_node *node;

	/*
	 * It should now be safe to clean quotarealms_inode tree without holding
	 * mdsc->quotarealms_inodes_mutex...
	 */
	mutex_lock(&mdsc->quotarealms_inodes_mutex);
	while (!RB_EMPTY_ROOT(&mdsc->quotarealms_inodes)) {
		node = rb_first(&mdsc->quotarealms_inodes);
		qri = rb_entry(node, struct ceph_quotarealm_inode, node);
		rb_erase(node, &mdsc->quotarealms_inodes);
		iput(qri->inode);
		kfree(qri);
	}
	mutex_unlock(&mdsc->quotarealms_inodes_mutex);
}

/*
 * 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.
 *
 * Callers of this function need to hold mdsc->snap_rwsem.  However, if there's
 * a need to do an inode lookup, this rwsem will be temporarily dropped.  Hence
 * the 'retry' argument: if rwsem needs to be dropped and 'retry' is 'false'
 * this function will return -EAGAIN; otherwise, the snaprealms walk-through
 * will be restarted.
 */
static struct ceph_snap_realm *get_quota_realm(struct ceph_mds_client *mdsc,
					       struct inode *inode, bool retry)
{
	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;

restart:
	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) {
		bool has_inode;

		spin_lock(&realm->inodes_with_caps_lock);
		has_inode = realm->inode;
		in = has_inode ? igrab(realm->inode) : NULL;
		spin_unlock(&realm->inodes_with_caps_lock);
		if (has_inode && !in)
			break;
		if (!in) {
			up_read(&mdsc->snap_rwsem);
			in = lookup_quotarealm_inode(mdsc, inode->i_sb, realm);
			down_read(&mdsc->snap_rwsem);
			if (IS_ERR_OR_NULL(in))
				break;
			ceph_put_snap_realm(mdsc, realm);
			if (!retry)
				return ERR_PTR(-EAGAIN);
			goto restart;
		}

		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_sb_to_mdsc(old->i_sb);
	struct ceph_snap_realm *old_realm, *new_realm;
	bool is_same;

restart:
	/*
	 * We need to lookup 2 quota realms atomically, i.e. with snap_rwsem.
	 * However, get_quota_realm may drop it temporarily.  By setting the
	 * 'retry' parameter to 'false', we'll get -EAGAIN if the rwsem was
	 * dropped and we can then restart the whole operation.
	 */
	down_read(&mdsc->snap_rwsem);
	old_realm = get_quota_realm(mdsc, old, true);
	new_realm = get_quota_realm(mdsc, new, false);
	if (PTR_ERR(new_realm) == -EAGAIN) {
		up_read(&mdsc->snap_rwsem);
		if (old_realm)
			ceph_put_snap_realm(mdsc, old_realm);
		goto restart;
	}
	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_sb_to_mdsc(inode->i_sb);
	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);
restart:
	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) {
		bool has_inode;

		spin_lock(&realm->inodes_with_caps_lock);
		has_inode = realm->inode;
		in = has_inode ? igrab(realm->inode) : NULL;
		spin_unlock(&realm->inodes_with_caps_lock);
		if (has_inode && !in)
			break;
		if (!in) {
			up_read(&mdsc->snap_rwsem);
			in = lookup_quotarealm_inode(mdsc, inode->i_sb, realm);
			down_read(&mdsc->snap_rwsem);
			if (IS_ERR_OR_NULL(in))
				break;
			ceph_put_snap_realm(mdsc, realm);
			goto restart;
		}
		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:
		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;
	}
	if (realm)
		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, 1);
}

/*
 * 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), true);
	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
fb18a575 LH	6	*/
fb18a575 LH	7
9122eed5 LH	8	#include <linux/statfs.h>
9122eed5 LH	9
fb18a575 LH	10	#include "super.h"
	11	#include "mds_client.h"
	12
d557c48d	13	void ceph_adjust_quota_realms_count(struct inode *inode, bool inc)
cafe21a4	14	{
2678da88	15	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
d557c48d LH	16	if (inc)
	17	atomic64_inc(&mdsc->quotarealms_count);
	18	else
	19	atomic64_dec(&mdsc->quotarealms_count);
	20	}
	21
	22	static inline bool ceph_has_realms_with_quotas(struct inode *inode)
	23	{
2678da88 XL	24	struct super_block *sb = inode->i_sb;
2678da88 XL	25	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(sb);
ebce3eb2	26	struct inode *root = d_inode(sb->s_root);
0c44a8e0 LH	27
	28	if (atomic64_read(&mdsc->quotarealms_count) > 0)
	29	return true;
	30	/* if root is the real CephFS root, we don't have quota realms */
ebce3eb2	31	if (root && ceph_ino(root) == CEPH_INO_ROOT)
0c44a8e0 LH	32	return false;
	33	/* otherwise, we can't know for sure */
	34	return true;
cafe21a4 LH	35	}
cafe21a4 LH	36
fb18a575 LH	37	void ceph_handle_quota(struct ceph_mds_client *mdsc,
	38	struct ceph_mds_session *session,
	39	struct ceph_msg *msg)
	40	{
	41	struct super_block *sb = mdsc->fsc->sb;
	42	struct ceph_mds_quota *h = msg->front.iov_base;
	43	struct ceph_vino vino;
	44	struct inode *inode;
	45	struct ceph_inode_info *ci;
	46
0fcf6c02	47	if (msg->front.iov_len < sizeof(*h)) {
fb18a575 LH	48	pr_err("%s corrupt message mds%d len %d\n", __func__,
	49	session->s_mds, (int)msg->front.iov_len);
	50	ceph_msg_dump(msg);
	51	return;
	52	}
	53
	54	/* increment msg sequence number */
	55	mutex_lock(&session->s_mutex);
62575e27	56	inc_session_sequence(session);
fb18a575 LH	57	mutex_unlock(&session->s_mutex);
	58
	59	/* lookup inode */
	60	vino.ino = le64_to_cpu(h->ino);
	61	vino.snap = CEPH_NOSNAP;
	62	inode = ceph_find_inode(sb, vino);
	63	if (!inode) {
	64	pr_warn("Failed to find inode %llu\n", vino.ino);
	65	return;
	66	}
	67	ci = ceph_inode(inode);
	68
	69	spin_lock(&ci->i_ceph_lock);
	70	ci->i_rbytes = le64_to_cpu(h->rbytes);
	71	ci->i_rfiles = le64_to_cpu(h->rfiles);
	72	ci->i_rsubdirs = le64_to_cpu(h->rsubdirs);
d557c48d LH	73	__ceph_update_quota(ci, le64_to_cpu(h->max_bytes),
d557c48d LH	74	le64_to_cpu(h->max_files));
fb18a575 LH	75	spin_unlock(&ci->i_ceph_lock);
fb18a575 LH	76
23c2c76e	77	iput(inode);
fb18a575	78	}
b7a29217	79
0c44a8e0 LH	80	static struct ceph_quotarealm_inode *
	81	find_quotarealm_inode(struct ceph_mds_client *mdsc, u64 ino)
	82	{
	83	struct ceph_quotarealm_inode *qri = NULL;
	84	struct rb_node *node, parent = NULL;
	85
	86	mutex_lock(&mdsc->quotarealms_inodes_mutex);
	87	node = &(mdsc->quotarealms_inodes.rb_node);
	88	while (*node) {
	89	parent = *node;
	90	qri = container_of(*node, struct ceph_quotarealm_inode, node);
	91
	92	if (ino < qri->ino)
	93	node = &((*node)->rb_left);
	94	else if (ino > qri->ino)
	95	node = &((*node)->rb_right);
	96	else
	97	break;
	98	}
	99	if (!qri \|\| (qri->ino != ino)) {
	100	/* Not found, create a new one and insert it */
	101	qri = kmalloc(sizeof(*qri), GFP_KERNEL);
	102	if (qri) {
	103	qri->ino = ino;
	104	qri->inode = NULL;
	105	qri->timeout = 0;
	106	mutex_init(&qri->mutex);
	107	rb_link_node(&qri->node, parent, node);
	108	rb_insert_color(&qri->node, &mdsc->quotarealms_inodes);
	109	} else
	110	pr_warn("Failed to alloc quotarealms_inode\n");
	111	}
	112	mutex_unlock(&mdsc->quotarealms_inodes_mutex);
	113
	114	return qri;
	115	}
	116
	117	/*
	118	* This function will try to lookup a realm inode which isn't visible in the
	119	* filesystem mountpoint. A list of these kind of inodes (not visible) is
	120	* maintained in the mdsc and freed only when the filesystem is umounted.
	121	*
	122	* Note that these inodes are kept in this list even if the lookup fails, which
	123	* allows to prevent useless lookup requests.
	124	*/
	125	static struct inode lookup_quotarealm_inode(struct ceph_mds_client mdsc,
	126	struct super_block *sb,
	127	struct ceph_snap_realm *realm)
	128	{
	129	struct ceph_quotarealm_inode *qri;
	130	struct inode *in;
	131
	132	qri = find_quotarealm_inode(mdsc, realm->ino);
	133	if (!qri)
	134	return NULL;
	135
	136	mutex_lock(&qri->mutex);
2ef5df1a	137	if (qri->inode && ceph_is_any_caps(qri->inode)) {
0c44a8e0 LH	138	/* A request has already returned the inode */
	139	mutex_unlock(&qri->mutex);
	140	return qri->inode;
	141	}
	142	/* Check if this inode lookup has failed recently */
	143	if (qri->timeout &&
	144	time_before_eq(jiffies, qri->timeout)) {
	145	mutex_unlock(&qri->mutex);
	146	return NULL;
	147	}
2ef5df1a YZ	148	if (qri->inode) {
	149	/* get caps */
	150	int ret = __ceph_do_getattr(qri->inode, NULL,
	151	CEPH_STAT_CAP_INODE, true);
	152	if (ret >= 0)
	153	in = qri->inode;
	154	else
	155	in = ERR_PTR(ret);
	156	} else {
	157	in = ceph_lookup_inode(sb, realm->ino);
	158	}
	159
0c44a8e0	160	if (IS_ERR(in)) {
12ae44a4 LH	161	dout("Can't lookup inode %llx (err: %ld)\n",
12ae44a4 LH	162	realm->ino, PTR_ERR(in));
0c44a8e0 LH	163	qri->timeout = jiffies + msecs_to_jiffies(60 * 1000); /* XXX */
	164	} else {
	165	qri->timeout = 0;
	166	qri->inode = in;
	167	}
	168	mutex_unlock(&qri->mutex);
	169
	170	return in;
	171	}
	172
	173	void ceph_cleanup_quotarealms_inodes(struct ceph_mds_client *mdsc)
	174	{
	175	struct ceph_quotarealm_inode *qri;
	176	struct rb_node *node;
	177
	178	/*
	179	* It should now be safe to clean quotarealms_inode tree without holding
	180	* mdsc->quotarealms_inodes_mutex...
	181	*/
	182	mutex_lock(&mdsc->quotarealms_inodes_mutex);
	183	while (!RB_EMPTY_ROOT(&mdsc->quotarealms_inodes)) {
	184	node = rb_first(&mdsc->quotarealms_inodes);
	185	qri = rb_entry(node, struct ceph_quotarealm_inode, node);
	186	rb_erase(node, &mdsc->quotarealms_inodes);
	187	iput(qri->inode);
	188	kfree(qri);
	189	}
	190	mutex_unlock(&mdsc->quotarealms_inodes_mutex);
	191	}
	192
cafe21a4 LH	193	/*
	194	* This function walks through the snaprealm for an inode and returns the
	195	* ceph_snap_realm for the first snaprealm that has quotas set (either max_files
	196	* or max_bytes). If the root is reached, return the root ceph_snap_realm
	197	* instead.
	198	*
	199	* Note that the caller is responsible for calling ceph_put_snap_realm() on the
	200	* returned realm.
0c44a8e0 LH	201	*
	202	* Callers of this function need to hold mdsc->snap_rwsem. However, if there's
	203	* a need to do an inode lookup, this rwsem will be temporarily dropped. Hence
	204	* the 'retry' argument: if rwsem needs to be dropped and 'retry' is 'false'
	205	* this function will return -EAGAIN; otherwise, the snaprealms walk-through
	206	* will be restarted.
cafe21a4 LH	207	*/
cafe21a4 LH	208	static struct ceph_snap_realm get_quota_realm(struct ceph_mds_client mdsc,
0c44a8e0	209	struct inode *inode, bool retry)
cafe21a4 LH	210	{
	211	struct ceph_inode_info *ci = NULL;
	212	struct ceph_snap_realm realm, next;
cafe21a4	213	struct inode *in;
0eb6bbe4	214	bool has_quota;
cafe21a4	215
25963669 YZ	216	if (ceph_snap(inode) != CEPH_NOSNAP)
	217	return NULL;
	218
0c44a8e0	219	restart:
cafe21a4	220	realm = ceph_inode(inode)->i_snap_realm;
25963669 YZ	221	if (realm)
	222	ceph_get_snap_realm(mdsc, realm);
	223	else
	224	pr_err_ratelimited("get_quota_realm: ino (%llx.%llx) "
	225	"null i_snap_realm\n", ceph_vinop(inode));
cafe21a4	226	while (realm) {
0c44a8e0 LH	227	bool has_inode;
0c44a8e0 LH	228
e3161f17	229	spin_lock(&realm->inodes_with_caps_lock);
0c44a8e0 LH	230	has_inode = realm->inode;
0c44a8e0 LH	231	in = has_inode ? igrab(realm->inode) : NULL;
e3161f17	232	spin_unlock(&realm->inodes_with_caps_lock);
0c44a8e0	233	if (has_inode && !in)
cafe21a4	234	break;
0c44a8e0 LH	235	if (!in) {
	236	up_read(&mdsc->snap_rwsem);
	237	in = lookup_quotarealm_inode(mdsc, inode->i_sb, realm);
	238	down_read(&mdsc->snap_rwsem);
	239	if (IS_ERR_OR_NULL(in))
	240	break;
	241	ceph_put_snap_realm(mdsc, realm);
	242	if (!retry)
	243	return ERR_PTR(-EAGAIN);
	244	goto restart;
	245	}
e3161f17	246
cafe21a4	247	ci = ceph_inode(in);
d557c48d	248	has_quota = __ceph_has_any_quota(ci);
23c2c76e	249	iput(in);
0eb6bbe4	250
cafe21a4	251	next = realm->parent;
0eb6bbe4 YZ	252	if (has_quota \|\| !next)
	253	return realm;
	254
cafe21a4 LH	255	ceph_get_snap_realm(mdsc, next);
	256	ceph_put_snap_realm(mdsc, realm);
	257	realm = next;
	258	}
	259	if (realm)
	260	ceph_put_snap_realm(mdsc, realm);
	261
	262	return NULL;
	263	}
	264
6646ea1c	265	bool ceph_quota_is_same_realm(struct inode old, struct inode new)
cafe21a4	266	{
2678da88	267	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(old->i_sb);
cafe21a4 LH	268	struct ceph_snap_realm old_realm, new_realm;
	269	bool is_same;
	270
0c44a8e0 LH	271	restart:
	272	/*
	273	* We need to lookup 2 quota realms atomically, i.e. with snap_rwsem.
	274	* However, get_quota_realm may drop it temporarily. By setting the
	275	* 'retry' parameter to 'false', we'll get -EAGAIN if the rwsem was
	276	* dropped and we can then restart the whole operation.
	277	*/
cafe21a4	278	down_read(&mdsc->snap_rwsem);
0c44a8e0 LH	279	old_realm = get_quota_realm(mdsc, old, true);
	280	new_realm = get_quota_realm(mdsc, new, false);
	281	if (PTR_ERR(new_realm) == -EAGAIN) {
	282	up_read(&mdsc->snap_rwsem);
	283	if (old_realm)
	284	ceph_put_snap_realm(mdsc, old_realm);
	285	goto restart;
	286	}
cafe21a4 LH	287	is_same = (old_realm == new_realm);
	288	up_read(&mdsc->snap_rwsem);
	289
	290	if (old_realm)
	291	ceph_put_snap_realm(mdsc, old_realm);
	292	if (new_realm)
	293	ceph_put_snap_realm(mdsc, new_realm);
	294
	295	return is_same;
	296	}
	297
b7a29217	298	enum quota_check_op {
2b83845f	299	QUOTA_CHECK_MAX_FILES_OP, /* check quota max_files limit */
1ab302a0 LH	300	QUOTA_CHECK_MAX_BYTES_OP, /* check quota max_files limit */
	301	QUOTA_CHECK_MAX_BYTES_APPROACHING_OP /* check if quota max_files
	302	limit is approaching */
b7a29217 LH	303	};
	304
	305	/*
	306	* check_quota_exceeded() will walk up the snaprealm hierarchy and, for each
	307	* realm, it will execute quota check operation defined by the 'op' parameter.
	308	* The snaprealm walk is interrupted if the quota check detects that the quota
	309	* is exceeded or if the root inode is reached.
	310	*/
	311	static bool check_quota_exceeded(struct inode *inode, enum quota_check_op op,
	312	loff_t delta)
	313	{
2678da88	314	struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
b7a29217 LH	315	struct ceph_inode_info *ci;
b7a29217 LH	316	struct ceph_snap_realm realm, next;
b7a29217 LH	317	struct inode *in;
b7a29217 LH	318	u64 max, rvalue;
b7a29217 LH	319	bool exceeded = false;
b7a29217 LH	320
25963669 YZ	321	if (ceph_snap(inode) != CEPH_NOSNAP)
	322	return false;
	323
b7a29217	324	down_read(&mdsc->snap_rwsem);
0c44a8e0	325	restart:
b7a29217	326	realm = ceph_inode(inode)->i_snap_realm;
25963669 YZ	327	if (realm)
	328	ceph_get_snap_realm(mdsc, realm);
	329	else
	330	pr_err_ratelimited("check_quota_exceeded: ino (%llx.%llx) "
	331	"null i_snap_realm\n", ceph_vinop(inode));
b7a29217	332	while (realm) {
0c44a8e0 LH	333	bool has_inode;
0c44a8e0 LH	334
e3161f17	335	spin_lock(&realm->inodes_with_caps_lock);
0c44a8e0 LH	336	has_inode = realm->inode;
0c44a8e0 LH	337	in = has_inode ? igrab(realm->inode) : NULL;
e3161f17	338	spin_unlock(&realm->inodes_with_caps_lock);
0c44a8e0	339	if (has_inode && !in)
b7a29217	340	break;
0c44a8e0 LH	341	if (!in) {
	342	up_read(&mdsc->snap_rwsem);
	343	in = lookup_quotarealm_inode(mdsc, inode->i_sb, realm);
	344	down_read(&mdsc->snap_rwsem);
	345	if (IS_ERR_OR_NULL(in))
	346	break;
	347	ceph_put_snap_realm(mdsc, realm);
	348	goto restart;
	349	}
b7a29217 LH	350	ci = ceph_inode(in);
	351	spin_lock(&ci->i_ceph_lock);
	352	if (op == QUOTA_CHECK_MAX_FILES_OP) {
	353	max = ci->i_max_files;
	354	rvalue = ci->i_rfiles + ci->i_rsubdirs;
2b83845f LH	355	} else {
	356	max = ci->i_max_bytes;
	357	rvalue = ci->i_rbytes;
b7a29217	358	}
b7a29217 LH	359	spin_unlock(&ci->i_ceph_lock);
	360	switch (op) {
	361	case QUOTA_CHECK_MAX_FILES_OP:
2b83845f LH	362	case QUOTA_CHECK_MAX_BYTES_OP:
	363	exceeded = (max && (rvalue + delta > max));
	364	break;
1ab302a0 LH	365	case QUOTA_CHECK_MAX_BYTES_APPROACHING_OP:
	366	if (max) {
	367	if (rvalue >= max)
	368	exceeded = true;
	369	else {
	370	/*
	371	* when we're writing more that 1/16th
	372	* of the available space
	373	*/
	374	exceeded =
	375	(((max - rvalue) >> 4) < delta);
	376	}
	377	}
	378	break;
b7a29217 LH	379	default:
	380	/* Shouldn't happen */
	381	pr_warn("Invalid quota check op (%d)\n", op);
	382	exceeded = true; /* Just break the loop */
	383	}
23c2c76e	384	iput(in);
b7a29217	385
b7a29217	386	next = realm->parent;
0eb6bbe4 YZ	387	if (exceeded \|\| !next)
0eb6bbe4 YZ	388	break;
b7a29217 LH	389	ceph_get_snap_realm(mdsc, next);
	390	ceph_put_snap_realm(mdsc, realm);
	391	realm = next;
	392	}
71f2cc64 LH	393	if (realm)
71f2cc64 LH	394	ceph_put_snap_realm(mdsc, realm);
b7a29217 LH	395	up_read(&mdsc->snap_rwsem);
	396
	397	return exceeded;
	398	}
	399
	400	/*
	401	* ceph_quota_is_max_files_exceeded - check if we can create a new file
	402	* @inode: directory where a new file is being created
	403	*
	404	* This functions returns true is max_files quota allows a new file to be
	405	* created. It is necessary to walk through the snaprealm hierarchy (until the
	406	* FS root) to check all realms with quotas set.
	407	*/
	408	bool ceph_quota_is_max_files_exceeded(struct inode *inode)
	409	{
d557c48d LH	410	if (!ceph_has_realms_with_quotas(inode))
	411	return false;
	412
b7a29217 LH	413	WARN_ON(!S_ISDIR(inode->i_mode));
b7a29217 LH	414
daa668fb	415	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_FILES_OP, 1);
b7a29217	416	}
2b83845f LH	417
	418	/*
	419	* ceph_quota_is_max_bytes_exceeded - check if we can write to a file
	420	* @inode: inode being written
	421	* @newsize: new size if write succeeds
	422	*
	423	* This functions returns true is max_bytes quota allows a file size to reach
	424	* @newsize; it returns false otherwise.
	425	*/
	426	bool ceph_quota_is_max_bytes_exceeded(struct inode *inode, loff_t newsize)
	427	{
	428	loff_t size = i_size_read(inode);
	429
d557c48d LH	430	if (!ceph_has_realms_with_quotas(inode))
	431	return false;
	432
2b83845f LH	433	/* return immediately if we're decreasing file size */
	434	if (newsize <= size)
	435	return false;
	436
	437	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_OP, (newsize - size));
	438	}
1ab302a0 LH	439
	440	/*
	441	* ceph_quota_is_max_bytes_approaching - check if we're reaching max_bytes
	442	* @inode: inode being written
	443	* @newsize: new size if write succeeds
	444	*
	445	* This function returns true if the new file size @newsize will be consuming
	446	* more than 1/16th of the available quota space; it returns false otherwise.
	447	*/
	448	bool ceph_quota_is_max_bytes_approaching(struct inode *inode, loff_t newsize)
	449	{
	450	loff_t size = ceph_inode(inode)->i_reported_size;
	451
d557c48d LH	452	if (!ceph_has_realms_with_quotas(inode))
	453	return false;
	454
1ab302a0 LH	455	/* return immediately if we're decreasing file size */
	456	if (newsize <= size)
	457	return false;
	458
	459	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_APPROACHING_OP,
	460	(newsize - size));
	461	}
9122eed5 LH	462
	463	/*
	464	* ceph_quota_update_statfs - if root has quota update statfs with quota status
	465	* @fsc: filesystem client instance
	466	* @buf: statfs to update
	467	*
	468	* If the mounted filesystem root has max_bytes quota set, update the filesystem
	469	* statistics with the quota status.
	470	*
	471	* This function returns true if the stats have been updated, false otherwise.
	472	*/
	473	bool ceph_quota_update_statfs(struct ceph_fs_client fsc, struct kstatfs buf)
	474	{
	475	struct ceph_mds_client *mdsc = fsc->mdsc;
	476	struct ceph_inode_info *ci;
	477	struct ceph_snap_realm *realm;
	478	struct inode *in;
	479	u64 total = 0, used, free;
	480	bool is_updated = false;
	481
	482	down_read(&mdsc->snap_rwsem);
0c44a8e0	483	realm = get_quota_realm(mdsc, d_inode(fsc->sb->s_root), true);
9122eed5 LH	484	up_read(&mdsc->snap_rwsem);
	485	if (!realm)
	486	return false;
	487
	488	spin_lock(&realm->inodes_with_caps_lock);
	489	in = realm->inode ? igrab(realm->inode) : NULL;
	490	spin_unlock(&realm->inodes_with_caps_lock);
	491	if (in) {
	492	ci = ceph_inode(in);
	493	spin_lock(&ci->i_ceph_lock);
	494	if (ci->i_max_bytes) {
	495	total = ci->i_max_bytes >> CEPH_BLOCK_SHIFT;
	496	used = ci->i_rbytes >> CEPH_BLOCK_SHIFT;
	497	/* It is possible for a quota to be exceeded.
	498	* Report 'zero' in that case
	499	*/
	500	free = total > used ? total - used : 0;
	501	}
	502	spin_unlock(&ci->i_ceph_lock);
	503	if (total) {
	504	buf->f_blocks = total;
	505	buf->f_bfree = free;
	506	buf->f_bavail = free;
	507	is_updated = true;
	508	}
	509	iput(in);
	510	}
	511	ceph_put_snap_realm(mdsc, realm);
	512
	513	return is_updated;
	514	}
	515