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