[mirror_ubuntu-bionic-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;
	bool has_quota;

	realm = ceph_inode(inode)->i_snap_realm;
	ceph_get_snap_realm(mdsc, realm);
	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);
		has_quota = ceph_has_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 */
};

/*
 * 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 exceeded = false;

	down_read(&mdsc->snap_rwsem);
	realm = ceph_inode(inode)->i_snap_realm;
	ceph_get_snap_realm(mdsc, realm);
	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;
		}
		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;
		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)
{
	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));
}
Commit	Line	Data
7370e8a4 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
68a16a23 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
7370e8a4 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	}
6aa007ee	71
68a16a23 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;
780ac19f	88	bool has_quota;
68a16a23 LH	89
	90	realm = ceph_inode(inode)->i_snap_realm;
	91	ceph_get_snap_realm(mdsc, realm);
	92	while (realm) {
	93	vino.ino = realm->ino;
	94	vino.snap = CEPH_NOSNAP;
	95	in = ceph_find_inode(inode->i_sb, vino);
	96	if (!in) {
	97	pr_warn("Failed to find inode for %llu\n", vino.ino);
	98	break;
	99	}
	100	ci = ceph_inode(in);
780ac19f	101	has_quota = ceph_has_quota(ci);
68a16a23	102	iput(in);
780ac19f	103
68a16a23	104	next = realm->parent;
780ac19f YZ	105	if (has_quota \|\| !next)
	106	return realm;
	107
68a16a23 LH	108	ceph_get_snap_realm(mdsc, next);
	109	ceph_put_snap_realm(mdsc, realm);
	110	realm = next;
	111	}
	112	if (realm)
	113	ceph_put_snap_realm(mdsc, realm);
	114
	115	return NULL;
	116	}
	117
	118	bool ceph_quota_is_same_realm(struct inode old, struct inode new)
	119	{
	120	struct ceph_mds_client *mdsc = ceph_inode_to_client(old)->mdsc;
	121	struct ceph_snap_realm old_realm, new_realm;
	122	bool is_same;
	123
	124	down_read(&mdsc->snap_rwsem);
	125	old_realm = get_quota_realm(mdsc, old);
	126	new_realm = get_quota_realm(mdsc, new);
	127	is_same = (old_realm == new_realm);
	128	up_read(&mdsc->snap_rwsem);
	129
	130	if (old_realm)
	131	ceph_put_snap_realm(mdsc, old_realm);
	132	if (new_realm)
	133	ceph_put_snap_realm(mdsc, new_realm);
	134
	135	return is_same;
	136	}
	137
6aa007ee	138	enum quota_check_op {
0cb65d53 LH	139	QUOTA_CHECK_MAX_FILES_OP, /* check quota max_files limit */
0cb65d53 LH	140	QUOTA_CHECK_MAX_BYTES_OP /* check quota max_files limit */
6aa007ee LH	141	};
	142
	143	/*
	144	* check_quota_exceeded() will walk up the snaprealm hierarchy and, for each
	145	* realm, it will execute quota check operation defined by the 'op' parameter.
	146	* The snaprealm walk is interrupted if the quota check detects that the quota
	147	* is exceeded or if the root inode is reached.
	148	*/
	149	static bool check_quota_exceeded(struct inode *inode, enum quota_check_op op,
	150	loff_t delta)
	151	{
	152	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	153	struct ceph_inode_info *ci;
	154	struct ceph_snap_realm realm, next;
	155	struct ceph_vino vino;
	156	struct inode *in;
	157	u64 max, rvalue;
6aa007ee LH	158	bool exceeded = false;
	159
	160	down_read(&mdsc->snap_rwsem);
	161	realm = ceph_inode(inode)->i_snap_realm;
	162	ceph_get_snap_realm(mdsc, realm);
	163	while (realm) {
	164	vino.ino = realm->ino;
	165	vino.snap = CEPH_NOSNAP;
	166	in = ceph_find_inode(inode->i_sb, vino);
	167	if (!in) {
	168	pr_warn("Failed to find inode for %llu\n", vino.ino);
	169	break;
	170	}
	171	ci = ceph_inode(in);
	172	spin_lock(&ci->i_ceph_lock);
	173	if (op == QUOTA_CHECK_MAX_FILES_OP) {
	174	max = ci->i_max_files;
	175	rvalue = ci->i_rfiles + ci->i_rsubdirs;
0cb65d53 LH	176	} else {
	177	max = ci->i_max_bytes;
	178	rvalue = ci->i_rbytes;
6aa007ee	179	}
6aa007ee LH	180	spin_unlock(&ci->i_ceph_lock);
	181	switch (op) {
	182	case QUOTA_CHECK_MAX_FILES_OP:
	183	exceeded = (max && (rvalue >= max));
	184	break;
0cb65d53 LH	185	case QUOTA_CHECK_MAX_BYTES_OP:
	186	exceeded = (max && (rvalue + delta > max));
	187	break;
6aa007ee LH	188	default:
	189	/* Shouldn't happen */
	190	pr_warn("Invalid quota check op (%d)\n", op);
	191	exceeded = true; /* Just break the loop */
	192	}
	193	iput(in);
	194
6aa007ee	195	next = realm->parent;
780ac19f YZ	196	if (exceeded \|\| !next)
780ac19f YZ	197	break;
6aa007ee LH	198	ceph_get_snap_realm(mdsc, next);
	199	ceph_put_snap_realm(mdsc, realm);
	200	realm = next;
	201	}
	202	ceph_put_snap_realm(mdsc, realm);
	203	up_read(&mdsc->snap_rwsem);
	204
	205	return exceeded;
	206	}
	207
	208	/*
	209	* ceph_quota_is_max_files_exceeded - check if we can create a new file
	210	* @inode: directory where a new file is being created
	211	*
	212	* This functions returns true is max_files quota allows a new file to be
	213	* created. It is necessary to walk through the snaprealm hierarchy (until the
	214	* FS root) to check all realms with quotas set.
	215	*/
	216	bool ceph_quota_is_max_files_exceeded(struct inode *inode)
	217	{
	218	WARN_ON(!S_ISDIR(inode->i_mode));
	219
	220	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_FILES_OP, 0);
	221	}
0cb65d53 LH	222
	223	/*
	224	* ceph_quota_is_max_bytes_exceeded - check if we can write to a file
	225	* @inode: inode being written
	226	* @newsize: new size if write succeeds
	227	*
	228	* This functions returns true is max_bytes quota allows a file size to reach
	229	* @newsize; it returns false otherwise.
	230	*/
	231	bool ceph_quota_is_max_bytes_exceeded(struct inode *inode, loff_t newsize)
	232	{
	233	loff_t size = i_size_read(inode);
	234
	235	/* return immediately if we're decreasing file size */
	236	if (newsize <= size)
	237	return false;
	238
	239	return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_OP, (newsize - size));
	240	}