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  * 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
  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
  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 }
  71
  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         bool has_quota;
  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);
 101                 has_quota = ceph_has_quota(ci);
 102                 iput(in);
 103
 104                 next = realm->parent;
 105                 if (has_quota || !next)
 106                        return realm;
 107
 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
 138 enum quota_check_op {
 139         QUOTA_CHECK_MAX_FILES_OP,       /* check quota max_files limit */
 140         QUOTA_CHECK_MAX_BYTES_OP        /* check quota max_files limit */
 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;
 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;
 176                 } else {
 177                         max = ci->i_max_bytes;
 178                         rvalue = ci->i_rbytes;
 179                 }
 180                 spin_unlock(&ci->i_ceph_lock);
 181                 switch (op) {
 182                 case QUOTA_CHECK_MAX_FILES_OP:
 183                         exceeded = (max && (rvalue >= max));
 184                         break;
 185                 case QUOTA_CHECK_MAX_BYTES_OP:
 186                         exceeded = (max && (rvalue + delta > max));
 187                         break;
 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
 195                 next = realm->parent;
 196                 if (exceeded || !next)
 197                         break;
 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 }
 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 }