2 * Implementation of operations over local quota file
6 #include <linux/quota.h>
7 #include <linux/quotaops.h>
8 #include <linux/module.h>
10 #define MLOG_MASK_PREFIX ML_QUOTA
11 #include <cluster/masklog.h>
18 #include "buffer_head_io.h"
24 /* Number of local quota structures per block */
25 static inline unsigned int ol_quota_entries_per_block(struct super_block *sb)
27 return ((sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE) /
28 sizeof(struct ocfs2_local_disk_dqblk));
31 /* Number of blocks with entries in one chunk */
32 static inline unsigned int ol_chunk_blocks(struct super_block *sb)
34 return ((sb->s_blocksize - sizeof(struct ocfs2_local_disk_chunk) -
35 OCFS2_QBLK_RESERVED_SPACE) << 3) /
36 ol_quota_entries_per_block(sb);
39 /* Number of entries in a chunk bitmap */
40 static unsigned int ol_chunk_entries(struct super_block *sb)
42 return ol_chunk_blocks(sb) * ol_quota_entries_per_block(sb);
45 /* Offset of the chunk in quota file */
46 static unsigned int ol_quota_chunk_block(struct super_block *sb, int c)
48 /* 1 block for local quota file info, 1 block per chunk for chunk info */
49 return 1 + (ol_chunk_blocks(sb) + 1) * c;
52 static unsigned int ol_dqblk_block(struct super_block *sb, int c, int off)
54 int epb = ol_quota_entries_per_block(sb);
56 return ol_quota_chunk_block(sb, c) + 1 + off / epb;
59 static unsigned int ol_dqblk_block_off(struct super_block *sb, int c, int off)
61 int epb = ol_quota_entries_per_block(sb);
63 return (off % epb) * sizeof(struct ocfs2_local_disk_dqblk);
66 /* Offset of the dquot structure in the quota file */
67 static loff_t ol_dqblk_off(struct super_block *sb, int c, int off)
69 return (ol_dqblk_block(sb, c, off) << sb->s_blocksize_bits) +
70 ol_dqblk_block_off(sb, c, off);
73 /* Compute block number from given offset */
74 static inline unsigned int ol_dqblk_file_block(struct super_block *sb, loff_t off)
76 return off >> sb->s_blocksize_bits;
79 static inline unsigned int ol_dqblk_block_offset(struct super_block *sb, loff_t off)
81 return off & ((1 << sb->s_blocksize_bits) - 1);
84 /* Compute offset in the chunk of a structure with the given offset */
85 static int ol_dqblk_chunk_off(struct super_block *sb, int c, loff_t off)
87 int epb = ol_quota_entries_per_block(sb);
89 return ((off >> sb->s_blocksize_bits) -
90 ol_quota_chunk_block(sb, c) - 1) * epb
91 + ((unsigned int)(off & ((1 << sb->s_blocksize_bits) - 1))) /
92 sizeof(struct ocfs2_local_disk_dqblk);
95 /* Write bufferhead into the fs */
96 static int ocfs2_modify_bh(struct inode *inode, struct buffer_head *bh,
97 void (*modify)(struct buffer_head *, void *), void *private)
99 struct super_block *sb = inode->i_sb;
103 handle = ocfs2_start_trans(OCFS2_SB(sb), 1);
104 if (IS_ERR(handle)) {
105 status = PTR_ERR(handle);
109 status = ocfs2_journal_access(handle, inode, bh,
110 OCFS2_JOURNAL_ACCESS_WRITE);
113 ocfs2_commit_trans(OCFS2_SB(sb), handle);
119 status = ocfs2_journal_dirty(handle, bh);
122 ocfs2_commit_trans(OCFS2_SB(sb), handle);
125 status = ocfs2_commit_trans(OCFS2_SB(sb), handle);
133 /* Check whether we understand format of quota files */
134 static int ocfs2_local_check_quota_file(struct super_block *sb, int type)
136 unsigned int lmagics[MAXQUOTAS] = OCFS2_LOCAL_QMAGICS;
137 unsigned int lversions[MAXQUOTAS] = OCFS2_LOCAL_QVERSIONS;
138 unsigned int gmagics[MAXQUOTAS] = OCFS2_GLOBAL_QMAGICS;
139 unsigned int gversions[MAXQUOTAS] = OCFS2_GLOBAL_QVERSIONS;
140 unsigned int ino[MAXQUOTAS] = { USER_QUOTA_SYSTEM_INODE,
141 GROUP_QUOTA_SYSTEM_INODE };
142 struct buffer_head *bh;
143 struct inode *linode = sb_dqopt(sb)->files[type];
144 struct inode *ginode = NULL;
145 struct ocfs2_disk_dqheader *dqhead;
148 /* First check whether we understand local quota file */
149 bh = ocfs2_read_quota_block(linode, 0, &status);
152 mlog(ML_ERROR, "failed to read quota file header (type=%d)\n",
156 dqhead = (struct ocfs2_disk_dqheader *)(bh->b_data);
157 if (le32_to_cpu(dqhead->dqh_magic) != lmagics[type]) {
158 mlog(ML_ERROR, "quota file magic does not match (%u != %u),"
159 " type=%d\n", le32_to_cpu(dqhead->dqh_magic),
160 lmagics[type], type);
163 if (le32_to_cpu(dqhead->dqh_version) != lversions[type]) {
164 mlog(ML_ERROR, "quota file version does not match (%u != %u),"
165 " type=%d\n", le32_to_cpu(dqhead->dqh_version),
166 lversions[type], type);
172 /* Next check whether we understand global quota file */
173 ginode = ocfs2_get_system_file_inode(OCFS2_SB(sb), ino[type],
176 mlog(ML_ERROR, "cannot get global quota file inode "
177 "(type=%d)\n", type);
180 /* Since the header is read only, we don't care about locking */
181 bh = ocfs2_read_quota_block(ginode, 0, &status);
184 mlog(ML_ERROR, "failed to read global quota file header "
185 "(type=%d)\n", type);
188 dqhead = (struct ocfs2_disk_dqheader *)(bh->b_data);
189 if (le32_to_cpu(dqhead->dqh_magic) != gmagics[type]) {
190 mlog(ML_ERROR, "global quota file magic does not match "
191 "(%u != %u), type=%d\n",
192 le32_to_cpu(dqhead->dqh_magic), gmagics[type], type);
195 if (le32_to_cpu(dqhead->dqh_version) != gversions[type]) {
196 mlog(ML_ERROR, "global quota file version does not match "
197 "(%u != %u), type=%d\n",
198 le32_to_cpu(dqhead->dqh_version), gversions[type],
210 /* Release given list of quota file chunks */
211 static void ocfs2_release_local_quota_bitmaps(struct list_head *head)
213 struct ocfs2_quota_chunk *pos, *next;
215 list_for_each_entry_safe(pos, next, head, qc_chunk) {
216 list_del(&pos->qc_chunk);
217 brelse(pos->qc_headerbh);
218 kmem_cache_free(ocfs2_qf_chunk_cachep, pos);
222 /* Load quota bitmaps into memory */
223 static int ocfs2_load_local_quota_bitmaps(struct inode *inode,
224 struct ocfs2_local_disk_dqinfo *ldinfo,
225 struct list_head *head)
227 struct ocfs2_quota_chunk *newchunk;
230 INIT_LIST_HEAD(head);
231 for (i = 0; i < le32_to_cpu(ldinfo->dqi_chunks); i++) {
232 newchunk = kmem_cache_alloc(ocfs2_qf_chunk_cachep, GFP_NOFS);
234 ocfs2_release_local_quota_bitmaps(head);
237 newchunk->qc_num = i;
238 newchunk->qc_headerbh = ocfs2_read_quota_block(inode,
239 ol_quota_chunk_block(inode->i_sb, i),
241 if (!newchunk->qc_headerbh) {
243 kmem_cache_free(ocfs2_qf_chunk_cachep, newchunk);
244 ocfs2_release_local_quota_bitmaps(head);
247 list_add_tail(&newchunk->qc_chunk, head);
252 static void olq_update_info(struct buffer_head *bh, void *private)
254 struct mem_dqinfo *info = private;
255 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
256 struct ocfs2_local_disk_dqinfo *ldinfo;
258 ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data +
259 OCFS2_LOCAL_INFO_OFF);
260 spin_lock(&dq_data_lock);
261 ldinfo->dqi_flags = cpu_to_le32(info->dqi_flags & DQF_MASK);
262 ldinfo->dqi_chunks = cpu_to_le32(oinfo->dqi_chunks);
263 ldinfo->dqi_blocks = cpu_to_le32(oinfo->dqi_blocks);
264 spin_unlock(&dq_data_lock);
267 static int ocfs2_add_recovery_chunk(struct super_block *sb,
268 struct ocfs2_local_disk_chunk *dchunk,
270 struct list_head *head)
272 struct ocfs2_recovery_chunk *rc;
274 rc = kmalloc(sizeof(struct ocfs2_recovery_chunk), GFP_NOFS);
277 rc->rc_chunk = chunk;
278 rc->rc_bitmap = kmalloc(sb->s_blocksize, GFP_NOFS);
279 if (!rc->rc_bitmap) {
283 memcpy(rc->rc_bitmap, dchunk->dqc_bitmap,
284 (ol_chunk_entries(sb) + 7) >> 3);
285 list_add_tail(&rc->rc_list, head);
289 static void free_recovery_list(struct list_head *head)
291 struct ocfs2_recovery_chunk *next;
292 struct ocfs2_recovery_chunk *rchunk;
294 list_for_each_entry_safe(rchunk, next, head, rc_list) {
295 list_del(&rchunk->rc_list);
296 kfree(rchunk->rc_bitmap);
301 void ocfs2_free_quota_recovery(struct ocfs2_quota_recovery *rec)
305 for (type = 0; type < MAXQUOTAS; type++)
306 free_recovery_list(&(rec->r_list[type]));
310 /* Load entries in our quota file we have to recover*/
311 static int ocfs2_recovery_load_quota(struct inode *lqinode,
312 struct ocfs2_local_disk_dqinfo *ldinfo,
314 struct list_head *head)
316 struct super_block *sb = lqinode->i_sb;
317 struct buffer_head *hbh;
318 struct ocfs2_local_disk_chunk *dchunk;
319 int i, chunks = le32_to_cpu(ldinfo->dqi_chunks);
322 for (i = 0; i < chunks; i++) {
323 hbh = ocfs2_read_quota_block(lqinode,
324 ol_quota_chunk_block(sb, i),
330 dchunk = (struct ocfs2_local_disk_chunk *)hbh->b_data;
331 if (le32_to_cpu(dchunk->dqc_free) < ol_chunk_entries(sb))
332 status = ocfs2_add_recovery_chunk(sb, dchunk, i, head);
338 free_recovery_list(head);
342 static struct ocfs2_quota_recovery *ocfs2_alloc_quota_recovery(void)
345 struct ocfs2_quota_recovery *rec;
347 rec = kmalloc(sizeof(struct ocfs2_quota_recovery), GFP_NOFS);
350 for (type = 0; type < MAXQUOTAS; type++)
351 INIT_LIST_HEAD(&(rec->r_list[type]));
355 /* Load information we need for quota recovery into memory */
356 struct ocfs2_quota_recovery *ocfs2_begin_quota_recovery(
357 struct ocfs2_super *osb,
360 unsigned int feature[MAXQUOTAS] = { OCFS2_FEATURE_RO_COMPAT_USRQUOTA,
361 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA};
362 unsigned int ino[MAXQUOTAS] = { LOCAL_USER_QUOTA_SYSTEM_INODE,
363 LOCAL_GROUP_QUOTA_SYSTEM_INODE };
364 struct super_block *sb = osb->sb;
365 struct ocfs2_local_disk_dqinfo *ldinfo;
366 struct inode *lqinode;
367 struct buffer_head *bh;
370 struct ocfs2_quota_recovery *rec;
372 mlog(ML_NOTICE, "Beginning quota recovery in slot %u\n", slot_num);
373 rec = ocfs2_alloc_quota_recovery();
375 return ERR_PTR(-ENOMEM);
378 for (type = 0; type < MAXQUOTAS; type++) {
379 if (!OCFS2_HAS_RO_COMPAT_FEATURE(sb, feature[type]))
381 /* At this point, journal of the slot is already replayed so
382 * we can trust metadata and data of the quota file */
383 lqinode = ocfs2_get_system_file_inode(osb, ino[type], slot_num);
388 status = ocfs2_inode_lock_full(lqinode, NULL, 1,
389 OCFS2_META_LOCK_RECOVERY);
394 /* Now read local header */
395 bh = ocfs2_read_quota_block(lqinode, 0, &status);
398 mlog(ML_ERROR, "failed to read quota file info header "
399 "(slot=%d type=%d)\n", slot_num, type);
402 ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data +
403 OCFS2_LOCAL_INFO_OFF);
404 status = ocfs2_recovery_load_quota(lqinode, ldinfo, type,
408 ocfs2_inode_unlock(lqinode, 1);
416 ocfs2_free_quota_recovery(rec);
417 rec = ERR_PTR(status);
422 /* Sync changes in local quota file into global quota file and
423 * reinitialize local quota file.
424 * The function expects local quota file to be already locked and
425 * dqonoff_mutex locked. */
426 static int ocfs2_recover_local_quota_file(struct inode *lqinode,
428 struct ocfs2_quota_recovery *rec)
430 struct super_block *sb = lqinode->i_sb;
431 struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv;
432 struct ocfs2_local_disk_chunk *dchunk;
433 struct ocfs2_local_disk_dqblk *dqblk;
436 struct buffer_head *hbh = NULL, *qbh = NULL;
439 struct ocfs2_recovery_chunk *rchunk, *next;
440 qsize_t spacechange, inodechange;
442 mlog_entry("ino=%lu type=%u", (unsigned long)lqinode->i_ino, type);
444 status = ocfs2_lock_global_qf(oinfo, 1);
448 list_for_each_entry_safe(rchunk, next, &(rec->r_list[type]), rc_list) {
449 chunk = rchunk->rc_chunk;
450 hbh = ocfs2_read_quota_block(lqinode,
451 ol_quota_chunk_block(sb, chunk),
457 dchunk = (struct ocfs2_local_disk_chunk *)hbh->b_data;
458 for_each_bit(bit, rchunk->rc_bitmap, ol_chunk_entries(sb)) {
459 qbh = ocfs2_read_quota_block(lqinode,
460 ol_dqblk_block(sb, chunk, bit),
466 dqblk = (struct ocfs2_local_disk_dqblk *)(qbh->b_data +
467 ol_dqblk_block_off(sb, chunk, bit));
468 dquot = dqget(sb, le64_to_cpu(dqblk->dqb_id), type);
471 mlog(ML_ERROR, "Failed to get quota structure "
472 "for id %u, type %d. Cannot finish quota "
474 (unsigned)le64_to_cpu(dqblk->dqb_id),
478 handle = ocfs2_start_trans(OCFS2_SB(sb),
479 OCFS2_QSYNC_CREDITS);
480 if (IS_ERR(handle)) {
481 status = PTR_ERR(handle);
485 mutex_lock(&sb_dqopt(sb)->dqio_mutex);
486 spin_lock(&dq_data_lock);
487 /* Add usage from quota entry into quota changes
488 * of our node. Auxiliary variables are important
489 * due to signedness */
490 spacechange = le64_to_cpu(dqblk->dqb_spacemod);
491 inodechange = le64_to_cpu(dqblk->dqb_inodemod);
492 dquot->dq_dqb.dqb_curspace += spacechange;
493 dquot->dq_dqb.dqb_curinodes += inodechange;
494 spin_unlock(&dq_data_lock);
495 /* We want to drop reference held by the crashed
496 * node. Since we have our own reference we know
497 * global structure actually won't be freed. */
498 status = ocfs2_global_release_dquot(dquot);
503 /* Release local quota file entry */
504 status = ocfs2_journal_access(handle, lqinode,
505 qbh, OCFS2_JOURNAL_ACCESS_WRITE);
511 WARN_ON(!ocfs2_test_bit(bit, dchunk->dqc_bitmap));
512 ocfs2_clear_bit(bit, dchunk->dqc_bitmap);
513 le32_add_cpu(&dchunk->dqc_free, 1);
515 status = ocfs2_journal_dirty(handle, qbh);
519 mutex_unlock(&sb_dqopt(sb)->dqio_mutex);
520 ocfs2_commit_trans(OCFS2_SB(sb), handle);
529 list_del(&rchunk->rc_list);
530 kfree(rchunk->rc_bitmap);
535 ocfs2_unlock_global_qf(oinfo, 1);
538 free_recovery_list(&(rec->r_list[type]));
543 /* Recover local quota files for given node different from us */
544 int ocfs2_finish_quota_recovery(struct ocfs2_super *osb,
545 struct ocfs2_quota_recovery *rec,
548 unsigned int ino[MAXQUOTAS] = { LOCAL_USER_QUOTA_SYSTEM_INODE,
549 LOCAL_GROUP_QUOTA_SYSTEM_INODE };
550 struct super_block *sb = osb->sb;
551 struct ocfs2_local_disk_dqinfo *ldinfo;
552 struct buffer_head *bh;
556 struct inode *lqinode;
559 mlog(ML_NOTICE, "Finishing quota recovery in slot %u\n", slot_num);
560 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
561 for (type = 0; type < MAXQUOTAS; type++) {
562 if (list_empty(&(rec->r_list[type])))
564 mlog(0, "Recovering quota in slot %d\n", slot_num);
565 lqinode = ocfs2_get_system_file_inode(osb, ino[type], slot_num);
570 status = ocfs2_inode_lock_full(lqinode, NULL, 1,
571 OCFS2_META_LOCK_NOQUEUE);
572 /* Someone else is holding the lock? Then he must be
573 * doing the recovery. Just skip the file... */
574 if (status == -EAGAIN) {
575 mlog(ML_NOTICE, "skipping quota recovery for slot %d "
576 "because quota file is locked.\n", slot_num);
579 } else if (status < 0) {
583 /* Now read local header */
584 bh = ocfs2_read_quota_block(lqinode, 0, &status);
587 mlog(ML_ERROR, "failed to read quota file info header "
588 "(slot=%d type=%d)\n", slot_num, type);
591 ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data +
592 OCFS2_LOCAL_INFO_OFF);
593 /* Is recovery still needed? */
594 flags = le32_to_cpu(ldinfo->dqi_flags);
595 if (!(flags & OLQF_CLEAN))
596 status = ocfs2_recover_local_quota_file(lqinode,
599 /* We don't want to mark file as clean when it is actually
601 if (slot_num == osb->slot_num)
603 /* Mark quota file as clean if we are recovering quota file of
604 * some other node. */
605 handle = ocfs2_start_trans(osb, 1);
606 if (IS_ERR(handle)) {
607 status = PTR_ERR(handle);
611 status = ocfs2_journal_access(handle, lqinode, bh,
612 OCFS2_JOURNAL_ACCESS_WRITE);
618 ldinfo->dqi_flags = cpu_to_le32(flags | OLQF_CLEAN);
620 status = ocfs2_journal_dirty(handle, bh);
624 ocfs2_commit_trans(osb, handle);
628 ocfs2_inode_unlock(lqinode, 1);
635 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
640 /* Read information header from quota file */
641 static int ocfs2_local_read_info(struct super_block *sb, int type)
643 struct ocfs2_local_disk_dqinfo *ldinfo;
644 struct mem_dqinfo *info = sb_dqinfo(sb, type);
645 struct ocfs2_mem_dqinfo *oinfo;
646 struct inode *lqinode = sb_dqopt(sb)->files[type];
648 struct buffer_head *bh = NULL;
649 struct ocfs2_quota_recovery *rec;
652 info->dqi_maxblimit = 0x7fffffffffffffffLL;
653 info->dqi_maxilimit = 0x7fffffffffffffffLL;
654 oinfo = kmalloc(sizeof(struct ocfs2_mem_dqinfo), GFP_NOFS);
656 mlog(ML_ERROR, "failed to allocate memory for ocfs2 quota"
660 info->dqi_priv = oinfo;
661 oinfo->dqi_type = type;
662 INIT_LIST_HEAD(&oinfo->dqi_chunk);
663 oinfo->dqi_rec = NULL;
664 oinfo->dqi_lqi_bh = NULL;
665 oinfo->dqi_ibh = NULL;
667 status = ocfs2_global_read_info(sb, type);
671 status = ocfs2_inode_lock(lqinode, &oinfo->dqi_lqi_bh, 1);
678 /* Now read local header */
679 bh = ocfs2_read_quota_block(lqinode, 0, &status);
682 mlog(ML_ERROR, "failed to read quota file info header "
683 "(type=%d)\n", type);
686 ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data +
687 OCFS2_LOCAL_INFO_OFF);
688 info->dqi_flags = le32_to_cpu(ldinfo->dqi_flags);
689 oinfo->dqi_chunks = le32_to_cpu(ldinfo->dqi_chunks);
690 oinfo->dqi_blocks = le32_to_cpu(ldinfo->dqi_blocks);
693 /* We crashed when using local quota file? */
694 if (!(info->dqi_flags & OLQF_CLEAN)) {
695 rec = OCFS2_SB(sb)->quota_rec;
697 rec = ocfs2_alloc_quota_recovery();
703 OCFS2_SB(sb)->quota_rec = rec;
706 status = ocfs2_recovery_load_quota(lqinode, ldinfo, type,
714 status = ocfs2_load_local_quota_bitmaps(lqinode,
722 /* Now mark quota file as used */
723 info->dqi_flags &= ~OLQF_CLEAN;
724 status = ocfs2_modify_bh(lqinode, bh, olq_update_info, info);
733 iput(oinfo->dqi_gqinode);
734 ocfs2_simple_drop_lockres(OCFS2_SB(sb), &oinfo->dqi_gqlock);
735 ocfs2_lock_res_free(&oinfo->dqi_gqlock);
736 brelse(oinfo->dqi_lqi_bh);
738 ocfs2_inode_unlock(lqinode, 1);
739 ocfs2_release_local_quota_bitmaps(&oinfo->dqi_chunk);
746 /* Write local info to quota file */
747 static int ocfs2_local_write_info(struct super_block *sb, int type)
749 struct mem_dqinfo *info = sb_dqinfo(sb, type);
750 struct buffer_head *bh = ((struct ocfs2_mem_dqinfo *)info->dqi_priv)
754 status = ocfs2_modify_bh(sb_dqopt(sb)->files[type], bh, olq_update_info,
764 /* Release info from memory */
765 static int ocfs2_local_free_info(struct super_block *sb, int type)
767 struct mem_dqinfo *info = sb_dqinfo(sb, type);
768 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
769 struct ocfs2_quota_chunk *chunk;
770 struct ocfs2_local_disk_chunk *dchunk;
771 int mark_clean = 1, len;
774 /* At this point we know there are no more dquots and thus
775 * even if there's some sync in the pdflush queue, it won't
776 * find any dquots and return without doing anything */
777 cancel_delayed_work_sync(&oinfo->dqi_sync_work);
778 iput(oinfo->dqi_gqinode);
779 ocfs2_simple_drop_lockres(OCFS2_SB(sb), &oinfo->dqi_gqlock);
780 ocfs2_lock_res_free(&oinfo->dqi_gqlock);
781 list_for_each_entry(chunk, &oinfo->dqi_chunk, qc_chunk) {
782 dchunk = (struct ocfs2_local_disk_chunk *)
783 (chunk->qc_headerbh->b_data);
784 if (chunk->qc_num < oinfo->dqi_chunks - 1) {
785 len = ol_chunk_entries(sb);
787 len = (oinfo->dqi_blocks -
788 ol_quota_chunk_block(sb, chunk->qc_num) - 1)
789 * ol_quota_entries_per_block(sb);
791 /* Not all entries free? Bug! */
792 if (le32_to_cpu(dchunk->dqc_free) != len) {
793 mlog(ML_ERROR, "releasing quota file with used "
794 "entries (type=%d)\n", type);
798 ocfs2_release_local_quota_bitmaps(&oinfo->dqi_chunk);
800 /* dqonoff_mutex protects us against racing with recovery thread... */
801 if (oinfo->dqi_rec) {
802 ocfs2_free_quota_recovery(oinfo->dqi_rec);
809 /* Mark local file as clean */
810 info->dqi_flags |= OLQF_CLEAN;
811 status = ocfs2_modify_bh(sb_dqopt(sb)->files[type],
821 ocfs2_inode_unlock(sb_dqopt(sb)->files[type], 1);
822 brelse(oinfo->dqi_ibh);
823 brelse(oinfo->dqi_lqi_bh);
828 static void olq_set_dquot(struct buffer_head *bh, void *private)
830 struct ocfs2_dquot *od = private;
831 struct ocfs2_local_disk_dqblk *dqblk;
832 struct super_block *sb = od->dq_dquot.dq_sb;
834 dqblk = (struct ocfs2_local_disk_dqblk *)(bh->b_data
835 + ol_dqblk_block_offset(sb, od->dq_local_off));
837 dqblk->dqb_id = cpu_to_le64(od->dq_dquot.dq_id);
838 spin_lock(&dq_data_lock);
839 dqblk->dqb_spacemod = cpu_to_le64(od->dq_dquot.dq_dqb.dqb_curspace -
841 dqblk->dqb_inodemod = cpu_to_le64(od->dq_dquot.dq_dqb.dqb_curinodes -
843 spin_unlock(&dq_data_lock);
844 mlog(0, "Writing local dquot %u space %lld inodes %lld\n",
845 od->dq_dquot.dq_id, dqblk->dqb_spacemod, dqblk->dqb_inodemod);
848 /* Write dquot to local quota file */
849 static int ocfs2_local_write_dquot(struct dquot *dquot)
851 struct super_block *sb = dquot->dq_sb;
852 struct ocfs2_dquot *od = OCFS2_DQUOT(dquot);
853 struct buffer_head *bh;
856 bh = ocfs2_read_quota_block(sb_dqopt(sb)->files[dquot->dq_type],
857 ol_dqblk_file_block(sb, od->dq_local_off),
863 status = ocfs2_modify_bh(sb_dqopt(sb)->files[dquot->dq_type], bh,
874 /* Find free entry in local quota file */
875 static struct ocfs2_quota_chunk *ocfs2_find_free_entry(struct super_block *sb,
879 struct mem_dqinfo *info = sb_dqinfo(sb, type);
880 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
881 struct ocfs2_quota_chunk *chunk;
882 struct ocfs2_local_disk_chunk *dchunk;
885 list_for_each_entry(chunk, &oinfo->dqi_chunk, qc_chunk) {
886 dchunk = (struct ocfs2_local_disk_chunk *)
887 chunk->qc_headerbh->b_data;
888 if (le32_to_cpu(dchunk->dqc_free) > 0) {
896 if (chunk->qc_num < oinfo->dqi_chunks - 1) {
897 len = ol_chunk_entries(sb);
899 len = (oinfo->dqi_blocks -
900 ol_quota_chunk_block(sb, chunk->qc_num) - 1)
901 * ol_quota_entries_per_block(sb);
904 found = ocfs2_find_next_zero_bit(dchunk->dqc_bitmap, len, 0);
907 mlog(ML_ERROR, "Did not find empty entry in chunk %d with %u"
908 " entries free (type=%d)\n", chunk->qc_num,
909 le32_to_cpu(dchunk->dqc_free), type);
910 return ERR_PTR(-EIO);
916 /* Add new chunk to the local quota file */
917 static struct ocfs2_quota_chunk *ocfs2_local_quota_add_chunk(
918 struct super_block *sb,
922 struct mem_dqinfo *info = sb_dqinfo(sb, type);
923 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
924 struct inode *lqinode = sb_dqopt(sb)->files[type];
925 struct ocfs2_quota_chunk *chunk = NULL;
926 struct ocfs2_local_disk_chunk *dchunk;
929 struct buffer_head *bh = NULL;
932 /* We are protected by dqio_sem so no locking needed */
933 status = ocfs2_extend_no_holes(lqinode,
934 lqinode->i_size + 2 * sb->s_blocksize,
940 status = ocfs2_simple_size_update(lqinode, oinfo->dqi_lqi_bh,
941 lqinode->i_size + 2 * sb->s_blocksize);
947 chunk = kmem_cache_alloc(ocfs2_qf_chunk_cachep, GFP_NOFS);
954 down_read(&OCFS2_I(lqinode)->ip_alloc_sem);
955 status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks,
956 &p_blkno, NULL, NULL);
957 up_read(&OCFS2_I(lqinode)->ip_alloc_sem);
962 bh = sb_getblk(sb, p_blkno);
968 dchunk = (struct ocfs2_local_disk_chunk *)bh->b_data;
970 handle = ocfs2_start_trans(OCFS2_SB(sb), 2);
971 if (IS_ERR(handle)) {
972 status = PTR_ERR(handle);
977 status = ocfs2_journal_access(handle, lqinode, bh,
978 OCFS2_JOURNAL_ACCESS_WRITE);
984 dchunk->dqc_free = ol_quota_entries_per_block(sb);
985 memset(dchunk->dqc_bitmap, 0,
986 sb->s_blocksize - sizeof(struct ocfs2_local_disk_chunk) -
987 OCFS2_QBLK_RESERVED_SPACE);
988 set_buffer_uptodate(bh);
990 status = ocfs2_journal_dirty(handle, bh);
996 oinfo->dqi_blocks += 2;
998 status = ocfs2_local_write_info(sb, type);
1003 status = ocfs2_commit_trans(OCFS2_SB(sb), handle);
1009 list_add_tail(&chunk->qc_chunk, &oinfo->dqi_chunk);
1010 chunk->qc_num = list_entry(chunk->qc_chunk.prev,
1011 struct ocfs2_quota_chunk,
1012 qc_chunk)->qc_num + 1;
1013 chunk->qc_headerbh = bh;
1017 ocfs2_commit_trans(OCFS2_SB(sb), handle);
1020 kmem_cache_free(ocfs2_qf_chunk_cachep, chunk);
1021 return ERR_PTR(status);
1024 /* Find free entry in local quota file */
1025 static struct ocfs2_quota_chunk *ocfs2_extend_local_quota_file(
1026 struct super_block *sb,
1030 struct mem_dqinfo *info = sb_dqinfo(sb, type);
1031 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
1032 struct ocfs2_quota_chunk *chunk;
1033 struct inode *lqinode = sb_dqopt(sb)->files[type];
1034 struct ocfs2_local_disk_chunk *dchunk;
1035 int epb = ol_quota_entries_per_block(sb);
1036 unsigned int chunk_blocks;
1040 if (list_empty(&oinfo->dqi_chunk))
1041 return ocfs2_local_quota_add_chunk(sb, type, offset);
1042 /* Is the last chunk full? */
1043 chunk = list_entry(oinfo->dqi_chunk.prev,
1044 struct ocfs2_quota_chunk, qc_chunk);
1045 chunk_blocks = oinfo->dqi_blocks -
1046 ol_quota_chunk_block(sb, chunk->qc_num) - 1;
1047 if (ol_chunk_blocks(sb) == chunk_blocks)
1048 return ocfs2_local_quota_add_chunk(sb, type, offset);
1050 /* We are protected by dqio_sem so no locking needed */
1051 status = ocfs2_extend_no_holes(lqinode,
1052 lqinode->i_size + sb->s_blocksize,
1058 status = ocfs2_simple_size_update(lqinode, oinfo->dqi_lqi_bh,
1059 lqinode->i_size + sb->s_blocksize);
1064 handle = ocfs2_start_trans(OCFS2_SB(sb), 2);
1065 if (IS_ERR(handle)) {
1066 status = PTR_ERR(handle);
1070 status = ocfs2_journal_access(handle, lqinode, chunk->qc_headerbh,
1071 OCFS2_JOURNAL_ACCESS_WRITE);
1077 dchunk = (struct ocfs2_local_disk_chunk *)chunk->qc_headerbh->b_data;
1078 lock_buffer(chunk->qc_headerbh);
1079 le32_add_cpu(&dchunk->dqc_free, ol_quota_entries_per_block(sb));
1080 unlock_buffer(chunk->qc_headerbh);
1081 status = ocfs2_journal_dirty(handle, chunk->qc_headerbh);
1086 oinfo->dqi_blocks++;
1087 status = ocfs2_local_write_info(sb, type);
1093 status = ocfs2_commit_trans(OCFS2_SB(sb), handle);
1098 *offset = chunk_blocks * epb;
1101 ocfs2_commit_trans(OCFS2_SB(sb), handle);
1103 return ERR_PTR(status);
1106 void olq_alloc_dquot(struct buffer_head *bh, void *private)
1108 int *offset = private;
1109 struct ocfs2_local_disk_chunk *dchunk;
1111 dchunk = (struct ocfs2_local_disk_chunk *)bh->b_data;
1112 ocfs2_set_bit(*offset, dchunk->dqc_bitmap);
1113 le32_add_cpu(&dchunk->dqc_free, -1);
1116 /* Create dquot in the local file for given id */
1117 static int ocfs2_create_local_dquot(struct dquot *dquot)
1119 struct super_block *sb = dquot->dq_sb;
1120 int type = dquot->dq_type;
1121 struct inode *lqinode = sb_dqopt(sb)->files[type];
1122 struct ocfs2_quota_chunk *chunk;
1123 struct ocfs2_dquot *od = OCFS2_DQUOT(dquot);
1127 chunk = ocfs2_find_free_entry(sb, type, &offset);
1129 chunk = ocfs2_extend_local_quota_file(sb, type, &offset);
1131 return PTR_ERR(chunk);
1132 } else if (IS_ERR(chunk)) {
1133 return PTR_ERR(chunk);
1135 od->dq_local_off = ol_dqblk_off(sb, chunk->qc_num, offset);
1136 od->dq_chunk = chunk;
1138 /* Initialize dquot structure on disk */
1139 status = ocfs2_local_write_dquot(dquot);
1145 /* Mark structure as allocated */
1146 status = ocfs2_modify_bh(lqinode, chunk->qc_headerbh, olq_alloc_dquot,
1156 /* Create entry in local file for dquot, load data from the global file */
1157 static int ocfs2_local_read_dquot(struct dquot *dquot)
1161 mlog_entry("id=%u, type=%d\n", dquot->dq_id, dquot->dq_type);
1163 status = ocfs2_global_read_dquot(dquot);
1169 /* Now create entry in the local quota file */
1170 status = ocfs2_create_local_dquot(dquot);
1182 /* Release dquot structure from local quota file. ocfs2_release_dquot() has
1183 * already started a transaction and obtained exclusive lock for global
1185 static int ocfs2_local_release_dquot(struct dquot *dquot)
1188 int type = dquot->dq_type;
1189 struct ocfs2_dquot *od = OCFS2_DQUOT(dquot);
1190 struct super_block *sb = dquot->dq_sb;
1191 struct ocfs2_local_disk_chunk *dchunk;
1193 handle_t *handle = journal_current_handle();
1196 /* First write all local changes to global file */
1197 status = ocfs2_global_release_dquot(dquot);
1203 status = ocfs2_journal_access(handle, sb_dqopt(sb)->files[type],
1204 od->dq_chunk->qc_headerbh, OCFS2_JOURNAL_ACCESS_WRITE);
1209 offset = ol_dqblk_chunk_off(sb, od->dq_chunk->qc_num,
1211 dchunk = (struct ocfs2_local_disk_chunk *)
1212 (od->dq_chunk->qc_headerbh->b_data);
1213 /* Mark structure as freed */
1214 lock_buffer(od->dq_chunk->qc_headerbh);
1215 ocfs2_clear_bit(offset, dchunk->dqc_bitmap);
1216 le32_add_cpu(&dchunk->dqc_free, 1);
1217 unlock_buffer(od->dq_chunk->qc_headerbh);
1218 status = ocfs2_journal_dirty(handle, od->dq_chunk->qc_headerbh);
1225 /* Clear the read bit so that next time someone uses this
1226 * dquot he reads fresh info from disk and allocates local
1227 * dquot structure */
1228 clear_bit(DQ_READ_B, &dquot->dq_flags);
1232 static struct quota_format_ops ocfs2_format_ops = {
1233 .check_quota_file = ocfs2_local_check_quota_file,
1234 .read_file_info = ocfs2_local_read_info,
1235 .write_file_info = ocfs2_global_write_info,
1236 .free_file_info = ocfs2_local_free_info,
1237 .read_dqblk = ocfs2_local_read_dquot,
1238 .commit_dqblk = ocfs2_local_write_dquot,
1239 .release_dqblk = ocfs2_local_release_dquot,
1242 struct quota_format_type ocfs2_quota_format = {
1243 .qf_fmt_id = QFMT_OCFS2,
1244 .qf_ops = &ocfs2_format_ops,
1245 .qf_owner = THIS_MODULE