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 56struct 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 71static 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 82static inline void ocfs2_debug_bg(struct ocfs2_group_desc *bg); 83static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode *fe); 84static inline u16 ocfs2_find_victim_chain(struct ocfs2_chain_list *cl); 85static 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); 92static 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 99static 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); 104static 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); 109static 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); 114static int ocfs2_test_bg_bit_allocatable(struct buffer_head *bg_bh, 115 int nr); 116static 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); 122static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg, 123 u32 wanted); 124static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode, 125 u64 bg_blkno, 126 u16 bg_bit_off); 127static inline void ocfs2_block_to_cluster_group(struct inode *inode, 128 u64 data_blkno, 129 u64 *bg_blkno, 130 u16 *bg_bit_off); 131static 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 136void 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 156void ocfs2_free_alloc_context(struct ocfs2_alloc_context *ac) 157{ 158 ocfs2_free_ac_resource(ac); 159 kfree(ac); 160} 161 162static 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, ...) \ 168do { \ 169 if (resize) \ 170 mlog(ML_ERROR, fmt, ##__VA_ARGS__); \ 171 else \ 172 return ocfs2_error(sb, fmt, ##__VA_ARGS__); \ 173} while (0) 174 175static 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 216static 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 */ 257int 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 284static 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 311int 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 332out: 333 return rc; 334} 335 336static 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 358static 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 414bail: 415 if (status) 416 mlog_errno(status); 417 return status; 418} 419 420static 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 434static struct buffer_head * 435ocfs2_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 475bail: 476 return status ? ERR_PTR(status) : bg_bh; 477} 478 479static 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 499static 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 557bail: 558 return status; 559} 560 561static 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 591static struct buffer_head * 592ocfs2_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 660bail: 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 */ 669static 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 766bail: 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 780static 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; 864bail: 865 brelse(bh); 866 867 if (status) 868 mlog_errno(status); 869 return status; 870} 871 872static 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 880static 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 888void 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 894static 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 904static 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 918static int ocfs2_get_inode_steal_slot(struct ocfs2_super *osb) 919{ 920 return __ocfs2_get_steal_slot(osb, INODE_ALLOC_SYSTEM_INODE); 921} 922 923static int ocfs2_get_meta_steal_slot(struct ocfs2_super *osb) 924{ 925 return __ocfs2_get_steal_slot(osb, EXTENT_ALLOC_SYSTEM_INODE); 926} 927 928static 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 961static 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 967static 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 973int 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 1014extent_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; 1024bail: 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 1035int 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 1044int 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 1115inode_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; 1125bail: 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.. */ 1138int 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 1155bail: 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. */ 1162static 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; 1201bail: 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 1212int 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 */ 1242static 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 1265static 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 1325int 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 1368bail: 1369 return status; 1370} 1371 1372/* find the one with the most empty bits */ 1373static 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 1391static 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 1444out: 1445 if (status < 0) 1446 mlog_errno(status); 1447 return status; 1448 1449out_rollback_bg: 1450 bg->bg_next_group = cpu_to_le64(bg_ptr); 1451out_rollback_prev_bg: 1452 prev_bg->bg_next_group = cpu_to_le64(prev_bg_ptr); 1453 goto out; 1454} 1455 1456static 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. */ 1464static 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 1535static 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 1567int 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 1590out: 1591 return ret; 1592} 1593 1594void 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 1609static 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 1628static 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 1658static 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 1716out_loc_only: 1717 *bits_left = le16_to_cpu(gd->bg_free_bits_count); 1718 1719out: 1720 brelse(group_bh); 1721 1722 return ret; 1723} 1724 1725static 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 1854out_loc_only: 1855 *bits_left = le16_to_cpu(bg->bg_free_bits_count); 1856bail: 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. */ 1866static 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 if (ocfs2_is_cluster_bitmap(ac->ac_inode)) 1924 hint = res->sr_bg_blkno; 1925 else 1926 hint = ocfs2_group_from_res(res); 1927 goto set_hint; 1928 } 1929 if (status < 0 && status != -ENOSPC) { 1930 mlog_errno(status); 1931 goto bail; 1932 } 1933 1934 trace_ocfs2_claim_suballoc_bits(victim); 1935 1936 /* If we didn't pick a good victim, then just default to 1937 * searching each chain in order. Don't allow chain relinking 1938 * because we only calculate enough journal credits for one 1939 * relink per alloc. */ 1940 ac->ac_disable_chain_relink = 1; 1941 for (i = 0; i < le16_to_cpu(cl->cl_next_free_rec); i ++) { 1942 if (i == victim) 1943 continue; 1944 if (!cl->cl_recs[i].c_free) 1945 continue; 1946 1947 ac->ac_chain = i; 1948 status = ocfs2_search_chain(ac, handle, bits_wanted, min_bits, 1949 res, &bits_left); 1950 if (!status) { 1951 hint = ocfs2_group_from_res(res); 1952 break; 1953 } 1954 if (status < 0 && status != -ENOSPC) { 1955 mlog_errno(status); 1956 goto bail; 1957 } 1958 } 1959 1960set_hint: 1961 if (status != -ENOSPC) { 1962 /* If the next search of this group is not likely to 1963 * yield a suitable extent, then we reset the last 1964 * group hint so as to not waste a disk read */ 1965 if (bits_left < min_bits) 1966 ac->ac_last_group = 0; 1967 else 1968 ac->ac_last_group = hint; 1969 } 1970 1971bail: 1972 if (status) 1973 mlog_errno(status); 1974 return status; 1975} 1976 1977int ocfs2_claim_metadata(handle_t *handle, 1978 struct ocfs2_alloc_context *ac, 1979 u32 bits_wanted, 1980 u64 *suballoc_loc, 1981 u16 *suballoc_bit_start, 1982 unsigned int *num_bits, 1983 u64 *blkno_start) 1984{ 1985 int status; 1986 struct ocfs2_suballoc_result res = { .sr_blkno = 0, }; 1987 1988 BUG_ON(!ac); 1989 BUG_ON(ac->ac_bits_wanted < (ac->ac_bits_given + bits_wanted)); 1990 BUG_ON(ac->ac_which != OCFS2_AC_USE_META); 1991 1992 status = ocfs2_claim_suballoc_bits(ac, 1993 handle, 1994 bits_wanted, 1995 1, 1996 &res); 1997 if (status < 0) { 1998 mlog_errno(status); 1999 goto bail; 2000 } 2001 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); 2002 2003 *suballoc_loc = res.sr_bg_blkno; 2004 *suballoc_bit_start = res.sr_bit_offset; 2005 *blkno_start = res.sr_blkno; 2006 ac->ac_bits_given += res.sr_bits; 2007 *num_bits = res.sr_bits; 2008 status = 0; 2009bail: 2010 if (status) 2011 mlog_errno(status); 2012 return status; 2013} 2014 2015static void ocfs2_init_inode_ac_group(struct inode *dir, 2016 struct buffer_head *parent_di_bh, 2017 struct ocfs2_alloc_context *ac) 2018{ 2019 struct ocfs2_dinode *di = (struct ocfs2_dinode *)parent_di_bh->b_data; 2020 /* 2021 * Try to allocate inodes from some specific group. 2022 * 2023 * If the parent dir has recorded the last group used in allocation, 2024 * cool, use it. Otherwise if we try to allocate new inode from the 2025 * same slot the parent dir belongs to, use the same chunk. 2026 * 2027 * We are very careful here to avoid the mistake of setting 2028 * ac_last_group to a group descriptor from a different (unlocked) slot. 2029 */ 2030 if (OCFS2_I(dir)->ip_last_used_group && 2031 OCFS2_I(dir)->ip_last_used_slot == ac->ac_alloc_slot) 2032 ac->ac_last_group = OCFS2_I(dir)->ip_last_used_group; 2033 else if (le16_to_cpu(di->i_suballoc_slot) == ac->ac_alloc_slot) { 2034 if (di->i_suballoc_loc) 2035 ac->ac_last_group = le64_to_cpu(di->i_suballoc_loc); 2036 else 2037 ac->ac_last_group = ocfs2_which_suballoc_group( 2038 le64_to_cpu(di->i_blkno), 2039 le16_to_cpu(di->i_suballoc_bit)); 2040 } 2041} 2042 2043static inline void ocfs2_save_inode_ac_group(struct inode *dir, 2044 struct ocfs2_alloc_context *ac) 2045{ 2046 OCFS2_I(dir)->ip_last_used_group = ac->ac_last_group; 2047 OCFS2_I(dir)->ip_last_used_slot = ac->ac_alloc_slot; 2048} 2049 2050int ocfs2_find_new_inode_loc(struct inode *dir, 2051 struct buffer_head *parent_fe_bh, 2052 struct ocfs2_alloc_context *ac, 2053 u64 *fe_blkno) 2054{ 2055 int ret; 2056 handle_t *handle = NULL; 2057 struct ocfs2_suballoc_result *res; 2058 2059 BUG_ON(!ac); 2060 BUG_ON(ac->ac_bits_given != 0); 2061 BUG_ON(ac->ac_bits_wanted != 1); 2062 BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE); 2063 2064 res = kzalloc(sizeof(*res), GFP_NOFS); 2065 if (res == NULL) { 2066 ret = -ENOMEM; 2067 mlog_errno(ret); 2068 goto out; 2069 } 2070 2071 ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac); 2072 2073 /* 2074 * The handle started here is for chain relink. Alternatively, 2075 * we could just disable relink for these calls. 2076 */ 2077 handle = ocfs2_start_trans(OCFS2_SB(dir->i_sb), OCFS2_SUBALLOC_ALLOC); 2078 if (IS_ERR(handle)) { 2079 ret = PTR_ERR(handle); 2080 handle = NULL; 2081 mlog_errno(ret); 2082 goto out; 2083 } 2084 2085 /* 2086 * This will instruct ocfs2_claim_suballoc_bits and 2087 * ocfs2_search_one_group to search but save actual allocation 2088 * for later. 2089 */ 2090 ac->ac_find_loc_only = 1; 2091 2092 ret = ocfs2_claim_suballoc_bits(ac, handle, 1, 1, res); 2093 if (ret < 0) { 2094 mlog_errno(ret); 2095 goto out; 2096 } 2097 2098 ac->ac_find_loc_priv = res; 2099 *fe_blkno = res->sr_blkno; 2100 ocfs2_update_inode_fsync_trans(handle, dir, 0); 2101out: 2102 if (handle) 2103 ocfs2_commit_trans(OCFS2_SB(dir->i_sb), handle); 2104 2105 if (ret) 2106 kfree(res); 2107 2108 return ret; 2109} 2110 2111int ocfs2_claim_new_inode_at_loc(handle_t *handle, 2112 struct inode *dir, 2113 struct ocfs2_alloc_context *ac, 2114 u64 *suballoc_loc, 2115 u16 *suballoc_bit, 2116 u64 di_blkno) 2117{ 2118 int ret; 2119 u16 chain; 2120 struct ocfs2_suballoc_result *res = ac->ac_find_loc_priv; 2121 struct buffer_head *bg_bh = NULL; 2122 struct ocfs2_group_desc *bg; 2123 struct ocfs2_dinode *di = (struct ocfs2_dinode *) ac->ac_bh->b_data; 2124 2125 /* 2126 * Since di_blkno is being passed back in, we check for any 2127 * inconsistencies which may have happened between 2128 * calls. These are code bugs as di_blkno is not expected to 2129 * change once returned from ocfs2_find_new_inode_loc() 2130 */ 2131 BUG_ON(res->sr_blkno != di_blkno); 2132 2133 ret = ocfs2_read_group_descriptor(ac->ac_inode, di, 2134 res->sr_bg_stable_blkno, &bg_bh); 2135 if (ret) { 2136 mlog_errno(ret); 2137 goto out; 2138 } 2139 2140 bg = (struct ocfs2_group_desc *) bg_bh->b_data; 2141 chain = le16_to_cpu(bg->bg_chain); 2142 2143 ret = ocfs2_alloc_dinode_update_counts(ac->ac_inode, handle, 2144 ac->ac_bh, res->sr_bits, 2145 chain); 2146 if (ret) { 2147 mlog_errno(ret); 2148 goto out; 2149 } 2150 2151 ret = ocfs2_block_group_set_bits(handle, 2152 ac->ac_inode, 2153 bg, 2154 bg_bh, 2155 res->sr_bit_offset, 2156 res->sr_bits); 2157 if (ret < 0) { 2158 ocfs2_rollback_alloc_dinode_counts(ac->ac_inode, 2159 ac->ac_bh, res->sr_bits, chain); 2160 mlog_errno(ret); 2161 goto out; 2162 } 2163 2164 trace_ocfs2_claim_new_inode_at_loc((unsigned long long)di_blkno, 2165 res->sr_bits); 2166 2167 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); 2168 2169 BUG_ON(res->sr_bits != 1); 2170 2171 *suballoc_loc = res->sr_bg_blkno; 2172 *suballoc_bit = res->sr_bit_offset; 2173 ac->ac_bits_given++; 2174 ocfs2_save_inode_ac_group(dir, ac); 2175 2176out: 2177 brelse(bg_bh); 2178 2179 return ret; 2180} 2181 2182int ocfs2_claim_new_inode(handle_t *handle, 2183 struct inode *dir, 2184 struct buffer_head *parent_fe_bh, 2185 struct ocfs2_alloc_context *ac, 2186 u64 *suballoc_loc, 2187 u16 *suballoc_bit, 2188 u64 *fe_blkno) 2189{ 2190 int status; 2191 struct ocfs2_suballoc_result res; 2192 2193 BUG_ON(!ac); 2194 BUG_ON(ac->ac_bits_given != 0); 2195 BUG_ON(ac->ac_bits_wanted != 1); 2196 BUG_ON(ac->ac_which != OCFS2_AC_USE_INODE); 2197 2198 ocfs2_init_inode_ac_group(dir, parent_fe_bh, ac); 2199 2200 status = ocfs2_claim_suballoc_bits(ac, 2201 handle, 2202 1, 2203 1, 2204 &res); 2205 if (status < 0) { 2206 mlog_errno(status); 2207 goto bail; 2208 } 2209 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); 2210 2211 BUG_ON(res.sr_bits != 1); 2212 2213 *suballoc_loc = res.sr_bg_blkno; 2214 *suballoc_bit = res.sr_bit_offset; 2215 *fe_blkno = res.sr_blkno; 2216 ac->ac_bits_given++; 2217 ocfs2_save_inode_ac_group(dir, ac); 2218 status = 0; 2219bail: 2220 if (status) 2221 mlog_errno(status); 2222 return status; 2223} 2224 2225/* translate a group desc. blkno and it's bitmap offset into 2226 * disk cluster offset. */ 2227static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode, 2228 u64 bg_blkno, 2229 u16 bg_bit_off) 2230{ 2231 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2232 u32 cluster = 0; 2233 2234 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 2235 2236 if (bg_blkno != osb->first_cluster_group_blkno) 2237 cluster = ocfs2_blocks_to_clusters(inode->i_sb, bg_blkno); 2238 cluster += (u32) bg_bit_off; 2239 return cluster; 2240} 2241 2242/* given a cluster offset, calculate which block group it belongs to 2243 * and return that block offset. */ 2244u64 ocfs2_which_cluster_group(struct inode *inode, u32 cluster) 2245{ 2246 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2247 u32 group_no; 2248 2249 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 2250 2251 group_no = cluster / osb->bitmap_cpg; 2252 if (!group_no) 2253 return osb->first_cluster_group_blkno; 2254 return ocfs2_clusters_to_blocks(inode->i_sb, 2255 group_no * osb->bitmap_cpg); 2256} 2257 2258/* given the block number of a cluster start, calculate which cluster 2259 * group and descriptor bitmap offset that corresponds to. */ 2260static inline void ocfs2_block_to_cluster_group(struct inode *inode, 2261 u64 data_blkno, 2262 u64 *bg_blkno, 2263 u16 *bg_bit_off) 2264{ 2265 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2266 u32 data_cluster = ocfs2_blocks_to_clusters(osb->sb, data_blkno); 2267 2268 BUG_ON(!ocfs2_is_cluster_bitmap(inode)); 2269 2270 *bg_blkno = ocfs2_which_cluster_group(inode, 2271 data_cluster); 2272 2273 if (*bg_blkno == osb->first_cluster_group_blkno) 2274 *bg_bit_off = (u16) data_cluster; 2275 else 2276 *bg_bit_off = (u16) ocfs2_blocks_to_clusters(osb->sb, 2277 data_blkno - *bg_blkno); 2278} 2279 2280/* 2281 * min_bits - minimum contiguous chunk from this total allocation we 2282 * can handle. set to what we asked for originally for a full 2283 * contig. allocation, set to '1' to indicate we can deal with extents 2284 * of any size. 2285 */ 2286int __ocfs2_claim_clusters(handle_t *handle, 2287 struct ocfs2_alloc_context *ac, 2288 u32 min_clusters, 2289 u32 max_clusters, 2290 u32 *cluster_start, 2291 u32 *num_clusters) 2292{ 2293 int status; 2294 unsigned int bits_wanted = max_clusters; 2295 struct ocfs2_suballoc_result res = { .sr_blkno = 0, }; 2296 struct ocfs2_super *osb = OCFS2_SB(ac->ac_inode->i_sb); 2297 2298 BUG_ON(ac->ac_bits_given >= ac->ac_bits_wanted); 2299 2300 BUG_ON(ac->ac_which != OCFS2_AC_USE_LOCAL 2301 && ac->ac_which != OCFS2_AC_USE_MAIN); 2302 2303 if (ac->ac_which == OCFS2_AC_USE_LOCAL) { 2304 WARN_ON(min_clusters > 1); 2305 2306 status = ocfs2_claim_local_alloc_bits(osb, 2307 handle, 2308 ac, 2309 bits_wanted, 2310 cluster_start, 2311 num_clusters); 2312 if (!status) 2313 atomic_inc(&osb->alloc_stats.local_data); 2314 } else { 2315 if (min_clusters > (osb->bitmap_cpg - 1)) { 2316 /* The only paths asking for contiguousness 2317 * should know about this already. */ 2318 mlog(ML_ERROR, "minimum allocation requested %u exceeds " 2319 "group bitmap size %u!\n", min_clusters, 2320 osb->bitmap_cpg); 2321 status = -ENOSPC; 2322 goto bail; 2323 } 2324 /* clamp the current request down to a realistic size. */ 2325 if (bits_wanted > (osb->bitmap_cpg - 1)) 2326 bits_wanted = osb->bitmap_cpg - 1; 2327 2328 status = ocfs2_claim_suballoc_bits(ac, 2329 handle, 2330 bits_wanted, 2331 min_clusters, 2332 &res); 2333 if (!status) { 2334 BUG_ON(res.sr_blkno); /* cluster alloc can't set */ 2335 *cluster_start = 2336 ocfs2_desc_bitmap_to_cluster_off(ac->ac_inode, 2337 res.sr_bg_blkno, 2338 res.sr_bit_offset); 2339 atomic_inc(&osb->alloc_stats.bitmap_data); 2340 *num_clusters = res.sr_bits; 2341 } 2342 } 2343 if (status < 0) { 2344 if (status != -ENOSPC) 2345 mlog_errno(status); 2346 goto bail; 2347 } 2348 2349 ac->ac_bits_given += *num_clusters; 2350 2351bail: 2352 if (status) 2353 mlog_errno(status); 2354 return status; 2355} 2356 2357int ocfs2_claim_clusters(handle_t *handle, 2358 struct ocfs2_alloc_context *ac, 2359 u32 min_clusters, 2360 u32 *cluster_start, 2361 u32 *num_clusters) 2362{ 2363 unsigned int bits_wanted = ac->ac_bits_wanted - ac->ac_bits_given; 2364 2365 return __ocfs2_claim_clusters(handle, ac, min_clusters, 2366 bits_wanted, cluster_start, num_clusters); 2367} 2368 2369static int ocfs2_block_group_clear_bits(handle_t *handle, 2370 struct inode *alloc_inode, 2371 struct ocfs2_group_desc *bg, 2372 struct buffer_head *group_bh, 2373 unsigned int bit_off, 2374 unsigned int num_bits, 2375 void (*undo_fn)(unsigned int bit, 2376 unsigned long *bmap)) 2377{ 2378 int status; 2379 unsigned int tmp; 2380 struct ocfs2_group_desc *undo_bg = NULL; 2381 2382 /* The caller got this descriptor from 2383 * ocfs2_read_group_descriptor(). Any corruption is a code bug. */ 2384 BUG_ON(!OCFS2_IS_VALID_GROUP_DESC(bg)); 2385 2386 trace_ocfs2_block_group_clear_bits(bit_off, num_bits); 2387 2388 BUG_ON(undo_fn && !ocfs2_is_cluster_bitmap(alloc_inode)); 2389 status = ocfs2_journal_access_gd(handle, INODE_CACHE(alloc_inode), 2390 group_bh, 2391 undo_fn ? 2392 OCFS2_JOURNAL_ACCESS_UNDO : 2393 OCFS2_JOURNAL_ACCESS_WRITE); 2394 if (status < 0) { 2395 mlog_errno(status); 2396 goto bail; 2397 } 2398 2399 if (undo_fn) { 2400 jbd_lock_bh_state(group_bh); 2401 undo_bg = (struct ocfs2_group_desc *) 2402 bh2jh(group_bh)->b_committed_data; 2403 BUG_ON(!undo_bg); 2404 } 2405 2406 tmp = num_bits; 2407 while(tmp--) { 2408 ocfs2_clear_bit((bit_off + tmp), 2409 (unsigned long *) bg->bg_bitmap); 2410 if (undo_fn) 2411 undo_fn(bit_off + tmp, 2412 (unsigned long *) undo_bg->bg_bitmap); 2413 } 2414 le16_add_cpu(&bg->bg_free_bits_count, num_bits); 2415 if (le16_to_cpu(bg->bg_free_bits_count) > le16_to_cpu(bg->bg_bits)) { 2416 return ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit count %u but claims %u are freed. num_bits %d\n", 2417 (unsigned long long)le64_to_cpu(bg->bg_blkno), 2418 le16_to_cpu(bg->bg_bits), 2419 le16_to_cpu(bg->bg_free_bits_count), 2420 num_bits); 2421 } 2422 2423 if (undo_fn) 2424 jbd_unlock_bh_state(group_bh); 2425 2426 ocfs2_journal_dirty(handle, group_bh); 2427bail: 2428 return status; 2429} 2430 2431/* 2432 * expects the suballoc inode to already be locked. 2433 */ 2434static int _ocfs2_free_suballoc_bits(handle_t *handle, 2435 struct inode *alloc_inode, 2436 struct buffer_head *alloc_bh, 2437 unsigned int start_bit, 2438 u64 bg_blkno, 2439 unsigned int count, 2440 void (*undo_fn)(unsigned int bit, 2441 unsigned long *bitmap)) 2442{ 2443 int status = 0; 2444 u32 tmp_used; 2445 struct ocfs2_dinode *fe = (struct ocfs2_dinode *) alloc_bh->b_data; 2446 struct ocfs2_chain_list *cl = &fe->id2.i_chain; 2447 struct buffer_head *group_bh = NULL; 2448 struct ocfs2_group_desc *group; 2449 2450 /* The alloc_bh comes from ocfs2_free_dinode() or 2451 * ocfs2_free_clusters(). The callers have all locked the 2452 * allocator and gotten alloc_bh from the lock call. This 2453 * validates the dinode buffer. Any corruption that has happened 2454 * is a code bug. */ 2455 BUG_ON(!OCFS2_IS_VALID_DINODE(fe)); 2456 BUG_ON((count + start_bit) > ocfs2_bits_per_group(cl)); 2457 2458 trace_ocfs2_free_suballoc_bits( 2459 (unsigned long long)OCFS2_I(alloc_inode)->ip_blkno, 2460 (unsigned long long)bg_blkno, 2461 start_bit, count); 2462 2463 status = ocfs2_read_group_descriptor(alloc_inode, fe, bg_blkno, 2464 &group_bh); 2465 if (status < 0) { 2466 mlog_errno(status); 2467 goto bail; 2468 } 2469 group = (struct ocfs2_group_desc *) group_bh->b_data; 2470 2471 BUG_ON((count + start_bit) > le16_to_cpu(group->bg_bits)); 2472 2473 status = ocfs2_block_group_clear_bits(handle, alloc_inode, 2474 group, group_bh, 2475 start_bit, count, undo_fn); 2476 if (status < 0) { 2477 mlog_errno(status); 2478 goto bail; 2479 } 2480 2481 status = ocfs2_journal_access_di(handle, INODE_CACHE(alloc_inode), 2482 alloc_bh, OCFS2_JOURNAL_ACCESS_WRITE); 2483 if (status < 0) { 2484 mlog_errno(status); 2485 ocfs2_block_group_set_bits(handle, alloc_inode, group, group_bh, 2486 start_bit, count); 2487 goto bail; 2488 } 2489 2490 le32_add_cpu(&cl->cl_recs[le16_to_cpu(group->bg_chain)].c_free, 2491 count); 2492 tmp_used = le32_to_cpu(fe->id1.bitmap1.i_used); 2493 fe->id1.bitmap1.i_used = cpu_to_le32(tmp_used - count); 2494 ocfs2_journal_dirty(handle, alloc_bh); 2495 2496bail: 2497 brelse(group_bh); 2498 2499 if (status) 2500 mlog_errno(status); 2501 return status; 2502} 2503 2504int ocfs2_free_suballoc_bits(handle_t *handle, 2505 struct inode *alloc_inode, 2506 struct buffer_head *alloc_bh, 2507 unsigned int start_bit, 2508 u64 bg_blkno, 2509 unsigned int count) 2510{ 2511 return _ocfs2_free_suballoc_bits(handle, alloc_inode, alloc_bh, 2512 start_bit, bg_blkno, count, NULL); 2513} 2514 2515int ocfs2_free_dinode(handle_t *handle, 2516 struct inode *inode_alloc_inode, 2517 struct buffer_head *inode_alloc_bh, 2518 struct ocfs2_dinode *di) 2519{ 2520 u64 blk = le64_to_cpu(di->i_blkno); 2521 u16 bit = le16_to_cpu(di->i_suballoc_bit); 2522 u64 bg_blkno = ocfs2_which_suballoc_group(blk, bit); 2523 2524 if (di->i_suballoc_loc) 2525 bg_blkno = le64_to_cpu(di->i_suballoc_loc); 2526 return ocfs2_free_suballoc_bits(handle, inode_alloc_inode, 2527 inode_alloc_bh, bit, bg_blkno, 1); 2528} 2529 2530static int _ocfs2_free_clusters(handle_t *handle, 2531 struct inode *bitmap_inode, 2532 struct buffer_head *bitmap_bh, 2533 u64 start_blk, 2534 unsigned int num_clusters, 2535 void (*undo_fn)(unsigned int bit, 2536 unsigned long *bitmap)) 2537{ 2538 int status; 2539 u16 bg_start_bit; 2540 u64 bg_blkno; 2541 struct ocfs2_dinode *fe; 2542 2543 /* You can't ever have a contiguous set of clusters 2544 * bigger than a block group bitmap so we never have to worry 2545 * about looping on them. 2546 * This is expensive. We can safely remove once this stuff has 2547 * gotten tested really well. */ 2548 BUG_ON(start_blk != ocfs2_clusters_to_blocks(bitmap_inode->i_sb, ocfs2_blocks_to_clusters(bitmap_inode->i_sb, start_blk))); 2549 2550 fe = (struct ocfs2_dinode *) bitmap_bh->b_data; 2551 2552 ocfs2_block_to_cluster_group(bitmap_inode, start_blk, &bg_blkno, 2553 &bg_start_bit); 2554 2555 trace_ocfs2_free_clusters((unsigned long long)bg_blkno, 2556 (unsigned long long)start_blk, 2557 bg_start_bit, num_clusters); 2558 2559 status = _ocfs2_free_suballoc_bits(handle, bitmap_inode, bitmap_bh, 2560 bg_start_bit, bg_blkno, 2561 num_clusters, undo_fn); 2562 if (status < 0) { 2563 mlog_errno(status); 2564 goto out; 2565 } 2566 2567 ocfs2_local_alloc_seen_free_bits(OCFS2_SB(bitmap_inode->i_sb), 2568 num_clusters); 2569 2570out: 2571 if (status) 2572 mlog_errno(status); 2573 return status; 2574} 2575 2576int ocfs2_free_clusters(handle_t *handle, 2577 struct inode *bitmap_inode, 2578 struct buffer_head *bitmap_bh, 2579 u64 start_blk, 2580 unsigned int num_clusters) 2581{ 2582 return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh, 2583 start_blk, num_clusters, 2584 _ocfs2_set_bit); 2585} 2586 2587/* 2588 * Give never-used clusters back to the global bitmap. We don't need 2589 * to protect these bits in the undo buffer. 2590 */ 2591int ocfs2_release_clusters(handle_t *handle, 2592 struct inode *bitmap_inode, 2593 struct buffer_head *bitmap_bh, 2594 u64 start_blk, 2595 unsigned int num_clusters) 2596{ 2597 return _ocfs2_free_clusters(handle, bitmap_inode, bitmap_bh, 2598 start_blk, num_clusters, 2599 _ocfs2_clear_bit); 2600} 2601 2602static inline void ocfs2_debug_bg(struct ocfs2_group_desc *bg) 2603{ 2604 printk("Block Group:\n"); 2605 printk("bg_signature: %s\n", bg->bg_signature); 2606 printk("bg_size: %u\n", bg->bg_size); 2607 printk("bg_bits: %u\n", bg->bg_bits); 2608 printk("bg_free_bits_count: %u\n", bg->bg_free_bits_count); 2609 printk("bg_chain: %u\n", bg->bg_chain); 2610 printk("bg_generation: %u\n", le32_to_cpu(bg->bg_generation)); 2611 printk("bg_next_group: %llu\n", 2612 (unsigned long long)bg->bg_next_group); 2613 printk("bg_parent_dinode: %llu\n", 2614 (unsigned long long)bg->bg_parent_dinode); 2615 printk("bg_blkno: %llu\n", 2616 (unsigned long long)bg->bg_blkno); 2617} 2618 2619static inline void ocfs2_debug_suballoc_inode(struct ocfs2_dinode *fe) 2620{ 2621 int i; 2622 2623 printk("Suballoc Inode %llu:\n", (unsigned long long)fe->i_blkno); 2624 printk("i_signature: %s\n", fe->i_signature); 2625 printk("i_size: %llu\n", 2626 (unsigned long long)fe->i_size); 2627 printk("i_clusters: %u\n", fe->i_clusters); 2628 printk("i_generation: %u\n", 2629 le32_to_cpu(fe->i_generation)); 2630 printk("id1.bitmap1.i_used: %u\n", 2631 le32_to_cpu(fe->id1.bitmap1.i_used)); 2632 printk("id1.bitmap1.i_total: %u\n", 2633 le32_to_cpu(fe->id1.bitmap1.i_total)); 2634 printk("id2.i_chain.cl_cpg: %u\n", fe->id2.i_chain.cl_cpg); 2635 printk("id2.i_chain.cl_bpc: %u\n", fe->id2.i_chain.cl_bpc); 2636 printk("id2.i_chain.cl_count: %u\n", fe->id2.i_chain.cl_count); 2637 printk("id2.i_chain.cl_next_free_rec: %u\n", 2638 fe->id2.i_chain.cl_next_free_rec); 2639 for(i = 0; i < fe->id2.i_chain.cl_next_free_rec; i++) { 2640 printk("fe->id2.i_chain.cl_recs[%d].c_free: %u\n", i, 2641 fe->id2.i_chain.cl_recs[i].c_free); 2642 printk("fe->id2.i_chain.cl_recs[%d].c_total: %u\n", i, 2643 fe->id2.i_chain.cl_recs[i].c_total); 2644 printk("fe->id2.i_chain.cl_recs[%d].c_blkno: %llu\n", i, 2645 (unsigned long long)fe->id2.i_chain.cl_recs[i].c_blkno); 2646 } 2647} 2648 2649/* 2650 * For a given allocation, determine which allocators will need to be 2651 * accessed, and lock them, reserving the appropriate number of bits. 2652 * 2653 * Sparse file systems call this from ocfs2_write_begin_nolock() 2654 * and ocfs2_allocate_unwritten_extents(). 2655 * 2656 * File systems which don't support holes call this from 2657 * ocfs2_extend_allocation(). 2658 */ 2659int ocfs2_lock_allocators(struct inode *inode, 2660 struct ocfs2_extent_tree *et, 2661 u32 clusters_to_add, u32 extents_to_split, 2662 struct ocfs2_alloc_context **data_ac, 2663 struct ocfs2_alloc_context **meta_ac) 2664{ 2665 int ret = 0, num_free_extents; 2666 unsigned int max_recs_needed = clusters_to_add + 2 * extents_to_split; 2667 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2668 2669 *meta_ac = NULL; 2670 if (data_ac) 2671 *data_ac = NULL; 2672 2673 BUG_ON(clusters_to_add != 0 && data_ac == NULL); 2674 2675 num_free_extents = ocfs2_num_free_extents(osb, et); 2676 if (num_free_extents < 0) { 2677 ret = num_free_extents; 2678 mlog_errno(ret); 2679 goto out; 2680 } 2681 2682 /* 2683 * Sparse allocation file systems need to be more conservative 2684 * with reserving room for expansion - the actual allocation 2685 * happens while we've got a journal handle open so re-taking 2686 * a cluster lock (because we ran out of room for another 2687 * extent) will violate ordering rules. 2688 * 2689 * Most of the time we'll only be seeing this 1 cluster at a time 2690 * anyway. 2691 * 2692 * Always lock for any unwritten extents - we might want to 2693 * add blocks during a split. 2694 */ 2695 if (!num_free_extents || 2696 (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed)) { 2697 ret = ocfs2_reserve_new_metadata(osb, et->et_root_el, meta_ac); 2698 if (ret < 0) { 2699 if (ret != -ENOSPC) 2700 mlog_errno(ret); 2701 goto out; 2702 } 2703 } 2704 2705 if (clusters_to_add == 0) 2706 goto out; 2707 2708 ret = ocfs2_reserve_clusters(osb, clusters_to_add, data_ac); 2709 if (ret < 0) { 2710 if (ret != -ENOSPC) 2711 mlog_errno(ret); 2712 goto out; 2713 } 2714 2715out: 2716 if (ret) { 2717 if (*meta_ac) { 2718 ocfs2_free_alloc_context(*meta_ac); 2719 *meta_ac = NULL; 2720 } 2721 2722 /* 2723 * We cannot have an error and a non null *data_ac. 2724 */ 2725 } 2726 2727 return ret; 2728} 2729 2730/* 2731 * Read the inode specified by blkno to get suballoc_slot and 2732 * suballoc_bit. 2733 */ 2734static int ocfs2_get_suballoc_slot_bit(struct ocfs2_super *osb, u64 blkno, 2735 u16 *suballoc_slot, u64 *group_blkno, 2736 u16 *suballoc_bit) 2737{ 2738 int status; 2739 struct buffer_head *inode_bh = NULL; 2740 struct ocfs2_dinode *inode_fe; 2741 2742 trace_ocfs2_get_suballoc_slot_bit((unsigned long long)blkno); 2743 2744 /* dirty read disk */ 2745 status = ocfs2_read_blocks_sync(osb, blkno, 1, &inode_bh); 2746 if (status < 0) { 2747 mlog(ML_ERROR, "read block %llu failed %d\n", 2748 (unsigned long long)blkno, status); 2749 goto bail; 2750 } 2751 2752 inode_fe = (struct ocfs2_dinode *) inode_bh->b_data; 2753 if (!OCFS2_IS_VALID_DINODE(inode_fe)) { 2754 mlog(ML_ERROR, "invalid inode %llu requested\n", 2755 (unsigned long long)blkno); 2756 status = -EINVAL; 2757 goto bail; 2758 } 2759 2760 if (le16_to_cpu(inode_fe->i_suballoc_slot) != (u16)OCFS2_INVALID_SLOT && 2761 (u32)le16_to_cpu(inode_fe->i_suballoc_slot) > osb->max_slots - 1) { 2762 mlog(ML_ERROR, "inode %llu has invalid suballoc slot %u\n", 2763 (unsigned long long)blkno, 2764 (u32)le16_to_cpu(inode_fe->i_suballoc_slot)); 2765 status = -EINVAL; 2766 goto bail; 2767 } 2768 2769 if (suballoc_slot) 2770 *suballoc_slot = le16_to_cpu(inode_fe->i_suballoc_slot); 2771 if (suballoc_bit) 2772 *suballoc_bit = le16_to_cpu(inode_fe->i_suballoc_bit); 2773 if (group_blkno) 2774 *group_blkno = le64_to_cpu(inode_fe->i_suballoc_loc); 2775 2776bail: 2777 brelse(inode_bh); 2778 2779 if (status) 2780 mlog_errno(status); 2781 return status; 2782} 2783 2784/* 2785 * test whether bit is SET in allocator bitmap or not. on success, 0 2786 * is returned and *res is 1 for SET; 0 otherwise. when fails, errno 2787 * is returned and *res is meaningless. Call this after you have 2788 * cluster locked against suballoc, or you may get a result based on 2789 * non-up2date contents 2790 */ 2791static int ocfs2_test_suballoc_bit(struct ocfs2_super *osb, 2792 struct inode *suballoc, 2793 struct buffer_head *alloc_bh, 2794 u64 group_blkno, u64 blkno, 2795 u16 bit, int *res) 2796{ 2797 struct ocfs2_dinode *alloc_di; 2798 struct ocfs2_group_desc *group; 2799 struct buffer_head *group_bh = NULL; 2800 u64 bg_blkno; 2801 int status; 2802 2803 trace_ocfs2_test_suballoc_bit((unsigned long long)blkno, 2804 (unsigned int)bit); 2805 2806 alloc_di = (struct ocfs2_dinode *)alloc_bh->b_data; 2807 if ((bit + 1) > ocfs2_bits_per_group(&alloc_di->id2.i_chain)) { 2808 mlog(ML_ERROR, "suballoc bit %u out of range of %u\n", 2809 (unsigned int)bit, 2810 ocfs2_bits_per_group(&alloc_di->id2.i_chain)); 2811 status = -EINVAL; 2812 goto bail; 2813 } 2814 2815 bg_blkno = group_blkno ? group_blkno : 2816 ocfs2_which_suballoc_group(blkno, bit); 2817 status = ocfs2_read_group_descriptor(suballoc, alloc_di, bg_blkno, 2818 &group_bh); 2819 if (status < 0) { 2820 mlog(ML_ERROR, "read group %llu failed %d\n", 2821 (unsigned long long)bg_blkno, status); 2822 goto bail; 2823 } 2824 2825 group = (struct ocfs2_group_desc *) group_bh->b_data; 2826 *res = ocfs2_test_bit(bit, (unsigned long *)group->bg_bitmap); 2827 2828bail: 2829 brelse(group_bh); 2830 2831 if (status) 2832 mlog_errno(status); 2833 return status; 2834} 2835 2836/* 2837 * Test if the bit representing this inode (blkno) is set in the 2838 * suballocator. 2839 * 2840 * On success, 0 is returned and *res is 1 for SET; 0 otherwise. 2841 * 2842 * In the event of failure, a negative value is returned and *res is 2843 * meaningless. 2844 * 2845 * Callers must make sure to hold nfs_sync_lock to prevent 2846 * ocfs2_delete_inode() on another node from accessing the same 2847 * suballocator concurrently. 2848 */ 2849int ocfs2_test_inode_bit(struct ocfs2_super *osb, u64 blkno, int *res) 2850{ 2851 int status; 2852 u64 group_blkno = 0; 2853 u16 suballoc_bit = 0, suballoc_slot = 0; 2854 struct inode *inode_alloc_inode; 2855 struct buffer_head *alloc_bh = NULL; 2856 2857 trace_ocfs2_test_inode_bit((unsigned long long)blkno); 2858 2859 status = ocfs2_get_suballoc_slot_bit(osb, blkno, &suballoc_slot, 2860 &group_blkno, &suballoc_bit); 2861 if (status < 0) { 2862 mlog(ML_ERROR, "get alloc slot and bit failed %d\n", status); 2863 goto bail; 2864 } 2865 2866 inode_alloc_inode = 2867 ocfs2_get_system_file_inode(osb, INODE_ALLOC_SYSTEM_INODE, 2868 suballoc_slot); 2869 if (!inode_alloc_inode) { 2870 /* the error code could be inaccurate, but we are not able to 2871 * get the correct one. */ 2872 status = -EINVAL; 2873 mlog(ML_ERROR, "unable to get alloc inode in slot %u\n", 2874 (u32)suballoc_slot); 2875 goto bail; 2876 } 2877 2878 mutex_lock(&inode_alloc_inode->i_mutex); 2879 status = ocfs2_inode_lock(inode_alloc_inode, &alloc_bh, 0); 2880 if (status < 0) { 2881 mutex_unlock(&inode_alloc_inode->i_mutex); 2882 iput(inode_alloc_inode); 2883 mlog(ML_ERROR, "lock on alloc inode on slot %u failed %d\n", 2884 (u32)suballoc_slot, status); 2885 goto bail; 2886 } 2887 2888 status = ocfs2_test_suballoc_bit(osb, inode_alloc_inode, alloc_bh, 2889 group_blkno, blkno, suballoc_bit, res); 2890 if (status < 0) 2891 mlog(ML_ERROR, "test suballoc bit failed %d\n", status); 2892 2893 ocfs2_inode_unlock(inode_alloc_inode, 0); 2894 mutex_unlock(&inode_alloc_inode->i_mutex); 2895 2896 iput(inode_alloc_inode); 2897 brelse(alloc_bh); 2898bail: 2899 if (status) 2900 mlog_errno(status); 2901 return status; 2902} 2903