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