fs/ceph/quota.c

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