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