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 goto retry; 1204 1205 if (ret < 0) 1206 mlog_errno(ret); 1207 1208 inode_lock((*ac)->ac_inode); 1209 ocfs2_inode_lock((*ac)->ac_inode, NULL, 1); 1210 } 1211 if (status < 0) { 1212 if (status != -ENOSPC) 1213 mlog_errno(status); 1214 goto bail; 1215 } 1216 } 1217 1218 status = 0; 1219 bail: 1220 if ((status < 0) && *ac) { 1221 ocfs2_free_alloc_context(*ac); 1222 *ac = NULL; 1223 } 1224 1225 if (status) 1226 mlog_errno(status); 1227 return status; 1228 } 1229 1230 int ocfs2_reserve_clusters(struct ocfs2_super *osb, 1231 u32 bits_wanted, 1232 struct ocfs2_alloc_context **ac) 1233 { 1234 return ocfs2_reserve_clusters_with_limit(osb, bits_wanted, 0, 1235 ALLOC_NEW_GROUP, ac); 1236 } 1237 1238 /* 1239 * More or less lifted from ext3. I'll leave their description below: 1240 * 1241 * "For ext3 allocations, we must not reuse any blocks which are 1242 * allocated in the bitmap buffer's "last committed data" copy. This 1243 * prevents deletes from freeing up the page for reuse until we have 1244 * committed the delete transaction. 1245 * 1246 * If we didn't do this, then deleting something and reallocating it as 1247 * data would allow the old block to be overwritten before the 1248 * transaction committed (because we force data to disk before commit). 1249 * This would lead to corruption if we crashed between overwriting the 1250 * data and committing the delete. 1251 * 1252 * @@@ We may want to make this allocation behaviour conditional on 1253 * data-writes at some point, and disable it for metadata allocations or 1254 * sync-data inodes." 1255 * 1256 * Note: OCFS2 already does this differently for metadata vs data 1257 * allocations, as those bitmaps are separate and undo access is never 1258 * called on a metadata group descriptor. 1259 */ 1260 static int ocfs2_test_bg_bit_allocatable(struct buffer_head *bg_bh, 1261 int nr) 1262 { 1263 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data; 1264 int ret; 1265 1266 if (ocfs2_test_bit(nr, (unsigned long *)bg->bg_bitmap)) 1267 return 0; 1268 1269 if (!buffer_jbd(bg_bh)) 1270 return 1; 1271 1272 jbd_lock_bh_state(bg_bh); 1273 bg = (struct ocfs2_group_desc *) bh2jh(bg_bh)->b_committed_data; 1274 if (bg) 1275 ret = !ocfs2_test_bit(nr, (unsigned long *)bg->bg_bitmap); 1276 else 1277 ret = 1; 1278 jbd_unlock_bh_state(bg_bh); 1279 1280 return ret; 1281 } 1282 1283 static int ocfs2_block_group_find_clear_bits(struct ocfs2_super *osb, 1284 struct buffer_head *bg_bh, 1285 unsigned int bits_wanted, 1286 unsigned int total_bits, 1287 struct ocfs2_suballoc_result *res) 1288 { 1289 void *bitmap; 1290 u16 best_offset, best_size; 1291 int offset, start, found, status = 0; 1292 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data; 1293 1294 /* Callers got this descriptor from 1295 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */ 1296 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg)); 1297 1298 found = start = best_offset = best_size = 0; 1299 bitmap = bg->bg_bitmap; 1300 1301 while((offset = ocfs2_find_next_zero_bit(bitmap, total_bits, start)) != -1) { 1302 if (offset == total_bits) 1303 break; 1304 1305 if (!ocfs2_test_bg_bit_allocatable(bg_bh, offset)) { 1306 /* We found a zero, but we can't use it as it 1307 * hasn't been put to disk yet! */ 1308 found = 0; 1309 start = offset + 1; 1310 } else if (offset == start) { 1311 /* we found a zero */ 1312 found++; 1313 /* move start to the next bit to test */ 1314 start++; 1315 } else { 1316 /* got a zero after some ones */ 1317 found = 1; 1318 start = offset + 1; 1319 } 1320 if (found > best_size) { 1321 best_size = found; 1322 best_offset = start - found; 1323 } 1324 /* we got everything we needed */ 1325 if (found == bits_wanted) { 1326 /* mlog(0, "Found it all!\n"); */ 1327 break; 1328 } 1329 } 1330 1331 if (best_size) { 1332 res->sr_bit_offset = best_offset; 1333 res->sr_bits = best_size; 1334 } else { 1335 status = -ENOSPC; 1336 /* No error log here -- see the comment above 1337 * ocfs2_test_bg_bit_allocatable */ 1338 } 1339 1340 return status; 1341 } 1342 1343 int ocfs2_block_group_set_bits(handle_t *handle, 1344 struct inode *alloc_inode, 1345 struct ocfs2_group_desc *bg, 1346 struct buffer_head *group_bh, 1347 unsigned int bit_off, 1348 unsigned int num_bits) 1349 { 1350 int status; 1351 void *bitmap = bg->bg_bitmap; 1352 int journal_type = OCFS2_JOURNAL_ACCESS_WRITE; 1353 1354 /* All callers get the descriptor via 1355 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */ 1356 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg)); 1357 BUG_ON(le16_to_cpu(bg->bg_free_bits_count) < num_bits); 1358 1359 trace_ocfs2_block_group_set_bits(bit_off, num_bits); 1360 1361 if (ocfs2_is_cluster_bitmap(alloc_inode)) 1362 journal_type = OCFS2_JOURNAL_ACCESS_UNDO; 1363 1364 status = ocfs2_journal_access_gd(handle, 1365 INODE_CACHE(alloc_inode), 1366 group_bh, 1367 journal_type); 1368 if (status < 0) { 1369 mlog_errno(status); 1370 goto bail; 1371 } 1372 1373 le16_add_cpu(&bg->bg_free_bits_count, -num_bits); 1374 if (le16_to_cpu(bg->bg_free_bits_count) > le16_to_cpu(bg->bg_bits)) { 1375 return ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit count %u but claims %u are freed. num_bits %d\n", 1376 (unsigned long long)le64_to_cpu(bg->bg_blkno), 1377 le16_to_cpu(bg->bg_bits), 1378 le16_to_cpu(bg->bg_free_bits_count), 1379 num_bits); 1380 } 1381 while(num_bits--) 1382 ocfs2_set_bit(bit_off++, bitmap); 1383 1384 ocfs2_journal_dirty(handle, group_bh); 1385 1386 bail: 1387 return status; 1388 } 1389 1390 /* find the one with the most empty bits */ 1391 static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl) 1392 { 1393 u16 curr, best; 1394 1395 BUG_ON(!cl->cl_next_free_rec); 1396 1397 best = curr = 0; 1398 while (curr < le16_to_cpu(cl->cl_next_free_rec)) { 1399 if (le32_to_cpu(cl->cl_recs[curr].c_free) > 1400 le32_to_cpu(cl->cl_recs[best].c_free)) 1401 best = curr; 1402 curr++; 1403 } 1404 1405 BUG_ON(best >= le16_to_cpu(cl->cl_next_free_rec)); 1406 return best; 1407 } 1408 1409 static int ocfs2_relink_block_group(handle_t *handle, 1410 struct inode *alloc_inode, 1411 struct buffer_head *fe_bh, 1412 struct buffer_head *bg_bh, 1413 struct buffer_head *prev_bg_bh, 1414 u16 chain) 1415 { 1416 int status; 1417 /* there is a really tiny chance the journal calls could fail, 1418 * but we wouldn't want inconsistent blocks in *any* case. */ 1419 u64 bg_ptr, prev_bg_ptr; 1420 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data; 1421 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) bg_bh->b_data; 1422 struct ocfs2_group_desc *prev_bg = (struct ocfs2_group_desc *) prev_bg_bh->b_data; 1423 1424 /* The caller got these descriptors from 1425 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */ 1426 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg)); 1427 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(prev_bg)); 1428 1429 trace_ocfs2_relink_block_group( 1430 (unsigned long long)le64_to_cpu(fe->i_blkno), chain, 1431 (unsigned long long)le64_to_cpu(bg->bg_blkno), 1432 (unsigned long long)le64_to_cpu(prev_bg->bg_blkno)); 1433 1434 bg_ptr = le64_to_cpu(bg->bg_next_group); 1435 prev_bg_ptr = le64_to_cpu(prev_bg->bg_next_group); 1436 1437 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode), 1438 prev_bg_bh, 1439 OCFS2_JOURNAL_ACCESS_WRITE); 1440 if (status < 0) 1441 goto out; 1442 1443 prev_bg->bg_next_group = bg->bg_next_group; 1444 ocfs2_journal_dirty(handle, prev_bg_bh); 1445 1446 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode), 1447 bg_bh, OCFS2_JOURNAL_ACCESS_WRITE); 1448 if (status < 0) 1449 goto out_rollback_prev_bg; 1450 1451 bg->bg_next_group = fe->id2.i_chain.cl_recs[chain].c_blkno; 1452 ocfs2_journal_dirty(handle, bg_bh); 1453 1454 status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode), 1455 fe_bh, OCFS2_JOURNAL_ACCESS_WRITE); 1456 if (status < 0) 1457 goto out_rollback_bg; 1458 1459 fe->id2.i_chain.cl_recs[chain].c_blkno = bg->bg_blkno; 1460 ocfs2_journal_dirty(handle, fe_bh); 1461 1462 out: 1463 if (status < 0) 1464 mlog_errno(status); 1465 return status; 1466 1467 out_rollback_bg: 1468 bg->bg_next_group = cpu_to_le64(bg_ptr); 1469 out_rollback_prev_bg: 1470 prev_bg->bg_next_group = cpu_to_le64(prev_bg_ptr); 1471 goto out; 1472 } 1473 1474 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg, 1475 u32 wanted) 1476 { 1477 return le16_to_cpu(bg->bg_free_bits_count) > wanted; 1478 } 1479 1480 /* return 0 on success, -ENOSPC to keep searching and any other < 0 1481 * value on error. */ 1482 static int ocfs2_cluster_group_search(struct inode *inode, 1483 struct buffer_head *group_bh, 1484 u32 bits_wanted, u32 min_bits, 1485 u64 max_block, 1486 struct ocfs2_suballoc_result *res) 1487 { 1488 int search = -ENOSPC; 1489 int ret; 1490 u64 blkoff; 1491 struct ocfs2_group_desc *gd = (struct ocfs2_group_desc *) group_bh->b_data; 1492 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 1493 unsigned int max_bits, gd_cluster_off; 1494 1495 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 1496 1497 if (gd->bg_free_bits_count) { 1498 max_bits = le16_to_cpu(gd->bg_bits); 1499 1500 /* Tail groups in cluster bitmaps which aren't cpg 1501 * aligned are prone to partial extension by a failed 1502 * fs resize. If the file system resize never got to 1503 * update the dinode cluster count, then we don't want 1504 * to trust any clusters past it, regardless of what 1505 * the group descriptor says. */ 1506 gd_cluster_off = ocfs2_blocks_to_clusters(inode->i_sb, 1507 le64_to_cpu(gd->bg_blkno)); 1508 if ((gd_cluster_off + max_bits) > 1509 OCFS2_I(inode)->ip_clusters) { 1510 max_bits = OCFS2_I(inode)->ip_clusters - gd_cluster_off; 1511 trace_ocfs2_cluster_group_search_wrong_max_bits( 1512 (unsigned long long)le64_to_cpu(gd->bg_blkno), 1513 le16_to_cpu(gd->bg_bits), 1514 OCFS2_I(inode)->ip_clusters, max_bits); 1515 } 1516 1517 ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb), 1518 group_bh, bits_wanted, 1519 max_bits, res); 1520 if (ret) 1521 return ret; 1522 1523 if (max_block) { 1524 blkoff = ocfs2_clusters_to_blocks(inode->i_sb, 1525 gd_cluster_off + 1526 res->sr_bit_offset + 1527 res->sr_bits); 1528 trace_ocfs2_cluster_group_search_max_block( 1529 (unsigned long long)blkoff, 1530 (unsigned long long)max_block); 1531 if (blkoff > max_block) 1532 return -ENOSPC; 1533 } 1534 1535 /* ocfs2_block_group_find_clear_bits() might 1536 * return success, but we still want to return 1537 * -ENOSPC unless it found the minimum number 1538 * of bits. */ 1539 if (min_bits <= res->sr_bits) 1540 search = 0; /* success */ 1541 else if (res->sr_bits) { 1542 /* 1543 * Don't show bits which we'll be returning 1544 * for allocation to the local alloc bitmap. 1545 */ 1546 ocfs2_local_alloc_seen_free_bits(osb, res->sr_bits); 1547 } 1548 } 1549 1550 return search; 1551 } 1552 1553 static int ocfs2_block_group_search(struct inode *inode, 1554 struct buffer_head *group_bh, 1555 u32 bits_wanted, u32 min_bits, 1556 u64 max_block, 1557 struct ocfs2_suballoc_result *res) 1558 { 1559 int ret = -ENOSPC; 1560 u64 blkoff; 1561 struct ocfs2_group_desc *bg = (struct ocfs2_group_desc *) group_bh->b_data; 1562 1563 BUG_ON(min_bits != 1); 1564 BUG_ON(ocfs2_is_cluster_bitmap(inode)); 1565 1566 if (bg->bg_free_bits_count) { 1567 ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb), 1568 group_bh, bits_wanted, 1569 le16_to_cpu(bg->bg_bits), 1570 res); 1571 if (!ret && max_block) { 1572 blkoff = le64_to_cpu(bg->bg_blkno) + 1573 res->sr_bit_offset + res->sr_bits; 1574 trace_ocfs2_block_group_search_max_block( 1575 (unsigned long long)blkoff, 1576 (unsigned long long)max_block); 1577 if (blkoff > max_block) 1578 ret = -ENOSPC; 1579 } 1580 } 1581 1582 return ret; 1583 } 1584 1585 int ocfs2_alloc_dinode_update_counts(struct inode *inode, 1586 handle_t *handle, 1587 struct buffer_head *di_bh, 1588 u32 num_bits, 1589 u16 chain) 1590 { 1591 int ret; 1592 u32 tmp_used; 1593 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data; 1594 struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &di->id2.i_chain; 1595 1596 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh, 1597 OCFS2_JOURNAL_ACCESS_WRITE); 1598 if (ret < 0) { 1599 mlog_errno(ret); 1600 goto out; 1601 } 1602 1603 tmp_used = le32_to_cpu(di->id1.bitmap1.i_used); 1604 di->id1.bitmap1.i_used = cpu_to_le32(num_bits + tmp_used); 1605 le32_add_cpu(&cl->cl_recs[chain].c_free, -num_bits); 1606 ocfs2_journal_dirty(handle, di_bh); 1607 1608 out: 1609 return ret; 1610 } 1611 1612 void ocfs2_rollback_alloc_dinode_counts(struct inode *inode, 1613 struct buffer_head *di_bh, 1614 u32 num_bits, 1615 u16 chain) 1616 { 1617 u32 tmp_used; 1618 struct ocfs2_dinode *di = (struct ocfs2_dinode *) di_bh->b_data; 1619 struct ocfs2_chain_list *cl; 1620 1621 cl = (struct ocfs2_chain_list *)&di->id2.i_chain; 1622 tmp_used = le32_to_cpu(di->id1.bitmap1.i_used); 1623 di->id1.bitmap1.i_used = cpu_to_le32(tmp_used - num_bits); 1624 le32_add_cpu(&cl->cl_recs[chain].c_free, num_bits); 1625 } 1626 1627 static int ocfs2_bg_discontig_fix_by_rec(struct ocfs2_suballoc_result *res, 1628 struct ocfs2_extent_rec *rec, 1629 struct ocfs2_chain_list *cl) 1630 { 1631 unsigned int bpc = le16_to_cpu(cl->cl_bpc); 1632 unsigned int bitoff = le32_to_cpu(rec->e_cpos) * bpc; 1633 unsigned int bitcount = le16_to_cpu(rec->e_leaf_clusters) * bpc; 1634 1635 if (res->sr_bit_offset < bitoff) 1636 return 0; 1637 if (res->sr_bit_offset >= (bitoff + bitcount)) 1638 return 0; 1639 res->sr_blkno = le64_to_cpu(rec->e_blkno) + 1640 (res->sr_bit_offset - bitoff); 1641 if ((res->sr_bit_offset + res->sr_bits) > (bitoff + bitcount)) 1642 res->sr_bits = (bitoff + bitcount) - res->sr_bit_offset; 1643 return 1; 1644 } 1645 1646 static void ocfs2_bg_discontig_fix_result(struct ocfs2_alloc_context *ac, 1647 struct ocfs2_group_desc *bg, 1648 struct ocfs2_suballoc_result *res) 1649 { 1650 int i; 1651 u64 bg_blkno = res->sr_bg_blkno; /* Save off */ 1652 struct ocfs2_extent_rec *rec; 1653 struct ocfs2_dinode *di = (struct ocfs2_dinode *)ac->ac_bh->b_data; 1654 struct ocfs2_chain_list *cl = &di->id2.i_chain; 1655 1656 if (ocfs2_is_cluster_bitmap(ac->ac_inode)) { 1657 res->sr_blkno = 0; 1658 return; 1659 } 1660 1661 res->sr_blkno = res->sr_bg_blkno + res->sr_bit_offset; 1662 res->sr_bg_blkno = 0; /* Clear it for contig block groups */ 1663 if (!ocfs2_supports_discontig_bg(OCFS2_SB(ac->ac_inode->i_sb)) || 1664 !bg->bg_list.l_next_free_rec) 1665 return; 1666 1667 for (i = 0; i < le16_to_cpu(bg->bg_list.l_next_free_rec); i++) { 1668 rec = &bg->bg_list.l_recs[i]; 1669 if (ocfs2_bg_discontig_fix_by_rec(res, rec, cl)) { 1670 res->sr_bg_blkno = bg_blkno; /* Restore */ 1671 break; 1672 } 1673 } 1674 } 1675 1676 static int ocfs2_search_one_group(struct ocfs2_alloc_context *ac, 1677 handle_t *handle, 1678 u32 bits_wanted, 1679 u32 min_bits, 1680 struct ocfs2_suballoc_result *res, 1681 u16 *bits_left) 1682 { 1683 int ret; 1684 struct buffer_head *group_bh = NULL; 1685 struct ocfs2_group_desc *gd; 1686 struct ocfs2_dinode *di = (struct ocfs2_dinode *)ac->ac_bh->b_data; 1687 struct inode *alloc_inode = ac->ac_inode; 1688 1689 ret = ocfs2_read_group_descriptor(alloc_inode, di, 1690 res->sr_bg_blkno, &group_bh); 1691 if (ret < 0) { 1692 mlog_errno(ret); 1693 return ret; 1694 } 1695 1696 gd = (struct ocfs2_group_desc *) group_bh->b_data; 1697 ret = ac->ac_group_search(alloc_inode, group_bh, bits_wanted, min_bits, 1698 ac->ac_max_block, res); 1699 if (ret < 0) { 1700 if (ret != -ENOSPC) 1701 mlog_errno(ret); 1702 goto out; 1703 } 1704 1705 if (!ret) 1706 ocfs2_bg_discontig_fix_result(ac, gd, res); 1707 1708 /* 1709 * sr_bg_blkno might have been changed by 1710 * ocfs2_bg_discontig_fix_result 1711 */ 1712 res->sr_bg_stable_blkno = group_bh->b_blocknr; 1713 1714 if (ac->ac_find_loc_only) 1715 goto out_loc_only; 1716 1717 ret = ocfs2_alloc_dinode_update_counts(alloc_inode, handle, ac->ac_bh, 1718 res->sr_bits, 1719 le16_to_cpu(gd->bg_chain)); 1720 if (ret < 0) { 1721 mlog_errno(ret); 1722 goto out; 1723 } 1724 1725 ret = ocfs2_block_group_set_bits(handle, alloc_inode, gd, group_bh, 1726 res->sr_bit_offset, res->sr_bits); 1727 if (ret < 0) { 1728 ocfs2_rollback_alloc_dinode_counts(alloc_inode, ac->ac_bh, 1729 res->sr_bits, 1730 le16_to_cpu(gd->bg_chain)); 1731 mlog_errno(ret); 1732 } 1733 1734 out_loc_only: 1735 *bits_left = le16_to_cpu(gd->bg_free_bits_count); 1736 1737 out: 1738 brelse(group_bh); 1739 1740 return ret; 1741 } 1742 1743 static int ocfs2_search_chain(struct ocfs2_alloc_context *ac, 1744 handle_t *handle, 1745 u32 bits_wanted, 1746 u32 min_bits, 1747 struct ocfs2_suballoc_result *res, 1748 u16 *bits_left) 1749 { 1750 int status; 1751 u16 chain; 1752 u64 next_group; 1753 struct inode *alloc_inode = ac->ac_inode; 1754 struct buffer_head *group_bh = NULL; 1755 struct buffer_head *prev_group_bh = NULL; 1756 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) ac->ac_bh->b_data; 1757 struct ocfs2_chain_list *cl = (struct ocfs2_chain_list *) &fe->id2.i_chain; 1758 struct ocfs2_group_desc *bg; 1759 1760 chain = ac->ac_chain; 1761 trace_ocfs2_search_chain_begin( 1762 (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno, 1763 bits_wanted, chain); 1764 1765 status = ocfs2_read_group_descriptor(alloc_inode, fe, 1766 le64_to_cpu(cl->cl_recs[chain].c_blkno), 1767 &group_bh); 1768 if (status < 0) { 1769 mlog_errno(status); 1770 goto bail; 1771 } 1772 bg = (struct ocfs2_group_desc *) group_bh->b_data; 1773 1774 status = -ENOSPC; 1775 /* for now, the chain search is a bit simplistic. We just use 1776 * the 1st group with any empty bits. */ 1777 while ((status = ac->ac_group_search(alloc_inode, group_bh, 1778 bits_wanted, min_bits, 1779 ac->ac_max_block, 1780 res)) == -ENOSPC) { 1781 if (!bg->bg_next_group) 1782 break; 1783 1784 brelse(prev_group_bh); 1785 prev_group_bh = NULL; 1786 1787 next_group = le64_to_cpu(bg->bg_next_group); 1788 prev_group_bh = group_bh; 1789 group_bh = NULL; 1790 status = ocfs2_read_group_descriptor(alloc_inode, fe, 1791 next_group, &group_bh); 1792 if (status < 0) { 1793 mlog_errno(status); 1794 goto bail; 1795 } 1796 bg = (struct ocfs2_group_desc *) group_bh->b_data; 1797 } 1798 if (status < 0) { 1799 if (status != -ENOSPC) 1800 mlog_errno(status); 1801 goto bail; 1802 } 1803 1804 trace_ocfs2_search_chain_succ( 1805 (unsigned long long)le64_to_cpu(bg->bg_blkno), res->sr_bits); 1806 1807 res->sr_bg_blkno = le64_to_cpu(bg->bg_blkno); 1808 1809 BUG_ON(res->sr_bits == 0); 1810 if (!status) 1811 ocfs2_bg_discontig_fix_result(ac, bg, res); 1812 1813 /* 1814 * sr_bg_blkno might have been changed by 1815 * ocfs2_bg_discontig_fix_result 1816 */ 1817 res->sr_bg_stable_blkno = group_bh->b_blocknr; 1818 1819 /* 1820 * Keep track of previous block descriptor read. When 1821 * we find a target, if we have read more than X 1822 * number of descriptors, and the target is reasonably 1823 * empty, relink him to top of his chain. 1824 * 1825 * We've read 0 extra blocks and only send one more to 1826 * the transaction, yet the next guy to search has a 1827 * much easier time. 1828 * 1829 * Do this *after* figuring out how many bits we're taking out 1830 * of our target group. 1831 */ 1832 if (!ac->ac_disable_chain_relink && 1833 (prev_group_bh) && 1834 (ocfs2_block_group_reasonably_empty(bg, res->sr_bits))) { 1835 status = ocfs2_relink_block_group(handle, alloc_inode, 1836 ac->ac_bh, group_bh, 1837 prev_group_bh, chain); 1838 if (status < 0) { 1839 mlog_errno(status); 1840 goto bail; 1841 } 1842 } 1843 1844 if (ac->ac_find_loc_only) 1845 goto out_loc_only; 1846 1847 status = ocfs2_alloc_dinode_update_counts(alloc_inode, handle, 1848 ac->ac_bh, res->sr_bits, 1849 chain); 1850 if (status) { 1851 mlog_errno(status); 1852 goto bail; 1853 } 1854 1855 status = ocfs2_block_group_set_bits(handle, 1856 alloc_inode, 1857 bg, 1858 group_bh, 1859 res->sr_bit_offset, 1860 res->sr_bits); 1861 if (status < 0) { 1862 ocfs2_rollback_alloc_dinode_counts(alloc_inode, 1863 ac->ac_bh, res->sr_bits, chain); 1864 mlog_errno(status); 1865 goto bail; 1866 } 1867 1868 trace_ocfs2_search_chain_end( 1869 (unsigned long long)le64_to_cpu(fe->i_blkno), 1870 res->sr_bits); 1871 1872 out_loc_only: 1873 *bits_left = le16_to_cpu(bg->bg_free_bits_count); 1874 bail: 1875 brelse(group_bh); 1876 brelse(prev_group_bh); 1877 1878 if (status) 1879 mlog_errno(status); 1880 return status; 1881 } 1882 1883 /* will give out up to bits_wanted contiguous bits. */ 1884 static int ocfs2_claim_suballoc_bits(struct ocfs2_alloc_context *ac, 1885 handle_t *handle, 1886 u32 bits_wanted, 1887 u32 min_bits, 1888 struct ocfs2_suballoc_result *res) 1889 { 1890 int status; 1891 u16 victim, i; 1892 u16 bits_left = 0; 1893 u64 hint = ac->ac_last_group; 1894 struct ocfs2_chain_list *cl; 1895 struct ocfs2_dinode *fe; 1896 1897 BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted); 1898 BUG_ON(bits_wanted > (ac->ac_bits_wanted - ac->ac_bits_given)); 1899 BUG_ON(!ac->ac_bh); 1900 1901 fe = (struct ocfs2_dinode *) ac->ac_bh->b_data; 1902 1903 /* The bh was validated by the inode read during 1904 * ocfs2_reserve_suballoc_bits(). Any corruption is a code bug. */ 1905 BUG_ON(!OCFS2_IS_VALID_DINODE(fe)); 1906 1907 if (le32_to_cpu(fe->id1.bitmap1.i_used) >= 1908 le32_to_cpu(fe->id1.bitmap1.i_total)) { 1909 status = ocfs2_error(ac->ac_inode->i_sb, 1910 "Chain allocator dinode %llu has %u used bits but only %u total\n", 1911 (unsigned long long)le64_to_cpu(fe->i_blkno), 1912 le32_to_cpu(fe->id1.bitmap1.i_used), 1913 le32_to_cpu(fe->id1.bitmap1.i_total)); 1914 goto bail; 1915 } 1916 1917 res->sr_bg_blkno = hint; 1918 if (res->sr_bg_blkno) { 1919 /* Attempt to short-circuit the usual search mechanism 1920 * by jumping straight to the most recently used 1921 * allocation group. This helps us maintain some 1922 * contiguousness across allocations. */ 1923 status = ocfs2_search_one_group(ac, handle, bits_wanted, 1924 min_bits, res, &bits_left); 1925 if (!status) 1926 goto set_hint; 1927 if (status < 0 && status != -ENOSPC) { 1928 mlog_errno(status); 1929 goto bail; 1930 } 1931 } 1932 1933 cl = (struct ocfs2_chain_list *) &fe->id2.i_chain; 1934 1935 victim = ocfs2_find_victim_chain(cl); 1936 ac->ac_chain = victim; 1937 1938 status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits, 1939 res, &bits_left); 1940 if (!status) { 1941 if (ocfs2_is_cluster_bitmap(ac->ac_inode)) 1942 hint = res->sr_bg_blkno; 1943 else 1944 hint = ocfs2_group_from_res(res); 1945 goto set_hint; 1946 } 1947 if (status < 0 && status != -ENOSPC) { 1948 mlog_errno(status); 1949 goto bail; 1950 } 1951 1952 trace_ocfs2_claim_suballoc_bits(victim); 1953 1954 /* If we didn't pick a good victim, then just default to 1955 * searching each chain in order. Don't allow chain relinking 1956 * because we only calculate enough journal credits for one 1957 * relink per alloc. */ 1958 ac->ac_disable_chain_relink = 1; 1959 for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i ++) { 1960 if (i == victim) 1961 continue; 1962 if (!cl->cl_recs[i].c_free) 1963 continue; 1964 1965 ac->ac_chain = i; 1966 status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits, 1967 res, &bits_left); 1968 if (!status) { 1969 hint = ocfs2_group_from_res(res); 1970 break; 1971 } 1972 if (status < 0 && status != -ENOSPC) { 1973 mlog_errno(status); 1974 goto bail; 1975 } 1976 } 1977 1978 set_hint: 1979 if (status != -ENOSPC) { 1980 /* If the next search of this group is not likely to 1981 * yield a suitable extent, then we reset the last 1982 * group hint so as to not waste a disk read */ 1983 if (bits_left < min_bits) 1984 ac->ac_last_group = 0; 1985 else 1986 ac->ac_last_group = hint; 1987 } 1988 1989 bail: 1990 if (status) 1991 mlog_errno(status); 1992 return status; 1993 } 1994 1995 int ocfs2_claim_metadata(handle_t *handle, 1996 struct ocfs2_alloc_context *ac, 1997 u32 bits_wanted, 1998 u64 *suballoc_loc, 1999 u16 *suballoc_bit_start, 2000 unsigned int *num_bits, 2001 u64 *blkno_start) 2002 { 2003 int status; 2004 struct ocfs2_suballoc_result res = { .sr_blkno = 0, }; 2005 2006 BUG_ON(!ac); 2007 BUG_ON(ac->ac_bits_wanted < (ac->ac_bits_given + bits_wanted)); 2008 BUG_ON(ac->ac_which != OCFS2_AC_USE_META); 2009 2010 status = ocfs2_claim_suballoc_bits(ac, 2011 handle, 2012 bits_wanted, 2013 1, 2014 &res); 2015 if (status < 0) { 2016 mlog_errno(status); 2017 goto bail; 2018 } 2019 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); 2020 2021 *suballoc_loc = res.sr_bg_blkno; 2022 *suballoc_bit_start = res.sr_bit_offset; 2023 *blkno_start = res.sr_blkno; 2024 ac->ac_bits_given += res.sr_bits; 2025 *num_bits = res.sr_bits; 2026 status = 0; 2027 bail: 2028 if (status) 2029 mlog_errno(status); 2030 return status; 2031 } 2032 2033 static void ocfs2_init_inode_ac_group(struct inode *dir, 2034 struct buffer_head *parent_di_bh, 2035 struct ocfs2_alloc_context *ac) 2036 { 2037 struct ocfs2_dinode *di = (struct ocfs2_dinode *)parent_di_bh->b_data; 2038 /* 2039 * Try to allocate inodes from some specific group. 2040 * 2041 * If the parent dir has recorded the last group used in allocation, 2042 * cool, use it. Otherwise if we try to allocate new inode from the 2043 * same slot the parent dir belongs to, use the same chunk. 2044 * 2045 * We are very careful here to avoid the mistake of setting 2046 * ac_last_group to a group descriptor from a different (unlocked) slot. 2047 */ 2048 if (OCFS2_I(dir)->ip_last_used_group && 2049 OCFS2_I(dir)->ip_last_used_slot == ac->ac_alloc_slot) 2050 ac->ac_last_group = OCFS2_I(dir)->ip_last_used_group; 2051 else if (le16_to_cpu(di->i_suballoc_slot) == ac->ac_alloc_slot) { 2052 if (di->i_suballoc_loc) 2053 ac->ac_last_group = le64_to_cpu(di->i_suballoc_loc); 2054 else 2055 ac->ac_last_group = ocfs2_which_suballoc_group( 2056 le64_to_cpu(di->i_blkno), 2057 le16_to_cpu(di->i_suballoc_bit)); 2058 } 2059 } 2060 2061 static inline void ocfs2_save_inode_ac_group(struct inode *dir, 2062 struct ocfs2_alloc_context *ac) 2063 { 2064 OCFS2_I(dir)->ip_last_used_group = ac->ac_last_group; 2065 OCFS2_I(dir)->ip_last_used_slot = ac->ac_alloc_slot; 2066 } 2067 2068 int ocfs2_find_new_inode_loc(struct inode *dir, 2069 struct buffer_head *parent_fe_bh, 2070 struct ocfs2_alloc_context *ac, 2071 u64 *fe_blkno) 2072 { 2073 int ret; 2074 handle_t *handle = NULL; 2075 struct ocfs2_suballoc_result *res; 2076 2077 BUG_ON(!ac); 2078 BUG_ON(ac->ac_bits_given != 0); 2079 BUG_ON(ac->ac_bits_wanted != 1); 2080 BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE); 2081 2082 res = kzalloc(sizeof(*res), GFP_NOFS); 2083 if (res == NULL) { 2084 ret = -ENOMEM; 2085 mlog_errno(ret); 2086 goto out; 2087 } 2088 2089 ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac); 2090 2091 /* 2092 * The handle started here is for chain relink. Alternatively, 2093 * we could just disable relink for these calls. 2094 */ 2095 handle = ocfs2_start_trans(OCFS2_SB(dir->i_sb), OCFS2_SUBALLOC_ALLOC); 2096 if (IS_ERR(handle)) { 2097 ret = PTR_ERR(handle); 2098 handle = NULL; 2099 mlog_errno(ret); 2100 goto out; 2101 } 2102 2103 /* 2104 * This will instruct ocfs2_claim_suballoc_bits and 2105 * ocfs2_search_one_group to search but save actual allocation 2106 * for later. 2107 */ 2108 ac->ac_find_loc_only = 1; 2109 2110 ret = ocfs2_claim_suballoc_bits(ac, handle, 1, 1, res); 2111 if (ret < 0) { 2112 mlog_errno(ret); 2113 goto out; 2114 } 2115 2116 ac->ac_find_loc_priv = res; 2117 *fe_blkno = res->sr_blkno; 2118 ocfs2_update_inode_fsync_trans(handle, dir, 0); 2119 out: 2120 if (handle) 2121 ocfs2_commit_trans(OCFS2_SB(dir->i_sb), handle); 2122 2123 if (ret) 2124 kfree(res); 2125 2126 return ret; 2127 } 2128 2129 int ocfs2_claim_new_inode_at_loc(handle_t *handle, 2130 struct inode *dir, 2131 struct ocfs2_alloc_context *ac, 2132 u64 *suballoc_loc, 2133 u16 *suballoc_bit, 2134 u64 di_blkno) 2135 { 2136 int ret; 2137 u16 chain; 2138 struct ocfs2_suballoc_result *res = ac->ac_find_loc_priv; 2139 struct buffer_head *bg_bh = NULL; 2140 struct ocfs2_group_desc *bg; 2141 struct ocfs2_dinode *di = (struct ocfs2_dinode *) ac->ac_bh->b_data; 2142 2143 /* 2144 * Since di_blkno is being passed back in, we check for any 2145 * inconsistencies which may have happened between 2146 * calls. These are code bugs as di_blkno is not expected to 2147 * change once returned from ocfs2_find_new_inode_loc() 2148 */ 2149 BUG_ON(res->sr_blkno != di_blkno); 2150 2151 ret = ocfs2_read_group_descriptor(ac->ac_inode, di, 2152 res->sr_bg_stable_blkno, &bg_bh); 2153 if (ret) { 2154 mlog_errno(ret); 2155 goto out; 2156 } 2157 2158 bg = (struct ocfs2_group_desc *) bg_bh->b_data; 2159 chain = le16_to_cpu(bg->bg_chain); 2160 2161 ret = ocfs2_alloc_dinode_update_counts(ac->ac_inode, handle, 2162 ac->ac_bh, res->sr_bits, 2163 chain); 2164 if (ret) { 2165 mlog_errno(ret); 2166 goto out; 2167 } 2168 2169 ret = ocfs2_block_group_set_bits(handle, 2170 ac->ac_inode, 2171 bg, 2172 bg_bh, 2173 res->sr_bit_offset, 2174 res->sr_bits); 2175 if (ret < 0) { 2176 ocfs2_rollback_alloc_dinode_counts(ac->ac_inode, 2177 ac->ac_bh, res->sr_bits, chain); 2178 mlog_errno(ret); 2179 goto out; 2180 } 2181 2182 trace_ocfs2_claim_new_inode_at_loc((unsigned long long)di_blkno, 2183 res->sr_bits); 2184 2185 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); 2186 2187 BUG_ON(res->sr_bits != 1); 2188 2189 *suballoc_loc = res->sr_bg_blkno; 2190 *suballoc_bit = res->sr_bit_offset; 2191 ac->ac_bits_given++; 2192 ocfs2_save_inode_ac_group(dir, ac); 2193 2194 out: 2195 brelse(bg_bh); 2196 2197 return ret; 2198 } 2199 2200 int ocfs2_claim_new_inode(handle_t *handle, 2201 struct inode *dir, 2202 struct buffer_head *parent_fe_bh, 2203 struct ocfs2_alloc_context *ac, 2204 u64 *suballoc_loc, 2205 u16 *suballoc_bit, 2206 u64 *fe_blkno) 2207 { 2208 int status; 2209 struct ocfs2_suballoc_result res; 2210 2211 BUG_ON(!ac); 2212 BUG_ON(ac->ac_bits_given != 0); 2213 BUG_ON(ac->ac_bits_wanted != 1); 2214 BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE); 2215 2216 ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac); 2217 2218 status = ocfs2_claim_suballoc_bits(ac, 2219 handle, 2220 1, 2221 1, 2222 &res); 2223 if (status < 0) { 2224 mlog_errno(status); 2225 goto bail; 2226 } 2227 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); 2228 2229 BUG_ON(res.sr_bits != 1); 2230 2231 *suballoc_loc = res.sr_bg_blkno; 2232 *suballoc_bit = res.sr_bit_offset; 2233 *fe_blkno = res.sr_blkno; 2234 ac->ac_bits_given++; 2235 ocfs2_save_inode_ac_group(dir, ac); 2236 status = 0; 2237 bail: 2238 if (status) 2239 mlog_errno(status); 2240 return status; 2241 } 2242 2243 /* translate a group desc. blkno and it's bitmap offset into 2244 * disk cluster offset. */ 2245 static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode, 2246 u64 bg_blkno, 2247 u16 bg_bit_off) 2248 { 2249 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2250 u32 cluster = 0; 2251 2252 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 2253 2254 if (bg_blkno != osb->first_cluster_group_blkno) 2255 cluster = ocfs2_blocks_to_clusters(inode->i_sb, bg_blkno); 2256 cluster += (u32) bg_bit_off; 2257 return cluster; 2258 } 2259 2260 /* given a cluster offset, calculate which block group it belongs to 2261 * and return that block offset. */ 2262 u64 ocfs2_which_cluster_group(struct inode *inode, u32 cluster) 2263 { 2264 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2265 u32 group_no; 2266 2267 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 2268 2269 group_no = cluster / osb->bitmap_cpg; 2270 if (!group_no) 2271 return osb->first_cluster_group_blkno; 2272 return ocfs2_clusters_to_blocks(inode->i_sb, 2273 group_no * osb->bitmap_cpg); 2274 } 2275 2276 /* given the block number of a cluster start, calculate which cluster 2277 * group and descriptor bitmap offset that corresponds to. */ 2278 static inline void ocfs2_block_to_cluster_group(struct inode *inode, 2279 u64 data_blkno, 2280 u64 *bg_blkno, 2281 u16 *bg_bit_off) 2282 { 2283 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2284 u32 data_cluster = ocfs2_blocks_to_clusters(osb->sb, data_blkno); 2285 2286 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 2287 2288 *bg_blkno = ocfs2_which_cluster_group(inode, 2289 data_cluster); 2290 2291 if (*bg_blkno == osb->first_cluster_group_blkno) 2292 *bg_bit_off = (u16) data_cluster; 2293 else 2294 *bg_bit_off = (u16) ocfs2_blocks_to_clusters(osb->sb, 2295 data_blkno - *bg_blkno); 2296 } 2297 2298 /* 2299 * min_bits - minimum contiguous chunk from this total allocation we 2300 * can handle. set to what we asked for originally for a full 2301 * contig. allocation, set to '1' to indicate we can deal with extents 2302 * of any size. 2303 */ 2304 int __ocfs2_claim_clusters(handle_t *handle, 2305 struct ocfs2_alloc_context *ac, 2306 u32 min_clusters, 2307 u32 max_clusters, 2308 u32 *cluster_start, 2309 u32 *num_clusters) 2310 { 2311 int status; 2312 unsigned int bits_wanted = max_clusters; 2313 struct ocfs2_suballoc_result res = { .sr_blkno = 0, }; 2314 struct ocfs2_super *osb = OCFS2_SB(ac->ac_inode->i_sb); 2315 2316 BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted); 2317 2318 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL 2319 && ac->ac_which != OCFS2_AC_USE_MAIN); 2320 2321 if (ac->ac_which == OCFS2_AC_USE_LOCAL) { 2322 WARN_ON(min_clusters > 1); 2323 2324 status = ocfs2_claim_local_alloc_bits(osb, 2325 handle, 2326 ac, 2327 bits_wanted, 2328 cluster_start, 2329 num_clusters); 2330 if (!status) 2331 atomic_inc(&osb->alloc_stats.local_data); 2332 } else { 2333 if (min_clusters > (osb->bitmap_cpg - 1)) { 2334 /* The only paths asking for contiguousness 2335 * should know about this already. */ 2336 mlog(ML_ERROR, "minimum allocation requested %u exceeds " 2337 "group bitmap size %u!\n", min_clusters, 2338 osb->bitmap_cpg); 2339 status = -ENOSPC; 2340 goto bail; 2341 } 2342 /* clamp the current request down to a realistic size. */ 2343 if (bits_wanted > (osb->bitmap_cpg - 1)) 2344 bits_wanted = osb->bitmap_cpg - 1; 2345 2346 status = ocfs2_claim_suballoc_bits(ac, 2347 handle, 2348 bits_wanted, 2349 min_clusters, 2350 &res); 2351 if (!status) { 2352 BUG_ON(res.sr_blkno); /* cluster alloc can't set */ 2353 *cluster_start = 2354 ocfs2_desc_bitmap_to_cluster_off(ac->ac_inode, 2355 res.sr_bg_blkno, 2356 res.sr_bit_offset); 2357 atomic_inc(&osb->alloc_stats.bitmap_data); 2358 *num_clusters = res.sr_bits; 2359 } 2360 } 2361 if (status < 0) { 2362 if (status != -ENOSPC) 2363 mlog_errno(status); 2364 goto bail; 2365 } 2366 2367 ac->ac_bits_given += *num_clusters; 2368 2369 bail: 2370 if (status) 2371 mlog_errno(status); 2372 return status; 2373 } 2374 2375 int ocfs2_claim_clusters(handle_t *handle, 2376 struct ocfs2_alloc_context *ac, 2377 u32 min_clusters, 2378 u32 *cluster_start, 2379 u32 *num_clusters) 2380 { 2381 unsigned int bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given; 2382 2383 return __ocfs2_claim_clusters(handle, ac, min_clusters, 2384 bits_wanted, cluster_start, num_clusters); 2385 } 2386 2387 static int ocfs2_block_group_clear_bits(handle_t *handle, 2388 struct inode *alloc_inode, 2389 struct ocfs2_group_desc *bg, 2390 struct buffer_head *group_bh, 2391 unsigned int bit_off, 2392 unsigned int num_bits, 2393 void (*undo_fn)(unsigned int bit, 2394 unsigned long *bmap)) 2395 { 2396 int status; 2397 unsigned int tmp; 2398 struct ocfs2_group_desc *undo_bg = NULL; 2399 2400 /* The caller got this descriptor from 2401 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */ 2402 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg)); 2403 2404 trace_ocfs2_block_group_clear_bits(bit_off, num_bits); 2405 2406 BUG_ON(undo_fn && !ocfs2_is_cluster_bitmap(alloc_inode)); 2407 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode), 2408 group_bh, 2409 undo_fn ? 2410 OCFS2_JOURNAL_ACCESS_UNDO : 2411 OCFS2_JOURNAL_ACCESS_WRITE); 2412 if (status < 0) { 2413 mlog_errno(status); 2414 goto bail; 2415 } 2416 2417 if (undo_fn) { 2418 jbd_lock_bh_state(group_bh); 2419 undo_bg = (struct ocfs2_group_desc *) 2420 bh2jh(group_bh)->b_committed_data; 2421 BUG_ON(!undo_bg); 2422 } 2423 2424 tmp = num_bits; 2425 while(tmp--) { 2426 ocfs2_clear_bit((bit_off + tmp), 2427 (unsigned long *) bg->bg_bitmap); 2428 if (undo_fn) 2429 undo_fn(bit_off + tmp, 2430 (unsigned long *) undo_bg->bg_bitmap); 2431 } 2432 le16_add_cpu(&bg->bg_free_bits_count, num_bits); 2433 if (le16_to_cpu(bg->bg_free_bits_count) > le16_to_cpu(bg->bg_bits)) { 2434 return ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit count %u but claims %u are freed. num_bits %d\n", 2435 (unsigned long long)le64_to_cpu(bg->bg_blkno), 2436 le16_to_cpu(bg->bg_bits), 2437 le16_to_cpu(bg->bg_free_bits_count), 2438 num_bits); 2439 } 2440 2441 if (undo_fn) 2442 jbd_unlock_bh_state(group_bh); 2443 2444 ocfs2_journal_dirty(handle, group_bh); 2445 bail: 2446 return status; 2447 } 2448 2449 /* 2450 * expects the suballoc inode to already be locked. 2451 */ 2452 static int _ocfs2_free_suballoc_bits(handle_t *handle, 2453 struct inode *alloc_inode, 2454 struct buffer_head *alloc_bh, 2455 unsigned int start_bit, 2456 u64 bg_blkno, 2457 unsigned int count, 2458 void (*undo_fn)(unsigned int bit, 2459 unsigned long *bitmap)) 2460 { 2461 int status = 0; 2462 u32 tmp_used; 2463 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) alloc_bh->b_data; 2464 struct ocfs2_chain_list *cl = &fe->id2.i_chain; 2465 struct buffer_head *group_bh = NULL; 2466 struct ocfs2_group_desc *group; 2467 2468 /* The alloc_bh comes from ocfs2_free_dinode() or 2469 * ocfs2_free_clusters(). The callers have all locked the 2470 * allocator and gotten alloc_bh from the lock call. This 2471 * validates the dinode buffer. Any corruption that has happened 2472 * is a code bug. */ 2473 BUG_ON(!OCFS2_IS_VALID_DINODE(fe)); 2474 BUG_ON((count + start_bit) > ocfs2_bits_per_group(cl)); 2475 2476 trace_ocfs2_free_suballoc_bits( 2477 (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno, 2478 (unsigned long long)bg_blkno, 2479 start_bit, count); 2480 2481 status = ocfs2_read_group_descriptor(alloc_inode, fe, bg_blkno, 2482 &group_bh); 2483 if (status < 0) { 2484 mlog_errno(status); 2485 goto bail; 2486 } 2487 group = (struct ocfs2_group_desc *) group_bh->b_data; 2488 2489 BUG_ON((count + start_bit) > le16_to_cpu(group->bg_bits)); 2490 2491 status = ocfs2_block_group_clear_bits(handle, alloc_inode, 2492 group, group_bh, 2493 start_bit, count, undo_fn); 2494 if (status < 0) { 2495 mlog_errno(status); 2496 goto bail; 2497 } 2498 2499 status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode), 2500 alloc_bh, OCFS2_JOURNAL_ACCESS_WRITE); 2501 if (status < 0) { 2502 mlog_errno(status); 2503 ocfs2_block_group_set_bits(handle, alloc_inode, group, group_bh, 2504 start_bit, count); 2505 goto bail; 2506 } 2507 2508 le32_add_cpu(&cl->cl_recs[le16_to_cpu(group->bg_chain)].c_free, 2509 count); 2510 tmp_used = le32_to_cpu(fe->id1.bitmap1.i_used); 2511 fe->id1.bitmap1.i_used = cpu_to_le32(tmp_used - count); 2512 ocfs2_journal_dirty(handle, alloc_bh); 2513 2514 bail: 2515 brelse(group_bh); 2516 2517 if (status) 2518 mlog_errno(status); 2519 return status; 2520 } 2521 2522 int ocfs2_free_suballoc_bits(handle_t *handle, 2523 struct inode *alloc_inode, 2524 struct buffer_head *alloc_bh, 2525 unsigned int start_bit, 2526 u64 bg_blkno, 2527 unsigned int count) 2528 { 2529 return _ocfs2_free_suballoc_bits(handle, alloc_inode, alloc_bh, 2530 start_bit, bg_blkno, count, NULL); 2531 } 2532 2533 int ocfs2_free_dinode(handle_t *handle, 2534 struct inode *inode_alloc_inode, 2535 struct buffer_head *inode_alloc_bh, 2536 struct ocfs2_dinode *di) 2537 { 2538 u64 blk = le64_to_cpu(di->i_blkno); 2539 u16 bit = le16_to_cpu(di->i_suballoc_bit); 2540 u64 bg_blkno = ocfs2_which_suballoc_group(blk, bit); 2541 2542 if (di->i_suballoc_loc) 2543 bg_blkno = le64_to_cpu(di->i_suballoc_loc); 2544 return ocfs2_free_suballoc_bits(handle, inode_alloc_inode, 2545 inode_alloc_bh, bit, bg_blkno, 1); 2546 } 2547 2548 static int _ocfs2_free_clusters(handle_t *handle, 2549 struct inode *bitmap_inode, 2550 struct buffer_head *bitmap_bh, 2551 u64 start_blk, 2552 unsigned int num_clusters, 2553 void (*undo_fn)(unsigned int bit, 2554 unsigned long *bitmap)) 2555 { 2556 int status; 2557 u16 bg_start_bit; 2558 u64 bg_blkno; 2559 struct ocfs2_dinode *fe; 2560 2561 /* You can't ever have a contiguous set of clusters 2562 * bigger than a block group bitmap so we never have to worry 2563 * about looping on them. 2564 * This is expensive. We can safely remove once this stuff has 2565 * gotten tested really well. */ 2566 BUG_ON(start_blk != ocfs2_clusters_to_blocks(bitmap_inode->i_sb, ocfs2_blocks_to_clusters(bitmap_inode->i_sb, start_blk))); 2567 2568 fe = (struct ocfs2_dinode *) bitmap_bh->b_data; 2569 2570 ocfs2_block_to_cluster_group(bitmap_inode, start_blk, &bg_blkno, 2571 &bg_start_bit); 2572 2573 trace_ocfs2_free_clusters((unsigned long long)bg_blkno, 2574 (unsigned long long)start_blk, 2575 bg_start_bit, num_clusters); 2576 2577 status = _ocfs2_free_suballoc_bits(handle, bitmap_inode, bitmap_bh, 2578 bg_start_bit, bg_blkno, 2579 num_clusters, undo_fn); 2580 if (status < 0) { 2581 mlog_errno(status); 2582 goto out; 2583 } 2584 2585 ocfs2_local_alloc_seen_free_bits(OCFS2_SB(bitmap_inode->i_sb), 2586 num_clusters); 2587 2588 out: 2589 if (status) 2590 mlog_errno(status); 2591 return status; 2592 } 2593 2594 int ocfs2_free_clusters(handle_t *handle, 2595 struct inode *bitmap_inode, 2596 struct buffer_head *bitmap_bh, 2597 u64 start_blk, 2598 unsigned int num_clusters) 2599 { 2600 return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh, 2601 start_blk, num_clusters, 2602 _ocfs2_set_bit); 2603 } 2604 2605 /* 2606 * Give never-used clusters back to the global bitmap. We don't need 2607 * to protect these bits in the undo buffer. 2608 */ 2609 int ocfs2_release_clusters(handle_t *handle, 2610 struct inode *bitmap_inode, 2611 struct buffer_head *bitmap_bh, 2612 u64 start_blk, 2613 unsigned int num_clusters) 2614 { 2615 return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh, 2616 start_blk, num_clusters, 2617 _ocfs2_clear_bit); 2618 } 2619 2620 static inline void ocfs2_debug_bg(struct ocfs2_group_desc *bg) 2621 { 2622 printk("Block Group:\n"); 2623 printk("bg_signature: %s\n", bg->bg_signature); 2624 printk("bg_size: %u\n", bg->bg_size); 2625 printk("bg_bits: %u\n", bg->bg_bits); 2626 printk("bg_free_bits_count: %u\n", bg->bg_free_bits_count); 2627 printk("bg_chain: %u\n", bg->bg_chain); 2628 printk("bg_generation: %u\n", le32_to_cpu(bg->bg_generation)); 2629 printk("bg_next_group: %llu\n", 2630 (unsigned long long)bg->bg_next_group); 2631 printk("bg_parent_dinode: %llu\n", 2632 (unsigned long long)bg->bg_parent_dinode); 2633 printk("bg_blkno: %llu\n", 2634 (unsigned long long)bg->bg_blkno); 2635 } 2636 2637 static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode *fe) 2638 { 2639 int i; 2640 2641 printk("Suballoc Inode %llu:\n", (unsigned long long)fe->i_blkno); 2642 printk("i_signature: %s\n", fe->i_signature); 2643 printk("i_size: %llu\n", 2644 (unsigned long long)fe->i_size); 2645 printk("i_clusters: %u\n", fe->i_clusters); 2646 printk("i_generation: %u\n", 2647 le32_to_cpu(fe->i_generation)); 2648 printk("id1.bitmap1.i_used: %u\n", 2649 le32_to_cpu(fe->id1.bitmap1.i_used)); 2650 printk("id1.bitmap1.i_total: %u\n", 2651 le32_to_cpu(fe->id1.bitmap1.i_total)); 2652 printk("id2.i_chain.cl_cpg: %u\n", fe->id2.i_chain.cl_cpg); 2653 printk("id2.i_chain.cl_bpc: %u\n", fe->id2.i_chain.cl_bpc); 2654 printk("id2.i_chain.cl_count: %u\n", fe->id2.i_chain.cl_count); 2655 printk("id2.i_chain.cl_next_free_rec: %u\n", 2656 fe->id2.i_chain.cl_next_free_rec); 2657 for(i = 0; i < fe->id2.i_chain.cl_next_free_rec; i++) { 2658 printk("fe->id2.i_chain.cl_recs[%d].c_free: %u\n", i, 2659 fe->id2.i_chain.cl_recs[i].c_free); 2660 printk("fe->id2.i_chain.cl_recs[%d].c_total: %u\n", i, 2661 fe->id2.i_chain.cl_recs[i].c_total); 2662 printk("fe->id2.i_chain.cl_recs[%d].c_blkno: %llu\n", i, 2663 (unsigned long long)fe->id2.i_chain.cl_recs[i].c_blkno); 2664 } 2665 } 2666 2667 /* 2668 * For a given allocation, determine which allocators will need to be 2669 * accessed, and lock them, reserving the appropriate number of bits. 2670 * 2671 * Sparse file systems call this from ocfs2_write_begin_nolock() 2672 * and ocfs2_allocate_unwritten_extents(). 2673 * 2674 * File systems which don't support holes call this from 2675 * ocfs2_extend_allocation(). 2676 */ 2677 int ocfs2_lock_allocators(struct inode *inode, 2678 struct ocfs2_extent_tree *et, 2679 u32 clusters_to_add, u32 extents_to_split, 2680 struct ocfs2_alloc_context **data_ac, 2681 struct ocfs2_alloc_context **meta_ac) 2682 { 2683 int ret = 0, num_free_extents; 2684 unsigned int max_recs_needed = clusters_to_add + 2 * extents_to_split; 2685 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2686 2687 *meta_ac = NULL; 2688 if (data_ac) 2689 *data_ac = NULL; 2690 2691 BUG_ON(clusters_to_add != 0 && data_ac == NULL); 2692 2693 num_free_extents = ocfs2_num_free_extents(osb, et); 2694 if (num_free_extents < 0) { 2695 ret = num_free_extents; 2696 mlog_errno(ret); 2697 goto out; 2698 } 2699 2700 /* 2701 * Sparse allocation file systems need to be more conservative 2702 * with reserving room for expansion - the actual allocation 2703 * happens while we've got a journal handle open so re-taking 2704 * a cluster lock (because we ran out of room for another 2705 * extent) will violate ordering rules. 2706 * 2707 * Most of the time we'll only be seeing this 1 cluster at a time 2708 * anyway. 2709 * 2710 * Always lock for any unwritten extents - we might want to 2711 * add blocks during a split. 2712 */ 2713 if (!num_free_extents || 2714 (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed)) { 2715 ret = ocfs2_reserve_new_metadata(osb, et->et_root_el, meta_ac); 2716 if (ret < 0) { 2717 if (ret != -ENOSPC) 2718 mlog_errno(ret); 2719 goto out; 2720 } 2721 } 2722 2723 if (clusters_to_add == 0) 2724 goto out; 2725 2726 ret = ocfs2_reserve_clusters(osb, clusters_to_add, data_ac); 2727 if (ret < 0) { 2728 if (ret != -ENOSPC) 2729 mlog_errno(ret); 2730 goto out; 2731 } 2732 2733 out: 2734 if (ret) { 2735 if (*meta_ac) { 2736 ocfs2_free_alloc_context(*meta_ac); 2737 *meta_ac = NULL; 2738 } 2739 2740 /* 2741 * We cannot have an error and a non null *data_ac. 2742 */ 2743 } 2744 2745 return ret; 2746 } 2747 2748 /* 2749 * Read the inode specified by blkno to get suballoc_slot and 2750 * suballoc_bit. 2751 */ 2752 static int ocfs2_get_suballoc_slot_bit(struct ocfs2_super *osb, u64 blkno, 2753 u16 *suballoc_slot, u64 *group_blkno, 2754 u16 *suballoc_bit) 2755 { 2756 int status; 2757 struct buffer_head *inode_bh = NULL; 2758 struct ocfs2_dinode *inode_fe; 2759 2760 trace_ocfs2_get_suballoc_slot_bit((unsigned long long)blkno); 2761 2762 /* dirty read disk */ 2763 status = ocfs2_read_blocks_sync(osb, blkno, 1, &inode_bh); 2764 if (status < 0) { 2765 mlog(ML_ERROR, "read block %llu failed %d\n", 2766 (unsigned long long)blkno, status); 2767 goto bail; 2768 } 2769 2770 inode_fe = (struct ocfs2_dinode *) inode_bh->b_data; 2771 if (!OCFS2_IS_VALID_DINODE(inode_fe)) { 2772 mlog(ML_ERROR, "invalid inode %llu requested\n", 2773 (unsigned long long)blkno); 2774 status = -EINVAL; 2775 goto bail; 2776 } 2777 2778 if (le16_to_cpu(inode_fe->i_suballoc_slot) != (u16)OCFS2_INVALID_SLOT && 2779 (u32)le16_to_cpu(inode_fe->i_suballoc_slot) > osb->max_slots - 1) { 2780 mlog(ML_ERROR, "inode %llu has invalid suballoc slot %u\n", 2781 (unsigned long long)blkno, 2782 (u32)le16_to_cpu(inode_fe->i_suballoc_slot)); 2783 status = -EINVAL; 2784 goto bail; 2785 } 2786 2787 if (suballoc_slot) 2788 *suballoc_slot = le16_to_cpu(inode_fe->i_suballoc_slot); 2789 if (suballoc_bit) 2790 *suballoc_bit = le16_to_cpu(inode_fe->i_suballoc_bit); 2791 if (group_blkno) 2792 *group_blkno = le64_to_cpu(inode_fe->i_suballoc_loc); 2793 2794 bail: 2795 brelse(inode_bh); 2796 2797 if (status) 2798 mlog_errno(status); 2799 return status; 2800 } 2801 2802 /* 2803 * test whether bit is SET in allocator bitmap or not. on success, 0 2804 * is returned and *res is 1 for SET; 0 otherwise. when fails, errno 2805 * is returned and *res is meaningless. Call this after you have 2806 * cluster locked against suballoc, or you may get a result based on 2807 * non-up2date contents 2808 */ 2809 static int ocfs2_test_suballoc_bit(struct ocfs2_super *osb, 2810 struct inode *suballoc, 2811 struct buffer_head *alloc_bh, 2812 u64 group_blkno, u64 blkno, 2813 u16 bit, int *res) 2814 { 2815 struct ocfs2_dinode *alloc_di; 2816 struct ocfs2_group_desc *group; 2817 struct buffer_head *group_bh = NULL; 2818 u64 bg_blkno; 2819 int status; 2820 2821 trace_ocfs2_test_suballoc_bit((unsigned long long)blkno, 2822 (unsigned int)bit); 2823 2824 alloc_di = (struct ocfs2_dinode *)alloc_bh->b_data; 2825 if ((bit + 1) > ocfs2_bits_per_group(&alloc_di->id2.i_chain)) { 2826 mlog(ML_ERROR, "suballoc bit %u out of range of %u\n", 2827 (unsigned int)bit, 2828 ocfs2_bits_per_group(&alloc_di->id2.i_chain)); 2829 status = -EINVAL; 2830 goto bail; 2831 } 2832 2833 bg_blkno = group_blkno ? group_blkno : 2834 ocfs2_which_suballoc_group(blkno, bit); 2835 status = ocfs2_read_group_descriptor(suballoc, alloc_di, bg_blkno, 2836 &group_bh); 2837 if (status < 0) { 2838 mlog(ML_ERROR, "read group %llu failed %d\n", 2839 (unsigned long long)bg_blkno, status); 2840 goto bail; 2841 } 2842 2843 group = (struct ocfs2_group_desc *) group_bh->b_data; 2844 *res = ocfs2_test_bit(bit, (unsigned long *)group->bg_bitmap); 2845 2846 bail: 2847 brelse(group_bh); 2848 2849 if (status) 2850 mlog_errno(status); 2851 return status; 2852 } 2853 2854 /* 2855 * Test if the bit representing this inode (blkno) is set in the 2856 * suballocator. 2857 * 2858 * On success, 0 is returned and *res is 1 for SET; 0 otherwise. 2859 * 2860 * In the event of failure, a negative value is returned and *res is 2861 * meaningless. 2862 * 2863 * Callers must make sure to hold nfs_sync_lock to prevent 2864 * ocfs2_delete_inode() on another node from accessing the same 2865 * suballocator concurrently. 2866 */ 2867 int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res) 2868 { 2869 int status; 2870 u64 group_blkno = 0; 2871 u16 suballoc_bit = 0, suballoc_slot = 0; 2872 struct inode *inode_alloc_inode; 2873 struct buffer_head *alloc_bh = NULL; 2874 2875 trace_ocfs2_test_inode_bit((unsigned long long)blkno); 2876 2877 status = ocfs2_get_suballoc_slot_bit(osb, blkno, &suballoc_slot, 2878 &group_blkno, &suballoc_bit); 2879 if (status < 0) { 2880 mlog(ML_ERROR, "get alloc slot and bit failed %d\n", status); 2881 goto bail; 2882 } 2883 2884 inode_alloc_inode = 2885 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE, 2886 suballoc_slot); 2887 if (!inode_alloc_inode) { 2888 /* the error code could be inaccurate, but we are not able to 2889 * get the correct one. */ 2890 status = -EINVAL; 2891 mlog(ML_ERROR, "unable to get alloc inode in slot %u\n", 2892 (u32)suballoc_slot); 2893 goto bail; 2894 } 2895 2896 inode_lock(inode_alloc_inode); 2897 status = ocfs2_inode_lock(inode_alloc_inode, &alloc_bh, 0); 2898 if (status < 0) { 2899 inode_unlock(inode_alloc_inode); 2900 iput(inode_alloc_inode); 2901 mlog(ML_ERROR, "lock on alloc inode on slot %u failed %d\n", 2902 (u32)suballoc_slot, status); 2903 goto bail; 2904 } 2905 2906 status = ocfs2_test_suballoc_bit(osb, inode_alloc_inode, alloc_bh, 2907 group_blkno, blkno, suballoc_bit, res); 2908 if (status < 0) 2909 mlog(ML_ERROR, "test suballoc bit failed %d\n", status); 2910 2911 ocfs2_inode_unlock(inode_alloc_inode, 0); 2912 inode_unlock(inode_alloc_inode); 2913 2914 iput(inode_alloc_inode); 2915 brelse(alloc_bh); 2916 bail: 2917 if (status) 2918 mlog_errno(status); 2919 return status; 2920 } 2921