548 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * quota.c - CephFS quota4 *5 * Copyright (C) 2017-2018 SUSE6 */7 8#include <linux/statfs.h>9 10#include "super.h"11#include "mds_client.h"12 13void ceph_adjust_quota_realms_count(struct inode *inode, bool inc)14{15 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);16 if (inc)17 atomic64_inc(&mdsc->quotarealms_count);18 else19 atomic64_dec(&mdsc->quotarealms_count);20}21 22static inline bool ceph_has_realms_with_quotas(struct inode *inode)23{24 struct super_block *sb = inode->i_sb;25 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(sb);26 struct inode *root = d_inode(sb->s_root);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 */31 if (root && ceph_ino(root) == CEPH_INO_ROOT)32 return false;33 /* MDS stray dirs have no quota realms */34 if (ceph_vino_is_reserved(ceph_inode(inode)->i_vino))35 return false;36 /* otherwise, we can't know for sure */37 return true;38}39 40void ceph_handle_quota(struct ceph_mds_client *mdsc,41 struct ceph_mds_session *session,42 struct ceph_msg *msg)43{44 struct super_block *sb = mdsc->fsc->sb;45 struct ceph_mds_quota *h = msg->front.iov_base;46 struct ceph_client *cl = mdsc->fsc->client;47 struct ceph_vino vino;48 struct inode *inode;49 struct ceph_inode_info *ci;50 51 if (!ceph_inc_mds_stopping_blocker(mdsc, session))52 return;53 54 if (msg->front.iov_len < sizeof(*h)) {55 pr_err_client(cl, "corrupt message mds%d len %d\n",56 session->s_mds, (int)msg->front.iov_len);57 ceph_msg_dump(msg);58 goto out;59 }60 61 /* lookup inode */62 vino.ino = le64_to_cpu(h->ino);63 vino.snap = CEPH_NOSNAP;64 inode = ceph_find_inode(sb, vino);65 if (!inode) {66 pr_warn_client(cl, "failed to find inode %llx\n", vino.ino);67 goto out;68 }69 ci = ceph_inode(inode);70 71 spin_lock(&ci->i_ceph_lock);72 ci->i_rbytes = le64_to_cpu(h->rbytes);73 ci->i_rfiles = le64_to_cpu(h->rfiles);74 ci->i_rsubdirs = le64_to_cpu(h->rsubdirs);75 __ceph_update_quota(ci, le64_to_cpu(h->max_bytes),76 le64_to_cpu(h->max_files));77 spin_unlock(&ci->i_ceph_lock);78 79 iput(inode);80out:81 ceph_dec_mds_stopping_blocker(mdsc);82}83 84static struct ceph_quotarealm_inode *85find_quotarealm_inode(struct ceph_mds_client *mdsc, u64 ino)86{87 struct ceph_quotarealm_inode *qri = NULL;88 struct rb_node **node, *parent = NULL;89 struct ceph_client *cl = mdsc->fsc->client;90 91 mutex_lock(&mdsc->quotarealms_inodes_mutex);92 node = &(mdsc->quotarealms_inodes.rb_node);93 while (*node) {94 parent = *node;95 qri = container_of(*node, struct ceph_quotarealm_inode, node);96 97 if (ino < qri->ino)98 node = &((*node)->rb_left);99 else if (ino > qri->ino)100 node = &((*node)->rb_right);101 else102 break;103 }104 if (!qri || (qri->ino != ino)) {105 /* Not found, create a new one and insert it */106 qri = kmalloc(sizeof(*qri), GFP_KERNEL);107 if (qri) {108 qri->ino = ino;109 qri->inode = NULL;110 qri->timeout = 0;111 mutex_init(&qri->mutex);112 rb_link_node(&qri->node, parent, node);113 rb_insert_color(&qri->node, &mdsc->quotarealms_inodes);114 } else115 pr_warn_client(cl, "Failed to alloc quotarealms_inode\n");116 }117 mutex_unlock(&mdsc->quotarealms_inodes_mutex);118 119 return qri;120}121 122/*123 * This function will try to lookup a realm inode which isn't visible in the124 * filesystem mountpoint. A list of these kind of inodes (not visible) is125 * maintained in the mdsc and freed only when the filesystem is umounted.126 *127 * Note that these inodes are kept in this list even if the lookup fails, which128 * allows to prevent useless lookup requests.129 */130static struct inode *lookup_quotarealm_inode(struct ceph_mds_client *mdsc,131 struct super_block *sb,132 struct ceph_snap_realm *realm)133{134 struct ceph_client *cl = mdsc->fsc->client;135 struct ceph_quotarealm_inode *qri;136 struct inode *in;137 138 qri = find_quotarealm_inode(mdsc, realm->ino);139 if (!qri)140 return NULL;141 142 mutex_lock(&qri->mutex);143 if (qri->inode && ceph_is_any_caps(qri->inode)) {144 /* A request has already returned the inode */145 mutex_unlock(&qri->mutex);146 return qri->inode;147 }148 /* Check if this inode lookup has failed recently */149 if (qri->timeout &&150 time_before_eq(jiffies, qri->timeout)) {151 mutex_unlock(&qri->mutex);152 return NULL;153 }154 if (qri->inode) {155 /* get caps */156 int ret = __ceph_do_getattr(qri->inode, NULL,157 CEPH_STAT_CAP_INODE, true);158 if (ret >= 0)159 in = qri->inode;160 else161 in = ERR_PTR(ret);162 } else {163 in = ceph_lookup_inode(sb, realm->ino);164 }165 166 if (IS_ERR(in)) {167 doutc(cl, "Can't lookup inode %llx (err: %ld)\n", realm->ino,168 PTR_ERR(in));169 qri->timeout = jiffies + msecs_to_jiffies(60 * 1000); /* XXX */170 } else {171 qri->timeout = 0;172 qri->inode = in;173 }174 mutex_unlock(&qri->mutex);175 176 return in;177}178 179void ceph_cleanup_quotarealms_inodes(struct ceph_mds_client *mdsc)180{181 struct ceph_quotarealm_inode *qri;182 struct rb_node *node;183 184 /*185 * It should now be safe to clean quotarealms_inode tree without holding186 * mdsc->quotarealms_inodes_mutex...187 */188 mutex_lock(&mdsc->quotarealms_inodes_mutex);189 while (!RB_EMPTY_ROOT(&mdsc->quotarealms_inodes)) {190 node = rb_first(&mdsc->quotarealms_inodes);191 qri = rb_entry(node, struct ceph_quotarealm_inode, node);192 rb_erase(node, &mdsc->quotarealms_inodes);193 iput(qri->inode);194 kfree(qri);195 }196 mutex_unlock(&mdsc->quotarealms_inodes_mutex);197}198 199/*200 * This function walks through the snaprealm for an inode and set the201 * realmp with the first snaprealm that has quotas set (max_files,202 * max_bytes, or any, depending on the 'which_quota' argument). If the root is203 * reached, set the realmp with the root ceph_snap_realm instead.204 *205 * Note that the caller is responsible for calling ceph_put_snap_realm() on the206 * returned realm.207 *208 * Callers of this function need to hold mdsc->snap_rwsem. However, if there's209 * a need to do an inode lookup, this rwsem will be temporarily dropped. Hence210 * the 'retry' argument: if rwsem needs to be dropped and 'retry' is 'false'211 * this function will return -EAGAIN; otherwise, the snaprealms walk-through212 * will be restarted.213 */214static int get_quota_realm(struct ceph_mds_client *mdsc, struct inode *inode,215 enum quota_get_realm which_quota,216 struct ceph_snap_realm **realmp, bool retry)217{218 struct ceph_client *cl = mdsc->fsc->client;219 struct ceph_inode_info *ci = NULL;220 struct ceph_snap_realm *realm, *next;221 struct inode *in;222 bool has_quota;223 224 if (realmp)225 *realmp = NULL;226 if (ceph_snap(inode) != CEPH_NOSNAP)227 return 0;228 229restart:230 realm = ceph_inode(inode)->i_snap_realm;231 if (realm)232 ceph_get_snap_realm(mdsc, realm);233 else234 pr_err_ratelimited_client(cl,235 "%p %llx.%llx null i_snap_realm\n",236 inode, ceph_vinop(inode));237 while (realm) {238 bool has_inode;239 240 spin_lock(&realm->inodes_with_caps_lock);241 has_inode = realm->inode;242 in = has_inode ? igrab(realm->inode) : NULL;243 spin_unlock(&realm->inodes_with_caps_lock);244 if (has_inode && !in)245 break;246 if (!in) {247 up_read(&mdsc->snap_rwsem);248 in = lookup_quotarealm_inode(mdsc, inode->i_sb, realm);249 down_read(&mdsc->snap_rwsem);250 if (IS_ERR_OR_NULL(in))251 break;252 ceph_put_snap_realm(mdsc, realm);253 if (!retry)254 return -EAGAIN;255 goto restart;256 }257 258 ci = ceph_inode(in);259 has_quota = __ceph_has_quota(ci, which_quota);260 iput(in);261 262 next = realm->parent;263 if (has_quota || !next) {264 if (realmp)265 *realmp = realm;266 return 0;267 }268 269 ceph_get_snap_realm(mdsc, next);270 ceph_put_snap_realm(mdsc, realm);271 realm = next;272 }273 if (realm)274 ceph_put_snap_realm(mdsc, realm);275 276 return 0;277}278 279bool ceph_quota_is_same_realm(struct inode *old, struct inode *new)280{281 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(old->i_sb);282 struct ceph_snap_realm *old_realm, *new_realm;283 bool is_same;284 int ret;285 286restart:287 /*288 * We need to lookup 2 quota realms atomically, i.e. with snap_rwsem.289 * However, get_quota_realm may drop it temporarily. By setting the290 * 'retry' parameter to 'false', we'll get -EAGAIN if the rwsem was291 * dropped and we can then restart the whole operation.292 */293 down_read(&mdsc->snap_rwsem);294 get_quota_realm(mdsc, old, QUOTA_GET_ANY, &old_realm, true);295 ret = get_quota_realm(mdsc, new, QUOTA_GET_ANY, &new_realm, false);296 if (ret == -EAGAIN) {297 up_read(&mdsc->snap_rwsem);298 if (old_realm)299 ceph_put_snap_realm(mdsc, old_realm);300 goto restart;301 }302 is_same = (old_realm == new_realm);303 up_read(&mdsc->snap_rwsem);304 305 if (old_realm)306 ceph_put_snap_realm(mdsc, old_realm);307 if (new_realm)308 ceph_put_snap_realm(mdsc, new_realm);309 310 return is_same;311}312 313enum quota_check_op {314 QUOTA_CHECK_MAX_FILES_OP, /* check quota max_files limit */315 QUOTA_CHECK_MAX_BYTES_OP, /* check quota max_files limit */316 QUOTA_CHECK_MAX_BYTES_APPROACHING_OP /* check if quota max_files317 limit is approaching */318};319 320/*321 * check_quota_exceeded() will walk up the snaprealm hierarchy and, for each322 * realm, it will execute quota check operation defined by the 'op' parameter.323 * The snaprealm walk is interrupted if the quota check detects that the quota324 * is exceeded or if the root inode is reached.325 */326static bool check_quota_exceeded(struct inode *inode, enum quota_check_op op,327 loff_t delta)328{329 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);330 struct ceph_client *cl = mdsc->fsc->client;331 struct ceph_inode_info *ci;332 struct ceph_snap_realm *realm, *next;333 struct inode *in;334 u64 max, rvalue;335 bool exceeded = false;336 337 if (ceph_snap(inode) != CEPH_NOSNAP)338 return false;339 340 down_read(&mdsc->snap_rwsem);341restart:342 realm = ceph_inode(inode)->i_snap_realm;343 if (realm)344 ceph_get_snap_realm(mdsc, realm);345 else346 pr_err_ratelimited_client(cl,347 "%p %llx.%llx null i_snap_realm\n",348 inode, ceph_vinop(inode));349 while (realm) {350 bool has_inode;351 352 spin_lock(&realm->inodes_with_caps_lock);353 has_inode = realm->inode;354 in = has_inode ? igrab(realm->inode) : NULL;355 spin_unlock(&realm->inodes_with_caps_lock);356 if (has_inode && !in)357 break;358 if (!in) {359 up_read(&mdsc->snap_rwsem);360 in = lookup_quotarealm_inode(mdsc, inode->i_sb, realm);361 down_read(&mdsc->snap_rwsem);362 if (IS_ERR_OR_NULL(in))363 break;364 ceph_put_snap_realm(mdsc, realm);365 goto restart;366 }367 ci = ceph_inode(in);368 spin_lock(&ci->i_ceph_lock);369 if (op == QUOTA_CHECK_MAX_FILES_OP) {370 max = ci->i_max_files;371 rvalue = ci->i_rfiles + ci->i_rsubdirs;372 } else {373 max = ci->i_max_bytes;374 rvalue = ci->i_rbytes;375 }376 spin_unlock(&ci->i_ceph_lock);377 switch (op) {378 case QUOTA_CHECK_MAX_FILES_OP:379 case QUOTA_CHECK_MAX_BYTES_OP:380 exceeded = (max && (rvalue + delta > max));381 break;382 case QUOTA_CHECK_MAX_BYTES_APPROACHING_OP:383 if (max) {384 if (rvalue >= max)385 exceeded = true;386 else {387 /*388 * when we're writing more that 1/16th389 * of the available space390 */391 exceeded =392 (((max - rvalue) >> 4) < delta);393 }394 }395 break;396 default:397 /* Shouldn't happen */398 pr_warn_client(cl, "Invalid quota check op (%d)\n", op);399 exceeded = true; /* Just break the loop */400 }401 iput(in);402 403 next = realm->parent;404 if (exceeded || !next)405 break;406 ceph_get_snap_realm(mdsc, next);407 ceph_put_snap_realm(mdsc, realm);408 realm = next;409 }410 if (realm)411 ceph_put_snap_realm(mdsc, realm);412 up_read(&mdsc->snap_rwsem);413 414 return exceeded;415}416 417/*418 * ceph_quota_is_max_files_exceeded - check if we can create a new file419 * @inode: directory where a new file is being created420 *421 * This functions returns true is max_files quota allows a new file to be422 * created. It is necessary to walk through the snaprealm hierarchy (until the423 * FS root) to check all realms with quotas set.424 */425bool ceph_quota_is_max_files_exceeded(struct inode *inode)426{427 if (!ceph_has_realms_with_quotas(inode))428 return false;429 430 WARN_ON(!S_ISDIR(inode->i_mode));431 432 return check_quota_exceeded(inode, QUOTA_CHECK_MAX_FILES_OP, 1);433}434 435/*436 * ceph_quota_is_max_bytes_exceeded - check if we can write to a file437 * @inode: inode being written438 * @newsize: new size if write succeeds439 *440 * This functions returns true is max_bytes quota allows a file size to reach441 * @newsize; it returns false otherwise.442 */443bool ceph_quota_is_max_bytes_exceeded(struct inode *inode, loff_t newsize)444{445 loff_t size = i_size_read(inode);446 447 if (!ceph_has_realms_with_quotas(inode))448 return false;449 450 /* return immediately if we're decreasing file size */451 if (newsize <= size)452 return false;453 454 return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_OP, (newsize - size));455}456 457/*458 * ceph_quota_is_max_bytes_approaching - check if we're reaching max_bytes459 * @inode: inode being written460 * @newsize: new size if write succeeds461 *462 * This function returns true if the new file size @newsize will be consuming463 * more than 1/16th of the available quota space; it returns false otherwise.464 */465bool ceph_quota_is_max_bytes_approaching(struct inode *inode, loff_t newsize)466{467 loff_t size = ceph_inode(inode)->i_reported_size;468 469 if (!ceph_has_realms_with_quotas(inode))470 return false;471 472 /* return immediately if we're decreasing file size */473 if (newsize <= size)474 return false;475 476 return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_APPROACHING_OP,477 (newsize - size));478}479 480/*481 * ceph_quota_update_statfs - if root has quota update statfs with quota status482 * @fsc: filesystem client instance483 * @buf: statfs to update484 *485 * If the mounted filesystem root has max_bytes quota set, update the filesystem486 * statistics with the quota status.487 *488 * This function returns true if the stats have been updated, false otherwise.489 */490bool ceph_quota_update_statfs(struct ceph_fs_client *fsc, struct kstatfs *buf)491{492 struct ceph_mds_client *mdsc = fsc->mdsc;493 struct ceph_inode_info *ci;494 struct ceph_snap_realm *realm;495 struct inode *in;496 u64 total = 0, used, free;497 bool is_updated = false;498 499 down_read(&mdsc->snap_rwsem);500 get_quota_realm(mdsc, d_inode(fsc->sb->s_root), QUOTA_GET_MAX_BYTES,501 &realm, true);502 up_read(&mdsc->snap_rwsem);503 if (!realm)504 return false;505 506 spin_lock(&realm->inodes_with_caps_lock);507 in = realm->inode ? igrab(realm->inode) : NULL;508 spin_unlock(&realm->inodes_with_caps_lock);509 if (in) {510 ci = ceph_inode(in);511 spin_lock(&ci->i_ceph_lock);512 if (ci->i_max_bytes) {513 total = ci->i_max_bytes >> CEPH_BLOCK_SHIFT;514 used = ci->i_rbytes >> CEPH_BLOCK_SHIFT;515 /* For quota size less than 4MB, use 4KB block size */516 if (!total) {517 total = ci->i_max_bytes >> CEPH_4K_BLOCK_SHIFT;518 used = ci->i_rbytes >> CEPH_4K_BLOCK_SHIFT;519 buf->f_frsize = 1 << CEPH_4K_BLOCK_SHIFT;520 }521 /* It is possible for a quota to be exceeded.522 * Report 'zero' in that case523 */524 free = total > used ? total - used : 0;525 /* For quota size less than 4KB, report the526 * total=used=4KB,free=0 when quota is full527 * and total=free=4KB, used=0 otherwise */528 if (!total) {529 total = 1;530 free = ci->i_max_bytes > ci->i_rbytes ? 1 : 0;531 buf->f_frsize = 1 << CEPH_4K_BLOCK_SHIFT;532 }533 }534 spin_unlock(&ci->i_ceph_lock);535 if (total) {536 buf->f_blocks = total;537 buf->f_bfree = free;538 buf->f_bavail = free;539 is_updated = true;540 }541 iput(in);542 }543 ceph_put_snap_realm(mdsc, realm);544 545 return is_updated;546}547 548