2 * Implementation of operations over global quota file
4 #include <linux/spinlock.h>
6 #include <linux/slab.h>
7 #include <linux/quota.h>
8 #include <linux/quotaops.h>
9 #include <linux/dqblk_qtree.h>
10 #include <linux/jiffies.h>
11 #include <linux/writeback.h>
12 #include <linux/workqueue.h>
13 #include <linux/llist.h>
15 #include <cluster/masklog.h>
20 #include "blockcheck.h"
28 #include "buffer_head_io.h"
30 #include "ocfs2_trace.h"
33 * Locking of quotas with OCFS2 is rather complex. Here are rules that
34 * should be obeyed by all the functions:
35 * - any write of quota structure (either to local or global file) is protected
36 * by dqio_mutex or dquot->dq_lock.
37 * - any modification of global quota file holds inode cluster lock, i_mutex,
38 * and ip_alloc_sem of the global quota file (achieved by
39 * ocfs2_lock_global_qf). It also has to hold qinfo_lock.
40 * - an allocation of new blocks for local quota file is protected by
43 * A rough sketch of locking dependencies (lf = local file, gf = global file):
44 * Normal filesystem operation:
45 * start_trans -> dqio_mutex -> write to lf
46 * Syncing of local and global file:
47 * ocfs2_lock_global_qf -> start_trans -> dqio_mutex -> qinfo_lock ->
50 * Acquire dquot for the first time:
51 * dq_lock -> ocfs2_lock_global_qf -> qinfo_lock -> read from gf
52 * -> alloc space for gf
53 * -> start_trans -> qinfo_lock -> write to gf
54 * -> ip_alloc_sem of lf -> alloc space for lf
56 * Release last reference to dquot:
57 * dq_lock -> ocfs2_lock_global_qf -> start_trans -> qinfo_lock -> write to gf
59 * Note that all the above operations also hold the inode cluster lock of lf.
61 * inode cluster lock of recovered lf
62 * -> read bitmaps -> ip_alloc_sem of lf
63 * -> ocfs2_lock_global_qf -> start_trans -> dqio_mutex -> qinfo_lock ->
67 static void qsync_work_fn(struct work_struct
*work
);
69 static void ocfs2_global_disk2memdqb(struct dquot
*dquot
, void *dp
)
71 struct ocfs2_global_disk_dqblk
*d
= dp
;
72 struct mem_dqblk
*m
= &dquot
->dq_dqb
;
74 /* Update from disk only entries not set by the admin */
75 if (!test_bit(DQ_LASTSET_B
+ QIF_ILIMITS_B
, &dquot
->dq_flags
)) {
76 m
->dqb_ihardlimit
= le64_to_cpu(d
->dqb_ihardlimit
);
77 m
->dqb_isoftlimit
= le64_to_cpu(d
->dqb_isoftlimit
);
79 if (!test_bit(DQ_LASTSET_B
+ QIF_INODES_B
, &dquot
->dq_flags
))
80 m
->dqb_curinodes
= le64_to_cpu(d
->dqb_curinodes
);
81 if (!test_bit(DQ_LASTSET_B
+ QIF_BLIMITS_B
, &dquot
->dq_flags
)) {
82 m
->dqb_bhardlimit
= le64_to_cpu(d
->dqb_bhardlimit
);
83 m
->dqb_bsoftlimit
= le64_to_cpu(d
->dqb_bsoftlimit
);
85 if (!test_bit(DQ_LASTSET_B
+ QIF_SPACE_B
, &dquot
->dq_flags
))
86 m
->dqb_curspace
= le64_to_cpu(d
->dqb_curspace
);
87 if (!test_bit(DQ_LASTSET_B
+ QIF_BTIME_B
, &dquot
->dq_flags
))
88 m
->dqb_btime
= le64_to_cpu(d
->dqb_btime
);
89 if (!test_bit(DQ_LASTSET_B
+ QIF_ITIME_B
, &dquot
->dq_flags
))
90 m
->dqb_itime
= le64_to_cpu(d
->dqb_itime
);
91 OCFS2_DQUOT(dquot
)->dq_use_count
= le32_to_cpu(d
->dqb_use_count
);
94 static void ocfs2_global_mem2diskdqb(void *dp
, struct dquot
*dquot
)
96 struct ocfs2_global_disk_dqblk
*d
= dp
;
97 struct mem_dqblk
*m
= &dquot
->dq_dqb
;
99 d
->dqb_id
= cpu_to_le32(from_kqid(&init_user_ns
, dquot
->dq_id
));
100 d
->dqb_use_count
= cpu_to_le32(OCFS2_DQUOT(dquot
)->dq_use_count
);
101 d
->dqb_ihardlimit
= cpu_to_le64(m
->dqb_ihardlimit
);
102 d
->dqb_isoftlimit
= cpu_to_le64(m
->dqb_isoftlimit
);
103 d
->dqb_curinodes
= cpu_to_le64(m
->dqb_curinodes
);
104 d
->dqb_bhardlimit
= cpu_to_le64(m
->dqb_bhardlimit
);
105 d
->dqb_bsoftlimit
= cpu_to_le64(m
->dqb_bsoftlimit
);
106 d
->dqb_curspace
= cpu_to_le64(m
->dqb_curspace
);
107 d
->dqb_btime
= cpu_to_le64(m
->dqb_btime
);
108 d
->dqb_itime
= cpu_to_le64(m
->dqb_itime
);
109 d
->dqb_pad1
= d
->dqb_pad2
= 0;
112 static int ocfs2_global_is_id(void *dp
, struct dquot
*dquot
)
114 struct ocfs2_global_disk_dqblk
*d
= dp
;
115 struct ocfs2_mem_dqinfo
*oinfo
=
116 sb_dqinfo(dquot
->dq_sb
, dquot
->dq_id
.type
)->dqi_priv
;
118 if (qtree_entry_unused(&oinfo
->dqi_gi
, dp
))
121 return qid_eq(make_kqid(&init_user_ns
, dquot
->dq_id
.type
,
122 le32_to_cpu(d
->dqb_id
)),
126 const struct qtree_fmt_operations ocfs2_global_ops
= {
127 .mem2disk_dqblk
= ocfs2_global_mem2diskdqb
,
128 .disk2mem_dqblk
= ocfs2_global_disk2memdqb
,
129 .is_id
= ocfs2_global_is_id
,
132 int ocfs2_validate_quota_block(struct super_block
*sb
, struct buffer_head
*bh
)
134 struct ocfs2_disk_dqtrailer
*dqt
=
135 ocfs2_block_dqtrailer(sb
->s_blocksize
, bh
->b_data
);
137 trace_ocfs2_validate_quota_block((unsigned long long)bh
->b_blocknr
);
139 BUG_ON(!buffer_uptodate(bh
));
142 * If the ecc fails, we return the error but otherwise
143 * leave the filesystem running. We know any error is
144 * local to this block.
146 return ocfs2_validate_meta_ecc(sb
, bh
->b_data
, &dqt
->dq_check
);
149 int ocfs2_read_quota_phys_block(struct inode
*inode
, u64 p_block
,
150 struct buffer_head
**bhp
)
155 rc
= ocfs2_read_blocks(INODE_CACHE(inode
), p_block
, 1, bhp
, 0,
156 ocfs2_validate_quota_block
);
162 /* Read data from global quotafile - avoid pagecache and such because we cannot
163 * afford acquiring the locks... We use quota cluster lock to serialize
164 * operations. Caller is responsible for acquiring it. */
165 ssize_t
ocfs2_quota_read(struct super_block
*sb
, int type
, char *data
,
166 size_t len
, loff_t off
)
168 struct ocfs2_mem_dqinfo
*oinfo
= sb_dqinfo(sb
, type
)->dqi_priv
;
169 struct inode
*gqinode
= oinfo
->dqi_gqinode
;
170 loff_t i_size
= i_size_read(gqinode
);
171 int offset
= off
& (sb
->s_blocksize
- 1);
172 sector_t blk
= off
>> sb
->s_blocksize_bits
;
174 struct buffer_head
*bh
;
175 size_t toread
, tocopy
;
176 u64 pblock
= 0, pcount
= 0;
180 if (off
+ len
> i_size
)
184 tocopy
= min_t(size_t, (sb
->s_blocksize
- offset
), toread
);
186 err
= ocfs2_extent_map_get_blocks(gqinode
, blk
, &pblock
,
197 err
= ocfs2_read_quota_phys_block(gqinode
, pblock
, &bh
);
202 memcpy(data
, bh
->b_data
+ offset
, tocopy
);
212 /* Write to quotafile (we know the transaction is already started and has
214 ssize_t
ocfs2_quota_write(struct super_block
*sb
, int type
,
215 const char *data
, size_t len
, loff_t off
)
217 struct mem_dqinfo
*info
= sb_dqinfo(sb
, type
);
218 struct ocfs2_mem_dqinfo
*oinfo
= info
->dqi_priv
;
219 struct inode
*gqinode
= oinfo
->dqi_gqinode
;
220 int offset
= off
& (sb
->s_blocksize
- 1);
221 sector_t blk
= off
>> sb
->s_blocksize_bits
;
222 int err
= 0, new = 0, ja_type
;
223 struct buffer_head
*bh
= NULL
;
224 handle_t
*handle
= journal_current_handle();
228 mlog(ML_ERROR
, "Quota write (off=%llu, len=%llu) cancelled "
229 "because transaction was not started.\n",
230 (unsigned long long)off
, (unsigned long long)len
);
233 if (len
> sb
->s_blocksize
- OCFS2_QBLK_RESERVED_SPACE
- offset
) {
235 len
= sb
->s_blocksize
- OCFS2_QBLK_RESERVED_SPACE
- offset
;
238 if (i_size_read(gqinode
) < off
+ len
) {
240 ocfs2_align_bytes_to_blocks(sb
, off
+ len
);
242 /* Space is already allocated in ocfs2_acquire_dquot() */
243 err
= ocfs2_simple_size_update(gqinode
,
250 err
= ocfs2_extent_map_get_blocks(gqinode
, blk
, &pblock
, &pcount
, NULL
);
255 /* Not rewriting whole block? */
256 if ((offset
|| len
< sb
->s_blocksize
- OCFS2_QBLK_RESERVED_SPACE
) &&
258 err
= ocfs2_read_quota_phys_block(gqinode
, pblock
, &bh
);
259 ja_type
= OCFS2_JOURNAL_ACCESS_WRITE
;
261 bh
= sb_getblk(sb
, pblock
);
264 ja_type
= OCFS2_JOURNAL_ACCESS_CREATE
;
272 memset(bh
->b_data
, 0, sb
->s_blocksize
);
273 memcpy(bh
->b_data
+ offset
, data
, len
);
274 flush_dcache_page(bh
->b_page
);
275 set_buffer_uptodate(bh
);
277 ocfs2_set_buffer_uptodate(INODE_CACHE(gqinode
), bh
);
278 err
= ocfs2_journal_access_dq(handle
, INODE_CACHE(gqinode
), bh
,
284 ocfs2_journal_dirty(handle
, bh
);
291 gqinode
->i_version
++;
292 ocfs2_mark_inode_dirty(handle
, gqinode
, oinfo
->dqi_gqi_bh
);
296 int ocfs2_lock_global_qf(struct ocfs2_mem_dqinfo
*oinfo
, int ex
)
299 struct buffer_head
*bh
= NULL
;
301 status
= ocfs2_inode_lock(oinfo
->dqi_gqinode
, &bh
, ex
);
304 spin_lock(&dq_data_lock
);
305 if (!oinfo
->dqi_gqi_count
++)
306 oinfo
->dqi_gqi_bh
= bh
;
308 WARN_ON(bh
!= oinfo
->dqi_gqi_bh
);
309 spin_unlock(&dq_data_lock
);
311 inode_lock(oinfo
->dqi_gqinode
);
312 down_write(&OCFS2_I(oinfo
->dqi_gqinode
)->ip_alloc_sem
);
314 down_read(&OCFS2_I(oinfo
->dqi_gqinode
)->ip_alloc_sem
);
319 void ocfs2_unlock_global_qf(struct ocfs2_mem_dqinfo
*oinfo
, int ex
)
322 up_write(&OCFS2_I(oinfo
->dqi_gqinode
)->ip_alloc_sem
);
323 inode_unlock(oinfo
->dqi_gqinode
);
325 up_read(&OCFS2_I(oinfo
->dqi_gqinode
)->ip_alloc_sem
);
327 ocfs2_inode_unlock(oinfo
->dqi_gqinode
, ex
);
328 brelse(oinfo
->dqi_gqi_bh
);
329 spin_lock(&dq_data_lock
);
330 if (!--oinfo
->dqi_gqi_count
)
331 oinfo
->dqi_gqi_bh
= NULL
;
332 spin_unlock(&dq_data_lock
);
335 /* Read information header from global quota file */
336 int ocfs2_global_read_info(struct super_block
*sb
, int type
)
338 struct inode
*gqinode
= NULL
;
339 unsigned int ino
[OCFS2_MAXQUOTAS
] = { USER_QUOTA_SYSTEM_INODE
,
340 GROUP_QUOTA_SYSTEM_INODE
};
341 struct ocfs2_global_disk_dqinfo dinfo
;
342 struct mem_dqinfo
*info
= sb_dqinfo(sb
, type
);
343 struct ocfs2_mem_dqinfo
*oinfo
= info
->dqi_priv
;
347 /* Read global header */
348 gqinode
= ocfs2_get_system_file_inode(OCFS2_SB(sb
), ino
[type
],
351 mlog(ML_ERROR
, "failed to get global quota inode (type=%d)\n",
356 oinfo
->dqi_gi
.dqi_sb
= sb
;
357 oinfo
->dqi_gi
.dqi_type
= type
;
358 ocfs2_qinfo_lock_res_init(&oinfo
->dqi_gqlock
, oinfo
);
359 oinfo
->dqi_gi
.dqi_entry_size
= sizeof(struct ocfs2_global_disk_dqblk
);
360 oinfo
->dqi_gi
.dqi_ops
= &ocfs2_global_ops
;
361 oinfo
->dqi_gqi_bh
= NULL
;
362 oinfo
->dqi_gqi_count
= 0;
363 oinfo
->dqi_gqinode
= gqinode
;
364 status
= ocfs2_lock_global_qf(oinfo
, 0);
370 status
= ocfs2_extent_map_get_blocks(gqinode
, 0, &oinfo
->dqi_giblk
,
375 status
= ocfs2_qinfo_lock(oinfo
, 0);
378 status
= sb
->s_op
->quota_read(sb
, type
, (char *)&dinfo
,
379 sizeof(struct ocfs2_global_disk_dqinfo
),
380 OCFS2_GLOBAL_INFO_OFF
);
381 ocfs2_qinfo_unlock(oinfo
, 0);
382 ocfs2_unlock_global_qf(oinfo
, 0);
383 if (status
!= sizeof(struct ocfs2_global_disk_dqinfo
)) {
384 mlog(ML_ERROR
, "Cannot read global quota info (%d).\n",
391 info
->dqi_bgrace
= le32_to_cpu(dinfo
.dqi_bgrace
);
392 info
->dqi_igrace
= le32_to_cpu(dinfo
.dqi_igrace
);
393 oinfo
->dqi_syncms
= le32_to_cpu(dinfo
.dqi_syncms
);
394 oinfo
->dqi_gi
.dqi_blocks
= le32_to_cpu(dinfo
.dqi_blocks
);
395 oinfo
->dqi_gi
.dqi_free_blk
= le32_to_cpu(dinfo
.dqi_free_blk
);
396 oinfo
->dqi_gi
.dqi_free_entry
= le32_to_cpu(dinfo
.dqi_free_entry
);
397 oinfo
->dqi_gi
.dqi_blocksize_bits
= sb
->s_blocksize_bits
;
398 oinfo
->dqi_gi
.dqi_usable_bs
= sb
->s_blocksize
-
399 OCFS2_QBLK_RESERVED_SPACE
;
400 oinfo
->dqi_gi
.dqi_qtree_depth
= qtree_depth(&oinfo
->dqi_gi
);
401 INIT_DELAYED_WORK(&oinfo
->dqi_sync_work
, qsync_work_fn
);
402 schedule_delayed_work(&oinfo
->dqi_sync_work
,
403 msecs_to_jiffies(oinfo
->dqi_syncms
));
408 ocfs2_unlock_global_qf(oinfo
, 0);
413 /* Write information to global quota file. Expects exlusive lock on quota
414 * file inode and quota info */
415 static int __ocfs2_global_write_info(struct super_block
*sb
, int type
)
417 struct mem_dqinfo
*info
= sb_dqinfo(sb
, type
);
418 struct ocfs2_mem_dqinfo
*oinfo
= info
->dqi_priv
;
419 struct ocfs2_global_disk_dqinfo dinfo
;
422 spin_lock(&dq_data_lock
);
423 info
->dqi_flags
&= ~DQF_INFO_DIRTY
;
424 dinfo
.dqi_bgrace
= cpu_to_le32(info
->dqi_bgrace
);
425 dinfo
.dqi_igrace
= cpu_to_le32(info
->dqi_igrace
);
426 spin_unlock(&dq_data_lock
);
427 dinfo
.dqi_syncms
= cpu_to_le32(oinfo
->dqi_syncms
);
428 dinfo
.dqi_blocks
= cpu_to_le32(oinfo
->dqi_gi
.dqi_blocks
);
429 dinfo
.dqi_free_blk
= cpu_to_le32(oinfo
->dqi_gi
.dqi_free_blk
);
430 dinfo
.dqi_free_entry
= cpu_to_le32(oinfo
->dqi_gi
.dqi_free_entry
);
431 size
= sb
->s_op
->quota_write(sb
, type
, (char *)&dinfo
,
432 sizeof(struct ocfs2_global_disk_dqinfo
),
433 OCFS2_GLOBAL_INFO_OFF
);
434 if (size
!= sizeof(struct ocfs2_global_disk_dqinfo
)) {
435 mlog(ML_ERROR
, "Cannot write global quota info structure\n");
443 int ocfs2_global_write_info(struct super_block
*sb
, int type
)
446 struct ocfs2_mem_dqinfo
*info
= sb_dqinfo(sb
, type
)->dqi_priv
;
448 err
= ocfs2_qinfo_lock(info
, 1);
451 err
= __ocfs2_global_write_info(sb
, type
);
452 ocfs2_qinfo_unlock(info
, 1);
456 static int ocfs2_global_qinit_alloc(struct super_block
*sb
, int type
)
458 struct ocfs2_mem_dqinfo
*oinfo
= sb_dqinfo(sb
, type
)->dqi_priv
;
461 * We may need to allocate tree blocks and a leaf block but not the
464 return oinfo
->dqi_gi
.dqi_qtree_depth
;
467 static int ocfs2_calc_global_qinit_credits(struct super_block
*sb
, int type
)
469 /* We modify all the allocated blocks, tree root, info block and
471 return (ocfs2_global_qinit_alloc(sb
, type
) + 2) *
472 OCFS2_QUOTA_BLOCK_UPDATE_CREDITS
+ 1;
475 /* Sync local information about quota modifications with global quota file.
476 * Caller must have started the transaction and obtained exclusive lock for
477 * global quota file inode */
478 int __ocfs2_sync_dquot(struct dquot
*dquot
, int freeing
)
481 struct super_block
*sb
= dquot
->dq_sb
;
482 int type
= dquot
->dq_id
.type
;
483 struct ocfs2_mem_dqinfo
*info
= sb_dqinfo(sb
, type
)->dqi_priv
;
484 struct ocfs2_global_disk_dqblk dqblk
;
485 s64 spacechange
, inodechange
;
486 time64_t olditime
, oldbtime
;
488 err
= sb
->s_op
->quota_read(sb
, type
, (char *)&dqblk
,
489 sizeof(struct ocfs2_global_disk_dqblk
),
491 if (err
!= sizeof(struct ocfs2_global_disk_dqblk
)) {
493 mlog(ML_ERROR
, "Short read from global quota file "
500 /* Update space and inode usage. Get also other information from
501 * global quota file so that we don't overwrite any changes there.
503 spin_lock(&dq_data_lock
);
504 spacechange
= dquot
->dq_dqb
.dqb_curspace
-
505 OCFS2_DQUOT(dquot
)->dq_origspace
;
506 inodechange
= dquot
->dq_dqb
.dqb_curinodes
-
507 OCFS2_DQUOT(dquot
)->dq_originodes
;
508 olditime
= dquot
->dq_dqb
.dqb_itime
;
509 oldbtime
= dquot
->dq_dqb
.dqb_btime
;
510 ocfs2_global_disk2memdqb(dquot
, &dqblk
);
511 trace_ocfs2_sync_dquot(from_kqid(&init_user_ns
, dquot
->dq_id
),
512 dquot
->dq_dqb
.dqb_curspace
,
513 (long long)spacechange
,
514 dquot
->dq_dqb
.dqb_curinodes
,
515 (long long)inodechange
);
516 if (!test_bit(DQ_LASTSET_B
+ QIF_SPACE_B
, &dquot
->dq_flags
))
517 dquot
->dq_dqb
.dqb_curspace
+= spacechange
;
518 if (!test_bit(DQ_LASTSET_B
+ QIF_INODES_B
, &dquot
->dq_flags
))
519 dquot
->dq_dqb
.dqb_curinodes
+= inodechange
;
520 /* Set properly space grace time... */
521 if (dquot
->dq_dqb
.dqb_bsoftlimit
&&
522 dquot
->dq_dqb
.dqb_curspace
> dquot
->dq_dqb
.dqb_bsoftlimit
) {
523 if (!test_bit(DQ_LASTSET_B
+ QIF_BTIME_B
, &dquot
->dq_flags
) &&
525 if (dquot
->dq_dqb
.dqb_btime
> 0)
526 dquot
->dq_dqb
.dqb_btime
=
527 min(dquot
->dq_dqb
.dqb_btime
, oldbtime
);
529 dquot
->dq_dqb
.dqb_btime
= oldbtime
;
532 dquot
->dq_dqb
.dqb_btime
= 0;
533 clear_bit(DQ_BLKS_B
, &dquot
->dq_flags
);
535 /* Set properly inode grace time... */
536 if (dquot
->dq_dqb
.dqb_isoftlimit
&&
537 dquot
->dq_dqb
.dqb_curinodes
> dquot
->dq_dqb
.dqb_isoftlimit
) {
538 if (!test_bit(DQ_LASTSET_B
+ QIF_ITIME_B
, &dquot
->dq_flags
) &&
540 if (dquot
->dq_dqb
.dqb_itime
> 0)
541 dquot
->dq_dqb
.dqb_itime
=
542 min(dquot
->dq_dqb
.dqb_itime
, olditime
);
544 dquot
->dq_dqb
.dqb_itime
= olditime
;
547 dquot
->dq_dqb
.dqb_itime
= 0;
548 clear_bit(DQ_INODES_B
, &dquot
->dq_flags
);
550 /* All information is properly updated, clear the flags */
551 __clear_bit(DQ_LASTSET_B
+ QIF_SPACE_B
, &dquot
->dq_flags
);
552 __clear_bit(DQ_LASTSET_B
+ QIF_INODES_B
, &dquot
->dq_flags
);
553 __clear_bit(DQ_LASTSET_B
+ QIF_BLIMITS_B
, &dquot
->dq_flags
);
554 __clear_bit(DQ_LASTSET_B
+ QIF_ILIMITS_B
, &dquot
->dq_flags
);
555 __clear_bit(DQ_LASTSET_B
+ QIF_BTIME_B
, &dquot
->dq_flags
);
556 __clear_bit(DQ_LASTSET_B
+ QIF_ITIME_B
, &dquot
->dq_flags
);
557 OCFS2_DQUOT(dquot
)->dq_origspace
= dquot
->dq_dqb
.dqb_curspace
;
558 OCFS2_DQUOT(dquot
)->dq_originodes
= dquot
->dq_dqb
.dqb_curinodes
;
559 spin_unlock(&dq_data_lock
);
560 err
= ocfs2_qinfo_lock(info
, freeing
);
562 mlog(ML_ERROR
, "Failed to lock quota info, losing quota write"
563 " (type=%d, id=%u)\n", dquot
->dq_id
.type
,
564 (unsigned)from_kqid(&init_user_ns
, dquot
->dq_id
));
568 OCFS2_DQUOT(dquot
)->dq_use_count
--;
569 err
= qtree_write_dquot(&info
->dqi_gi
, dquot
);
572 if (freeing
&& !OCFS2_DQUOT(dquot
)->dq_use_count
) {
573 err
= qtree_release_dquot(&info
->dqi_gi
, dquot
);
574 if (info_dirty(sb_dqinfo(sb
, type
))) {
575 err2
= __ocfs2_global_write_info(sb
, type
);
581 ocfs2_qinfo_unlock(info
, freeing
);
589 * Functions for periodic syncing of dquots with global file
591 static int ocfs2_sync_dquot_helper(struct dquot
*dquot
, unsigned long type
)
594 struct super_block
*sb
= dquot
->dq_sb
;
595 struct ocfs2_mem_dqinfo
*oinfo
= sb_dqinfo(sb
, type
)->dqi_priv
;
596 struct ocfs2_super
*osb
= OCFS2_SB(sb
);
599 trace_ocfs2_sync_dquot_helper(from_kqid(&init_user_ns
, dquot
->dq_id
),
602 if (type
!= dquot
->dq_id
.type
)
604 status
= ocfs2_lock_global_qf(oinfo
, 1);
608 handle
= ocfs2_start_trans(osb
, OCFS2_QSYNC_CREDITS
);
609 if (IS_ERR(handle
)) {
610 status
= PTR_ERR(handle
);
614 mutex_lock(&sb_dqopt(sb
)->dqio_mutex
);
615 status
= ocfs2_sync_dquot(dquot
);
618 /* We have to write local structure as well... */
619 status
= ocfs2_local_write_dquot(dquot
);
622 mutex_unlock(&sb_dqopt(sb
)->dqio_mutex
);
623 ocfs2_commit_trans(osb
, handle
);
625 ocfs2_unlock_global_qf(oinfo
, 1);
630 static void qsync_work_fn(struct work_struct
*work
)
632 struct ocfs2_mem_dqinfo
*oinfo
= container_of(work
,
633 struct ocfs2_mem_dqinfo
,
635 struct super_block
*sb
= oinfo
->dqi_gqinode
->i_sb
;
638 * We have to be careful here not to deadlock on s_umount as umount
639 * disabling quotas may be in progress and it waits for this work to
640 * complete. If trylock fails, we'll do the sync next time...
642 if (down_read_trylock(&sb
->s_umount
)) {
643 dquot_scan_active(sb
, ocfs2_sync_dquot_helper
, oinfo
->dqi_type
);
644 up_read(&sb
->s_umount
);
646 schedule_delayed_work(&oinfo
->dqi_sync_work
,
647 msecs_to_jiffies(oinfo
->dqi_syncms
));
651 * Wrappers for generic quota functions
654 static int ocfs2_write_dquot(struct dquot
*dquot
)
657 struct ocfs2_super
*osb
= OCFS2_SB(dquot
->dq_sb
);
660 trace_ocfs2_write_dquot(from_kqid(&init_user_ns
, dquot
->dq_id
),
663 handle
= ocfs2_start_trans(osb
, OCFS2_QWRITE_CREDITS
);
664 if (IS_ERR(handle
)) {
665 status
= PTR_ERR(handle
);
669 mutex_lock(&sb_dqopt(dquot
->dq_sb
)->dqio_mutex
);
670 status
= ocfs2_local_write_dquot(dquot
);
671 mutex_unlock(&sb_dqopt(dquot
->dq_sb
)->dqio_mutex
);
672 ocfs2_commit_trans(osb
, handle
);
677 static int ocfs2_calc_qdel_credits(struct super_block
*sb
, int type
)
679 struct ocfs2_mem_dqinfo
*oinfo
= sb_dqinfo(sb
, type
)->dqi_priv
;
681 * We modify tree, leaf block, global info, local chunk header,
682 * global and local inode; OCFS2_QINFO_WRITE_CREDITS already
683 * accounts for inode update
685 return (oinfo
->dqi_gi
.dqi_qtree_depth
+ 2) *
686 OCFS2_QUOTA_BLOCK_UPDATE_CREDITS
+
687 OCFS2_QINFO_WRITE_CREDITS
+
688 OCFS2_INODE_UPDATE_CREDITS
;
691 void ocfs2_drop_dquot_refs(struct work_struct
*work
)
693 struct ocfs2_super
*osb
= container_of(work
, struct ocfs2_super
,
695 struct llist_node
*list
;
696 struct ocfs2_dquot
*odquot
, *next_odquot
;
698 list
= llist_del_all(&osb
->dquot_drop_list
);
699 llist_for_each_entry_safe(odquot
, next_odquot
, list
, list
) {
700 /* Drop the reference we acquired in ocfs2_dquot_release() */
701 dqput(&odquot
->dq_dquot
);
706 * Called when the last reference to dquot is dropped. If we are called from
707 * downconvert thread, we cannot do all the handling here because grabbing
708 * quota lock could deadlock (the node holding the quota lock could need some
709 * other cluster lock to proceed but with blocked downconvert thread we cannot
712 static int ocfs2_release_dquot(struct dquot
*dquot
)
715 struct ocfs2_mem_dqinfo
*oinfo
=
716 sb_dqinfo(dquot
->dq_sb
, dquot
->dq_id
.type
)->dqi_priv
;
717 struct ocfs2_super
*osb
= OCFS2_SB(dquot
->dq_sb
);
720 trace_ocfs2_release_dquot(from_kqid(&init_user_ns
, dquot
->dq_id
),
723 mutex_lock(&dquot
->dq_lock
);
724 /* Check whether we are not racing with some other dqget() */
725 if (atomic_read(&dquot
->dq_count
) > 1)
727 /* Running from downconvert thread? Postpone quota processing to wq */
728 if (current
== osb
->dc_task
) {
730 * Grab our own reference to dquot and queue it for delayed
731 * dropping. Quota code rechecks after calling
732 * ->release_dquot() and won't free dquot structure.
735 /* First entry on list -> queue work */
736 if (llist_add(&OCFS2_DQUOT(dquot
)->list
, &osb
->dquot_drop_list
))
737 queue_work(osb
->ocfs2_wq
, &osb
->dquot_drop_work
);
740 status
= ocfs2_lock_global_qf(oinfo
, 1);
743 handle
= ocfs2_start_trans(osb
,
744 ocfs2_calc_qdel_credits(dquot
->dq_sb
, dquot
->dq_id
.type
));
745 if (IS_ERR(handle
)) {
746 status
= PTR_ERR(handle
);
751 status
= ocfs2_global_release_dquot(dquot
);
756 status
= ocfs2_local_release_dquot(handle
, dquot
);
758 * If we fail here, we cannot do much as global structure is
759 * already released. So just complain...
764 * Clear dq_off so that we search for the structure in quota file next
765 * time we acquire it. The structure might be deleted and reallocated
766 * elsewhere by another node while our dquot structure is on freelist.
769 clear_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
);
771 ocfs2_commit_trans(osb
, handle
);
773 ocfs2_unlock_global_qf(oinfo
, 1);
775 mutex_unlock(&dquot
->dq_lock
);
782 * Read global dquot structure from disk or create it if it does
783 * not exist. Also update use count of the global structure and
784 * create structure in node-local quota file.
786 static int ocfs2_acquire_dquot(struct dquot
*dquot
)
790 struct super_block
*sb
= dquot
->dq_sb
;
791 struct ocfs2_super
*osb
= OCFS2_SB(sb
);
792 int type
= dquot
->dq_id
.type
;
793 struct ocfs2_mem_dqinfo
*info
= sb_dqinfo(sb
, type
)->dqi_priv
;
794 struct inode
*gqinode
= info
->dqi_gqinode
;
795 int need_alloc
= ocfs2_global_qinit_alloc(sb
, type
);
798 trace_ocfs2_acquire_dquot(from_kqid(&init_user_ns
, dquot
->dq_id
),
800 mutex_lock(&dquot
->dq_lock
);
802 * We need an exclusive lock, because we're going to update use count
803 * and instantiate possibly new dquot structure
805 status
= ocfs2_lock_global_qf(info
, 1);
808 status
= ocfs2_qinfo_lock(info
, 0);
812 * We always want to read dquot structure from disk because we don't
813 * know what happened with it while it was on freelist.
815 status
= qtree_read_dquot(&info
->dqi_gi
, dquot
);
816 ocfs2_qinfo_unlock(info
, 0);
820 OCFS2_DQUOT(dquot
)->dq_use_count
++;
821 OCFS2_DQUOT(dquot
)->dq_origspace
= dquot
->dq_dqb
.dqb_curspace
;
822 OCFS2_DQUOT(dquot
)->dq_originodes
= dquot
->dq_dqb
.dqb_curinodes
;
823 if (!dquot
->dq_off
) { /* No real quota entry? */
826 * Add blocks to quota file before we start a transaction since
827 * locking allocators ranks above a transaction start
829 WARN_ON(journal_current_handle());
830 status
= ocfs2_extend_no_holes(gqinode
, NULL
,
831 i_size_read(gqinode
) + (need_alloc
<< sb
->s_blocksize_bits
),
832 i_size_read(gqinode
));
837 handle
= ocfs2_start_trans(osb
,
838 ocfs2_calc_global_qinit_credits(sb
, type
));
839 if (IS_ERR(handle
)) {
840 status
= PTR_ERR(handle
);
843 status
= ocfs2_qinfo_lock(info
, ex
);
846 status
= qtree_write_dquot(&info
->dqi_gi
, dquot
);
847 if (ex
&& info_dirty(sb_dqinfo(sb
, type
))) {
848 err
= __ocfs2_global_write_info(sb
, type
);
852 ocfs2_qinfo_unlock(info
, ex
);
854 ocfs2_commit_trans(osb
, handle
);
856 ocfs2_unlock_global_qf(info
, 1);
860 status
= ocfs2_create_local_dquot(dquot
);
863 set_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
);
865 mutex_unlock(&dquot
->dq_lock
);
871 static int ocfs2_get_next_id(struct super_block
*sb
, struct kqid
*qid
)
873 int type
= qid
->type
;
874 struct ocfs2_mem_dqinfo
*info
= sb_dqinfo(sb
, type
)->dqi_priv
;
877 trace_ocfs2_get_next_id(from_kqid(&init_user_ns
, *qid
), type
);
878 if (!sb_has_quota_loaded(sb
, type
)) {
882 status
= ocfs2_lock_global_qf(info
, 0);
885 status
= ocfs2_qinfo_lock(info
, 0);
888 status
= qtree_get_next_id(&info
->dqi_gi
, qid
);
889 ocfs2_qinfo_unlock(info
, 0);
891 ocfs2_unlock_global_qf(info
, 0);
894 * Avoid logging ENOENT since it just means there isn't next ID and
895 * ESRCH which means quota isn't enabled for the filesystem.
897 if (status
&& status
!= -ENOENT
&& status
!= -ESRCH
)
902 static int ocfs2_mark_dquot_dirty(struct dquot
*dquot
)
904 unsigned long mask
= (1 << (DQ_LASTSET_B
+ QIF_ILIMITS_B
)) |
905 (1 << (DQ_LASTSET_B
+ QIF_BLIMITS_B
)) |
906 (1 << (DQ_LASTSET_B
+ QIF_INODES_B
)) |
907 (1 << (DQ_LASTSET_B
+ QIF_SPACE_B
)) |
908 (1 << (DQ_LASTSET_B
+ QIF_BTIME_B
)) |
909 (1 << (DQ_LASTSET_B
+ QIF_ITIME_B
));
912 struct super_block
*sb
= dquot
->dq_sb
;
913 int type
= dquot
->dq_id
.type
;
914 struct ocfs2_mem_dqinfo
*oinfo
= sb_dqinfo(sb
, type
)->dqi_priv
;
916 struct ocfs2_super
*osb
= OCFS2_SB(sb
);
918 trace_ocfs2_mark_dquot_dirty(from_kqid(&init_user_ns
, dquot
->dq_id
),
921 /* In case user set some limits, sync dquot immediately to global
922 * quota file so that information propagates quicker */
923 spin_lock(&dq_data_lock
);
924 if (dquot
->dq_flags
& mask
)
926 spin_unlock(&dq_data_lock
);
927 /* This is a slight hack but we can't afford getting global quota
928 * lock if we already have a transaction started. */
929 if (!sync
|| journal_current_handle()) {
930 status
= ocfs2_write_dquot(dquot
);
933 status
= ocfs2_lock_global_qf(oinfo
, 1);
936 handle
= ocfs2_start_trans(osb
, OCFS2_QSYNC_CREDITS
);
937 if (IS_ERR(handle
)) {
938 status
= PTR_ERR(handle
);
942 mutex_lock(&sb_dqopt(sb
)->dqio_mutex
);
943 status
= ocfs2_sync_dquot(dquot
);
948 /* Now write updated local dquot structure */
949 status
= ocfs2_local_write_dquot(dquot
);
951 mutex_unlock(&sb_dqopt(sb
)->dqio_mutex
);
952 ocfs2_commit_trans(osb
, handle
);
954 ocfs2_unlock_global_qf(oinfo
, 1);
961 /* This should happen only after set_dqinfo(). */
962 static int ocfs2_write_info(struct super_block
*sb
, int type
)
966 struct ocfs2_mem_dqinfo
*oinfo
= sb_dqinfo(sb
, type
)->dqi_priv
;
968 status
= ocfs2_lock_global_qf(oinfo
, 1);
971 handle
= ocfs2_start_trans(OCFS2_SB(sb
), OCFS2_QINFO_WRITE_CREDITS
);
972 if (IS_ERR(handle
)) {
973 status
= PTR_ERR(handle
);
977 status
= dquot_commit_info(sb
, type
);
978 ocfs2_commit_trans(OCFS2_SB(sb
), handle
);
980 ocfs2_unlock_global_qf(oinfo
, 1);
987 static struct dquot
*ocfs2_alloc_dquot(struct super_block
*sb
, int type
)
989 struct ocfs2_dquot
*dquot
=
990 kmem_cache_zalloc(ocfs2_dquot_cachep
, GFP_NOFS
);
994 return &dquot
->dq_dquot
;
997 static void ocfs2_destroy_dquot(struct dquot
*dquot
)
999 kmem_cache_free(ocfs2_dquot_cachep
, dquot
);
1002 const struct dquot_operations ocfs2_quota_operations
= {
1003 /* We never make dquot dirty so .write_dquot is never called */
1004 .acquire_dquot
= ocfs2_acquire_dquot
,
1005 .release_dquot
= ocfs2_release_dquot
,
1006 .mark_dirty
= ocfs2_mark_dquot_dirty
,
1007 .write_info
= ocfs2_write_info
,
1008 .alloc_dquot
= ocfs2_alloc_dquot
,
1009 .destroy_dquot
= ocfs2_destroy_dquot
,
1010 .get_next_id
= ocfs2_get_next_id
,