1/* 2 * Implementation of operations over local quota file 3 */ 4 5#include <linux/fs.h> 6#include <linux/slab.h> 7#include <linux/quota.h> 8#include <linux/quotaops.h> 9#include <linux/module.h> 10 11#define MLOG_MASK_PREFIX ML_QUOTA 12#include <cluster/masklog.h> 13 14#include "ocfs2_fs.h" 15#include "ocfs2.h" 16#include "inode.h" 17#include "alloc.h" 18#include "file.h" 19#include "buffer_head_io.h" 20#include "journal.h" 21#include "sysfile.h" 22#include "dlmglue.h" 23#include "quota.h" 24#include "uptodate.h" 25#include "super.h" 26 27/* Number of local quota structures per block */ 28static inline unsigned int ol_quota_entries_per_block(struct super_block *sb) 29{ 30 return ((sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE) / 31 sizeof(struct ocfs2_local_disk_dqblk)); 32} 33 34/* Number of blocks with entries in one chunk */ 35static inline unsigned int ol_chunk_blocks(struct super_block *sb) 36{ 37 return ((sb->s_blocksize - sizeof(struct ocfs2_local_disk_chunk) - 38 OCFS2_QBLK_RESERVED_SPACE) << 3) / 39 ol_quota_entries_per_block(sb); 40} 41 42/* Number of entries in a chunk bitmap */ 43static unsigned int ol_chunk_entries(struct super_block *sb) 44{ 45 return ol_chunk_blocks(sb) * ol_quota_entries_per_block(sb); 46} 47 48/* Offset of the chunk in quota file */ 49static unsigned int ol_quota_chunk_block(struct super_block *sb, int c) 50{ 51 /* 1 block for local quota file info, 1 block per chunk for chunk info */ 52 return 1 + (ol_chunk_blocks(sb) + 1) * c; 53} 54 55static unsigned int ol_dqblk_block(struct super_block *sb, int c, int off) 56{ 57 int epb = ol_quota_entries_per_block(sb); 58 59 return ol_quota_chunk_block(sb, c) + 1 + off / epb; 60} 61 62static unsigned int ol_dqblk_block_off(struct super_block *sb, int c, int off) 63{ 64 int epb = ol_quota_entries_per_block(sb); 65 66 return (off % epb) * sizeof(struct ocfs2_local_disk_dqblk); 67} 68 69/* Offset of the dquot structure in the quota file */ 70static loff_t ol_dqblk_off(struct super_block *sb, int c, int off) 71{ 72 return (ol_dqblk_block(sb, c, off) << sb->s_blocksize_bits) + 73 ol_dqblk_block_off(sb, c, off); 74} 75 76/* Compute block number from given offset */ 77static inline unsigned int ol_dqblk_file_block(struct super_block *sb, loff_t off) 78{ 79 return off >> sb->s_blocksize_bits; 80} 81 82static inline unsigned int ol_dqblk_block_offset(struct super_block *sb, loff_t off) 83{ 84 return off & ((1 << sb->s_blocksize_bits) - 1); 85} 86 87/* Compute offset in the chunk of a structure with the given offset */ 88static int ol_dqblk_chunk_off(struct super_block *sb, int c, loff_t off) 89{ 90 int epb = ol_quota_entries_per_block(sb); 91 92 return ((off >> sb->s_blocksize_bits) - 93 ol_quota_chunk_block(sb, c) - 1) * epb 94 + ((unsigned int)(off & ((1 << sb->s_blocksize_bits) - 1))) / 95 sizeof(struct ocfs2_local_disk_dqblk); 96} 97 98/* Write bufferhead into the fs */ 99static int ocfs2_modify_bh(struct inode *inode, struct buffer_head *bh, 100 void (*modify)(struct buffer_head *, void *), void *private) 101{ 102 struct super_block *sb = inode->i_sb; 103 handle_t *handle; 104 int status; 105 106 handle = ocfs2_start_trans(OCFS2_SB(sb), 107 OCFS2_QUOTA_BLOCK_UPDATE_CREDITS); 108 if (IS_ERR(handle)) { 109 status = PTR_ERR(handle); 110 mlog_errno(status); 111 return status; 112 } 113 status = ocfs2_journal_access_dq(handle, INODE_CACHE(inode), bh, 114 OCFS2_JOURNAL_ACCESS_WRITE); 115 if (status < 0) { 116 mlog_errno(status); 117 ocfs2_commit_trans(OCFS2_SB(sb), handle); 118 return status; 119 } 120 lock_buffer(bh); 121 modify(bh, private); 122 unlock_buffer(bh); 123 ocfs2_journal_dirty(handle, bh); 124 125 status = ocfs2_commit_trans(OCFS2_SB(sb), handle); 126 if (status < 0) { 127 mlog_errno(status); 128 return status; 129 } 130 return 0; 131} 132 133/* 134 * Read quota block from a given logical offset. 135 * 136 * This function acquires ip_alloc_sem and thus it must not be called with a 137 * transaction started. 138 */ 139static int ocfs2_read_quota_block(struct inode *inode, u64 v_block, 140 struct buffer_head **bh) 141{ 142 int rc = 0; 143 struct buffer_head *tmp = *bh; 144 145 if (i_size_read(inode) >> inode->i_sb->s_blocksize_bits <= v_block) { 146 ocfs2_error(inode->i_sb, 147 "Quota file %llu is probably corrupted! Requested " 148 "to read block %Lu but file has size only %Lu\n", 149 (unsigned long long)OCFS2_I(inode)->ip_blkno, 150 (unsigned long long)v_block, 151 (unsigned long long)i_size_read(inode)); 152 return -EIO; 153 } 154 rc = ocfs2_read_virt_blocks(inode, v_block, 1, &tmp, 0, 155 ocfs2_validate_quota_block); 156 if (rc) 157 mlog_errno(rc); 158 159 /* If ocfs2_read_virt_blocks() got us a new bh, pass it up. */ 160 if (!rc && !*bh) 161 *bh = tmp; 162 163 return rc; 164} 165 166/* Check whether we understand format of quota files */ 167static int ocfs2_local_check_quota_file(struct super_block *sb, int type) 168{ 169 unsigned int lmagics[MAXQUOTAS] = OCFS2_LOCAL_QMAGICS; 170 unsigned int lversions[MAXQUOTAS] = OCFS2_LOCAL_QVERSIONS; 171 unsigned int gmagics[MAXQUOTAS] = OCFS2_GLOBAL_QMAGICS; 172 unsigned int gversions[MAXQUOTAS] = OCFS2_GLOBAL_QVERSIONS; 173 unsigned int ino[MAXQUOTAS] = { USER_QUOTA_SYSTEM_INODE, 174 GROUP_QUOTA_SYSTEM_INODE }; 175 struct buffer_head *bh = NULL; 176 struct inode *linode = sb_dqopt(sb)->files[type]; 177 struct inode *ginode = NULL; 178 struct ocfs2_disk_dqheader *dqhead; 179 int status, ret = 0; 180 181 /* First check whether we understand local quota file */ 182 status = ocfs2_read_quota_block(linode, 0, &bh); 183 if (status) { 184 mlog_errno(status); 185 mlog(ML_ERROR, "failed to read quota file header (type=%d)\n", 186 type); 187 goto out_err; 188 } 189 dqhead = (struct ocfs2_disk_dqheader *)(bh->b_data); 190 if (le32_to_cpu(dqhead->dqh_magic) != lmagics[type]) { 191 mlog(ML_ERROR, "quota file magic does not match (%u != %u)," 192 " type=%d\n", le32_to_cpu(dqhead->dqh_magic), 193 lmagics[type], type); 194 goto out_err; 195 } 196 if (le32_to_cpu(dqhead->dqh_version) != lversions[type]) { 197 mlog(ML_ERROR, "quota file version does not match (%u != %u)," 198 " type=%d\n", le32_to_cpu(dqhead->dqh_version), 199 lversions[type], type); 200 goto out_err; 201 } 202 brelse(bh); 203 bh = NULL; 204 205 /* Next check whether we understand global quota file */ 206 ginode = ocfs2_get_system_file_inode(OCFS2_SB(sb), ino[type], 207 OCFS2_INVALID_SLOT); 208 if (!ginode) { 209 mlog(ML_ERROR, "cannot get global quota file inode " 210 "(type=%d)\n", type); 211 goto out_err; 212 } 213 /* Since the header is read only, we don't care about locking */ 214 status = ocfs2_read_quota_block(ginode, 0, &bh); 215 if (status) { 216 mlog_errno(status); 217 mlog(ML_ERROR, "failed to read global quota file header " 218 "(type=%d)\n", type); 219 goto out_err; 220 } 221 dqhead = (struct ocfs2_disk_dqheader *)(bh->b_data); 222 if (le32_to_cpu(dqhead->dqh_magic) != gmagics[type]) { 223 mlog(ML_ERROR, "global quota file magic does not match " 224 "(%u != %u), type=%d\n", 225 le32_to_cpu(dqhead->dqh_magic), gmagics[type], type); 226 goto out_err; 227 } 228 if (le32_to_cpu(dqhead->dqh_version) != gversions[type]) { 229 mlog(ML_ERROR, "global quota file version does not match " 230 "(%u != %u), type=%d\n", 231 le32_to_cpu(dqhead->dqh_version), gversions[type], 232 type); 233 goto out_err; 234 } 235 236 ret = 1; 237out_err: 238 brelse(bh); 239 iput(ginode); 240 return ret; 241} 242 243/* Release given list of quota file chunks */ 244static void ocfs2_release_local_quota_bitmaps(struct list_head *head) 245{ 246 struct ocfs2_quota_chunk *pos, *next; 247 248 list_for_each_entry_safe(pos, next, head, qc_chunk) { 249 list_del(&pos->qc_chunk); 250 brelse(pos->qc_headerbh); 251 kmem_cache_free(ocfs2_qf_chunk_cachep, pos); 252 } 253} 254 255/* Load quota bitmaps into memory */ 256static int ocfs2_load_local_quota_bitmaps(struct inode *inode, 257 struct ocfs2_local_disk_dqinfo *ldinfo, 258 struct list_head *head) 259{ 260 struct ocfs2_quota_chunk *newchunk; 261 int i, status; 262 263 INIT_LIST_HEAD(head); 264 for (i = 0; i < le32_to_cpu(ldinfo->dqi_chunks); i++) { 265 newchunk = kmem_cache_alloc(ocfs2_qf_chunk_cachep, GFP_NOFS); 266 if (!newchunk) { 267 ocfs2_release_local_quota_bitmaps(head); 268 return -ENOMEM; 269 } 270 newchunk->qc_num = i; 271 newchunk->qc_headerbh = NULL; 272 status = ocfs2_read_quota_block(inode, 273 ol_quota_chunk_block(inode->i_sb, i), 274 &newchunk->qc_headerbh); 275 if (status) { 276 mlog_errno(status); 277 kmem_cache_free(ocfs2_qf_chunk_cachep, newchunk); 278 ocfs2_release_local_quota_bitmaps(head); 279 return status; 280 } 281 list_add_tail(&newchunk->qc_chunk, head); 282 } 283 return 0; 284} 285 286static void olq_update_info(struct buffer_head *bh, void *private) 287{ 288 struct mem_dqinfo *info = private; 289 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv; 290 struct ocfs2_local_disk_dqinfo *ldinfo; 291 292 ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data + 293 OCFS2_LOCAL_INFO_OFF); 294 spin_lock(&dq_data_lock); 295 ldinfo->dqi_flags = cpu_to_le32(info->dqi_flags & DQF_MASK); 296 ldinfo->dqi_chunks = cpu_to_le32(oinfo->dqi_chunks); 297 ldinfo->dqi_blocks = cpu_to_le32(oinfo->dqi_blocks); 298 spin_unlock(&dq_data_lock); 299} 300 301static int ocfs2_add_recovery_chunk(struct super_block *sb, 302 struct ocfs2_local_disk_chunk *dchunk, 303 int chunk, 304 struct list_head *head) 305{ 306 struct ocfs2_recovery_chunk *rc; 307 308 rc = kmalloc(sizeof(struct ocfs2_recovery_chunk), GFP_NOFS); 309 if (!rc) 310 return -ENOMEM; 311 rc->rc_chunk = chunk; 312 rc->rc_bitmap = kmalloc(sb->s_blocksize, GFP_NOFS); 313 if (!rc->rc_bitmap) { 314 kfree(rc); 315 return -ENOMEM; 316 } 317 memcpy(rc->rc_bitmap, dchunk->dqc_bitmap, 318 (ol_chunk_entries(sb) + 7) >> 3); 319 list_add_tail(&rc->rc_list, head); 320 return 0; 321} 322 323static void free_recovery_list(struct list_head *head) 324{ 325 struct ocfs2_recovery_chunk *next; 326 struct ocfs2_recovery_chunk *rchunk; 327 328 list_for_each_entry_safe(rchunk, next, head, rc_list) { 329 list_del(&rchunk->rc_list); 330 kfree(rchunk->rc_bitmap); 331 kfree(rchunk); 332 } 333} 334 335void ocfs2_free_quota_recovery(struct ocfs2_quota_recovery *rec) 336{ 337 int type; 338 339 for (type = 0; type < MAXQUOTAS; type++) 340 free_recovery_list(&(rec->r_list[type])); 341 kfree(rec); 342} 343 344/* Load entries in our quota file we have to recover*/ 345static int ocfs2_recovery_load_quota(struct inode *lqinode, 346 struct ocfs2_local_disk_dqinfo *ldinfo, 347 int type, 348 struct list_head *head) 349{ 350 struct super_block *sb = lqinode->i_sb; 351 struct buffer_head *hbh; 352 struct ocfs2_local_disk_chunk *dchunk; 353 int i, chunks = le32_to_cpu(ldinfo->dqi_chunks); 354 int status = 0; 355 356 for (i = 0; i < chunks; i++) { 357 hbh = NULL; 358 status = ocfs2_read_quota_block(lqinode, 359 ol_quota_chunk_block(sb, i), 360 &hbh); 361 if (status) { 362 mlog_errno(status); 363 break; 364 } 365 dchunk = (struct ocfs2_local_disk_chunk *)hbh->b_data; 366 if (le32_to_cpu(dchunk->dqc_free) < ol_chunk_entries(sb)) 367 status = ocfs2_add_recovery_chunk(sb, dchunk, i, head); 368 brelse(hbh); 369 if (status < 0) 370 break; 371 } 372 if (status < 0) 373 free_recovery_list(head); 374 return status; 375} 376 377static struct ocfs2_quota_recovery *ocfs2_alloc_quota_recovery(void) 378{ 379 int type; 380 struct ocfs2_quota_recovery *rec; 381 382 rec = kmalloc(sizeof(struct ocfs2_quota_recovery), GFP_NOFS); 383 if (!rec) 384 return NULL; 385 for (type = 0; type < MAXQUOTAS; type++) 386 INIT_LIST_HEAD(&(rec->r_list[type])); 387 return rec; 388} 389 390/* Load information we need for quota recovery into memory */ 391struct ocfs2_quota_recovery *ocfs2_begin_quota_recovery( 392 struct ocfs2_super *osb, 393 int slot_num) 394{ 395 unsigned int feature[MAXQUOTAS] = { OCFS2_FEATURE_RO_COMPAT_USRQUOTA, 396 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA}; 397 unsigned int ino[MAXQUOTAS] = { LOCAL_USER_QUOTA_SYSTEM_INODE, 398 LOCAL_GROUP_QUOTA_SYSTEM_INODE }; 399 struct super_block *sb = osb->sb; 400 struct ocfs2_local_disk_dqinfo *ldinfo; 401 struct inode *lqinode; 402 struct buffer_head *bh; 403 int type; 404 int status = 0; 405 struct ocfs2_quota_recovery *rec; 406 407 mlog(ML_NOTICE, "Beginning quota recovery in slot %u\n", slot_num); 408 rec = ocfs2_alloc_quota_recovery(); 409 if (!rec) 410 return ERR_PTR(-ENOMEM); 411 /* First init... */ 412 413 for (type = 0; type < MAXQUOTAS; type++) { 414 if (!OCFS2_HAS_RO_COMPAT_FEATURE(sb, feature[type])) 415 continue; 416 /* At this point, journal of the slot is already replayed so 417 * we can trust metadata and data of the quota file */ 418 lqinode = ocfs2_get_system_file_inode(osb, ino[type], slot_num); 419 if (!lqinode) { 420 status = -ENOENT; 421 goto out; 422 } 423 status = ocfs2_inode_lock_full(lqinode, NULL, 1, 424 OCFS2_META_LOCK_RECOVERY); 425 if (status < 0) { 426 mlog_errno(status); 427 goto out_put; 428 } 429 /* Now read local header */ 430 bh = NULL; 431 status = ocfs2_read_quota_block(lqinode, 0, &bh); 432 if (status) { 433 mlog_errno(status); 434 mlog(ML_ERROR, "failed to read quota file info header " 435 "(slot=%d type=%d)\n", slot_num, type); 436 goto out_lock; 437 } 438 ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data + 439 OCFS2_LOCAL_INFO_OFF); 440 status = ocfs2_recovery_load_quota(lqinode, ldinfo, type, 441 &rec->r_list[type]); 442 brelse(bh); 443out_lock: 444 ocfs2_inode_unlock(lqinode, 1); 445out_put: 446 iput(lqinode); 447 if (status < 0) 448 break; 449 } 450out: 451 if (status < 0) { 452 ocfs2_free_quota_recovery(rec); 453 rec = ERR_PTR(status); 454 } 455 return rec; 456} 457 458/* Sync changes in local quota file into global quota file and 459 * reinitialize local quota file. 460 * The function expects local quota file to be already locked and 461 * dqonoff_mutex locked. */ 462static int ocfs2_recover_local_quota_file(struct inode *lqinode, 463 int type, 464 struct ocfs2_quota_recovery *rec) 465{ 466 struct super_block *sb = lqinode->i_sb; 467 struct ocfs2_mem_dqinfo *oinfo = sb_dqinfo(sb, type)->dqi_priv; 468 struct ocfs2_local_disk_chunk *dchunk; 469 struct ocfs2_local_disk_dqblk *dqblk; 470 struct dquot *dquot; 471 handle_t *handle; 472 struct buffer_head *hbh = NULL, *qbh = NULL; 473 int status = 0; 474 int bit, chunk; 475 struct ocfs2_recovery_chunk *rchunk, *next; 476 qsize_t spacechange, inodechange; 477 478 mlog_entry("ino=%lu type=%u", (unsigned long)lqinode->i_ino, type); 479 480 list_for_each_entry_safe(rchunk, next, &(rec->r_list[type]), rc_list) { 481 chunk = rchunk->rc_chunk; 482 hbh = NULL; 483 status = ocfs2_read_quota_block(lqinode, 484 ol_quota_chunk_block(sb, chunk), 485 &hbh); 486 if (status) { 487 mlog_errno(status); 488 break; 489 } 490 dchunk = (struct ocfs2_local_disk_chunk *)hbh->b_data; 491 for_each_set_bit(bit, rchunk->rc_bitmap, ol_chunk_entries(sb)) { 492 qbh = NULL; 493 status = ocfs2_read_quota_block(lqinode, 494 ol_dqblk_block(sb, chunk, bit), 495 &qbh); 496 if (status) { 497 mlog_errno(status); 498 break; 499 } 500 dqblk = (struct ocfs2_local_disk_dqblk *)(qbh->b_data + 501 ol_dqblk_block_off(sb, chunk, bit)); 502 dquot = dqget(sb, le64_to_cpu(dqblk->dqb_id), type); 503 if (!dquot) { 504 status = -EIO; 505 mlog(ML_ERROR, "Failed to get quota structure " 506 "for id %u, type %d. Cannot finish quota " 507 "file recovery.\n", 508 (unsigned)le64_to_cpu(dqblk->dqb_id), 509 type); 510 goto out_put_bh; 511 } 512 status = ocfs2_lock_global_qf(oinfo, 1); 513 if (status < 0) { 514 mlog_errno(status); 515 goto out_put_dquot; 516 } 517 518 handle = ocfs2_start_trans(OCFS2_SB(sb), 519 OCFS2_QSYNC_CREDITS); 520 if (IS_ERR(handle)) { 521 status = PTR_ERR(handle); 522 mlog_errno(status); 523 goto out_drop_lock; 524 } 525 mutex_lock(&sb_dqopt(sb)->dqio_mutex); 526 spin_lock(&dq_data_lock); 527 /* Add usage from quota entry into quota changes 528 * of our node. Auxiliary variables are important 529 * due to signedness */ 530 spacechange = le64_to_cpu(dqblk->dqb_spacemod); 531 inodechange = le64_to_cpu(dqblk->dqb_inodemod); 532 dquot->dq_dqb.dqb_curspace += spacechange; 533 dquot->dq_dqb.dqb_curinodes += inodechange; 534 spin_unlock(&dq_data_lock); 535 /* We want to drop reference held by the crashed 536 * node. Since we have our own reference we know 537 * global structure actually won't be freed. */ 538 status = ocfs2_global_release_dquot(dquot); 539 if (status < 0) { 540 mlog_errno(status); 541 goto out_commit; 542 } 543 /* Release local quota file entry */ 544 status = ocfs2_journal_access_dq(handle, 545 INODE_CACHE(lqinode), 546 qbh, OCFS2_JOURNAL_ACCESS_WRITE); 547 if (status < 0) { 548 mlog_errno(status); 549 goto out_commit; 550 } 551 lock_buffer(qbh); 552 WARN_ON(!ocfs2_test_bit(bit, dchunk->dqc_bitmap)); 553 ocfs2_clear_bit(bit, dchunk->dqc_bitmap); 554 le32_add_cpu(&dchunk->dqc_free, 1); 555 unlock_buffer(qbh); 556 ocfs2_journal_dirty(handle, qbh); 557out_commit: 558 mutex_unlock(&sb_dqopt(sb)->dqio_mutex); 559 ocfs2_commit_trans(OCFS2_SB(sb), handle); 560out_drop_lock: 561 ocfs2_unlock_global_qf(oinfo, 1); 562out_put_dquot: 563 dqput(dquot); 564out_put_bh: 565 brelse(qbh); 566 if (status < 0) 567 break; 568 } 569 brelse(hbh); 570 list_del(&rchunk->rc_list); 571 kfree(rchunk->rc_bitmap); 572 kfree(rchunk); 573 if (status < 0) 574 break; 575 } 576 if (status < 0) 577 free_recovery_list(&(rec->r_list[type])); 578 mlog_exit(status); 579 return status; 580} 581 582/* Recover local quota files for given node different from us */ 583int ocfs2_finish_quota_recovery(struct ocfs2_super *osb, 584 struct ocfs2_quota_recovery *rec, 585 int slot_num) 586{ 587 unsigned int ino[MAXQUOTAS] = { LOCAL_USER_QUOTA_SYSTEM_INODE, 588 LOCAL_GROUP_QUOTA_SYSTEM_INODE }; 589 struct super_block *sb = osb->sb; 590 struct ocfs2_local_disk_dqinfo *ldinfo; 591 struct buffer_head *bh; 592 handle_t *handle; 593 int type; 594 int status = 0; 595 struct inode *lqinode; 596 unsigned int flags; 597 598 mlog(ML_NOTICE, "Finishing quota recovery in slot %u\n", slot_num); 599 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 600 for (type = 0; type < MAXQUOTAS; type++) { 601 if (list_empty(&(rec->r_list[type]))) 602 continue; 603 mlog(0, "Recovering quota in slot %d\n", slot_num); 604 lqinode = ocfs2_get_system_file_inode(osb, ino[type], slot_num); 605 if (!lqinode) { 606 status = -ENOENT; 607 goto out; 608 } 609 status = ocfs2_inode_lock_full(lqinode, NULL, 1, 610 OCFS2_META_LOCK_NOQUEUE); 611 /* Someone else is holding the lock? Then he must be 612 * doing the recovery. Just skip the file... */ 613 if (status == -EAGAIN) { 614 mlog(ML_NOTICE, "skipping quota recovery for slot %d " 615 "because quota file is locked.\n", slot_num); 616 status = 0; 617 goto out_put; 618 } else if (status < 0) { 619 mlog_errno(status); 620 goto out_put; 621 } 622 /* Now read local header */ 623 bh = NULL; 624 status = ocfs2_read_quota_block(lqinode, 0, &bh); 625 if (status) { 626 mlog_errno(status); 627 mlog(ML_ERROR, "failed to read quota file info header " 628 "(slot=%d type=%d)\n", slot_num, type); 629 goto out_lock; 630 } 631 ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data + 632 OCFS2_LOCAL_INFO_OFF); 633 /* Is recovery still needed? */ 634 flags = le32_to_cpu(ldinfo->dqi_flags); 635 if (!(flags & OLQF_CLEAN)) 636 status = ocfs2_recover_local_quota_file(lqinode, 637 type, 638 rec); 639 /* We don't want to mark file as clean when it is actually 640 * active */ 641 if (slot_num == osb->slot_num) 642 goto out_bh; 643 /* Mark quota file as clean if we are recovering quota file of 644 * some other node. */ 645 handle = ocfs2_start_trans(osb, 646 OCFS2_LOCAL_QINFO_WRITE_CREDITS); 647 if (IS_ERR(handle)) { 648 status = PTR_ERR(handle); 649 mlog_errno(status); 650 goto out_bh; 651 } 652 status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode), 653 bh, 654 OCFS2_JOURNAL_ACCESS_WRITE); 655 if (status < 0) { 656 mlog_errno(status); 657 goto out_trans; 658 } 659 lock_buffer(bh); 660 ldinfo->dqi_flags = cpu_to_le32(flags | OLQF_CLEAN); 661 unlock_buffer(bh); 662 ocfs2_journal_dirty(handle, bh); 663out_trans: 664 ocfs2_commit_trans(osb, handle); 665out_bh: 666 brelse(bh); 667out_lock: 668 ocfs2_inode_unlock(lqinode, 1); 669out_put: 670 iput(lqinode); 671 if (status < 0) 672 break; 673 } 674out: 675 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 676 kfree(rec); 677 return status; 678} 679 680/* Read information header from quota file */ 681static int ocfs2_local_read_info(struct super_block *sb, int type) 682{ 683 struct ocfs2_local_disk_dqinfo *ldinfo; 684 struct mem_dqinfo *info = sb_dqinfo(sb, type); 685 struct ocfs2_mem_dqinfo *oinfo; 686 struct inode *lqinode = sb_dqopt(sb)->files[type]; 687 int status; 688 struct buffer_head *bh = NULL; 689 struct ocfs2_quota_recovery *rec; 690 int locked = 0; 691 692 /* We don't need the lock and we have to acquire quota file locks 693 * which will later depend on this lock */ 694 mutex_unlock(&sb_dqopt(sb)->dqio_mutex); 695 info->dqi_maxblimit = 0x7fffffffffffffffLL; 696 info->dqi_maxilimit = 0x7fffffffffffffffLL; 697 oinfo = kmalloc(sizeof(struct ocfs2_mem_dqinfo), GFP_NOFS); 698 if (!oinfo) { 699 mlog(ML_ERROR, "failed to allocate memory for ocfs2 quota" 700 " info."); 701 goto out_err; 702 } 703 info->dqi_priv = oinfo; 704 oinfo->dqi_type = type; 705 INIT_LIST_HEAD(&oinfo->dqi_chunk); 706 oinfo->dqi_rec = NULL; 707 oinfo->dqi_lqi_bh = NULL; 708 oinfo->dqi_libh = NULL; 709 710 status = ocfs2_global_read_info(sb, type); 711 if (status < 0) 712 goto out_err; 713 714 status = ocfs2_inode_lock(lqinode, &oinfo->dqi_lqi_bh, 1); 715 if (status < 0) { 716 mlog_errno(status); 717 goto out_err; 718 } 719 locked = 1; 720 721 /* Now read local header */ 722 status = ocfs2_read_quota_block(lqinode, 0, &bh); 723 if (status) { 724 mlog_errno(status); 725 mlog(ML_ERROR, "failed to read quota file info header " 726 "(type=%d)\n", type); 727 goto out_err; 728 } 729 ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data + 730 OCFS2_LOCAL_INFO_OFF); 731 info->dqi_flags = le32_to_cpu(ldinfo->dqi_flags); 732 oinfo->dqi_chunks = le32_to_cpu(ldinfo->dqi_chunks); 733 oinfo->dqi_blocks = le32_to_cpu(ldinfo->dqi_blocks); 734 oinfo->dqi_libh = bh; 735 736 /* We crashed when using local quota file? */ 737 if (!(info->dqi_flags & OLQF_CLEAN)) { 738 rec = OCFS2_SB(sb)->quota_rec; 739 if (!rec) { 740 rec = ocfs2_alloc_quota_recovery(); 741 if (!rec) { 742 status = -ENOMEM; 743 mlog_errno(status); 744 goto out_err; 745 } 746 OCFS2_SB(sb)->quota_rec = rec; 747 } 748 749 status = ocfs2_recovery_load_quota(lqinode, ldinfo, type, 750 &rec->r_list[type]); 751 if (status < 0) { 752 mlog_errno(status); 753 goto out_err; 754 } 755 } 756 757 status = ocfs2_load_local_quota_bitmaps(lqinode, 758 ldinfo, 759 &oinfo->dqi_chunk); 760 if (status < 0) { 761 mlog_errno(status); 762 goto out_err; 763 } 764 765 /* Now mark quota file as used */ 766 info->dqi_flags &= ~OLQF_CLEAN; 767 status = ocfs2_modify_bh(lqinode, bh, olq_update_info, info); 768 if (status < 0) { 769 mlog_errno(status); 770 goto out_err; 771 } 772 773 mutex_lock(&sb_dqopt(sb)->dqio_mutex); 774 return 0; 775out_err: 776 if (oinfo) { 777 iput(oinfo->dqi_gqinode); 778 ocfs2_simple_drop_lockres(OCFS2_SB(sb), &oinfo->dqi_gqlock); 779 ocfs2_lock_res_free(&oinfo->dqi_gqlock); 780 brelse(oinfo->dqi_lqi_bh); 781 if (locked) 782 ocfs2_inode_unlock(lqinode, 1); 783 ocfs2_release_local_quota_bitmaps(&oinfo->dqi_chunk); 784 kfree(oinfo); 785 } 786 brelse(bh); 787 mutex_lock(&sb_dqopt(sb)->dqio_mutex); 788 return -1; 789} 790 791/* Write local info to quota file */ 792static int ocfs2_local_write_info(struct super_block *sb, int type) 793{ 794 struct mem_dqinfo *info = sb_dqinfo(sb, type); 795 struct buffer_head *bh = ((struct ocfs2_mem_dqinfo *)info->dqi_priv) 796 ->dqi_libh; 797 int status; 798 799 status = ocfs2_modify_bh(sb_dqopt(sb)->files[type], bh, olq_update_info, 800 info); 801 if (status < 0) { 802 mlog_errno(status); 803 return -1; 804 } 805 806 return 0; 807} 808 809/* Release info from memory */ 810static int ocfs2_local_free_info(struct super_block *sb, int type) 811{ 812 struct mem_dqinfo *info = sb_dqinfo(sb, type); 813 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv; 814 struct ocfs2_quota_chunk *chunk; 815 struct ocfs2_local_disk_chunk *dchunk; 816 int mark_clean = 1, len; 817 int status; 818 819 iput(oinfo->dqi_gqinode); 820 ocfs2_simple_drop_lockres(OCFS2_SB(sb), &oinfo->dqi_gqlock); 821 ocfs2_lock_res_free(&oinfo->dqi_gqlock); 822 list_for_each_entry(chunk, &oinfo->dqi_chunk, qc_chunk) { 823 dchunk = (struct ocfs2_local_disk_chunk *) 824 (chunk->qc_headerbh->b_data); 825 if (chunk->qc_num < oinfo->dqi_chunks - 1) { 826 len = ol_chunk_entries(sb); 827 } else { 828 len = (oinfo->dqi_blocks - 829 ol_quota_chunk_block(sb, chunk->qc_num) - 1) 830 * ol_quota_entries_per_block(sb); 831 } 832 /* Not all entries free? Bug! */ 833 if (le32_to_cpu(dchunk->dqc_free) != len) { 834 mlog(ML_ERROR, "releasing quota file with used " 835 "entries (type=%d)\n", type); 836 mark_clean = 0; 837 } 838 } 839 ocfs2_release_local_quota_bitmaps(&oinfo->dqi_chunk); 840 841 /* dqonoff_mutex protects us against racing with recovery thread... */ 842 if (oinfo->dqi_rec) { 843 ocfs2_free_quota_recovery(oinfo->dqi_rec); 844 mark_clean = 0; 845 } 846 847 if (!mark_clean) 848 goto out; 849 850 /* Mark local file as clean */ 851 info->dqi_flags |= OLQF_CLEAN; 852 status = ocfs2_modify_bh(sb_dqopt(sb)->files[type], 853 oinfo->dqi_libh, 854 olq_update_info, 855 info); 856 if (status < 0) { 857 mlog_errno(status); 858 goto out; 859 } 860 861out: 862 ocfs2_inode_unlock(sb_dqopt(sb)->files[type], 1); 863 brelse(oinfo->dqi_libh); 864 brelse(oinfo->dqi_lqi_bh); 865 kfree(oinfo); 866 return 0; 867} 868 869static void olq_set_dquot(struct buffer_head *bh, void *private) 870{ 871 struct ocfs2_dquot *od = private; 872 struct ocfs2_local_disk_dqblk *dqblk; 873 struct super_block *sb = od->dq_dquot.dq_sb; 874 875 dqblk = (struct ocfs2_local_disk_dqblk *)(bh->b_data 876 + ol_dqblk_block_offset(sb, od->dq_local_off)); 877 878 dqblk->dqb_id = cpu_to_le64(od->dq_dquot.dq_id); 879 spin_lock(&dq_data_lock); 880 dqblk->dqb_spacemod = cpu_to_le64(od->dq_dquot.dq_dqb.dqb_curspace - 881 od->dq_origspace); 882 dqblk->dqb_inodemod = cpu_to_le64(od->dq_dquot.dq_dqb.dqb_curinodes - 883 od->dq_originodes); 884 spin_unlock(&dq_data_lock); 885 mlog(0, "Writing local dquot %u space %lld inodes %lld\n", 886 od->dq_dquot.dq_id, (long long)le64_to_cpu(dqblk->dqb_spacemod), 887 (long long)le64_to_cpu(dqblk->dqb_inodemod)); 888} 889 890/* Write dquot to local quota file */ 891int ocfs2_local_write_dquot(struct dquot *dquot) 892{ 893 struct super_block *sb = dquot->dq_sb; 894 struct ocfs2_dquot *od = OCFS2_DQUOT(dquot); 895 struct buffer_head *bh; 896 struct inode *lqinode = sb_dqopt(sb)->files[dquot->dq_type]; 897 int status; 898 899 status = ocfs2_read_quota_phys_block(lqinode, od->dq_local_phys_blk, 900 &bh); 901 if (status) { 902 mlog_errno(status); 903 goto out; 904 } 905 status = ocfs2_modify_bh(lqinode, bh, olq_set_dquot, od); 906 if (status < 0) { 907 mlog_errno(status); 908 goto out; 909 } 910out: 911 brelse(bh); 912 return status; 913} 914 915/* Find free entry in local quota file */ 916static struct ocfs2_quota_chunk *ocfs2_find_free_entry(struct super_block *sb, 917 int type, 918 int *offset) 919{ 920 struct mem_dqinfo *info = sb_dqinfo(sb, type); 921 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv; 922 struct ocfs2_quota_chunk *chunk; 923 struct ocfs2_local_disk_chunk *dchunk; 924 int found = 0, len; 925 926 list_for_each_entry(chunk, &oinfo->dqi_chunk, qc_chunk) { 927 dchunk = (struct ocfs2_local_disk_chunk *) 928 chunk->qc_headerbh->b_data; 929 if (le32_to_cpu(dchunk->dqc_free) > 0) { 930 found = 1; 931 break; 932 } 933 } 934 if (!found) 935 return NULL; 936 937 if (chunk->qc_num < oinfo->dqi_chunks - 1) { 938 len = ol_chunk_entries(sb); 939 } else { 940 len = (oinfo->dqi_blocks - 941 ol_quota_chunk_block(sb, chunk->qc_num) - 1) 942 * ol_quota_entries_per_block(sb); 943 } 944 945 found = ocfs2_find_next_zero_bit(dchunk->dqc_bitmap, len, 0); 946 /* We failed? */ 947 if (found == len) { 948 mlog(ML_ERROR, "Did not find empty entry in chunk %d with %u" 949 " entries free (type=%d)\n", chunk->qc_num, 950 le32_to_cpu(dchunk->dqc_free), type); 951 return ERR_PTR(-EIO); 952 } 953 *offset = found; 954 return chunk; 955} 956 957/* Add new chunk to the local quota file */ 958static struct ocfs2_quota_chunk *ocfs2_local_quota_add_chunk( 959 struct super_block *sb, 960 int type, 961 int *offset) 962{ 963 struct mem_dqinfo *info = sb_dqinfo(sb, type); 964 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv; 965 struct inode *lqinode = sb_dqopt(sb)->files[type]; 966 struct ocfs2_quota_chunk *chunk = NULL; 967 struct ocfs2_local_disk_chunk *dchunk; 968 int status; 969 handle_t *handle; 970 struct buffer_head *bh = NULL, *dbh = NULL; 971 u64 p_blkno; 972 973 /* We are protected by dqio_sem so no locking needed */ 974 status = ocfs2_extend_no_holes(lqinode, NULL, 975 lqinode->i_size + 2 * sb->s_blocksize, 976 lqinode->i_size); 977 if (status < 0) { 978 mlog_errno(status); 979 goto out; 980 } 981 status = ocfs2_simple_size_update(lqinode, oinfo->dqi_lqi_bh, 982 lqinode->i_size + 2 * sb->s_blocksize); 983 if (status < 0) { 984 mlog_errno(status); 985 goto out; 986 } 987 988 chunk = kmem_cache_alloc(ocfs2_qf_chunk_cachep, GFP_NOFS); 989 if (!chunk) { 990 status = -ENOMEM; 991 mlog_errno(status); 992 goto out; 993 } 994 /* Local quota info and two new blocks we initialize */ 995 handle = ocfs2_start_trans(OCFS2_SB(sb), 996 OCFS2_LOCAL_QINFO_WRITE_CREDITS + 997 2 * OCFS2_QUOTA_BLOCK_UPDATE_CREDITS); 998 if (IS_ERR(handle)) { 999 status = PTR_ERR(handle); 1000 mlog_errno(status); 1001 goto out; 1002 } 1003 1004 /* Initialize chunk header */ 1005 status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks, 1006 &p_blkno, NULL, NULL); 1007 if (status < 0) { 1008 mlog_errno(status); 1009 goto out_trans; 1010 } 1011 bh = sb_getblk(sb, p_blkno); 1012 if (!bh) { 1013 status = -ENOMEM; 1014 mlog_errno(status); 1015 goto out_trans; 1016 } 1017 dchunk = (struct ocfs2_local_disk_chunk *)bh->b_data; 1018 ocfs2_set_new_buffer_uptodate(INODE_CACHE(lqinode), bh); 1019 status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode), bh, 1020 OCFS2_JOURNAL_ACCESS_CREATE); 1021 if (status < 0) { 1022 mlog_errno(status); 1023 goto out_trans; 1024 } 1025 lock_buffer(bh); 1026 dchunk->dqc_free = cpu_to_le32(ol_quota_entries_per_block(sb)); 1027 memset(dchunk->dqc_bitmap, 0, 1028 sb->s_blocksize - sizeof(struct ocfs2_local_disk_chunk) - 1029 OCFS2_QBLK_RESERVED_SPACE); 1030 unlock_buffer(bh); 1031 ocfs2_journal_dirty(handle, bh); 1032 1033 /* Initialize new block with structures */ 1034 status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks + 1, 1035 &p_blkno, NULL, NULL); 1036 if (status < 0) { 1037 mlog_errno(status); 1038 goto out_trans; 1039 } 1040 dbh = sb_getblk(sb, p_blkno); 1041 if (!dbh) { 1042 status = -ENOMEM; 1043 mlog_errno(status); 1044 goto out_trans; 1045 } 1046 ocfs2_set_new_buffer_uptodate(INODE_CACHE(lqinode), dbh); 1047 status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode), dbh, 1048 OCFS2_JOURNAL_ACCESS_CREATE); 1049 if (status < 0) { 1050 mlog_errno(status); 1051 goto out_trans; 1052 } 1053 lock_buffer(dbh); 1054 memset(dbh->b_data, 0, sb->s_blocksize - OCFS2_QBLK_RESERVED_SPACE); 1055 unlock_buffer(dbh); 1056 ocfs2_journal_dirty(handle, dbh); 1057 1058 /* Update local quotafile info */ 1059 oinfo->dqi_blocks += 2; 1060 oinfo->dqi_chunks++; 1061 status = ocfs2_local_write_info(sb, type); 1062 if (status < 0) { 1063 mlog_errno(status); 1064 goto out_trans; 1065 } 1066 status = ocfs2_commit_trans(OCFS2_SB(sb), handle); 1067 if (status < 0) { 1068 mlog_errno(status); 1069 goto out; 1070 } 1071 1072 list_add_tail(&chunk->qc_chunk, &oinfo->dqi_chunk); 1073 chunk->qc_num = list_entry(chunk->qc_chunk.prev, 1074 struct ocfs2_quota_chunk, 1075 qc_chunk)->qc_num + 1; 1076 chunk->qc_headerbh = bh; 1077 *offset = 0; 1078 return chunk; 1079out_trans: 1080 ocfs2_commit_trans(OCFS2_SB(sb), handle); 1081out: 1082 brelse(bh); 1083 brelse(dbh); 1084 kmem_cache_free(ocfs2_qf_chunk_cachep, chunk); 1085 return ERR_PTR(status); 1086} 1087 1088/* Find free entry in local quota file */ 1089static struct ocfs2_quota_chunk *ocfs2_extend_local_quota_file( 1090 struct super_block *sb, 1091 int type, 1092 int *offset) 1093{ 1094 struct mem_dqinfo *info = sb_dqinfo(sb, type); 1095 struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv; 1096 struct ocfs2_quota_chunk *chunk; 1097 struct inode *lqinode = sb_dqopt(sb)->files[type]; 1098 struct ocfs2_local_disk_chunk *dchunk; 1099 int epb = ol_quota_entries_per_block(sb); 1100 unsigned int chunk_blocks; 1101 struct buffer_head *bh; 1102 u64 p_blkno; 1103 int status; 1104 handle_t *handle; 1105 1106 if (list_empty(&oinfo->dqi_chunk)) 1107 return ocfs2_local_quota_add_chunk(sb, type, offset); 1108 /* Is the last chunk full? */ 1109 chunk = list_entry(oinfo->dqi_chunk.prev, 1110 struct ocfs2_quota_chunk, qc_chunk); 1111 chunk_blocks = oinfo->dqi_blocks - 1112 ol_quota_chunk_block(sb, chunk->qc_num) - 1; 1113 if (ol_chunk_blocks(sb) == chunk_blocks) 1114 return ocfs2_local_quota_add_chunk(sb, type, offset); 1115 1116 /* We are protected by dqio_sem so no locking needed */ 1117 status = ocfs2_extend_no_holes(lqinode, NULL, 1118 lqinode->i_size + sb->s_blocksize, 1119 lqinode->i_size); 1120 if (status < 0) { 1121 mlog_errno(status); 1122 goto out; 1123 } 1124 status = ocfs2_simple_size_update(lqinode, oinfo->dqi_lqi_bh, 1125 lqinode->i_size + sb->s_blocksize); 1126 if (status < 0) { 1127 mlog_errno(status); 1128 goto out; 1129 } 1130 1131 /* Get buffer from the just added block */ 1132 status = ocfs2_extent_map_get_blocks(lqinode, oinfo->dqi_blocks, 1133 &p_blkno, NULL, NULL); 1134 if (status < 0) { 1135 mlog_errno(status); 1136 goto out; 1137 } 1138 bh = sb_getblk(sb, p_blkno); 1139 if (!bh) { 1140 status = -ENOMEM; 1141 mlog_errno(status); 1142 goto out; 1143 } 1144 ocfs2_set_new_buffer_uptodate(INODE_CACHE(lqinode), bh); 1145 1146 /* Local quota info, chunk header and the new block we initialize */ 1147 handle = ocfs2_start_trans(OCFS2_SB(sb), 1148 OCFS2_LOCAL_QINFO_WRITE_CREDITS + 1149 2 * OCFS2_QUOTA_BLOCK_UPDATE_CREDITS); 1150 if (IS_ERR(handle)) { 1151 status = PTR_ERR(handle); 1152 mlog_errno(status); 1153 goto out; 1154 } 1155 /* Zero created block */ 1156 status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode), bh, 1157 OCFS2_JOURNAL_ACCESS_CREATE); 1158 if (status < 0) { 1159 mlog_errno(status); 1160 goto out_trans; 1161 } 1162 lock_buffer(bh); 1163 memset(bh->b_data, 0, sb->s_blocksize); 1164 unlock_buffer(bh); 1165 ocfs2_journal_dirty(handle, bh); 1166 1167 /* Update chunk header */ 1168 status = ocfs2_journal_access_dq(handle, INODE_CACHE(lqinode), 1169 chunk->qc_headerbh, 1170 OCFS2_JOURNAL_ACCESS_WRITE); 1171 if (status < 0) { 1172 mlog_errno(status); 1173 goto out_trans; 1174 } 1175 1176 dchunk = (struct ocfs2_local_disk_chunk *)chunk->qc_headerbh->b_data; 1177 lock_buffer(chunk->qc_headerbh); 1178 le32_add_cpu(&dchunk->dqc_free, ol_quota_entries_per_block(sb)); 1179 unlock_buffer(chunk->qc_headerbh); 1180 ocfs2_journal_dirty(handle, chunk->qc_headerbh); 1181 1182 /* Update file header */ 1183 oinfo->dqi_blocks++; 1184 status = ocfs2_local_write_info(sb, type); 1185 if (status < 0) { 1186 mlog_errno(status); 1187 goto out_trans; 1188 } 1189 1190 status = ocfs2_commit_trans(OCFS2_SB(sb), handle); 1191 if (status < 0) { 1192 mlog_errno(status); 1193 goto out; 1194 } 1195 *offset = chunk_blocks * epb; 1196 return chunk; 1197out_trans: 1198 ocfs2_commit_trans(OCFS2_SB(sb), handle); 1199out: 1200 return ERR_PTR(status); 1201} 1202 1203static void olq_alloc_dquot(struct buffer_head *bh, void *private) 1204{ 1205 int *offset = private; 1206 struct ocfs2_local_disk_chunk *dchunk; 1207 1208 dchunk = (struct ocfs2_local_disk_chunk *)bh->b_data; 1209 ocfs2_set_bit(*offset, dchunk->dqc_bitmap); 1210 le32_add_cpu(&dchunk->dqc_free, -1); 1211} 1212 1213/* Create dquot in the local file for given id */ 1214int ocfs2_create_local_dquot(struct dquot *dquot) 1215{ 1216 struct super_block *sb = dquot->dq_sb; 1217 int type = dquot->dq_type; 1218 struct inode *lqinode = sb_dqopt(sb)->files[type]; 1219 struct ocfs2_quota_chunk *chunk; 1220 struct ocfs2_dquot *od = OCFS2_DQUOT(dquot); 1221 int offset; 1222 int status; 1223 u64 pcount; 1224 1225 down_write(&OCFS2_I(lqinode)->ip_alloc_sem); 1226 chunk = ocfs2_find_free_entry(sb, type, &offset); 1227 if (!chunk) { 1228 chunk = ocfs2_extend_local_quota_file(sb, type, &offset); 1229 if (IS_ERR(chunk)) { 1230 status = PTR_ERR(chunk); 1231 goto out; 1232 } 1233 } else if (IS_ERR(chunk)) { 1234 status = PTR_ERR(chunk); 1235 goto out; 1236 } 1237 od->dq_local_off = ol_dqblk_off(sb, chunk->qc_num, offset); 1238 od->dq_chunk = chunk; 1239 status = ocfs2_extent_map_get_blocks(lqinode, 1240 ol_dqblk_block(sb, chunk->qc_num, offset), 1241 &od->dq_local_phys_blk, 1242 &pcount, 1243 NULL); 1244 1245 /* Initialize dquot structure on disk */ 1246 status = ocfs2_local_write_dquot(dquot); 1247 if (status < 0) { 1248 mlog_errno(status); 1249 goto out; 1250 } 1251 1252 /* Mark structure as allocated */ 1253 status = ocfs2_modify_bh(lqinode, chunk->qc_headerbh, olq_alloc_dquot, 1254 &offset); 1255 if (status < 0) { 1256 mlog_errno(status); 1257 goto out; 1258 } 1259out: 1260 up_write(&OCFS2_I(lqinode)->ip_alloc_sem); 1261 return status; 1262} 1263 1264/* 1265 * Release dquot structure from local quota file. ocfs2_release_dquot() has 1266 * already started a transaction and written all changes to global quota file 1267 */ 1268int ocfs2_local_release_dquot(handle_t *handle, struct dquot *dquot) 1269{ 1270 int status; 1271 int type = dquot->dq_type; 1272 struct ocfs2_dquot *od = OCFS2_DQUOT(dquot); 1273 struct super_block *sb = dquot->dq_sb; 1274 struct ocfs2_local_disk_chunk *dchunk; 1275 int offset; 1276 1277 status = ocfs2_journal_access_dq(handle, 1278 INODE_CACHE(sb_dqopt(sb)->files[type]), 1279 od->dq_chunk->qc_headerbh, OCFS2_JOURNAL_ACCESS_WRITE); 1280 if (status < 0) { 1281 mlog_errno(status); 1282 goto out; 1283 } 1284 offset = ol_dqblk_chunk_off(sb, od->dq_chunk->qc_num, 1285 od->dq_local_off); 1286 dchunk = (struct ocfs2_local_disk_chunk *) 1287 (od->dq_chunk->qc_headerbh->b_data); 1288 /* Mark structure as freed */ 1289 lock_buffer(od->dq_chunk->qc_headerbh); 1290 ocfs2_clear_bit(offset, dchunk->dqc_bitmap); 1291 le32_add_cpu(&dchunk->dqc_free, 1); 1292 unlock_buffer(od->dq_chunk->qc_headerbh); 1293 ocfs2_journal_dirty(handle, od->dq_chunk->qc_headerbh); 1294 1295out: 1296 /* Clear the read bit so that next time someone uses this 1297 * dquot he reads fresh info from disk and allocates local 1298 * dquot structure */ 1299 clear_bit(DQ_READ_B, &dquot->dq_flags); 1300 return status; 1301} 1302 1303static const struct quota_format_ops ocfs2_format_ops = { 1304 .check_quota_file = ocfs2_local_check_quota_file, 1305 .read_file_info = ocfs2_local_read_info, 1306 .write_file_info = ocfs2_global_write_info, 1307 .free_file_info = ocfs2_local_free_info, 1308}; 1309 1310struct quota_format_type ocfs2_quota_format = { 1311 .qf_fmt_id = QFMT_OCFS2, 1312 .qf_ops = &ocfs2_format_ops, 1313 .qf_owner = THIS_MODULE 1314}; 1315