1 /* -*- mode: c; c-basic-offset: 8; -*- 2 * vim: noexpandtab sw=8 ts=8 sts=0: 3 * 4 * suballoc.c 5 * 6 * metadata alloc and free 7 * Inspired by ext3 block groups. 8 * 9 * Copyright (C) 2002, 2004 Oracle. All rights reserved. 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public 13 * License as published by the Free Software Foundation; either 14 * version 2 of the License, or (at your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public 22 * License along with this program; if not, write to the 23 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 24 * Boston, MA 021110-1307, USA. 25 */ 26 27 #include <linux/fs.h> 28 #include <linux/types.h> 29 #include <linux/slab.h> 30 #include <linux/highmem.h> 31 32 #include <cluster/masklog.h> 33 34 #include "ocfs2.h" 35 36 #include "alloc.h" 37 #include "blockcheck.h" 38 #include "dlmglue.h" 39 #include "inode.h" 40 #include "journal.h" 41 #include "localalloc.h" 42 #include "suballoc.h" 43 #include "super.h" 44 #include "sysfile.h" 45 #include "uptodate.h" 46 #include "ocfs2_trace.h" 47 48 #include "buffer_head_io.h" 49 50 #define NOT_ALLOC_NEW_GROUP 0 51 #define ALLOC_NEW_GROUP 0x1 52 #define ALLOC_GROUPS_FROM_GLOBAL 0x2 53 54 #define OCFS2_MAX_TO_STEAL 1024 55 56 struct ocfs2_suballoc_result { 57 u64 sr_bg_blkno; /* The bg we allocated from. Set 58 to 0 when a block group is 59 contiguous. */ 60 u64 sr_bg_stable_blkno; /* 61 * Doesn't change, always 62 * set to target block 63 * group descriptor 64 * block. 65 */ 66 u64 sr_blkno; /* The first allocated block */ 67 unsigned int sr_bit_offset; /* The bit in the bg */ 68 unsigned int sr_bits; /* How many bits we claimed */ 69 }; 70 71 static u64 ocfs2_group_from_res(struct ocfs2_suballoc_result *res) 72 { 73 if (res->sr_blkno == 0) 74 return 0; 75 76 if (res->sr_bg_blkno) 77 return res->sr_bg_blkno; 78 79 return ocfs2_which_suballoc_group(res->sr_blkno, res->sr_bit_offset); 80 } 81 82 static inline void ocfs2_debug_bg(struct ocfs2_group_desc *bg); 83 static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode *fe); 84 static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl); 85 static int ocfs2_block_group_fill(handle_t *handle, 86 struct inode *alloc_inode, 87 struct buffer_head *bg_bh, 88 u64 group_blkno, 89 unsigned int group_clusters, 90 u16 my_chain, 91 struct ocfs2_chain_list *cl); 92 static int ocfs2_block_group_alloc(struct ocfs2_super *osb, 93 struct inode *alloc_inode, 94 struct buffer_head *bh, 95 u64 max_block, 96 u64 *last_alloc_group, 97 int flags); 98 99 static int ocfs2_cluster_group_search(struct inode *inode, 100 struct buffer_head *group_bh, 101 u32 bits_wanted, u32 min_bits, 102 u64 max_block, 103 struct ocfs2_suballoc_result *res); 104 static int ocfs2_block_group_search(struct inode *inode, 105 struct buffer_head *group_bh, 106 u32 bits_wanted, u32 min_bits, 107 u64 max_block, 108 struct ocfs2_suballoc_result *res); 109 static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac, 110 handle_t *handle, 111 u32 bits_wanted, 112 u32 min_bits, 113 struct ocfs2_suballoc_result *res); 114 static int ocfs2_test_bg_bit_allocatable(struct buffer_head *bg_bh, 115 int nr); 116 static int ocfs2_relink_block_group(handle_t *handle, 117 struct inode *alloc_inode, 118 struct buffer_head *fe_bh, 119 struct buffer_head *bg_bh, 120 struct buffer_head *prev_bg_bh, 121 u16 chain); 122 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg, 123 u32 wanted); 124 static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode, 125 u64 bg_blkno, 126 u16 bg_bit_off); 127 static inline void ocfs2_block_to_cluster_group(struct inode *inode, 128 u64 data_blkno, 129 u64 *bg_blkno, 130 u16 *bg_bit_off); 131 static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super *osb, 132 u32 bits_wanted, u64 max_block, 133 int flags, 134 struct ocfs2_alloc_context **ac); 135 136 void ocfs2_free_ac_resource(struct ocfs2_alloc_context *ac) 137 { 138 struct inode *inode = ac->ac_inode; 139 140 if (inode) { 141 if (ac->ac_which != OCFS2_AC_USE_LOCAL) 142 ocfs2_inode_unlock(inode, 1); 143 144 inode_unlock(inode); 145 146 iput(inode); 147 ac->ac_inode = NULL; 148 } 149 brelse(ac->ac_bh); 150 ac->ac_bh = NULL; 151 ac->ac_resv = NULL; 152 kfree(ac->ac_find_loc_priv); 153 ac->ac_find_loc_priv = NULL; 154 } 155 156 void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac) 157 { 158 ocfs2_free_ac_resource(ac); 159 kfree(ac); 160 } 161 162 static u32 ocfs2_bits_per_group(struct ocfs2_chain_list *cl) 163 { 164 return (u32)le16_to_cpu(cl->cl_cpg) * (u32)le16_to_cpu(cl->cl_bpc); 165 } 166 167 #define do_error(fmt, ...) \ 168 do { \ 169 if (resize) \ 170 mlog(ML_ERROR, fmt, ##__VA_ARGS__); \ 171 else \ 172 return ocfs2_error(sb, fmt, ##__VA_ARGS__); \ 173 } while (0) 174 175 static int ocfs2_validate_gd_self(struct super_block *sb, 176 struct buffer_head *bh, 177 int resize) 178 { 179 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data; 180 181 if (!OCFS2_IS_VALID_GROUP_DESC(gd)) { 182 do_error("Group descriptor #%llu has bad signature %.*s\n", 183 (unsigned long long)bh->b_blocknr, 7, 184 gd->bg_signature); 185 } 186 187 if (le64_to_cpu(gd->bg_blkno) != bh->b_blocknr) { 188 do_error("Group descriptor #%llu has an invalid bg_blkno of %llu\n", 189 (unsigned long long)bh->b_blocknr, 190 (unsigned long long)le64_to_cpu(gd->bg_blkno)); 191 } 192 193 if (le32_to_cpu(gd->bg_generation) != OCFS2_SB(sb)->fs_generation) { 194 do_error("Group descriptor #%llu has an invalid fs_generation of #%u\n", 195 (unsigned long long)bh->b_blocknr, 196 le32_to_cpu(gd->bg_generation)); 197 } 198 199 if (le16_to_cpu(gd->bg_free_bits_count) > le16_to_cpu(gd->bg_bits)) { 200 do_error("Group descriptor #%llu has bit count %u but claims that %u are free\n", 201 (unsigned long long)bh->b_blocknr, 202 le16_to_cpu(gd->bg_bits), 203 le16_to_cpu(gd->bg_free_bits_count)); 204 } 205 206 if (le16_to_cpu(gd->bg_bits) > (8 * le16_to_cpu(gd->bg_size))) { 207 do_error("Group descriptor #%llu has bit count %u but max bitmap bits of %u\n", 208 (unsigned long long)bh->b_blocknr, 209 le16_to_cpu(gd->bg_bits), 210 8 * le16_to_cpu(gd->bg_size)); 211 } 212 213 return 0; 214 } 215 216 static int ocfs2_validate_gd_parent(struct super_block *sb, 217 struct ocfs2_dinode *di, 218 struct buffer_head *bh, 219 int resize) 220 { 221 unsigned int max_bits; 222 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data; 223 224 if (di->i_blkno != gd->bg_parent_dinode) { 225 do_error("Group descriptor #%llu has bad parent pointer (%llu, expected %llu)\n", 226 (unsigned long long)bh->b_blocknr, 227 (unsigned long long)le64_to_cpu(gd->bg_parent_dinode), 228 (unsigned long long)le64_to_cpu(di->i_blkno)); 229 } 230 231 max_bits = le16_to_cpu(di->id2.i_chain.cl_cpg) * le16_to_cpu(di->id2.i_chain.cl_bpc); 232 if (le16_to_cpu(gd->bg_bits) > max_bits) { 233 do_error("Group descriptor #%llu has bit count of %u\n", 234 (unsigned long long)bh->b_blocknr, 235 le16_to_cpu(gd->bg_bits)); 236 } 237 238 /* In resize, we may meet the case bg_chain == cl_next_free_rec. */ 239 if ((le16_to_cpu(gd->bg_chain) > 240 le16_to_cpu(di->id2.i_chain.cl_next_free_rec)) || 241 ((le16_to_cpu(gd->bg_chain) == 242 le16_to_cpu(di->id2.i_chain.cl_next_free_rec)) && !resize)) { 243 do_error("Group descriptor #%llu has bad chain %u\n", 244 (unsigned long long)bh->b_blocknr, 245 le16_to_cpu(gd->bg_chain)); 246 } 247 248 return 0; 249 } 250 251 #undef do_error 252 253 /* 254 * This version only prints errors. It does not fail the filesystem, and 255 * exists only for resize. 256 */ 257 int ocfs2_check_group_descriptor(struct super_block *sb, 258 struct ocfs2_dinode *di, 259 struct buffer_head *bh) 260 { 261 int rc; 262 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data; 263 264 BUG_ON(!buffer_uptodate(bh)); 265 266 /* 267 * If the ecc fails, we return the error but otherwise 268 * leave the filesystem running. We know any error is 269 * local to this block. 270 */ 271 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &gd->bg_check); 272 if (rc) { 273 mlog(ML_ERROR, 274 "Checksum failed for group descriptor %llu\n", 275 (unsigned long long)bh->b_blocknr); 276 } else 277 rc = ocfs2_validate_gd_self(sb, bh, 1); 278 if (!rc) 279 rc = ocfs2_validate_gd_parent(sb, di, bh, 1); 280 281 return rc; 282 } 283 284 static int ocfs2_validate_group_descriptor(struct super_block *sb, 285 struct buffer_head *bh) 286 { 287 int rc; 288 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *)bh->b_data; 289 290 trace_ocfs2_validate_group_descriptor( 291 (unsigned long long)bh->b_blocknr); 292 293 BUG_ON(!buffer_uptodate(bh)); 294 295 /* 296 * If the ecc fails, we return the error but otherwise 297 * leave the filesystem running. We know any error is 298 * local to this block. 299 */ 300 rc = ocfs2_validate_meta_ecc(sb, bh->b_data, &gd->bg_check); 301 if (rc) 302 return rc; 303 304 /* 305 * Errors after here are fatal. 306 */ 307 308 return ocfs2_validate_gd_self(sb, bh, 0); 309 } 310 311 int ocfs2_read_group_descriptor(struct inode *inode, struct ocfs2_dinode *di, 312 u64 gd_blkno, struct buffer_head **bh) 313 { 314 int rc; 315 struct buffer_head *tmp = *bh; 316 317 rc = ocfs2_read_block(INODE_CACHE(inode), gd_blkno, &tmp, 318 ocfs2_validate_group_descriptor); 319 if (rc) 320 goto out; 321 322 rc = ocfs2_validate_gd_parent(inode->i_sb, di, tmp, 0); 323 if (rc) { 324 brelse(tmp); 325 goto out; 326 } 327 328 /* If ocfs2_read_block() got us a new bh, pass it up. */ 329 if (!*bh) 330 *bh = tmp; 331 332 out: 333 return rc; 334 } 335 336 static void ocfs2_bg_discontig_add_extent(struct ocfs2_super *osb, 337 struct ocfs2_group_desc *bg, 338 struct ocfs2_chain_list *cl, 339 u64 p_blkno, unsigned int clusters) 340 { 341 struct ocfs2_extent_list *el = &bg->bg_list; 342 struct ocfs2_extent_rec *rec; 343 344 BUG_ON(!ocfs2_supports_discontig_bg(osb)); 345 if (!el->l_next_free_rec) 346 el->l_count = cpu_to_le16(ocfs2_extent_recs_per_gd(osb->sb)); 347 rec = &el->l_recs[le16_to_cpu(el->l_next_free_rec)]; 348 rec->e_blkno = cpu_to_le64(p_blkno); 349 rec->e_cpos = cpu_to_le32(le16_to_cpu(bg->bg_bits) / 350 le16_to_cpu(cl->cl_bpc)); 351 rec->e_leaf_clusters = cpu_to_le16(clusters); 352 le16_add_cpu(&bg->bg_bits, clusters * le16_to_cpu(cl->cl_bpc)); 353 le16_add_cpu(&bg->bg_free_bits_count, 354 clusters * le16_to_cpu(cl->cl_bpc)); 355 le16_add_cpu(&el->l_next_free_rec, 1); 356 } 357 358 static int ocfs2_block_group_fill(handle_t *handle, 359 struct inode *alloc_inode, 360 struct buffer_head *bg_bh, 361 u64 group_blkno, 362 unsigned int group_clusters, 363 u16 my_chain, 364 struct ocfs2_chain_list *cl) 365 { 366 int status = 0; 367 struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb); 368 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data; 369 struct super_block * sb = alloc_inode->i_sb; 370 371 if (((unsigned long long) bg_bh->b_blocknr) != group_blkno) { 372 status = ocfs2_error(alloc_inode->i_sb, 373 "group block (%llu) != b_blocknr (%llu)\n", 374 (unsigned long long)group_blkno, 375 (unsigned long long) bg_bh->b_blocknr); 376 goto bail; 377 } 378 379 status = ocfs2_journal_access_gd(handle, 380 INODE_CACHE(alloc_inode), 381 bg_bh, 382 OCFS2_JOURNAL_ACCESS_CREATE); 383 if (status < 0) { 384 mlog_errno(status); 385 goto bail; 386 } 387 388 memset(bg, 0, sb->s_blocksize); 389 strcpy(bg->bg_signature, OCFS2_GROUP_DESC_SIGNATURE); 390 bg->bg_generation = cpu_to_le32(OCFS2_SB(sb)->fs_generation); 391 bg->bg_size = cpu_to_le16(ocfs2_group_bitmap_size(sb, 1, 392 osb->s_feature_incompat)); 393 bg->bg_chain = cpu_to_le16(my_chain); 394 bg->bg_next_group = cl->cl_recs[my_chain].c_blkno; 395 bg->bg_parent_dinode = cpu_to_le64(OCFS2_I(alloc_inode)->ip_blkno); 396 bg->bg_blkno = cpu_to_le64(group_blkno); 397 if (group_clusters == le16_to_cpu(cl->cl_cpg)) 398 bg->bg_bits = cpu_to_le16(ocfs2_bits_per_group(cl)); 399 else 400 ocfs2_bg_discontig_add_extent(osb, bg, cl, group_blkno, 401 group_clusters); 402 403 /* set the 1st bit in the bitmap to account for the descriptor block */ 404 ocfs2_set_bit(0, (unsigned long *)bg->bg_bitmap); 405 bg->bg_free_bits_count = cpu_to_le16(le16_to_cpu(bg->bg_bits) - 1); 406 407 ocfs2_journal_dirty(handle, bg_bh); 408 409 /* There is no need to zero out or otherwise initialize the 410 * other blocks in a group - All valid FS metadata in a block 411 * group stores the superblock fs_generation value at 412 * allocation time. */ 413 414 bail: 415 if (status) 416 mlog_errno(status); 417 return status; 418 } 419 420 static inline u16 ocfs2_find_smallest_chain(struct ocfs2_chain_list *cl) 421 { 422 u16 curr, best; 423 424 best = curr = 0; 425 while (curr < le16_to_cpu(cl->cl_count)) { 426 if (le32_to_cpu(cl->cl_recs[best].c_total) > 427 le32_to_cpu(cl->cl_recs[curr].c_total)) 428 best = curr; 429 curr++; 430 } 431 return best; 432 } 433 434 static struct buffer_head * 435 ocfs2_block_group_alloc_contig(struct ocfs2_super *osb, handle_t *handle, 436 struct inode *alloc_inode, 437 struct ocfs2_alloc_context *ac, 438 struct ocfs2_chain_list *cl) 439 { 440 int status; 441 u32 bit_off, num_bits; 442 u64 bg_blkno; 443 struct buffer_head *bg_bh; 444 unsigned int alloc_rec = ocfs2_find_smallest_chain(cl); 445 446 status = ocfs2_claim_clusters(handle, ac, 447 le16_to_cpu(cl->cl_cpg), &bit_off, 448 &num_bits); 449 if (status < 0) { 450 if (status != -ENOSPC) 451 mlog_errno(status); 452 goto bail; 453 } 454 455 /* setup the group */ 456 bg_blkno = ocfs2_clusters_to_blocks(osb->sb, bit_off); 457 trace_ocfs2_block_group_alloc_contig( 458 (unsigned long long)bg_blkno, alloc_rec); 459 460 bg_bh = sb_getblk(osb->sb, bg_blkno); 461 if (!bg_bh) { 462 status = -ENOMEM; 463 mlog_errno(status); 464 goto bail; 465 } 466 ocfs2_set_new_buffer_uptodate(INODE_CACHE(alloc_inode), bg_bh); 467 468 status = ocfs2_block_group_fill(handle, alloc_inode, bg_bh, 469 bg_blkno, num_bits, alloc_rec, cl); 470 if (status < 0) { 471 brelse(bg_bh); 472 mlog_errno(status); 473 } 474 475 bail: 476 return status ? ERR_PTR(status) : bg_bh; 477 } 478 479 static int ocfs2_block_group_claim_bits(struct ocfs2_super *osb, 480 handle_t *handle, 481 struct ocfs2_alloc_context *ac, 482 unsigned int min_bits, 483 u32 *bit_off, u32 *num_bits) 484 { 485 int status = 0; 486 487 while (min_bits) { 488 status = ocfs2_claim_clusters(handle, ac, min_bits, 489 bit_off, num_bits); 490 if (status != -ENOSPC) 491 break; 492 493 min_bits >>= 1; 494 } 495 496 return status; 497 } 498 499 static int ocfs2_block_group_grow_discontig(handle_t *handle, 500 struct inode *alloc_inode, 501 struct buffer_head *bg_bh, 502 struct ocfs2_alloc_context *ac, 503 struct ocfs2_chain_list *cl, 504 unsigned int min_bits) 505 { 506 int status; 507 struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb); 508 struct ocfs2_group_desc *bg = 509 (struct ocfs2_group_desc *)bg_bh->b_data; 510 unsigned int needed = le16_to_cpu(cl->cl_cpg) - 511 le16_to_cpu(bg->bg_bits) / le16_to_cpu(cl->cl_bpc); 512 u32 p_cpos, clusters; 513 u64 p_blkno; 514 struct ocfs2_extent_list *el = &bg->bg_list; 515 516 status = ocfs2_journal_access_gd(handle, 517 INODE_CACHE(alloc_inode), 518 bg_bh, 519 OCFS2_JOURNAL_ACCESS_CREATE); 520 if (status < 0) { 521 mlog_errno(status); 522 goto bail; 523 } 524 525 while ((needed > 0) && (le16_to_cpu(el->l_next_free_rec) < 526 le16_to_cpu(el->l_count))) { 527 if (min_bits > needed) 528 min_bits = needed; 529 status = ocfs2_block_group_claim_bits(osb, handle, ac, 530 min_bits, &p_cpos, 531 &clusters); 532 if (status < 0) { 533 if (status != -ENOSPC) 534 mlog_errno(status); 535 goto bail; 536 } 537 p_blkno = ocfs2_clusters_to_blocks(osb->sb, p_cpos); 538 ocfs2_bg_discontig_add_extent(osb, bg, cl, p_blkno, 539 clusters); 540 541 min_bits = clusters; 542 needed = le16_to_cpu(cl->cl_cpg) - 543 le16_to_cpu(bg->bg_bits) / le16_to_cpu(cl->cl_bpc); 544 } 545 546 if (needed > 0) { 547 /* 548 * We have used up all the extent rec but can't fill up 549 * the cpg. So bail out. 550 */ 551 status = -ENOSPC; 552 goto bail; 553 } 554 555 ocfs2_journal_dirty(handle, bg_bh); 556 557 bail: 558 return status; 559 } 560 561 static void ocfs2_bg_alloc_cleanup(handle_t *handle, 562 struct ocfs2_alloc_context *cluster_ac, 563 struct inode *alloc_inode, 564 struct buffer_head *bg_bh) 565 { 566 int i, ret; 567 struct ocfs2_group_desc *bg; 568 struct ocfs2_extent_list *el; 569 struct ocfs2_extent_rec *rec; 570 571 if (!bg_bh) 572 return; 573 574 bg = (struct ocfs2_group_desc *)bg_bh->b_data; 575 el = &bg->bg_list; 576 for (i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) { 577 rec = &el->l_recs[i]; 578 ret = ocfs2_free_clusters(handle, cluster_ac->ac_inode, 579 cluster_ac->ac_bh, 580 le64_to_cpu(rec->e_blkno), 581 le16_to_cpu(rec->e_leaf_clusters)); 582 if (ret) 583 mlog_errno(ret); 584 /* Try all the clusters to free */ 585 } 586 587 ocfs2_remove_from_cache(INODE_CACHE(alloc_inode), bg_bh); 588 brelse(bg_bh); 589 } 590 591 static struct buffer_head * 592 ocfs2_block_group_alloc_discontig(handle_t *handle, 593 struct inode *alloc_inode, 594 struct ocfs2_alloc_context *ac, 595 struct ocfs2_chain_list *cl) 596 { 597 int status; 598 u32 bit_off, num_bits; 599 u64 bg_blkno; 600 unsigned int min_bits = le16_to_cpu(cl->cl_cpg) >> 1; 601 struct buffer_head *bg_bh = NULL; 602 unsigned int alloc_rec = ocfs2_find_smallest_chain(cl); 603 struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb); 604 605 if (!ocfs2_supports_discontig_bg(osb)) { 606 status = -ENOSPC; 607 goto bail; 608 } 609 610 status = ocfs2_extend_trans(handle, 611 ocfs2_calc_bg_discontig_credits(osb->sb)); 612 if (status) { 613 mlog_errno(status); 614 goto bail; 615 } 616 617 /* 618 * We're going to be grabbing from multiple cluster groups. 619 * We don't have enough credits to relink them all, and the 620 * cluster groups will be staying in cache for the duration of 621 * this operation. 622 */ 623 ac->ac_disable_chain_relink = 1; 624 625 /* Claim the first region */ 626 status = ocfs2_block_group_claim_bits(osb, handle, ac, min_bits, 627 &bit_off, &num_bits); 628 if (status < 0) { 629 if (status != -ENOSPC) 630 mlog_errno(status); 631 goto bail; 632 } 633 min_bits = num_bits; 634 635 /* setup the group */ 636 bg_blkno = ocfs2_clusters_to_blocks(osb->sb, bit_off); 637 trace_ocfs2_block_group_alloc_discontig( 638 (unsigned long long)bg_blkno, alloc_rec); 639 640 bg_bh = sb_getblk(osb->sb, bg_blkno); 641 if (!bg_bh) { 642 status = -ENOMEM; 643 mlog_errno(status); 644 goto bail; 645 } 646 ocfs2_set_new_buffer_uptodate(INODE_CACHE(alloc_inode), bg_bh); 647 648 status = ocfs2_block_group_fill(handle, alloc_inode, bg_bh, 649 bg_blkno, num_bits, alloc_rec, cl); 650 if (status < 0) { 651 mlog_errno(status); 652 goto bail; 653 } 654 655 status = ocfs2_block_group_grow_discontig(handle, alloc_inode, 656 bg_bh, ac, cl, min_bits); 657 if (status) 658 mlog_errno(status); 659 660 bail: 661 if (status) 662 ocfs2_bg_alloc_cleanup(handle, ac, alloc_inode, bg_bh); 663 return status ? ERR_PTR(status) : bg_bh; 664 } 665 666 /* 667 * We expect the block group allocator to already be locked. 668 */ 669 static int ocfs2_block_group_alloc(struct ocfs2_super *osb, 670 struct inode *alloc_inode, 671 struct buffer_head *bh, 672 u64 max_block, 673 u64 *last_alloc_group, 674 int flags) 675 { 676 int status, credits; 677 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) bh->b_data; 678 struct ocfs2_chain_list *cl; 679 struct ocfs2_alloc_context *ac = NULL; 680 handle_t *handle = NULL; 681 u16 alloc_rec; 682 struct buffer_head *bg_bh = NULL; 683 struct ocfs2_group_desc *bg; 684 685 BUG_ON(ocfs2_is_cluster_bitmap(alloc_inode)); 686 687 cl = &fe->id2.i_chain; 688 status = ocfs2_reserve_clusters_with_limit(osb, 689 le16_to_cpu(cl->cl_cpg), 690 max_block, flags, &ac); 691 if (status < 0) { 692 if (status != -ENOSPC) 693 mlog_errno(status); 694 goto bail; 695 } 696 697 credits = ocfs2_calc_group_alloc_credits(osb->sb, 698 le16_to_cpu(cl->cl_cpg)); 699 handle = ocfs2_start_trans(osb, credits); 700 if (IS_ERR(handle)) { 701 status = PTR_ERR(handle); 702 handle = NULL; 703 mlog_errno(status); 704 goto bail; 705 } 706 707 if (last_alloc_group && *last_alloc_group != 0) { 708 trace_ocfs2_block_group_alloc( 709 (unsigned long long)*last_alloc_group); 710 ac->ac_last_group = *last_alloc_group; 711 } 712 713 bg_bh = ocfs2_block_group_alloc_contig(osb, handle, alloc_inode, 714 ac, cl); 715 if (IS_ERR(bg_bh) && (PTR_ERR(bg_bh) == -ENOSPC)) 716 bg_bh = ocfs2_block_group_alloc_discontig(handle, 717 alloc_inode, 718 ac, cl); 719 if (IS_ERR(bg_bh)) { 720 status = PTR_ERR(bg_bh); 721 bg_bh = NULL; 722 if (status != -ENOSPC) 723 mlog_errno(status); 724 goto bail; 725 } 726 bg = (struct ocfs2_group_desc *) bg_bh->b_data; 727 728 status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode), 729 bh, OCFS2_JOURNAL_ACCESS_WRITE); 730 if (status < 0) { 731 mlog_errno(status); 732 goto bail; 733 } 734 735 alloc_rec = le16_to_cpu(bg->bg_chain); 736 le32_add_cpu(&cl->cl_recs[alloc_rec].c_free, 737 le16_to_cpu(bg->bg_free_bits_count)); 738 le32_add_cpu(&cl->cl_recs[alloc_rec].c_total, 739 le16_to_cpu(bg->bg_bits)); 740 cl->cl_recs[alloc_rec].c_blkno = bg->bg_blkno; 741 if (le16_to_cpu(cl->cl_next_free_rec) < le16_to_cpu(cl->cl_count)) 742 le16_add_cpu(&cl->cl_next_free_rec, 1); 743 744 le32_add_cpu(&fe->id1.bitmap1.i_used, le16_to_cpu(bg->bg_bits) - 745 le16_to_cpu(bg->bg_free_bits_count)); 746 le32_add_cpu(&fe->id1.bitmap1.i_total, le16_to_cpu(bg->bg_bits)); 747 le32_add_cpu(&fe->i_clusters, le16_to_cpu(cl->cl_cpg)); 748 749 ocfs2_journal_dirty(handle, bh); 750 751 spin_lock(&OCFS2_I(alloc_inode)->ip_lock); 752 OCFS2_I(alloc_inode)->ip_clusters = le32_to_cpu(fe->i_clusters); 753 fe->i_size = cpu_to_le64(ocfs2_clusters_to_bytes(alloc_inode->i_sb, 754 le32_to_cpu(fe->i_clusters))); 755 spin_unlock(&OCFS2_I(alloc_inode)->ip_lock); 756 i_size_write(alloc_inode, le64_to_cpu(fe->i_size)); 757 alloc_inode->i_blocks = ocfs2_inode_sector_count(alloc_inode); 758 ocfs2_update_inode_fsync_trans(handle, alloc_inode, 0); 759 760 status = 0; 761 762 /* save the new last alloc group so that the caller can cache it. */ 763 if (last_alloc_group) 764 *last_alloc_group = ac->ac_last_group; 765 766 bail: 767 if (handle) 768 ocfs2_commit_trans(osb, handle); 769 770 if (ac) 771 ocfs2_free_alloc_context(ac); 772 773 brelse(bg_bh); 774 775 if (status) 776 mlog_errno(status); 777 return status; 778 } 779 780 static int ocfs2_reserve_suballoc_bits(struct ocfs2_super *osb, 781 struct ocfs2_alloc_context *ac, 782 int type, 783 u32 slot, 784 u64 *last_alloc_group, 785 int flags) 786 { 787 int status; 788 u32 bits_wanted = ac->ac_bits_wanted; 789 struct inode *alloc_inode; 790 struct buffer_head *bh = NULL; 791 struct ocfs2_dinode *fe; 792 u32 free_bits; 793 794 alloc_inode = ocfs2_get_system_file_inode(osb, type, slot); 795 if (!alloc_inode) { 796 mlog_errno(-EINVAL); 797 return -EINVAL; 798 } 799 800 inode_lock(alloc_inode); 801 802 status = ocfs2_inode_lock(alloc_inode, &bh, 1); 803 if (status < 0) { 804 inode_unlock(alloc_inode); 805 iput(alloc_inode); 806 807 mlog_errno(status); 808 return status; 809 } 810 811 ac->ac_inode = alloc_inode; 812 ac->ac_alloc_slot = slot; 813 814 fe = (struct ocfs2_dinode *) bh->b_data; 815 816 /* The bh was validated by the inode read inside 817 * ocfs2_inode_lock(). Any corruption is a code bug. */ 818 BUG_ON(!OCFS2_IS_VALID_DINODE(fe)); 819 820 if (!(fe->i_flags & cpu_to_le32(OCFS2_CHAIN_FL))) { 821 status = ocfs2_error(alloc_inode->i_sb, 822 "Invalid chain allocator %llu\n", 823 (unsigned long long)le64_to_cpu(fe->i_blkno)); 824 goto bail; 825 } 826 827 free_bits = le32_to_cpu(fe->id1.bitmap1.i_total) - 828 le32_to_cpu(fe->id1.bitmap1.i_used); 829 830 if (bits_wanted > free_bits) { 831 /* cluster bitmap never grows */ 832 if (ocfs2_is_cluster_bitmap(alloc_inode)) { 833 trace_ocfs2_reserve_suballoc_bits_nospc(bits_wanted, 834 free_bits); 835 status = -ENOSPC; 836 goto bail; 837 } 838 839 if (!(flags & ALLOC_NEW_GROUP)) { 840 trace_ocfs2_reserve_suballoc_bits_no_new_group( 841 slot, bits_wanted, free_bits); 842 status = -ENOSPC; 843 goto bail; 844 } 845 846 status = ocfs2_block_group_alloc(osb, alloc_inode, bh, 847 ac->ac_max_block, 848 last_alloc_group, flags); 849 if (status < 0) { 850 if (status != -ENOSPC) 851 mlog_errno(status); 852 goto bail; 853 } 854 atomic_inc(&osb->alloc_stats.bg_extends); 855 856 /* You should never ask for this much metadata */ 857 BUG_ON(bits_wanted > 858 (le32_to_cpu(fe->id1.bitmap1.i_total) 859 - le32_to_cpu(fe->id1.bitmap1.i_used))); 860 } 861 862 get_bh(bh); 863 ac->ac_bh = bh; 864 bail: 865 brelse(bh); 866 867 if (status) 868 mlog_errno(status); 869 return status; 870 } 871 872 static void ocfs2_init_inode_steal_slot(struct ocfs2_super *osb) 873 { 874 spin_lock(&osb->osb_lock); 875 osb->s_inode_steal_slot = OCFS2_INVALID_SLOT; 876 spin_unlock(&osb->osb_lock); 877 atomic_set(&osb->s_num_inodes_stolen, 0); 878 } 879 880 static void ocfs2_init_meta_steal_slot(struct ocfs2_super *osb) 881 { 882 spin_lock(&osb->osb_lock); 883 osb->s_meta_steal_slot = OCFS2_INVALID_SLOT; 884 spin_unlock(&osb->osb_lock); 885 atomic_set(&osb->s_num_meta_stolen, 0); 886 } 887 888 void ocfs2_init_steal_slots(struct ocfs2_super *osb) 889 { 890 ocfs2_init_inode_steal_slot(osb); 891 ocfs2_init_meta_steal_slot(osb); 892 } 893 894 static void __ocfs2_set_steal_slot(struct ocfs2_super *osb, int slot, int type) 895 { 896 spin_lock(&osb->osb_lock); 897 if (type == INODE_ALLOC_SYSTEM_INODE) 898 osb->s_inode_steal_slot = slot; 899 else if (type == EXTENT_ALLOC_SYSTEM_INODE) 900 osb->s_meta_steal_slot = slot; 901 spin_unlock(&osb->osb_lock); 902 } 903 904 static int __ocfs2_get_steal_slot(struct ocfs2_super *osb, int type) 905 { 906 int slot = OCFS2_INVALID_SLOT; 907 908 spin_lock(&osb->osb_lock); 909 if (type == INODE_ALLOC_SYSTEM_INODE) 910 slot = osb->s_inode_steal_slot; 911 else if (type == EXTENT_ALLOC_SYSTEM_INODE) 912 slot = osb->s_meta_steal_slot; 913 spin_unlock(&osb->osb_lock); 914 915 return slot; 916 } 917 918 static int ocfs2_get_inode_steal_slot(struct ocfs2_super *osb) 919 { 920 return __ocfs2_get_steal_slot(osb, INODE_ALLOC_SYSTEM_INODE); 921 } 922 923 static int ocfs2_get_meta_steal_slot(struct ocfs2_super *osb) 924 { 925 return __ocfs2_get_steal_slot(osb, EXTENT_ALLOC_SYSTEM_INODE); 926 } 927 928 static int ocfs2_steal_resource(struct ocfs2_super *osb, 929 struct ocfs2_alloc_context *ac, 930 int type) 931 { 932 int i, status = -ENOSPC; 933 int slot = __ocfs2_get_steal_slot(osb, type); 934 935 /* Start to steal resource from the first slot after ours. */ 936 if (slot == OCFS2_INVALID_SLOT) 937 slot = osb->slot_num + 1; 938 939 for (i = 0; i < osb->max_slots; i++, slot++) { 940 if (slot == osb->max_slots) 941 slot = 0; 942 943 if (slot == osb->slot_num) 944 continue; 945 946 status = ocfs2_reserve_suballoc_bits(osb, ac, 947 type, 948 (u32)slot, NULL, 949 NOT_ALLOC_NEW_GROUP); 950 if (status >= 0) { 951 __ocfs2_set_steal_slot(osb, slot, type); 952 break; 953 } 954 955 ocfs2_free_ac_resource(ac); 956 } 957 958 return status; 959 } 960 961 static int ocfs2_steal_inode(struct ocfs2_super *osb, 962 struct ocfs2_alloc_context *ac) 963 { 964 return ocfs2_steal_resource(osb, ac, INODE_ALLOC_SYSTEM_INODE); 965 } 966 967 static int ocfs2_steal_meta(struct ocfs2_super *osb, 968 struct ocfs2_alloc_context *ac) 969 { 970 return ocfs2_steal_resource(osb, ac, EXTENT_ALLOC_SYSTEM_INODE); 971 } 972 973 int ocfs2_reserve_new_metadata_blocks(struct ocfs2_super *osb, 974 int blocks, 975 struct ocfs2_alloc_context **ac) 976 { 977 int status; 978 int slot = ocfs2_get_meta_steal_slot(osb); 979 980 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL); 981 if (!(*ac)) { 982 status = -ENOMEM; 983 mlog_errno(status); 984 goto bail; 985 } 986 987 (*ac)->ac_bits_wanted = blocks; 988 (*ac)->ac_which = OCFS2_AC_USE_META; 989 (*ac)->ac_group_search = ocfs2_block_group_search; 990 991 if (slot != OCFS2_INVALID_SLOT && 992 atomic_read(&osb->s_num_meta_stolen) < OCFS2_MAX_TO_STEAL) 993 goto extent_steal; 994 995 atomic_set(&osb->s_num_meta_stolen, 0); 996 status = ocfs2_reserve_suballoc_bits(osb, (*ac), 997 EXTENT_ALLOC_SYSTEM_INODE, 998 (u32)osb->slot_num, NULL, 999 ALLOC_GROUPS_FROM_GLOBAL|ALLOC_NEW_GROUP); 1000 1001 1002 if (status >= 0) { 1003 status = 0; 1004 if (slot != OCFS2_INVALID_SLOT) 1005 ocfs2_init_meta_steal_slot(osb); 1006 goto bail; 1007 } else if (status < 0 && status != -ENOSPC) { 1008 mlog_errno(status); 1009 goto bail; 1010 } 1011 1012 ocfs2_free_ac_resource(*ac); 1013 1014 extent_steal: 1015 status = ocfs2_steal_meta(osb, *ac); 1016 atomic_inc(&osb->s_num_meta_stolen); 1017 if (status < 0) { 1018 if (status != -ENOSPC) 1019 mlog_errno(status); 1020 goto bail; 1021 } 1022 1023 status = 0; 1024 bail: 1025 if ((status < 0) && *ac) { 1026 ocfs2_free_alloc_context(*ac); 1027 *ac = NULL; 1028 } 1029 1030 if (status) 1031 mlog_errno(status); 1032 return status; 1033 } 1034 1035 int ocfs2_reserve_new_metadata(struct ocfs2_super *osb, 1036 struct ocfs2_extent_list *root_el, 1037 struct ocfs2_alloc_context **ac) 1038 { 1039 return ocfs2_reserve_new_metadata_blocks(osb, 1040 ocfs2_extend_meta_needed(root_el), 1041 ac); 1042 } 1043 1044 int ocfs2_reserve_new_inode(struct ocfs2_super *osb, 1045 struct ocfs2_alloc_context **ac) 1046 { 1047 int status; 1048 int slot = ocfs2_get_inode_steal_slot(osb); 1049 u64 alloc_group; 1050 1051 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL); 1052 if (!(*ac)) { 1053 status = -ENOMEM; 1054 mlog_errno(status); 1055 goto bail; 1056 } 1057 1058 (*ac)->ac_bits_wanted = 1; 1059 (*ac)->ac_which = OCFS2_AC_USE_INODE; 1060 1061 (*ac)->ac_group_search = ocfs2_block_group_search; 1062 1063 /* 1064 * stat(2) can't handle i_ino > 32bits, so we tell the 1065 * lower levels not to allocate us a block group past that 1066 * limit. The 'inode64' mount option avoids this behavior. 1067 */ 1068 if (!(osb->s_mount_opt & OCFS2_MOUNT_INODE64)) 1069 (*ac)->ac_max_block = (u32)~0U; 1070 1071 /* 1072 * slot is set when we successfully steal inode from other nodes. 1073 * It is reset in 3 places: 1074 * 1. when we flush the truncate log 1075 * 2. when we complete local alloc recovery. 1076 * 3. when we successfully allocate from our own slot. 1077 * After it is set, we will go on stealing inodes until we find the 1078 * need to check our slots to see whether there is some space for us. 1079 */ 1080 if (slot != OCFS2_INVALID_SLOT && 1081 atomic_read(&osb->s_num_inodes_stolen) < OCFS2_MAX_TO_STEAL) 1082 goto inode_steal; 1083 1084 atomic_set(&osb->s_num_inodes_stolen, 0); 1085 alloc_group = osb->osb_inode_alloc_group; 1086 status = ocfs2_reserve_suballoc_bits(osb, *ac, 1087 INODE_ALLOC_SYSTEM_INODE, 1088 (u32)osb->slot_num, 1089 &alloc_group, 1090 ALLOC_NEW_GROUP | 1091 ALLOC_GROUPS_FROM_GLOBAL); 1092 if (status >= 0) { 1093 status = 0; 1094 1095 spin_lock(&osb->osb_lock); 1096 osb->osb_inode_alloc_group = alloc_group; 1097 spin_unlock(&osb->osb_lock); 1098 trace_ocfs2_reserve_new_inode_new_group( 1099 (unsigned long long)alloc_group); 1100 1101 /* 1102 * Some inodes must be freed by us, so try to allocate 1103 * from our own next time. 1104 */ 1105 if (slot != OCFS2_INVALID_SLOT) 1106 ocfs2_init_inode_steal_slot(osb); 1107 goto bail; 1108 } else if (status < 0 && status != -ENOSPC) { 1109 mlog_errno(status); 1110 goto bail; 1111 } 1112 1113 ocfs2_free_ac_resource(*ac); 1114 1115 inode_steal: 1116 status = ocfs2_steal_inode(osb, *ac); 1117 atomic_inc(&osb->s_num_inodes_stolen); 1118 if (status < 0) { 1119 if (status != -ENOSPC) 1120 mlog_errno(status); 1121 goto bail; 1122 } 1123 1124 status = 0; 1125 bail: 1126 if ((status < 0) && *ac) { 1127 ocfs2_free_alloc_context(*ac); 1128 *ac = NULL; 1129 } 1130 1131 if (status) 1132 mlog_errno(status); 1133 return status; 1134 } 1135 1136 /* local alloc code has to do the same thing, so rather than do this 1137 * twice.. */ 1138 int ocfs2_reserve_cluster_bitmap_bits(struct ocfs2_super *osb, 1139 struct ocfs2_alloc_context *ac) 1140 { 1141 int status; 1142 1143 ac->ac_which = OCFS2_AC_USE_MAIN; 1144 ac->ac_group_search = ocfs2_cluster_group_search; 1145 1146 status = ocfs2_reserve_suballoc_bits(osb, ac, 1147 GLOBAL_BITMAP_SYSTEM_INODE, 1148 OCFS2_INVALID_SLOT, NULL, 1149 ALLOC_NEW_GROUP); 1150 if (status < 0 && status != -ENOSPC) { 1151 mlog_errno(status); 1152 goto bail; 1153 } 1154 1155 bail: 1156 return status; 1157 } 1158 1159 /* Callers don't need to care which bitmap (local alloc or main) to 1160 * use so we figure it out for them, but unfortunately this clutters 1161 * things a bit. */ 1162 static int ocfs2_reserve_clusters_with_limit(struct ocfs2_super *osb, 1163 u32 bits_wanted, u64 max_block, 1164 int flags, 1165 struct ocfs2_alloc_context **ac) 1166 { 1167 int status, ret = 0; 1168 int retried = 0; 1169 1170 *ac = kzalloc(sizeof(struct ocfs2_alloc_context), GFP_KERNEL); 1171 if (!(*ac)) { 1172 status = -ENOMEM; 1173 mlog_errno(status); 1174 goto bail; 1175 } 1176 1177 (*ac)->ac_bits_wanted = bits_wanted; 1178 (*ac)->ac_max_block = max_block; 1179 1180 status = -ENOSPC; 1181 if (!(flags & ALLOC_GROUPS_FROM_GLOBAL) && 1182 ocfs2_alloc_should_use_local(osb, bits_wanted)) { 1183 status = ocfs2_reserve_local_alloc_bits(osb, 1184 bits_wanted, 1185 *ac); 1186 if ((status < 0) && (status != -ENOSPC)) { 1187 mlog_errno(status); 1188 goto bail; 1189 } 1190 } 1191 1192 if (status == -ENOSPC) { 1193 retry: 1194 status = ocfs2_reserve_cluster_bitmap_bits(osb, *ac); 1195 /* Retry if there is sufficient space cached in truncate log */ 1196 if (status == -ENOSPC && !retried) { 1197 retried = 1; 1198 ocfs2_inode_unlock((*ac)->ac_inode, 1); 1199 inode_unlock((*ac)->ac_inode); 1200 1201 ret = ocfs2_try_to_free_truncate_log(osb, bits_wanted); 1202 if (ret == 1) { 1203 iput((*ac)->ac_inode); 1204 (*ac)->ac_inode = NULL; 1205 goto retry; 1206 } 1207 1208 if (ret < 0) 1209 mlog_errno(ret); 1210 1211 inode_lock((*ac)->ac_inode); 1212 ret = ocfs2_inode_lock((*ac)->ac_inode, NULL, 1); 1213 if (ret < 0) { 1214 mlog_errno(ret); 1215 inode_unlock((*ac)->ac_inode); 1216 iput((*ac)->ac_inode); 1217 (*ac)->ac_inode = NULL; 1218 goto bail; 1219 } 1220 } 1221 if (status < 0) { 1222 if (status != -ENOSPC) 1223 mlog_errno(status); 1224 goto bail; 1225 } 1226 } 1227 1228 status = 0; 1229 bail: 1230 if ((status < 0) && *ac) { 1231 ocfs2_free_alloc_context(*ac); 1232 *ac = NULL; 1233 } 1234 1235 if (status) 1236 mlog_errno(status); 1237 return status; 1238 } 1239 1240 int ocfs2_reserve_clusters(struct ocfs2_super *osb, 1241 u32 bits_wanted, 1242 struct ocfs2_alloc_context **ac) 1243 { 1244 return ocfs2_reserve_clusters_with_limit(osb, bits_wanted, 0, 1245 ALLOC_NEW_GROUP, ac); 1246 } 1247 1248 /* 1249 * More or less lifted from ext3. I'll leave their description below: 1250 * 1251 * "For ext3 allocations, we must not reuse any blocks which are 1252 * allocated in the bitmap buffer's "last committed data" copy. This 1253 * prevents deletes from freeing up the page for reuse until we have 1254 * committed the delete transaction. 1255 * 1256 * If we didn't do this, then deleting something and reallocating it as 1257 * data would allow the old block to be overwritten before the 1258 * transaction committed (because we force data to disk before commit). 1259 * This would lead to corruption if we crashed between overwriting the 1260 * data and committing the delete. 1261 * 1262 * @@@ We may want to make this allocation behaviour conditional on 1263 * data-writes at some point, and disable it for metadata allocations or 1264 * sync-data inodes." 1265 * 1266 * Note: OCFS2 already does this differently for metadata vs data 1267 * allocations, as those bitmaps are separate and undo access is never 1268 * called on a metadata group descriptor. 1269 */ 1270 static int ocfs2_test_bg_bit_allocatable(struct buffer_head *bg_bh, 1271 int nr) 1272 { 1273 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data; 1274 int ret; 1275 1276 if (ocfs2_test_bit(nr, (unsigned long *)bg->bg_bitmap)) 1277 return 0; 1278 1279 if (!buffer_jbd(bg_bh)) 1280 return 1; 1281 1282 jbd_lock_bh_state(bg_bh); 1283 bg = (struct ocfs2_group_desc *) bh2jh(bg_bh)->b_committed_data; 1284 if (bg) 1285 ret = !ocfs2_test_bit(nr, (unsigned long *)bg->bg_bitmap); 1286 else 1287 ret = 1; 1288 jbd_unlock_bh_state(bg_bh); 1289 1290 return ret; 1291 } 1292 1293 static int ocfs2_block_group_find_clear_bits(struct ocfs2_super *osb, 1294 struct buffer_head *bg_bh, 1295 unsigned int bits_wanted, 1296 unsigned int total_bits, 1297 struct ocfs2_suballoc_result *res) 1298 { 1299 void *bitmap; 1300 u16 best_offset, best_size; 1301 int offset, start, found, status = 0; 1302 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data; 1303 1304 /* Callers got this descriptor from 1305 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */ 1306 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg)); 1307 1308 found = start = best_offset = best_size = 0; 1309 bitmap = bg->bg_bitmap; 1310 1311 while((offset = ocfs2_find_next_zero_bit(bitmap, total_bits, start)) != -1) { 1312 if (offset == total_bits) 1313 break; 1314 1315 if (!ocfs2_test_bg_bit_allocatable(bg_bh, offset)) { 1316 /* We found a zero, but we can't use it as it 1317 * hasn't been put to disk yet! */ 1318 found = 0; 1319 start = offset + 1; 1320 } else if (offset == start) { 1321 /* we found a zero */ 1322 found++; 1323 /* move start to the next bit to test */ 1324 start++; 1325 } else { 1326 /* got a zero after some ones */ 1327 found = 1; 1328 start = offset + 1; 1329 } 1330 if (found > best_size) { 1331 best_size = found; 1332 best_offset = start - found; 1333 } 1334 /* we got everything we needed */ 1335 if (found == bits_wanted) { 1336 /* mlog(0, "Found it all!\n"); */ 1337 break; 1338 } 1339 } 1340 1341 if (best_size) { 1342 res->sr_bit_offset = best_offset; 1343 res->sr_bits = best_size; 1344 } else { 1345 status = -ENOSPC; 1346 /* No error log here -- see the comment above 1347 * ocfs2_test_bg_bit_allocatable */ 1348 } 1349 1350 return status; 1351 } 1352 1353 int ocfs2_block_group_set_bits(handle_t *handle, 1354 struct inode *alloc_inode, 1355 struct ocfs2_group_desc *bg, 1356 struct buffer_head *group_bh, 1357 unsigned int bit_off, 1358 unsigned int num_bits) 1359 { 1360 int status; 1361 void *bitmap = bg->bg_bitmap; 1362 int journal_type = OCFS2_JOURNAL_ACCESS_WRITE; 1363 1364 /* All callers get the descriptor via 1365 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */ 1366 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg)); 1367 BUG_ON(le16_to_cpu(bg->bg_free_bits_count) < num_bits); 1368 1369 trace_ocfs2_block_group_set_bits(bit_off, num_bits); 1370 1371 if (ocfs2_is_cluster_bitmap(alloc_inode)) 1372 journal_type = OCFS2_JOURNAL_ACCESS_UNDO; 1373 1374 status = ocfs2_journal_access_gd(handle, 1375 INODE_CACHE(alloc_inode), 1376 group_bh, 1377 journal_type); 1378 if (status < 0) { 1379 mlog_errno(status); 1380 goto bail; 1381 } 1382 1383 le16_add_cpu(&bg->bg_free_bits_count, -num_bits); 1384 if (le16_to_cpu(bg->bg_free_bits_count) > le16_to_cpu(bg->bg_bits)) { 1385 return ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit count %u but claims %u are freed. num_bits %d\n", 1386 (unsigned long long)le64_to_cpu(bg->bg_blkno), 1387 le16_to_cpu(bg->bg_bits), 1388 le16_to_cpu(bg->bg_free_bits_count), 1389 num_bits); 1390 } 1391 while(num_bits--) 1392 ocfs2_set_bit(bit_off++, bitmap); 1393 1394 ocfs2_journal_dirty(handle, group_bh); 1395 1396 bail: 1397 return status; 1398 } 1399 1400 /* find the one with the most empty bits */ 1401 static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl) 1402 { 1403 u16 curr, best; 1404 1405 BUG_ON(!cl->cl_next_free_rec); 1406 1407 best = curr = 0; 1408 while (curr < le16_to_cpu(cl->cl_next_free_rec)) { 1409 if (le32_to_cpu(cl->cl_recs[curr].c_free) > 1410 le32_to_cpu(cl->cl_recs[best].c_free)) 1411 best = curr; 1412 curr++; 1413 } 1414 1415 BUG_ON(best >= le16_to_cpu(cl->cl_next_free_rec)); 1416 return best; 1417 } 1418 1419 static int ocfs2_relink_block_group(handle_t *handle, 1420 struct inode *alloc_inode, 1421 struct buffer_head *fe_bh, 1422 struct buffer_head *bg_bh, 1423 struct buffer_head *prev_bg_bh, 1424 u16 chain) 1425 { 1426 int status; 1427 /* there is a really tiny chance the journal calls could fail, 1428 * but we wouldn't want inconsistent blocks in *any* case. */ 1429 u64 bg_ptr, prev_bg_ptr; 1430 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data; 1431 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data; 1432 struct ocfs2_group_desc *prev_bg = (struct ocfs2_group_desc *) prev_bg_bh->b_data; 1433 1434 /* The caller got these descriptors from 1435 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */ 1436 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg)); 1437 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(prev_bg)); 1438 1439 trace_ocfs2_relink_block_group( 1440 (unsigned long long)le64_to_cpu(fe->i_blkno), chain, 1441 (unsigned long long)le64_to_cpu(bg->bg_blkno), 1442 (unsigned long long)le64_to_cpu(prev_bg->bg_blkno)); 1443 1444 bg_ptr = le64_to_cpu(bg->bg_next_group); 1445 prev_bg_ptr = le64_to_cpu(prev_bg->bg_next_group); 1446 1447 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode), 1448 prev_bg_bh, 1449 OCFS2_JOURNAL_ACCESS_WRITE); 1450 if (status < 0) 1451 goto out; 1452 1453 prev_bg->bg_next_group = bg->bg_next_group; 1454 ocfs2_journal_dirty(handle, prev_bg_bh); 1455 1456 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode), 1457 bg_bh, OCFS2_JOURNAL_ACCESS_WRITE); 1458 if (status < 0) 1459 goto out_rollback_prev_bg; 1460 1461 bg->bg_next_group = fe->id2.i_chain.cl_recs[chain].c_blkno; 1462 ocfs2_journal_dirty(handle, bg_bh); 1463 1464 status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode), 1465 fe_bh, OCFS2_JOURNAL_ACCESS_WRITE); 1466 if (status < 0) 1467 goto out_rollback_bg; 1468 1469 fe->id2.i_chain.cl_recs[chain].c_blkno = bg->bg_blkno; 1470 ocfs2_journal_dirty(handle, fe_bh); 1471 1472 out: 1473 if (status < 0) 1474 mlog_errno(status); 1475 return status; 1476 1477 out_rollback_bg: 1478 bg->bg_next_group = cpu_to_le64(bg_ptr); 1479 out_rollback_prev_bg: 1480 prev_bg->bg_next_group = cpu_to_le64(prev_bg_ptr); 1481 goto out; 1482 } 1483 1484 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg, 1485 u32 wanted) 1486 { 1487 return le16_to_cpu(bg->bg_free_bits_count) > wanted; 1488 } 1489 1490 /* return 0 on success, -ENOSPC to keep searching and any other < 0 1491 * value on error. */ 1492 static int ocfs2_cluster_group_search(struct inode *inode, 1493 struct buffer_head *group_bh, 1494 u32 bits_wanted, u32 min_bits, 1495 u64 max_block, 1496 struct ocfs2_suballoc_result *res) 1497 { 1498 int search = -ENOSPC; 1499 int ret; 1500 u64 blkoff; 1501 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *) group_bh->b_data; 1502 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1503 unsigned int max_bits, gd_cluster_off; 1504 1505 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 1506 1507 if (gd->bg_free_bits_count) { 1508 max_bits = le16_to_cpu(gd->bg_bits); 1509 1510 /* Tail groups in cluster bitmaps which aren't cpg 1511 * aligned are prone to partial extension by a failed 1512 * fs resize. If the file system resize never got to 1513 * update the dinode cluster count, then we don't want 1514 * to trust any clusters past it, regardless of what 1515 * the group descriptor says. */ 1516 gd_cluster_off = ocfs2_blocks_to_clusters(inode->i_sb, 1517 le64_to_cpu(gd->bg_blkno)); 1518 if ((gd_cluster_off + max_bits) > 1519 OCFS2_I(inode)->ip_clusters) { 1520 max_bits = OCFS2_I(inode)->ip_clusters - gd_cluster_off; 1521 trace_ocfs2_cluster_group_search_wrong_max_bits( 1522 (unsigned long long)le64_to_cpu(gd->bg_blkno), 1523 le16_to_cpu(gd->bg_bits), 1524 OCFS2_I(inode)->ip_clusters, max_bits); 1525 } 1526 1527 ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb), 1528 group_bh, bits_wanted, 1529 max_bits, res); 1530 if (ret) 1531 return ret; 1532 1533 if (max_block) { 1534 blkoff = ocfs2_clusters_to_blocks(inode->i_sb, 1535 gd_cluster_off + 1536 res->sr_bit_offset + 1537 res->sr_bits); 1538 trace_ocfs2_cluster_group_search_max_block( 1539 (unsigned long long)blkoff, 1540 (unsigned long long)max_block); 1541 if (blkoff > max_block) 1542 return -ENOSPC; 1543 } 1544 1545 /* ocfs2_block_group_find_clear_bits() might 1546 * return success, but we still want to return 1547 * -ENOSPC unless it found the minimum number 1548 * of bits. */ 1549 if (min_bits <= res->sr_bits) 1550 search = 0; /* success */ 1551 else if (res->sr_bits) { 1552 /* 1553 * Don't show bits which we'll be returning 1554 * for allocation to the local alloc bitmap. 1555 */ 1556 ocfs2_local_alloc_seen_free_bits(osb, res->sr_bits); 1557 } 1558 } 1559 1560 return search; 1561 } 1562 1563 static int ocfs2_block_group_search(struct inode *inode, 1564 struct buffer_head *group_bh, 1565 u32 bits_wanted, u32 min_bits, 1566 u64 max_block, 1567 struct ocfs2_suballoc_result *res) 1568 { 1569 int ret = -ENOSPC; 1570 u64 blkoff; 1571 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) group_bh->b_data; 1572 1573 BUG_ON(min_bits != 1); 1574 BUG_ON(ocfs2_is_cluster_bitmap(inode)); 1575 1576 if (bg->bg_free_bits_count) { 1577 ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb), 1578 group_bh, bits_wanted, 1579 le16_to_cpu(bg->bg_bits), 1580 res); 1581 if (!ret && max_block) { 1582 blkoff = le64_to_cpu(bg->bg_blkno) + 1583 res->sr_bit_offset + res->sr_bits; 1584 trace_ocfs2_block_group_search_max_block( 1585 (unsigned long long)blkoff, 1586 (unsigned long long)max_block); 1587 if (blkoff > max_block) 1588 ret = -ENOSPC; 1589 } 1590 } 1591 1592 return ret; 1593 } 1594 1595 int ocfs2_alloc_dinode_update_counts(struct inode *inode, 1596 handle_t *handle, 1597 struct buffer_head *di_bh, 1598 u32 num_bits, 1599 u16 chain) 1600 { 1601 int ret; 1602 u32 tmp_used; 1603 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data; 1604 struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &di->id2.i_chain; 1605 1606 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh, 1607 OCFS2_JOURNAL_ACCESS_WRITE); 1608 if (ret < 0) { 1609 mlog_errno(ret); 1610 goto out; 1611 } 1612 1613 tmp_used = le32_to_cpu(di->id1.bitmap1.i_used); 1614 di->id1.bitmap1.i_used = cpu_to_le32(num_bits + tmp_used); 1615 le32_add_cpu(&cl->cl_recs[chain].c_free, -num_bits); 1616 ocfs2_journal_dirty(handle, di_bh); 1617 1618 out: 1619 return ret; 1620 } 1621 1622 void ocfs2_rollback_alloc_dinode_counts(struct inode *inode, 1623 struct buffer_head *di_bh, 1624 u32 num_bits, 1625 u16 chain) 1626 { 1627 u32 tmp_used; 1628 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data; 1629 struct ocfs2_chain_list *cl; 1630 1631 cl = (struct ocfs2_chain_list *)&di->id2.i_chain; 1632 tmp_used = le32_to_cpu(di->id1.bitmap1.i_used); 1633 di->id1.bitmap1.i_used = cpu_to_le32(tmp_used - num_bits); 1634 le32_add_cpu(&cl->cl_recs[chain].c_free, num_bits); 1635 } 1636 1637 static int ocfs2_bg_discontig_fix_by_rec(struct ocfs2_suballoc_result *res, 1638 struct ocfs2_extent_rec *rec, 1639 struct ocfs2_chain_list *cl) 1640 { 1641 unsigned int bpc = le16_to_cpu(cl->cl_bpc); 1642 unsigned int bitoff = le32_to_cpu(rec->e_cpos) * bpc; 1643 unsigned int bitcount = le16_to_cpu(rec->e_leaf_clusters) * bpc; 1644 1645 if (res->sr_bit_offset < bitoff) 1646 return 0; 1647 if (res->sr_bit_offset >= (bitoff + bitcount)) 1648 return 0; 1649 res->sr_blkno = le64_to_cpu(rec->e_blkno) + 1650 (res->sr_bit_offset - bitoff); 1651 if ((res->sr_bit_offset + res->sr_bits) > (bitoff + bitcount)) 1652 res->sr_bits = (bitoff + bitcount) - res->sr_bit_offset; 1653 return 1; 1654 } 1655 1656 static void ocfs2_bg_discontig_fix_result(struct ocfs2_alloc_context *ac, 1657 struct ocfs2_group_desc *bg, 1658 struct ocfs2_suballoc_result *res) 1659 { 1660 int i; 1661 u64 bg_blkno = res->sr_bg_blkno; /* Save off */ 1662 struct ocfs2_extent_rec *rec; 1663 struct ocfs2_dinode *di = (struct ocfs2_dinode *)ac->ac_bh->b_data; 1664 struct ocfs2_chain_list *cl = &di->id2.i_chain; 1665 1666 if (ocfs2_is_cluster_bitmap(ac->ac_inode)) { 1667 res->sr_blkno = 0; 1668 return; 1669 } 1670 1671 res->sr_blkno = res->sr_bg_blkno + res->sr_bit_offset; 1672 res->sr_bg_blkno = 0; /* Clear it for contig block groups */ 1673 if (!ocfs2_supports_discontig_bg(OCFS2_SB(ac->ac_inode->i_sb)) || 1674 !bg->bg_list.l_next_free_rec) 1675 return; 1676 1677 for (i = 0; i < le16_to_cpu(bg->bg_list.l_next_free_rec); i++) { 1678 rec = &bg->bg_list.l_recs[i]; 1679 if (ocfs2_bg_discontig_fix_by_rec(res, rec, cl)) { 1680 res->sr_bg_blkno = bg_blkno; /* Restore */ 1681 break; 1682 } 1683 } 1684 } 1685 1686 static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac, 1687 handle_t *handle, 1688 u32 bits_wanted, 1689 u32 min_bits, 1690 struct ocfs2_suballoc_result *res, 1691 u16 *bits_left) 1692 { 1693 int ret; 1694 struct buffer_head *group_bh = NULL; 1695 struct ocfs2_group_desc *gd; 1696 struct ocfs2_dinode *di = (struct ocfs2_dinode *)ac->ac_bh->b_data; 1697 struct inode *alloc_inode = ac->ac_inode; 1698 1699 ret = ocfs2_read_group_descriptor(alloc_inode, di, 1700 res->sr_bg_blkno, &group_bh); 1701 if (ret < 0) { 1702 mlog_errno(ret); 1703 return ret; 1704 } 1705 1706 gd = (struct ocfs2_group_desc *) group_bh->b_data; 1707 ret = ac->ac_group_search(alloc_inode, group_bh, bits_wanted, min_bits, 1708 ac->ac_max_block, res); 1709 if (ret < 0) { 1710 if (ret != -ENOSPC) 1711 mlog_errno(ret); 1712 goto out; 1713 } 1714 1715 if (!ret) 1716 ocfs2_bg_discontig_fix_result(ac, gd, res); 1717 1718 /* 1719 * sr_bg_blkno might have been changed by 1720 * ocfs2_bg_discontig_fix_result 1721 */ 1722 res->sr_bg_stable_blkno = group_bh->b_blocknr; 1723 1724 if (ac->ac_find_loc_only) 1725 goto out_loc_only; 1726 1727 ret = ocfs2_alloc_dinode_update_counts(alloc_inode, handle, ac->ac_bh, 1728 res->sr_bits, 1729 le16_to_cpu(gd->bg_chain)); 1730 if (ret < 0) { 1731 mlog_errno(ret); 1732 goto out; 1733 } 1734 1735 ret = ocfs2_block_group_set_bits(handle, alloc_inode, gd, group_bh, 1736 res->sr_bit_offset, res->sr_bits); 1737 if (ret < 0) { 1738 ocfs2_rollback_alloc_dinode_counts(alloc_inode, ac->ac_bh, 1739 res->sr_bits, 1740 le16_to_cpu(gd->bg_chain)); 1741 mlog_errno(ret); 1742 } 1743 1744 out_loc_only: 1745 *bits_left = le16_to_cpu(gd->bg_free_bits_count); 1746 1747 out: 1748 brelse(group_bh); 1749 1750 return ret; 1751 } 1752 1753 static int ocfs2_search_chain(struct ocfs2_alloc_context *ac, 1754 handle_t *handle, 1755 u32 bits_wanted, 1756 u32 min_bits, 1757 struct ocfs2_suballoc_result *res, 1758 u16 *bits_left) 1759 { 1760 int status; 1761 u16 chain; 1762 u64 next_group; 1763 struct inode *alloc_inode = ac->ac_inode; 1764 struct buffer_head *group_bh = NULL; 1765 struct buffer_head *prev_group_bh = NULL; 1766 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) ac->ac_bh->b_data; 1767 struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &fe->id2.i_chain; 1768 struct ocfs2_group_desc *bg; 1769 1770 chain = ac->ac_chain; 1771 trace_ocfs2_search_chain_begin( 1772 (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno, 1773 bits_wanted, chain); 1774 1775 status = ocfs2_read_group_descriptor(alloc_inode, fe, 1776 le64_to_cpu(cl->cl_recs[chain].c_blkno), 1777 &group_bh); 1778 if (status < 0) { 1779 mlog_errno(status); 1780 goto bail; 1781 } 1782 bg = (struct ocfs2_group_desc *) group_bh->b_data; 1783 1784 status = -ENOSPC; 1785 /* for now, the chain search is a bit simplistic. We just use 1786 * the 1st group with any empty bits. */ 1787 while ((status = ac->ac_group_search(alloc_inode, group_bh, 1788 bits_wanted, min_bits, 1789 ac->ac_max_block, 1790 res)) == -ENOSPC) { 1791 if (!bg->bg_next_group) 1792 break; 1793 1794 brelse(prev_group_bh); 1795 prev_group_bh = NULL; 1796 1797 next_group = le64_to_cpu(bg->bg_next_group); 1798 prev_group_bh = group_bh; 1799 group_bh = NULL; 1800 status = ocfs2_read_group_descriptor(alloc_inode, fe, 1801 next_group, &group_bh); 1802 if (status < 0) { 1803 mlog_errno(status); 1804 goto bail; 1805 } 1806 bg = (struct ocfs2_group_desc *) group_bh->b_data; 1807 } 1808 if (status < 0) { 1809 if (status != -ENOSPC) 1810 mlog_errno(status); 1811 goto bail; 1812 } 1813 1814 trace_ocfs2_search_chain_succ( 1815 (unsigned long long)le64_to_cpu(bg->bg_blkno), res->sr_bits); 1816 1817 res->sr_bg_blkno = le64_to_cpu(bg->bg_blkno); 1818 1819 BUG_ON(res->sr_bits == 0); 1820 if (!status) 1821 ocfs2_bg_discontig_fix_result(ac, bg, res); 1822 1823 /* 1824 * sr_bg_blkno might have been changed by 1825 * ocfs2_bg_discontig_fix_result 1826 */ 1827 res->sr_bg_stable_blkno = group_bh->b_blocknr; 1828 1829 /* 1830 * Keep track of previous block descriptor read. When 1831 * we find a target, if we have read more than X 1832 * number of descriptors, and the target is reasonably 1833 * empty, relink him to top of his chain. 1834 * 1835 * We've read 0 extra blocks and only send one more to 1836 * the transaction, yet the next guy to search has a 1837 * much easier time. 1838 * 1839 * Do this *after* figuring out how many bits we're taking out 1840 * of our target group. 1841 */ 1842 if (!ac->ac_disable_chain_relink && 1843 (prev_group_bh) && 1844 (ocfs2_block_group_reasonably_empty(bg, res->sr_bits))) { 1845 status = ocfs2_relink_block_group(handle, alloc_inode, 1846 ac->ac_bh, group_bh, 1847 prev_group_bh, chain); 1848 if (status < 0) { 1849 mlog_errno(status); 1850 goto bail; 1851 } 1852 } 1853 1854 if (ac->ac_find_loc_only) 1855 goto out_loc_only; 1856 1857 status = ocfs2_alloc_dinode_update_counts(alloc_inode, handle, 1858 ac->ac_bh, res->sr_bits, 1859 chain); 1860 if (status) { 1861 mlog_errno(status); 1862 goto bail; 1863 } 1864 1865 status = ocfs2_block_group_set_bits(handle, 1866 alloc_inode, 1867 bg, 1868 group_bh, 1869 res->sr_bit_offset, 1870 res->sr_bits); 1871 if (status < 0) { 1872 ocfs2_rollback_alloc_dinode_counts(alloc_inode, 1873 ac->ac_bh, res->sr_bits, chain); 1874 mlog_errno(status); 1875 goto bail; 1876 } 1877 1878 trace_ocfs2_search_chain_end( 1879 (unsigned long long)le64_to_cpu(fe->i_blkno), 1880 res->sr_bits); 1881 1882 out_loc_only: 1883 *bits_left = le16_to_cpu(bg->bg_free_bits_count); 1884 bail: 1885 brelse(group_bh); 1886 brelse(prev_group_bh); 1887 1888 if (status) 1889 mlog_errno(status); 1890 return status; 1891 } 1892 1893 /* will give out up to bits_wanted contiguous bits. */ 1894 static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac, 1895 handle_t *handle, 1896 u32 bits_wanted, 1897 u32 min_bits, 1898 struct ocfs2_suballoc_result *res) 1899 { 1900 int status; 1901 u16 victim, i; 1902 u16 bits_left = 0; 1903 u64 hint = ac->ac_last_group; 1904 struct ocfs2_chain_list *cl; 1905 struct ocfs2_dinode *fe; 1906 1907 BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted); 1908 BUG_ON(bits_wanted > (ac->ac_bits_wanted - ac->ac_bits_given)); 1909 BUG_ON(!ac->ac_bh); 1910 1911 fe = (struct ocfs2_dinode *) ac->ac_bh->b_data; 1912 1913 /* The bh was validated by the inode read during 1914 * ocfs2_reserve_suballoc_bits(). Any corruption is a code bug. */ 1915 BUG_ON(!OCFS2_IS_VALID_DINODE(fe)); 1916 1917 if (le32_to_cpu(fe->id1.bitmap1.i_used) >= 1918 le32_to_cpu(fe->id1.bitmap1.i_total)) { 1919 status = ocfs2_error(ac->ac_inode->i_sb, 1920 "Chain allocator dinode %llu has %u used bits but only %u total\n", 1921 (unsigned long long)le64_to_cpu(fe->i_blkno), 1922 le32_to_cpu(fe->id1.bitmap1.i_used), 1923 le32_to_cpu(fe->id1.bitmap1.i_total)); 1924 goto bail; 1925 } 1926 1927 res->sr_bg_blkno = hint; 1928 if (res->sr_bg_blkno) { 1929 /* Attempt to short-circuit the usual search mechanism 1930 * by jumping straight to the most recently used 1931 * allocation group. This helps us maintain some 1932 * contiguousness across allocations. */ 1933 status = ocfs2_search_one_group(ac, handle, bits_wanted, 1934 min_bits, res, &bits_left); 1935 if (!status) 1936 goto set_hint; 1937 if (status < 0 && status != -ENOSPC) { 1938 mlog_errno(status); 1939 goto bail; 1940 } 1941 } 1942 1943 cl = (struct ocfs2_chain_list *) &fe->id2.i_chain; 1944 1945 victim = ocfs2_find_victim_chain(cl); 1946 ac->ac_chain = victim; 1947 1948 status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits, 1949 res, &bits_left); 1950 if (!status) { 1951 if (ocfs2_is_cluster_bitmap(ac->ac_inode)) 1952 hint = res->sr_bg_blkno; 1953 else 1954 hint = ocfs2_group_from_res(res); 1955 goto set_hint; 1956 } 1957 if (status < 0 && status != -ENOSPC) { 1958 mlog_errno(status); 1959 goto bail; 1960 } 1961 1962 trace_ocfs2_claim_suballoc_bits(victim); 1963 1964 /* If we didn't pick a good victim, then just default to 1965 * searching each chain in order. Don't allow chain relinking 1966 * because we only calculate enough journal credits for one 1967 * relink per alloc. */ 1968 ac->ac_disable_chain_relink = 1; 1969 for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i ++) { 1970 if (i == victim) 1971 continue; 1972 if (!cl->cl_recs[i].c_free) 1973 continue; 1974 1975 ac->ac_chain = i; 1976 status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits, 1977 res, &bits_left); 1978 if (!status) { 1979 hint = ocfs2_group_from_res(res); 1980 break; 1981 } 1982 if (status < 0 && status != -ENOSPC) { 1983 mlog_errno(status); 1984 goto bail; 1985 } 1986 } 1987 1988 set_hint: 1989 if (status != -ENOSPC) { 1990 /* If the next search of this group is not likely to 1991 * yield a suitable extent, then we reset the last 1992 * group hint so as to not waste a disk read */ 1993 if (bits_left < min_bits) 1994 ac->ac_last_group = 0; 1995 else 1996 ac->ac_last_group = hint; 1997 } 1998 1999 bail: 2000 if (status) 2001 mlog_errno(status); 2002 return status; 2003 } 2004 2005 int ocfs2_claim_metadata(handle_t *handle, 2006 struct ocfs2_alloc_context *ac, 2007 u32 bits_wanted, 2008 u64 *suballoc_loc, 2009 u16 *suballoc_bit_start, 2010 unsigned int *num_bits, 2011 u64 *blkno_start) 2012 { 2013 int status; 2014 struct ocfs2_suballoc_result res = { .sr_blkno = 0, }; 2015 2016 BUG_ON(!ac); 2017 BUG_ON(ac->ac_bits_wanted < (ac->ac_bits_given + bits_wanted)); 2018 BUG_ON(ac->ac_which != OCFS2_AC_USE_META); 2019 2020 status = ocfs2_claim_suballoc_bits(ac, 2021 handle, 2022 bits_wanted, 2023 1, 2024 &res); 2025 if (status < 0) { 2026 mlog_errno(status); 2027 goto bail; 2028 } 2029 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); 2030 2031 *suballoc_loc = res.sr_bg_blkno; 2032 *suballoc_bit_start = res.sr_bit_offset; 2033 *blkno_start = res.sr_blkno; 2034 ac->ac_bits_given += res.sr_bits; 2035 *num_bits = res.sr_bits; 2036 status = 0; 2037 bail: 2038 if (status) 2039 mlog_errno(status); 2040 return status; 2041 } 2042 2043 static void ocfs2_init_inode_ac_group(struct inode *dir, 2044 struct buffer_head *parent_di_bh, 2045 struct ocfs2_alloc_context *ac) 2046 { 2047 struct ocfs2_dinode *di = (struct ocfs2_dinode *)parent_di_bh->b_data; 2048 /* 2049 * Try to allocate inodes from some specific group. 2050 * 2051 * If the parent dir has recorded the last group used in allocation, 2052 * cool, use it. Otherwise if we try to allocate new inode from the 2053 * same slot the parent dir belongs to, use the same chunk. 2054 * 2055 * We are very careful here to avoid the mistake of setting 2056 * ac_last_group to a group descriptor from a different (unlocked) slot. 2057 */ 2058 if (OCFS2_I(dir)->ip_last_used_group && 2059 OCFS2_I(dir)->ip_last_used_slot == ac->ac_alloc_slot) 2060 ac->ac_last_group = OCFS2_I(dir)->ip_last_used_group; 2061 else if (le16_to_cpu(di->i_suballoc_slot) == ac->ac_alloc_slot) { 2062 if (di->i_suballoc_loc) 2063 ac->ac_last_group = le64_to_cpu(di->i_suballoc_loc); 2064 else 2065 ac->ac_last_group = ocfs2_which_suballoc_group( 2066 le64_to_cpu(di->i_blkno), 2067 le16_to_cpu(di->i_suballoc_bit)); 2068 } 2069 } 2070 2071 static inline void ocfs2_save_inode_ac_group(struct inode *dir, 2072 struct ocfs2_alloc_context *ac) 2073 { 2074 OCFS2_I(dir)->ip_last_used_group = ac->ac_last_group; 2075 OCFS2_I(dir)->ip_last_used_slot = ac->ac_alloc_slot; 2076 } 2077 2078 int ocfs2_find_new_inode_loc(struct inode *dir, 2079 struct buffer_head *parent_fe_bh, 2080 struct ocfs2_alloc_context *ac, 2081 u64 *fe_blkno) 2082 { 2083 int ret; 2084 handle_t *handle = NULL; 2085 struct ocfs2_suballoc_result *res; 2086 2087 BUG_ON(!ac); 2088 BUG_ON(ac->ac_bits_given != 0); 2089 BUG_ON(ac->ac_bits_wanted != 1); 2090 BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE); 2091 2092 res = kzalloc(sizeof(*res), GFP_NOFS); 2093 if (res == NULL) { 2094 ret = -ENOMEM; 2095 mlog_errno(ret); 2096 goto out; 2097 } 2098 2099 ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac); 2100 2101 /* 2102 * The handle started here is for chain relink. Alternatively, 2103 * we could just disable relink for these calls. 2104 */ 2105 handle = ocfs2_start_trans(OCFS2_SB(dir->i_sb), OCFS2_SUBALLOC_ALLOC); 2106 if (IS_ERR(handle)) { 2107 ret = PTR_ERR(handle); 2108 handle = NULL; 2109 mlog_errno(ret); 2110 goto out; 2111 } 2112 2113 /* 2114 * This will instruct ocfs2_claim_suballoc_bits and 2115 * ocfs2_search_one_group to search but save actual allocation 2116 * for later. 2117 */ 2118 ac->ac_find_loc_only = 1; 2119 2120 ret = ocfs2_claim_suballoc_bits(ac, handle, 1, 1, res); 2121 if (ret < 0) { 2122 mlog_errno(ret); 2123 goto out; 2124 } 2125 2126 ac->ac_find_loc_priv = res; 2127 *fe_blkno = res->sr_blkno; 2128 ocfs2_update_inode_fsync_trans(handle, dir, 0); 2129 out: 2130 if (handle) 2131 ocfs2_commit_trans(OCFS2_SB(dir->i_sb), handle); 2132 2133 if (ret) 2134 kfree(res); 2135 2136 return ret; 2137 } 2138 2139 int ocfs2_claim_new_inode_at_loc(handle_t *handle, 2140 struct inode *dir, 2141 struct ocfs2_alloc_context *ac, 2142 u64 *suballoc_loc, 2143 u16 *suballoc_bit, 2144 u64 di_blkno) 2145 { 2146 int ret; 2147 u16 chain; 2148 struct ocfs2_suballoc_result *res = ac->ac_find_loc_priv; 2149 struct buffer_head *bg_bh = NULL; 2150 struct ocfs2_group_desc *bg; 2151 struct ocfs2_dinode *di = (struct ocfs2_dinode *) ac->ac_bh->b_data; 2152 2153 /* 2154 * Since di_blkno is being passed back in, we check for any 2155 * inconsistencies which may have happened between 2156 * calls. These are code bugs as di_blkno is not expected to 2157 * change once returned from ocfs2_find_new_inode_loc() 2158 */ 2159 BUG_ON(res->sr_blkno != di_blkno); 2160 2161 ret = ocfs2_read_group_descriptor(ac->ac_inode, di, 2162 res->sr_bg_stable_blkno, &bg_bh); 2163 if (ret) { 2164 mlog_errno(ret); 2165 goto out; 2166 } 2167 2168 bg = (struct ocfs2_group_desc *) bg_bh->b_data; 2169 chain = le16_to_cpu(bg->bg_chain); 2170 2171 ret = ocfs2_alloc_dinode_update_counts(ac->ac_inode, handle, 2172 ac->ac_bh, res->sr_bits, 2173 chain); 2174 if (ret) { 2175 mlog_errno(ret); 2176 goto out; 2177 } 2178 2179 ret = ocfs2_block_group_set_bits(handle, 2180 ac->ac_inode, 2181 bg, 2182 bg_bh, 2183 res->sr_bit_offset, 2184 res->sr_bits); 2185 if (ret < 0) { 2186 ocfs2_rollback_alloc_dinode_counts(ac->ac_inode, 2187 ac->ac_bh, res->sr_bits, chain); 2188 mlog_errno(ret); 2189 goto out; 2190 } 2191 2192 trace_ocfs2_claim_new_inode_at_loc((unsigned long long)di_blkno, 2193 res->sr_bits); 2194 2195 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); 2196 2197 BUG_ON(res->sr_bits != 1); 2198 2199 *suballoc_loc = res->sr_bg_blkno; 2200 *suballoc_bit = res->sr_bit_offset; 2201 ac->ac_bits_given++; 2202 ocfs2_save_inode_ac_group(dir, ac); 2203 2204 out: 2205 brelse(bg_bh); 2206 2207 return ret; 2208 } 2209 2210 int ocfs2_claim_new_inode(handle_t *handle, 2211 struct inode *dir, 2212 struct buffer_head *parent_fe_bh, 2213 struct ocfs2_alloc_context *ac, 2214 u64 *suballoc_loc, 2215 u16 *suballoc_bit, 2216 u64 *fe_blkno) 2217 { 2218 int status; 2219 struct ocfs2_suballoc_result res; 2220 2221 BUG_ON(!ac); 2222 BUG_ON(ac->ac_bits_given != 0); 2223 BUG_ON(ac->ac_bits_wanted != 1); 2224 BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE); 2225 2226 ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac); 2227 2228 status = ocfs2_claim_suballoc_bits(ac, 2229 handle, 2230 1, 2231 1, 2232 &res); 2233 if (status < 0) { 2234 mlog_errno(status); 2235 goto bail; 2236 } 2237 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); 2238 2239 BUG_ON(res.sr_bits != 1); 2240 2241 *suballoc_loc = res.sr_bg_blkno; 2242 *suballoc_bit = res.sr_bit_offset; 2243 *fe_blkno = res.sr_blkno; 2244 ac->ac_bits_given++; 2245 ocfs2_save_inode_ac_group(dir, ac); 2246 status = 0; 2247 bail: 2248 if (status) 2249 mlog_errno(status); 2250 return status; 2251 } 2252 2253 /* translate a group desc. blkno and it's bitmap offset into 2254 * disk cluster offset. */ 2255 static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode, 2256 u64 bg_blkno, 2257 u16 bg_bit_off) 2258 { 2259 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2260 u32 cluster = 0; 2261 2262 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 2263 2264 if (bg_blkno != osb->first_cluster_group_blkno) 2265 cluster = ocfs2_blocks_to_clusters(inode->i_sb, bg_blkno); 2266 cluster += (u32) bg_bit_off; 2267 return cluster; 2268 } 2269 2270 /* given a cluster offset, calculate which block group it belongs to 2271 * and return that block offset. */ 2272 u64 ocfs2_which_cluster_group(struct inode *inode, u32 cluster) 2273 { 2274 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2275 u32 group_no; 2276 2277 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 2278 2279 group_no = cluster / osb->bitmap_cpg; 2280 if (!group_no) 2281 return osb->first_cluster_group_blkno; 2282 return ocfs2_clusters_to_blocks(inode->i_sb, 2283 group_no * osb->bitmap_cpg); 2284 } 2285 2286 /* given the block number of a cluster start, calculate which cluster 2287 * group and descriptor bitmap offset that corresponds to. */ 2288 static inline void ocfs2_block_to_cluster_group(struct inode *inode, 2289 u64 data_blkno, 2290 u64 *bg_blkno, 2291 u16 *bg_bit_off) 2292 { 2293 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2294 u32 data_cluster = ocfs2_blocks_to_clusters(osb->sb, data_blkno); 2295 2296 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 2297 2298 *bg_blkno = ocfs2_which_cluster_group(inode, 2299 data_cluster); 2300 2301 if (*bg_blkno == osb->first_cluster_group_blkno) 2302 *bg_bit_off = (u16) data_cluster; 2303 else 2304 *bg_bit_off = (u16) ocfs2_blocks_to_clusters(osb->sb, 2305 data_blkno - *bg_blkno); 2306 } 2307 2308 /* 2309 * min_bits - minimum contiguous chunk from this total allocation we 2310 * can handle. set to what we asked for originally for a full 2311 * contig. allocation, set to '1' to indicate we can deal with extents 2312 * of any size. 2313 */ 2314 int __ocfs2_claim_clusters(handle_t *handle, 2315 struct ocfs2_alloc_context *ac, 2316 u32 min_clusters, 2317 u32 max_clusters, 2318 u32 *cluster_start, 2319 u32 *num_clusters) 2320 { 2321 int status; 2322 unsigned int bits_wanted = max_clusters; 2323 struct ocfs2_suballoc_result res = { .sr_blkno = 0, }; 2324 struct ocfs2_super *osb = OCFS2_SB(ac->ac_inode->i_sb); 2325 2326 BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted); 2327 2328 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL 2329 && ac->ac_which != OCFS2_AC_USE_MAIN); 2330 2331 if (ac->ac_which == OCFS2_AC_USE_LOCAL) { 2332 WARN_ON(min_clusters > 1); 2333 2334 status = ocfs2_claim_local_alloc_bits(osb, 2335 handle, 2336 ac, 2337 bits_wanted, 2338 cluster_start, 2339 num_clusters); 2340 if (!status) 2341 atomic_inc(&osb->alloc_stats.local_data); 2342 } else { 2343 if (min_clusters > (osb->bitmap_cpg - 1)) { 2344 /* The only paths asking for contiguousness 2345 * should know about this already. */ 2346 mlog(ML_ERROR, "minimum allocation requested %u exceeds " 2347 "group bitmap size %u!\n", min_clusters, 2348 osb->bitmap_cpg); 2349 status = -ENOSPC; 2350 goto bail; 2351 } 2352 /* clamp the current request down to a realistic size. */ 2353 if (bits_wanted > (osb->bitmap_cpg - 1)) 2354 bits_wanted = osb->bitmap_cpg - 1; 2355 2356 status = ocfs2_claim_suballoc_bits(ac, 2357 handle, 2358 bits_wanted, 2359 min_clusters, 2360 &res); 2361 if (!status) { 2362 BUG_ON(res.sr_blkno); /* cluster alloc can't set */ 2363 *cluster_start = 2364 ocfs2_desc_bitmap_to_cluster_off(ac->ac_inode, 2365 res.sr_bg_blkno, 2366 res.sr_bit_offset); 2367 atomic_inc(&osb->alloc_stats.bitmap_data); 2368 *num_clusters = res.sr_bits; 2369 } 2370 } 2371 if (status < 0) { 2372 if (status != -ENOSPC) 2373 mlog_errno(status); 2374 goto bail; 2375 } 2376 2377 ac->ac_bits_given += *num_clusters; 2378 2379 bail: 2380 if (status) 2381 mlog_errno(status); 2382 return status; 2383 } 2384 2385 int ocfs2_claim_clusters(handle_t *handle, 2386 struct ocfs2_alloc_context *ac, 2387 u32 min_clusters, 2388 u32 *cluster_start, 2389 u32 *num_clusters) 2390 { 2391 unsigned int bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given; 2392 2393 return __ocfs2_claim_clusters(handle, ac, min_clusters, 2394 bits_wanted, cluster_start, num_clusters); 2395 } 2396 2397 static int ocfs2_block_group_clear_bits(handle_t *handle, 2398 struct inode *alloc_inode, 2399 struct ocfs2_group_desc *bg, 2400 struct buffer_head *group_bh, 2401 unsigned int bit_off, 2402 unsigned int num_bits, 2403 void (*undo_fn)(unsigned int bit, 2404 unsigned long *bmap)) 2405 { 2406 int status; 2407 unsigned int tmp; 2408 struct ocfs2_group_desc *undo_bg = NULL; 2409 2410 /* The caller got this descriptor from 2411 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */ 2412 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg)); 2413 2414 trace_ocfs2_block_group_clear_bits(bit_off, num_bits); 2415 2416 BUG_ON(undo_fn && !ocfs2_is_cluster_bitmap(alloc_inode)); 2417 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode), 2418 group_bh, 2419 undo_fn ? 2420 OCFS2_JOURNAL_ACCESS_UNDO : 2421 OCFS2_JOURNAL_ACCESS_WRITE); 2422 if (status < 0) { 2423 mlog_errno(status); 2424 goto bail; 2425 } 2426 2427 if (undo_fn) { 2428 jbd_lock_bh_state(group_bh); 2429 undo_bg = (struct ocfs2_group_desc *) 2430 bh2jh(group_bh)->b_committed_data; 2431 BUG_ON(!undo_bg); 2432 } 2433 2434 tmp = num_bits; 2435 while(tmp--) { 2436 ocfs2_clear_bit((bit_off + tmp), 2437 (unsigned long *) bg->bg_bitmap); 2438 if (undo_fn) 2439 undo_fn(bit_off + tmp, 2440 (unsigned long *) undo_bg->bg_bitmap); 2441 } 2442 le16_add_cpu(&bg->bg_free_bits_count, num_bits); 2443 if (le16_to_cpu(bg->bg_free_bits_count) > le16_to_cpu(bg->bg_bits)) { 2444 return ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit count %u but claims %u are freed. num_bits %d\n", 2445 (unsigned long long)le64_to_cpu(bg->bg_blkno), 2446 le16_to_cpu(bg->bg_bits), 2447 le16_to_cpu(bg->bg_free_bits_count), 2448 num_bits); 2449 } 2450 2451 if (undo_fn) 2452 jbd_unlock_bh_state(group_bh); 2453 2454 ocfs2_journal_dirty(handle, group_bh); 2455 bail: 2456 return status; 2457 } 2458 2459 /* 2460 * expects the suballoc inode to already be locked. 2461 */ 2462 static int _ocfs2_free_suballoc_bits(handle_t *handle, 2463 struct inode *alloc_inode, 2464 struct buffer_head *alloc_bh, 2465 unsigned int start_bit, 2466 u64 bg_blkno, 2467 unsigned int count, 2468 void (*undo_fn)(unsigned int bit, 2469 unsigned long *bitmap)) 2470 { 2471 int status = 0; 2472 u32 tmp_used; 2473 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) alloc_bh->b_data; 2474 struct ocfs2_chain_list *cl = &fe->id2.i_chain; 2475 struct buffer_head *group_bh = NULL; 2476 struct ocfs2_group_desc *group; 2477 2478 /* The alloc_bh comes from ocfs2_free_dinode() or 2479 * ocfs2_free_clusters(). The callers have all locked the 2480 * allocator and gotten alloc_bh from the lock call. This 2481 * validates the dinode buffer. Any corruption that has happened 2482 * is a code bug. */ 2483 BUG_ON(!OCFS2_IS_VALID_DINODE(fe)); 2484 BUG_ON((count + start_bit) > ocfs2_bits_per_group(cl)); 2485 2486 trace_ocfs2_free_suballoc_bits( 2487 (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno, 2488 (unsigned long long)bg_blkno, 2489 start_bit, count); 2490 2491 status = ocfs2_read_group_descriptor(alloc_inode, fe, bg_blkno, 2492 &group_bh); 2493 if (status < 0) { 2494 mlog_errno(status); 2495 goto bail; 2496 } 2497 group = (struct ocfs2_group_desc *) group_bh->b_data; 2498 2499 BUG_ON((count + start_bit) > le16_to_cpu(group->bg_bits)); 2500 2501 status = ocfs2_block_group_clear_bits(handle, alloc_inode, 2502 group, group_bh, 2503 start_bit, count, undo_fn); 2504 if (status < 0) { 2505 mlog_errno(status); 2506 goto bail; 2507 } 2508 2509 status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode), 2510 alloc_bh, OCFS2_JOURNAL_ACCESS_WRITE); 2511 if (status < 0) { 2512 mlog_errno(status); 2513 ocfs2_block_group_set_bits(handle, alloc_inode, group, group_bh, 2514 start_bit, count); 2515 goto bail; 2516 } 2517 2518 le32_add_cpu(&cl->cl_recs[le16_to_cpu(group->bg_chain)].c_free, 2519 count); 2520 tmp_used = le32_to_cpu(fe->id1.bitmap1.i_used); 2521 fe->id1.bitmap1.i_used = cpu_to_le32(tmp_used - count); 2522 ocfs2_journal_dirty(handle, alloc_bh); 2523 2524 bail: 2525 brelse(group_bh); 2526 2527 if (status) 2528 mlog_errno(status); 2529 return status; 2530 } 2531 2532 int ocfs2_free_suballoc_bits(handle_t *handle, 2533 struct inode *alloc_inode, 2534 struct buffer_head *alloc_bh, 2535 unsigned int start_bit, 2536 u64 bg_blkno, 2537 unsigned int count) 2538 { 2539 return _ocfs2_free_suballoc_bits(handle, alloc_inode, alloc_bh, 2540 start_bit, bg_blkno, count, NULL); 2541 } 2542 2543 int ocfs2_free_dinode(handle_t *handle, 2544 struct inode *inode_alloc_inode, 2545 struct buffer_head *inode_alloc_bh, 2546 struct ocfs2_dinode *di) 2547 { 2548 u64 blk = le64_to_cpu(di->i_blkno); 2549 u16 bit = le16_to_cpu(di->i_suballoc_bit); 2550 u64 bg_blkno = ocfs2_which_suballoc_group(blk, bit); 2551 2552 if (di->i_suballoc_loc) 2553 bg_blkno = le64_to_cpu(di->i_suballoc_loc); 2554 return ocfs2_free_suballoc_bits(handle, inode_alloc_inode, 2555 inode_alloc_bh, bit, bg_blkno, 1); 2556 } 2557 2558 static int _ocfs2_free_clusters(handle_t *handle, 2559 struct inode *bitmap_inode, 2560 struct buffer_head *bitmap_bh, 2561 u64 start_blk, 2562 unsigned int num_clusters, 2563 void (*undo_fn)(unsigned int bit, 2564 unsigned long *bitmap)) 2565 { 2566 int status; 2567 u16 bg_start_bit; 2568 u64 bg_blkno; 2569 struct ocfs2_dinode *fe; 2570 2571 /* You can't ever have a contiguous set of clusters 2572 * bigger than a block group bitmap so we never have to worry 2573 * about looping on them. 2574 * This is expensive. We can safely remove once this stuff has 2575 * gotten tested really well. */ 2576 BUG_ON(start_blk != ocfs2_clusters_to_blocks(bitmap_inode->i_sb, ocfs2_blocks_to_clusters(bitmap_inode->i_sb, start_blk))); 2577 2578 fe = (struct ocfs2_dinode *) bitmap_bh->b_data; 2579 2580 ocfs2_block_to_cluster_group(bitmap_inode, start_blk, &bg_blkno, 2581 &bg_start_bit); 2582 2583 trace_ocfs2_free_clusters((unsigned long long)bg_blkno, 2584 (unsigned long long)start_blk, 2585 bg_start_bit, num_clusters); 2586 2587 status = _ocfs2_free_suballoc_bits(handle, bitmap_inode, bitmap_bh, 2588 bg_start_bit, bg_blkno, 2589 num_clusters, undo_fn); 2590 if (status < 0) { 2591 mlog_errno(status); 2592 goto out; 2593 } 2594 2595 ocfs2_local_alloc_seen_free_bits(OCFS2_SB(bitmap_inode->i_sb), 2596 num_clusters); 2597 2598 out: 2599 if (status) 2600 mlog_errno(status); 2601 return status; 2602 } 2603 2604 int ocfs2_free_clusters(handle_t *handle, 2605 struct inode *bitmap_inode, 2606 struct buffer_head *bitmap_bh, 2607 u64 start_blk, 2608 unsigned int num_clusters) 2609 { 2610 return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh, 2611 start_blk, num_clusters, 2612 _ocfs2_set_bit); 2613 } 2614 2615 /* 2616 * Give never-used clusters back to the global bitmap. We don't need 2617 * to protect these bits in the undo buffer. 2618 */ 2619 int ocfs2_release_clusters(handle_t *handle, 2620 struct inode *bitmap_inode, 2621 struct buffer_head *bitmap_bh, 2622 u64 start_blk, 2623 unsigned int num_clusters) 2624 { 2625 return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh, 2626 start_blk, num_clusters, 2627 _ocfs2_clear_bit); 2628 } 2629 2630 static inline void ocfs2_debug_bg(struct ocfs2_group_desc *bg) 2631 { 2632 printk("Block Group:\n"); 2633 printk("bg_signature: %s\n", bg->bg_signature); 2634 printk("bg_size: %u\n", bg->bg_size); 2635 printk("bg_bits: %u\n", bg->bg_bits); 2636 printk("bg_free_bits_count: %u\n", bg->bg_free_bits_count); 2637 printk("bg_chain: %u\n", bg->bg_chain); 2638 printk("bg_generation: %u\n", le32_to_cpu(bg->bg_generation)); 2639 printk("bg_next_group: %llu\n", 2640 (unsigned long long)bg->bg_next_group); 2641 printk("bg_parent_dinode: %llu\n", 2642 (unsigned long long)bg->bg_parent_dinode); 2643 printk("bg_blkno: %llu\n", 2644 (unsigned long long)bg->bg_blkno); 2645 } 2646 2647 static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode *fe) 2648 { 2649 int i; 2650 2651 printk("Suballoc Inode %llu:\n", (unsigned long long)fe->i_blkno); 2652 printk("i_signature: %s\n", fe->i_signature); 2653 printk("i_size: %llu\n", 2654 (unsigned long long)fe->i_size); 2655 printk("i_clusters: %u\n", fe->i_clusters); 2656 printk("i_generation: %u\n", 2657 le32_to_cpu(fe->i_generation)); 2658 printk("id1.bitmap1.i_used: %u\n", 2659 le32_to_cpu(fe->id1.bitmap1.i_used)); 2660 printk("id1.bitmap1.i_total: %u\n", 2661 le32_to_cpu(fe->id1.bitmap1.i_total)); 2662 printk("id2.i_chain.cl_cpg: %u\n", fe->id2.i_chain.cl_cpg); 2663 printk("id2.i_chain.cl_bpc: %u\n", fe->id2.i_chain.cl_bpc); 2664 printk("id2.i_chain.cl_count: %u\n", fe->id2.i_chain.cl_count); 2665 printk("id2.i_chain.cl_next_free_rec: %u\n", 2666 fe->id2.i_chain.cl_next_free_rec); 2667 for(i = 0; i < fe->id2.i_chain.cl_next_free_rec; i++) { 2668 printk("fe->id2.i_chain.cl_recs[%d].c_free: %u\n", i, 2669 fe->id2.i_chain.cl_recs[i].c_free); 2670 printk("fe->id2.i_chain.cl_recs[%d].c_total: %u\n", i, 2671 fe->id2.i_chain.cl_recs[i].c_total); 2672 printk("fe->id2.i_chain.cl_recs[%d].c_blkno: %llu\n", i, 2673 (unsigned long long)fe->id2.i_chain.cl_recs[i].c_blkno); 2674 } 2675 } 2676 2677 /* 2678 * For a given allocation, determine which allocators will need to be 2679 * accessed, and lock them, reserving the appropriate number of bits. 2680 * 2681 * Sparse file systems call this from ocfs2_write_begin_nolock() 2682 * and ocfs2_allocate_unwritten_extents(). 2683 * 2684 * File systems which don't support holes call this from 2685 * ocfs2_extend_allocation(). 2686 */ 2687 int ocfs2_lock_allocators(struct inode *inode, 2688 struct ocfs2_extent_tree *et, 2689 u32 clusters_to_add, u32 extents_to_split, 2690 struct ocfs2_alloc_context **data_ac, 2691 struct ocfs2_alloc_context **meta_ac) 2692 { 2693 int ret = 0, num_free_extents; 2694 unsigned int max_recs_needed = clusters_to_add + 2 * extents_to_split; 2695 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2696 2697 *meta_ac = NULL; 2698 if (data_ac) 2699 *data_ac = NULL; 2700 2701 BUG_ON(clusters_to_add != 0 && data_ac == NULL); 2702 2703 num_free_extents = ocfs2_num_free_extents(osb, et); 2704 if (num_free_extents < 0) { 2705 ret = num_free_extents; 2706 mlog_errno(ret); 2707 goto out; 2708 } 2709 2710 /* 2711 * Sparse allocation file systems need to be more conservative 2712 * with reserving room for expansion - the actual allocation 2713 * happens while we've got a journal handle open so re-taking 2714 * a cluster lock (because we ran out of room for another 2715 * extent) will violate ordering rules. 2716 * 2717 * Most of the time we'll only be seeing this 1 cluster at a time 2718 * anyway. 2719 * 2720 * Always lock for any unwritten extents - we might want to 2721 * add blocks during a split. 2722 */ 2723 if (!num_free_extents || 2724 (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed)) { 2725 ret = ocfs2_reserve_new_metadata(osb, et->et_root_el, meta_ac); 2726 if (ret < 0) { 2727 if (ret != -ENOSPC) 2728 mlog_errno(ret); 2729 goto out; 2730 } 2731 } 2732 2733 if (clusters_to_add == 0) 2734 goto out; 2735 2736 ret = ocfs2_reserve_clusters(osb, clusters_to_add, data_ac); 2737 if (ret < 0) { 2738 if (ret != -ENOSPC) 2739 mlog_errno(ret); 2740 goto out; 2741 } 2742 2743 out: 2744 if (ret) { 2745 if (*meta_ac) { 2746 ocfs2_free_alloc_context(*meta_ac); 2747 *meta_ac = NULL; 2748 } 2749 2750 /* 2751 * We cannot have an error and a non null *data_ac. 2752 */ 2753 } 2754 2755 return ret; 2756 } 2757 2758 /* 2759 * Read the inode specified by blkno to get suballoc_slot and 2760 * suballoc_bit. 2761 */ 2762 static int ocfs2_get_suballoc_slot_bit(struct ocfs2_super *osb, u64 blkno, 2763 u16 *suballoc_slot, u64 *group_blkno, 2764 u16 *suballoc_bit) 2765 { 2766 int status; 2767 struct buffer_head *inode_bh = NULL; 2768 struct ocfs2_dinode *inode_fe; 2769 2770 trace_ocfs2_get_suballoc_slot_bit((unsigned long long)blkno); 2771 2772 /* dirty read disk */ 2773 status = ocfs2_read_blocks_sync(osb, blkno, 1, &inode_bh); 2774 if (status < 0) { 2775 mlog(ML_ERROR, "read block %llu failed %d\n", 2776 (unsigned long long)blkno, status); 2777 goto bail; 2778 } 2779 2780 inode_fe = (struct ocfs2_dinode *) inode_bh->b_data; 2781 if (!OCFS2_IS_VALID_DINODE(inode_fe)) { 2782 mlog(ML_ERROR, "invalid inode %llu requested\n", 2783 (unsigned long long)blkno); 2784 status = -EINVAL; 2785 goto bail; 2786 } 2787 2788 if (le16_to_cpu(inode_fe->i_suballoc_slot) != (u16)OCFS2_INVALID_SLOT && 2789 (u32)le16_to_cpu(inode_fe->i_suballoc_slot) > osb->max_slots - 1) { 2790 mlog(ML_ERROR, "inode %llu has invalid suballoc slot %u\n", 2791 (unsigned long long)blkno, 2792 (u32)le16_to_cpu(inode_fe->i_suballoc_slot)); 2793 status = -EINVAL; 2794 goto bail; 2795 } 2796 2797 if (suballoc_slot) 2798 *suballoc_slot = le16_to_cpu(inode_fe->i_suballoc_slot); 2799 if (suballoc_bit) 2800 *suballoc_bit = le16_to_cpu(inode_fe->i_suballoc_bit); 2801 if (group_blkno) 2802 *group_blkno = le64_to_cpu(inode_fe->i_suballoc_loc); 2803 2804 bail: 2805 brelse(inode_bh); 2806 2807 if (status) 2808 mlog_errno(status); 2809 return status; 2810 } 2811 2812 /* 2813 * test whether bit is SET in allocator bitmap or not. on success, 0 2814 * is returned and *res is 1 for SET; 0 otherwise. when fails, errno 2815 * is returned and *res is meaningless. Call this after you have 2816 * cluster locked against suballoc, or you may get a result based on 2817 * non-up2date contents 2818 */ 2819 static int ocfs2_test_suballoc_bit(struct ocfs2_super *osb, 2820 struct inode *suballoc, 2821 struct buffer_head *alloc_bh, 2822 u64 group_blkno, u64 blkno, 2823 u16 bit, int *res) 2824 { 2825 struct ocfs2_dinode *alloc_di; 2826 struct ocfs2_group_desc *group; 2827 struct buffer_head *group_bh = NULL; 2828 u64 bg_blkno; 2829 int status; 2830 2831 trace_ocfs2_test_suballoc_bit((unsigned long long)blkno, 2832 (unsigned int)bit); 2833 2834 alloc_di = (struct ocfs2_dinode *)alloc_bh->b_data; 2835 if ((bit + 1) > ocfs2_bits_per_group(&alloc_di->id2.i_chain)) { 2836 mlog(ML_ERROR, "suballoc bit %u out of range of %u\n", 2837 (unsigned int)bit, 2838 ocfs2_bits_per_group(&alloc_di->id2.i_chain)); 2839 status = -EINVAL; 2840 goto bail; 2841 } 2842 2843 bg_blkno = group_blkno ? group_blkno : 2844 ocfs2_which_suballoc_group(blkno, bit); 2845 status = ocfs2_read_group_descriptor(suballoc, alloc_di, bg_blkno, 2846 &group_bh); 2847 if (status < 0) { 2848 mlog(ML_ERROR, "read group %llu failed %d\n", 2849 (unsigned long long)bg_blkno, status); 2850 goto bail; 2851 } 2852 2853 group = (struct ocfs2_group_desc *) group_bh->b_data; 2854 *res = ocfs2_test_bit(bit, (unsigned long *)group->bg_bitmap); 2855 2856 bail: 2857 brelse(group_bh); 2858 2859 if (status) 2860 mlog_errno(status); 2861 return status; 2862 } 2863 2864 /* 2865 * Test if the bit representing this inode (blkno) is set in the 2866 * suballocator. 2867 * 2868 * On success, 0 is returned and *res is 1 for SET; 0 otherwise. 2869 * 2870 * In the event of failure, a negative value is returned and *res is 2871 * meaningless. 2872 * 2873 * Callers must make sure to hold nfs_sync_lock to prevent 2874 * ocfs2_delete_inode() on another node from accessing the same 2875 * suballocator concurrently. 2876 */ 2877 int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res) 2878 { 2879 int status; 2880 u64 group_blkno = 0; 2881 u16 suballoc_bit = 0, suballoc_slot = 0; 2882 struct inode *inode_alloc_inode; 2883 struct buffer_head *alloc_bh = NULL; 2884 2885 trace_ocfs2_test_inode_bit((unsigned long long)blkno); 2886 2887 status = ocfs2_get_suballoc_slot_bit(osb, blkno, &suballoc_slot, 2888 &group_blkno, &suballoc_bit); 2889 if (status < 0) { 2890 mlog(ML_ERROR, "get alloc slot and bit failed %d\n", status); 2891 goto bail; 2892 } 2893 2894 inode_alloc_inode = 2895 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE, 2896 suballoc_slot); 2897 if (!inode_alloc_inode) { 2898 /* the error code could be inaccurate, but we are not able to 2899 * get the correct one. */ 2900 status = -EINVAL; 2901 mlog(ML_ERROR, "unable to get alloc inode in slot %u\n", 2902 (u32)suballoc_slot); 2903 goto bail; 2904 } 2905 2906 inode_lock(inode_alloc_inode); 2907 status = ocfs2_inode_lock(inode_alloc_inode, &alloc_bh, 0); 2908 if (status < 0) { 2909 inode_unlock(inode_alloc_inode); 2910 iput(inode_alloc_inode); 2911 mlog(ML_ERROR, "lock on alloc inode on slot %u failed %d\n", 2912 (u32)suballoc_slot, status); 2913 goto bail; 2914 } 2915 2916 status = ocfs2_test_suballoc_bit(osb, inode_alloc_inode, alloc_bh, 2917 group_blkno, blkno, suballoc_bit, res); 2918 if (status < 0) 2919 mlog(ML_ERROR, "test suballoc bit failed %d\n", status); 2920 2921 ocfs2_inode_unlock(inode_alloc_inode, 0); 2922 inode_unlock(inode_alloc_inode); 2923 2924 iput(inode_alloc_inode); 2925 brelse(alloc_bh); 2926 bail: 2927 if (status) 2928 mlog_errno(status); 2929 return status; 2930 } 2931