[mirror_ubuntu-jammy-kernel.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 "super.h"
#include "mds_client.h"

static inline bool ceph_has_quota(struct ceph_inode_info *ci)
{
	return (ci && (ci->i_max_files || ci->i_max_bytes));
}

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);
	ci->i_max_bytes = le64_to_cpu(h->max_bytes);
	ci->i_max_files = 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 ceph_vino vino;
	struct inode *in;

	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) {
		vino.ino = realm->ino;
		vino.snap = CEPH_NOSNAP;
		in = ceph_find_inode(inode->i_sb, vino);
		if (!in) {
			pr_warn("Failed to find inode for %llu\n", vino.ino);
			break;
		}
		ci = ceph_inode(in);
		if (ceph_has_quota(ci) || (ci->i_vino.ino == CEPH_INO_ROOT)) {
			iput(in);
			return realm;
		}
		iput(in);
		next = realm->parent;
		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 ceph_vino vino;
	struct inode *in;
	u64 max, rvalue;
	bool is_root;
	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) {
		vino.ino = realm->ino;
		vino.snap = CEPH_NOSNAP;
		in = ceph_find_inode(inode->i_sb, vino);
		if (!in) {
			pr_warn("Failed to find inode for %llu\n", vino.ino);
			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;
		}
		is_root = (ci->i_vino.ino == CEPH_INO_ROOT);
		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);

		if (is_root || exceeded)
			break;
		next = realm->parent;
		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)
{
	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);

	/* 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;

	/* 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));
}
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
	21	#include "super.h"
	22	#include "mds_client.h"
	23
cafe21a4 LH	24	static inline bool ceph_has_quota(struct ceph_inode_info *ci)
	25	{
	26	return (ci && (ci->i_max_files \|\| ci->i_max_bytes));
	27	}
	28
fb18a575 LH	29	void ceph_handle_quota(struct ceph_mds_client *mdsc,
	30	struct ceph_mds_session *session,
	31	struct ceph_msg *msg)
	32	{
	33	struct super_block *sb = mdsc->fsc->sb;
	34	struct ceph_mds_quota *h = msg->front.iov_base;
	35	struct ceph_vino vino;
	36	struct inode *inode;
	37	struct ceph_inode_info *ci;
	38
	39	if (msg->front.iov_len != sizeof(*h)) {
	40	pr_err("%s corrupt message mds%d len %d\n", __func__,
	41	session->s_mds, (int)msg->front.iov_len);
	42	ceph_msg_dump(msg);
	43	return;
	44	}
	45
	46	/* increment msg sequence number */
	47	mutex_lock(&session->s_mutex);
	48	session->s_seq++;
	49	mutex_unlock(&session->s_mutex);
	50
	51	/* lookup inode */
	52	vino.ino = le64_to_cpu(h->ino);
	53	vino.snap = CEPH_NOSNAP;
	54	inode = ceph_find_inode(sb, vino);
	55	if (!inode) {
	56	pr_warn("Failed to find inode %llu\n", vino.ino);
	57	return;
	58	}
	59	ci = ceph_inode(inode);
	60
	61	spin_lock(&ci->i_ceph_lock);
	62	ci->i_rbytes = le64_to_cpu(h->rbytes);
	63	ci->i_rfiles = le64_to_cpu(h->rfiles);
	64	ci->i_rsubdirs = le64_to_cpu(h->rsubdirs);
	65	ci->i_max_bytes = le64_to_cpu(h->max_bytes);
	66	ci->i_max_files = le64_to_cpu(h->max_files);
	67	spin_unlock(&ci->i_ceph_lock);
	68
	69	iput(inode);
	70	}
b7a29217	71
cafe21a4 LH	72	/*
	73	* This function walks through the snaprealm for an inode and returns the
	74	* ceph_snap_realm for the first snaprealm that has quotas set (either max_files
	75	* or max_bytes). If the root is reached, return the root ceph_snap_realm
	76	* instead.
	77	*
	78	* Note that the caller is responsible for calling ceph_put_snap_realm() on the
	79	* returned realm.
	80	*/
	81	static struct ceph_snap_realm get_quota_realm(struct ceph_mds_client mdsc,
	82	struct inode *inode)
	83	{
	84	struct ceph_inode_info *ci = NULL;
	85	struct ceph_snap_realm realm, next;
	86	struct ceph_vino vino;
	87	struct inode *in;
	88
25963669 YZ	89	if (ceph_snap(inode) != CEPH_NOSNAP)
	90	return NULL;
	91
cafe21a4	92	realm = ceph_inode(inode)->i_snap_realm;
25963669 YZ	93	if (realm)
	94	ceph_get_snap_realm(mdsc, realm);
	95	else
	96	pr_err_ratelimited("get_quota_realm: ino (%llx.%llx) "
	97	"null i_snap_realm\n", ceph_vinop(inode));
cafe21a4 LH	98	while (realm) {
	99	vino.ino = realm->ino;
	100	vino.snap = CEPH_NOSNAP;
	101	in = ceph_find_inode(inode->i_sb, vino);
	102	if (!in) {
	103	pr_warn("Failed to find inode for %llu\n", vino.ino);
	104	break;
	105	}
	106	ci = ceph_inode(in);
	107	if (ceph_has_quota(ci) \|\| (ci->i_vino.ino == CEPH_INO_ROOT)) {
	108	iput(in);
	109	return realm;
	110	}
	111	iput(in);
	112	next = realm->parent;
	113	ceph_get_snap_realm(mdsc, next);
	114	ceph_put_snap_realm(mdsc, realm);
	115	realm = next;
	116	}
	117	if (realm)
	118	ceph_put_snap_realm(mdsc, realm);
	119
	120	return NULL;
	121	}
	122
	123	bool ceph_quota_is_same_realm(struct inode old, struct inode new)
	124	{
	125	struct ceph_mds_client *mdsc = ceph_inode_to_client(old)->mdsc;
	126	struct ceph_snap_realm old_realm, new_realm;
	127	bool is_same;
	128
	129	down_read(&mdsc->snap_rwsem);
	130	old_realm = get_quota_realm(mdsc, old);
	131	new_realm = get_quota_realm(mdsc, new);
	132	is_same = (old_realm == new_realm);
	133	up_read(&mdsc->snap_rwsem);
	134
	135	if (old_realm)
	136	ceph_put_snap_realm(mdsc, old_realm);
	137	if (new_realm)
	138	ceph_put_snap_realm(mdsc, new_realm);
	139
	140	return is_same;
	141	}
	142
b7a29217	143	enum quota_check_op {
2b83845f	144	QUOTA_CHECK_MAX_FILES_OP, /* check quota max_files limit */
1ab302a0 LH	145	QUOTA_CHECK_MAX_BYTES_OP, /* check quota max_files limit */
	146	QUOTA_CHECK_MAX_BYTES_APPROACHING_OP /* check if quota max_files
	147	limit is approaching */
b7a29217 LH	148	};
	149
	150	/*
	151	* check_quota_exceeded() will walk up the snaprealm hierarchy and, for each
	152	* realm, it will execute quota check operation defined by the 'op' parameter.
	153	* The snaprealm walk is interrupted if the quota check detects that the quota
	154	* is exceeded or if the root inode is reached.
	155	*/
	156	static bool check_quota_exceeded(struct inode *inode, enum quota_check_op op,
	157	loff_t delta)
	158	{
	159	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	160	struct ceph_inode_info *ci;
	161	struct ceph_snap_realm realm, next;
	162	struct ceph_vino vino;
	163	struct inode *in;
	164	u64 max, rvalue;
	165	bool is_root;
	166	bool exceeded = false;
	167
25963669 YZ	168	if (ceph_snap(inode) != CEPH_NOSNAP)
	169	return false;
	170
b7a29217 LH	171	down_read(&mdsc->snap_rwsem);
b7a29217 LH	172	realm = ceph_inode(inode)->i_snap_realm;
25963669 YZ	173	if (realm)
	174	ceph_get_snap_realm(mdsc, realm);
	175	else
	176	pr_err_ratelimited("check_quota_exceeded: ino (%llx.%llx) "
	177	"null i_snap_realm\n", ceph_vinop(inode));
b7a29217 LH	178	while (realm) {
	179	vino.ino = realm->ino;
	180	vino.snap = CEPH_NOSNAP;
	181	in = ceph_find_inode(inode->i_sb, vino);
	182	if (!in) {
	183	pr_warn("Failed to find inode for %llu\n", vino.ino);
	184	break;
	185	}
	186	ci = ceph_inode(in);
	187	spin_lock(&ci->i_ceph_lock);
	188	if (op == QUOTA_CHECK_MAX_FILES_OP) {
	189	max = ci->i_max_files;
	190	rvalue = ci->i_rfiles + ci->i_rsubdirs;
2b83845f LH	191	} else {
	192	max = ci->i_max_bytes;
	193	rvalue = ci->i_rbytes;
b7a29217 LH	194	}
	195	is_root = (ci->i_vino.ino == CEPH_INO_ROOT);
	196	spin_unlock(&ci->i_ceph_lock);
	197	switch (op) {
	198	case QUOTA_CHECK_MAX_FILES_OP:
	199	exceeded = (max && (rvalue >= max));
	200	break;
2b83845f LH	201	case QUOTA_CHECK_MAX_BYTES_OP:
	202	exceeded = (max && (rvalue + delta > max));
	203	break;
1ab302a0 LH	204	case QUOTA_CHECK_MAX_BYTES_APPROACHING_OP:
	205	if (max) {
	206	if (rvalue >= max)
	207	exceeded = true;
	208	else {
	209	/*
	210	* when we're writing more that 1/16th
	211	* of the available space
	212	*/
	213	exceeded =
	214	(((max - rvalue) >> 4) < delta);
	215	}
	216	}
	217	break;
b7a29217 LH	218	default:
	219	/* Shouldn't happen */
	220	pr_warn("Invalid quota check op (%d)\n", op);
	221	exceeded = true; /* Just break the loop */
	222	}
	223	iput(in);
	224
	225	if (is_root \|\| exceeded)
	226	break;
	227	next = realm->parent;
	228	ceph_get_snap_realm(mdsc, next);
	229	ceph_put_snap_realm(mdsc, realm);
	230	realm = next;
	231	}
	232	ceph_put_snap_realm(mdsc, realm);
	233	up_read(&mdsc->snap_rwsem);
	234
	235	return exceeded;
	236	}
	237
	238	/*
	239	* ceph_quota_is_max_files_exceeded - check if we can create a new file
	240	* @inode: directory where a new file is being created
	241	*
	242	* This functions returns true is max_files quota allows a new file to be
	243	* created. It is necessary to walk through the snaprealm hierarchy (until the
	244	* FS root) to check all realms with quotas set.
	245	*/
	246	bool ceph_quota_is_max_files_exceeded(struct inode *inode)
	247	{
	248	WARN_ON(!S_ISDIR(inode->i_mode));
	249
	250	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_FILES_OP, 0);
	251	}
2b83845f LH	252
	253	/*
	254	* ceph_quota_is_max_bytes_exceeded - check if we can write to a file
	255	* @inode: inode being written
	256	* @newsize: new size if write succeeds
	257	*
	258	* This functions returns true is max_bytes quota allows a file size to reach
	259	* @newsize; it returns false otherwise.
	260	*/
	261	bool ceph_quota_is_max_bytes_exceeded(struct inode *inode, loff_t newsize)
	262	{
	263	loff_t size = i_size_read(inode);
	264
	265	/* return immediately if we're decreasing file size */
	266	if (newsize <= size)
	267	return false;
	268
	269	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_OP, (newsize - size));
	270	}
1ab302a0 LH	271
	272	/*
	273	* ceph_quota_is_max_bytes_approaching - check if we're reaching max_bytes
	274	* @inode: inode being written
	275	* @newsize: new size if write succeeds
	276	*
	277	* This function returns true if the new file size @newsize will be consuming
	278	* more than 1/16th of the available quota space; it returns false otherwise.
	279	*/
	280	bool ceph_quota_is_max_bytes_approaching(struct inode *inode, loff_t newsize)
	281	{
	282	loff_t size = ceph_inode(inode)->i_reported_size;
	283
	284	/* return immediately if we're decreasing file size */
	285	if (newsize <= size)
	286	return false;
	287
	288	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_APPROACHING_OP,
	289	(newsize - size));
	290	}