1
2
3
4
5
6
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 else
19 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
31 if (root && ceph_ino(root) == CEPH_INO_ROOT)
32 return false;
33
34 return true;
35}
36
37void ceph_handle_quota(struct ceph_mds_client *mdsc,
38 struct ceph_mds_session *session,
39 struct ceph_msg *msg)
40{
41 struct super_block *sb = mdsc->fsc->sb;
42 struct ceph_mds_quota *h = msg->front.iov_base;
43 struct ceph_vino vino;
44 struct inode *inode;
45 struct ceph_inode_info *ci;
46
47 if (msg->front.iov_len < sizeof(*h)) {
48 pr_err("%s corrupt message mds%d len %d\n", __func__,
49 session->s_mds, (int)msg->front.iov_len);
50 ceph_msg_dump(msg);
51 return;
52 }
53
54
55 mutex_lock(&session->s_mutex);
56 inc_session_sequence(session);
57 mutex_unlock(&session->s_mutex);
58
59
60 vino.ino = le64_to_cpu(h->ino);
61 vino.snap = CEPH_NOSNAP;
62 inode = ceph_find_inode(sb, vino);
63 if (!inode) {
64 pr_warn("Failed to find inode %llu\n", vino.ino);
65 return;
66 }
67 ci = ceph_inode(inode);
68
69 spin_lock(&ci->i_ceph_lock);
70 ci->i_rbytes = le64_to_cpu(h->rbytes);
71 ci->i_rfiles = le64_to_cpu(h->rfiles);
72 ci->i_rsubdirs = le64_to_cpu(h->rsubdirs);
73 __ceph_update_quota(ci, le64_to_cpu(h->max_bytes),
74 le64_to_cpu(h->max_files));
75 spin_unlock(&ci->i_ceph_lock);
76
77 iput(inode);
78}
79
80static struct ceph_quotarealm_inode *
81find_quotarealm_inode(struct ceph_mds_client *mdsc, u64 ino)
82{
83 struct ceph_quotarealm_inode *qri = NULL;
84 struct rb_node **node, *parent = NULL;
85
86 mutex_lock(&mdsc->quotarealms_inodes_mutex);
87 node = &(mdsc->quotarealms_inodes.rb_node);
88 while (*node) {
89 parent = *node;
90 qri = container_of(*node, struct ceph_quotarealm_inode, node);
91
92 if (ino < qri->ino)
93 node = &((*node)->rb_left);
94 else if (ino > qri->ino)
95 node = &((*node)->rb_right);
96 else
97 break;
98 }
99 if (!qri || (qri->ino != ino)) {
100
101 qri = kmalloc(sizeof(*qri), GFP_KERNEL);
102 if (qri) {
103 qri->ino = ino;
104 qri->inode = NULL;
105 qri->timeout = 0;
106 mutex_init(&qri->mutex);
107 rb_link_node(&qri->node, parent, node);
108 rb_insert_color(&qri->node, &mdsc->quotarealms_inodes);
109 } else
110 pr_warn("Failed to alloc quotarealms_inode\n");
111 }
112 mutex_unlock(&mdsc->quotarealms_inodes_mutex);
113
114 return qri;
115}
116
117
118
119
120
121
122
123
124
125static struct inode *lookup_quotarealm_inode(struct ceph_mds_client *mdsc,
126 struct super_block *sb,
127 struct ceph_snap_realm *realm)
128{
129 struct ceph_quotarealm_inode *qri;
130 struct inode *in;
131
132 qri = find_quotarealm_inode(mdsc, realm->ino);
133 if (!qri)
134 return NULL;
135
136 mutex_lock(&qri->mutex);
137 if (qri->inode && ceph_is_any_caps(qri->inode)) {
138
139 mutex_unlock(&qri->mutex);
140 return qri->inode;
141 }
142
143 if (qri->timeout &&
144 time_before_eq(jiffies, qri->timeout)) {
145 mutex_unlock(&qri->mutex);
146 return NULL;
147 }
148 if (qri->inode) {
149
150 int ret = __ceph_do_getattr(qri->inode, NULL,
151 CEPH_STAT_CAP_INODE, true);
152 if (ret >= 0)
153 in = qri->inode;
154 else
155 in = ERR_PTR(ret);
156 } else {
157 in = ceph_lookup_inode(sb, realm->ino);
158 }
159
160 if (IS_ERR(in)) {
161 dout("Can't lookup inode %llx (err: %ld)\n",
162 realm->ino, PTR_ERR(in));
163 qri->timeout = jiffies + msecs_to_jiffies(60 * 1000);
164 } else {
165 qri->timeout = 0;
166 qri->inode = in;
167 }
168 mutex_unlock(&qri->mutex);
169
170 return in;
171}
172
173void ceph_cleanup_quotarealms_inodes(struct ceph_mds_client *mdsc)
174{
175 struct ceph_quotarealm_inode *qri;
176 struct rb_node *node;
177
178
179
180
181
182 mutex_lock(&mdsc->quotarealms_inodes_mutex);
183 while (!RB_EMPTY_ROOT(&mdsc->quotarealms_inodes)) {
184 node = rb_first(&mdsc->quotarealms_inodes);
185 qri = rb_entry(node, struct ceph_quotarealm_inode, node);
186 rb_erase(node, &mdsc->quotarealms_inodes);
187 iput(qri->inode);
188 kfree(qri);
189 }
190 mutex_unlock(&mdsc->quotarealms_inodes_mutex);
191}
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208static struct ceph_snap_realm *get_quota_realm(struct ceph_mds_client *mdsc,
209 struct inode *inode, bool retry)
210{
211 struct ceph_inode_info *ci = NULL;
212 struct ceph_snap_realm *realm, *next;
213 struct inode *in;
214 bool has_quota;
215
216 if (ceph_snap(inode) != CEPH_NOSNAP)
217 return NULL;
218
219restart:
220 realm = ceph_inode(inode)->i_snap_realm;
221 if (realm)
222 ceph_get_snap_realm(mdsc, realm);
223 else
224 pr_err_ratelimited("get_quota_realm: ino (%llx.%llx) "
225 "null i_snap_realm\n", ceph_vinop(inode));
226 while (realm) {
227 bool has_inode;
228
229 spin_lock(&realm->inodes_with_caps_lock);
230 has_inode = realm->inode;
231 in = has_inode ? igrab(realm->inode) : NULL;
232 spin_unlock(&realm->inodes_with_caps_lock);
233 if (has_inode && !in)
234 break;
235 if (!in) {
236 up_read(&mdsc->snap_rwsem);
237 in = lookup_quotarealm_inode(mdsc, inode->i_sb, realm);
238 down_read(&mdsc->snap_rwsem);
239 if (IS_ERR_OR_NULL(in))
240 break;
241 ceph_put_snap_realm(mdsc, realm);
242 if (!retry)
243 return ERR_PTR(-EAGAIN);
244 goto restart;
245 }
246
247 ci = ceph_inode(in);
248 has_quota = __ceph_has_any_quota(ci);
249 iput(in);
250
251 next = realm->parent;
252 if (has_quota || !next)
253 return realm;
254
255 ceph_get_snap_realm(mdsc, next);
256 ceph_put_snap_realm(mdsc, realm);
257 realm = next;
258 }
259 if (realm)
260 ceph_put_snap_realm(mdsc, realm);
261
262 return NULL;
263}
264
265bool ceph_quota_is_same_realm(struct inode *old, struct inode *new)
266{
267 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(old->i_sb);
268 struct ceph_snap_realm *old_realm, *new_realm;
269 bool is_same;
270
271restart:
272
273
274
275
276
277
278 down_read(&mdsc->snap_rwsem);
279 old_realm = get_quota_realm(mdsc, old, true);
280 new_realm = get_quota_realm(mdsc, new, false);
281 if (PTR_ERR(new_realm) == -EAGAIN) {
282 up_read(&mdsc->snap_rwsem);
283 if (old_realm)
284 ceph_put_snap_realm(mdsc, old_realm);
285 goto restart;
286 }
287 is_same = (old_realm == new_realm);
288 up_read(&mdsc->snap_rwsem);
289
290 if (old_realm)
291 ceph_put_snap_realm(mdsc, old_realm);
292 if (new_realm)
293 ceph_put_snap_realm(mdsc, new_realm);
294
295 return is_same;
296}
297
298enum quota_check_op {
299 QUOTA_CHECK_MAX_FILES_OP,
300 QUOTA_CHECK_MAX_BYTES_OP,
301 QUOTA_CHECK_MAX_BYTES_APPROACHING_OP
302
303};
304
305
306
307
308
309
310
311static bool check_quota_exceeded(struct inode *inode, enum quota_check_op op,
312 loff_t delta)
313{
314 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
315 struct ceph_inode_info *ci;
316 struct ceph_snap_realm *realm, *next;
317 struct inode *in;
318 u64 max, rvalue;
319 bool exceeded = false;
320
321 if (ceph_snap(inode) != CEPH_NOSNAP)
322 return false;
323
324 down_read(&mdsc->snap_rwsem);
325restart:
326 realm = ceph_inode(inode)->i_snap_realm;
327 if (realm)
328 ceph_get_snap_realm(mdsc, realm);
329 else
330 pr_err_ratelimited("check_quota_exceeded: ino (%llx.%llx) "
331 "null i_snap_realm\n", ceph_vinop(inode));
332 while (realm) {
333 bool has_inode;
334
335 spin_lock(&realm->inodes_with_caps_lock);
336 has_inode = realm->inode;
337 in = has_inode ? igrab(realm->inode) : NULL;
338 spin_unlock(&realm->inodes_with_caps_lock);
339 if (has_inode && !in)
340 break;
341 if (!in) {
342 up_read(&mdsc->snap_rwsem);
343 in = lookup_quotarealm_inode(mdsc, inode->i_sb, realm);
344 down_read(&mdsc->snap_rwsem);
345 if (IS_ERR_OR_NULL(in))
346 break;
347 ceph_put_snap_realm(mdsc, realm);
348 goto restart;
349 }
350 ci = ceph_inode(in);
351 spin_lock(&ci->i_ceph_lock);
352 if (op == QUOTA_CHECK_MAX_FILES_OP) {
353 max = ci->i_max_files;
354 rvalue = ci->i_rfiles + ci->i_rsubdirs;
355 } else {
356 max = ci->i_max_bytes;
357 rvalue = ci->i_rbytes;
358 }
359 spin_unlock(&ci->i_ceph_lock);
360 switch (op) {
361 case QUOTA_CHECK_MAX_FILES_OP:
362 case QUOTA_CHECK_MAX_BYTES_OP:
363 exceeded = (max && (rvalue + delta > max));
364 break;
365 case QUOTA_CHECK_MAX_BYTES_APPROACHING_OP:
366 if (max) {
367 if (rvalue >= max)
368 exceeded = true;
369 else {
370
371
372
373
374 exceeded =
375 (((max - rvalue) >> 4) < delta);
376 }
377 }
378 break;
379 default:
380
381 pr_warn("Invalid quota check op (%d)\n", op);
382 exceeded = true;
383 }
384 iput(in);
385
386 next = realm->parent;
387 if (exceeded || !next)
388 break;
389 ceph_get_snap_realm(mdsc, next);
390 ceph_put_snap_realm(mdsc, realm);
391 realm = next;
392 }
393 if (realm)
394 ceph_put_snap_realm(mdsc, realm);
395 up_read(&mdsc->snap_rwsem);
396
397 return exceeded;
398}
399
400
401
402
403
404
405
406
407
408bool ceph_quota_is_max_files_exceeded(struct inode *inode)
409{
410 if (!ceph_has_realms_with_quotas(inode))
411 return false;
412
413 WARN_ON(!S_ISDIR(inode->i_mode));
414
415 return check_quota_exceeded(inode, QUOTA_CHECK_MAX_FILES_OP, 1);
416}
417
418
419
420
421
422
423
424
425
426bool ceph_quota_is_max_bytes_exceeded(struct inode *inode, loff_t newsize)
427{
428 loff_t size = i_size_read(inode);
429
430 if (!ceph_has_realms_with_quotas(inode))
431 return false;
432
433
434 if (newsize <= size)
435 return false;
436
437 return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_OP, (newsize - size));
438}
439
440
441
442
443
444
445
446
447
448bool ceph_quota_is_max_bytes_approaching(struct inode *inode, loff_t newsize)
449{
450 loff_t size = ceph_inode(inode)->i_reported_size;
451
452 if (!ceph_has_realms_with_quotas(inode))
453 return false;
454
455
456 if (newsize <= size)
457 return false;
458
459 return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_APPROACHING_OP,
460 (newsize - size));
461}
462
463
464
465
466
467
468
469
470
471
472
473bool ceph_quota_update_statfs(struct ceph_fs_client *fsc, struct kstatfs *buf)
474{
475 struct ceph_mds_client *mdsc = fsc->mdsc;
476 struct ceph_inode_info *ci;
477 struct ceph_snap_realm *realm;
478 struct inode *in;
479 u64 total = 0, used, free;
480 bool is_updated = false;
481
482 down_read(&mdsc->snap_rwsem);
483 realm = get_quota_realm(mdsc, d_inode(fsc->sb->s_root), true);
484 up_read(&mdsc->snap_rwsem);
485 if (!realm)
486 return false;
487
488 spin_lock(&realm->inodes_with_caps_lock);
489 in = realm->inode ? igrab(realm->inode) : NULL;
490 spin_unlock(&realm->inodes_with_caps_lock);
491 if (in) {
492 ci = ceph_inode(in);
493 spin_lock(&ci->i_ceph_lock);
494 if (ci->i_max_bytes) {
495 total = ci->i_max_bytes >> CEPH_BLOCK_SHIFT;
496 used = ci->i_rbytes >> CEPH_BLOCK_SHIFT;
497
498
499
500 free = total > used ? total - used : 0;
501 }
502 spin_unlock(&ci->i_ceph_lock);
503 if (total) {
504 buf->f_blocks = total;
505 buf->f_bfree = free;
506 buf->f_bavail = free;
507 is_updated = true;
508 }
509 iput(in);
510 }
511 ceph_put_snap_realm(mdsc, realm);
512
513 return is_updated;
514}
515
516