1 /* 2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. 4 * 5 * This copyrighted material is made available to anyone wishing to use, 6 * modify, copy, or redistribute it subject to the terms and conditions 7 * of the GNU General Public License version 2. 8 */ 9 10 #include <linux/slab.h> 11 #include <linux/spinlock.h> 12 #include <linux/completion.h> 13 #include <linux/buffer_head.h> 14 #include <linux/fs.h> 15 #include <linux/gfs2_ondisk.h> 16 #include <linux/lm_interface.h> 17 18 #include "gfs2.h" 19 #include "incore.h" 20 #include "glock.h" 21 #include "glops.h" 22 #include "lops.h" 23 #include "meta_io.h" 24 #include "quota.h" 25 #include "rgrp.h" 26 #include "super.h" 27 #include "trans.h" 28 #include "ops_file.h" 29 #include "util.h" 30 31 #define BFITNOENT ((u32)~0) 32 33 /* 34 * These routines are used by the resource group routines (rgrp.c) 35 * to keep track of block allocation. Each block is represented by two 36 * bits. So, each byte represents GFS2_NBBY (i.e. 4) blocks. 37 * 38 * 0 = Free 39 * 1 = Used (not metadata) 40 * 2 = Unlinked (still in use) inode 41 * 3 = Used (metadata) 42 */ 43 44 static const char valid_change[16] = { 45 /* current */ 46 /* n */ 0, 1, 1, 1, 47 /* e */ 1, 0, 0, 0, 48 /* w */ 0, 0, 0, 1, 49 1, 0, 0, 0 50 }; 51 52 /** 53 * gfs2_setbit - Set a bit in the bitmaps 54 * @buffer: the buffer that holds the bitmaps 55 * @buflen: the length (in bytes) of the buffer 56 * @block: the block to set 57 * @new_state: the new state of the block 58 * 59 */ 60 61 static void gfs2_setbit(struct gfs2_rgrpd *rgd, unsigned char *buffer, 62 unsigned int buflen, u32 block, 63 unsigned char new_state) 64 { 65 unsigned char *byte, *end, cur_state; 66 unsigned int bit; 67 68 byte = buffer + (block / GFS2_NBBY); 69 bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE; 70 end = buffer + buflen; 71 72 gfs2_assert(rgd->rd_sbd, byte < end); 73 74 cur_state = (*byte >> bit) & GFS2_BIT_MASK; 75 76 if (valid_change[new_state * 4 + cur_state]) { 77 *byte ^= cur_state << bit; 78 *byte |= new_state << bit; 79 } else 80 gfs2_consist_rgrpd(rgd); 81 } 82 83 /** 84 * gfs2_testbit - test a bit in the bitmaps 85 * @buffer: the buffer that holds the bitmaps 86 * @buflen: the length (in bytes) of the buffer 87 * @block: the block to read 88 * 89 */ 90 91 static unsigned char gfs2_testbit(struct gfs2_rgrpd *rgd, unsigned char *buffer, 92 unsigned int buflen, u32 block) 93 { 94 unsigned char *byte, *end, cur_state; 95 unsigned int bit; 96 97 byte = buffer + (block / GFS2_NBBY); 98 bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE; 99 end = buffer + buflen; 100 101 gfs2_assert(rgd->rd_sbd, byte < end); 102 103 cur_state = (*byte >> bit) & GFS2_BIT_MASK; 104 105 return cur_state; 106 } 107 108 /** 109 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing 110 * a block in a given allocation state. 111 * @buffer: the buffer that holds the bitmaps 112 * @buflen: the length (in bytes) of the buffer 113 * @goal: start search at this block's bit-pair (within @buffer) 114 * @old_state: GFS2_BLKST_XXX the state of the block we're looking for; 115 * bit 0 = alloc(1)/free(0), bit 1 = meta(1)/data(0) 116 * 117 * Scope of @goal and returned block number is only within this bitmap buffer, 118 * not entire rgrp or filesystem. @buffer will be offset from the actual 119 * beginning of a bitmap block buffer, skipping any header structures. 120 * 121 * Return: the block number (bitmap buffer scope) that was found 122 */ 123 124 static u32 gfs2_bitfit(struct gfs2_rgrpd *rgd, unsigned char *buffer, 125 unsigned int buflen, u32 goal, 126 unsigned char old_state) 127 { 128 unsigned char *byte, *end, alloc; 129 u32 blk = goal; 130 unsigned int bit; 131 132 byte = buffer + (goal / GFS2_NBBY); 133 bit = (goal % GFS2_NBBY) * GFS2_BIT_SIZE; 134 end = buffer + buflen; 135 alloc = (old_state & 1) ? 0 : 0x55; 136 137 while (byte < end) { 138 if ((*byte & 0x55) == alloc) { 139 blk += (8 - bit) >> 1; 140 141 bit = 0; 142 byte++; 143 144 continue; 145 } 146 147 if (((*byte >> bit) & GFS2_BIT_MASK) == old_state) 148 return blk; 149 150 bit += GFS2_BIT_SIZE; 151 if (bit >= 8) { 152 bit = 0; 153 byte++; 154 } 155 156 blk++; 157 } 158 159 return BFITNOENT; 160 } 161 162 /** 163 * gfs2_bitcount - count the number of bits in a certain state 164 * @buffer: the buffer that holds the bitmaps 165 * @buflen: the length (in bytes) of the buffer 166 * @state: the state of the block we're looking for 167 * 168 * Returns: The number of bits 169 */ 170 171 static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, unsigned char *buffer, 172 unsigned int buflen, unsigned char state) 173 { 174 unsigned char *byte = buffer; 175 unsigned char *end = buffer + buflen; 176 unsigned char state1 = state << 2; 177 unsigned char state2 = state << 4; 178 unsigned char state3 = state << 6; 179 u32 count = 0; 180 181 for (; byte < end; byte++) { 182 if (((*byte) & 0x03) == state) 183 count++; 184 if (((*byte) & 0x0C) == state1) 185 count++; 186 if (((*byte) & 0x30) == state2) 187 count++; 188 if (((*byte) & 0xC0) == state3) 189 count++; 190 } 191 192 return count; 193 } 194 195 /** 196 * gfs2_rgrp_verify - Verify that a resource group is consistent 197 * @sdp: the filesystem 198 * @rgd: the rgrp 199 * 200 */ 201 202 void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd) 203 { 204 struct gfs2_sbd *sdp = rgd->rd_sbd; 205 struct gfs2_bitmap *bi = NULL; 206 u32 length = rgd->rd_ri.ri_length; 207 u32 count[4], tmp; 208 int buf, x; 209 210 memset(count, 0, 4 * sizeof(u32)); 211 212 /* Count # blocks in each of 4 possible allocation states */ 213 for (buf = 0; buf < length; buf++) { 214 bi = rgd->rd_bits + buf; 215 for (x = 0; x < 4; x++) 216 count[x] += gfs2_bitcount(rgd, 217 bi->bi_bh->b_data + 218 bi->bi_offset, 219 bi->bi_len, x); 220 } 221 222 if (count[0] != rgd->rd_rg.rg_free) { 223 if (gfs2_consist_rgrpd(rgd)) 224 fs_err(sdp, "free data mismatch: %u != %u\n", 225 count[0], rgd->rd_rg.rg_free); 226 return; 227 } 228 229 tmp = rgd->rd_ri.ri_data - 230 rgd->rd_rg.rg_free - 231 rgd->rd_rg.rg_dinodes; 232 if (count[1] + count[2] != tmp) { 233 if (gfs2_consist_rgrpd(rgd)) 234 fs_err(sdp, "used data mismatch: %u != %u\n", 235 count[1], tmp); 236 return; 237 } 238 239 if (count[3] != rgd->rd_rg.rg_dinodes) { 240 if (gfs2_consist_rgrpd(rgd)) 241 fs_err(sdp, "used metadata mismatch: %u != %u\n", 242 count[3], rgd->rd_rg.rg_dinodes); 243 return; 244 } 245 246 if (count[2] > count[3]) { 247 if (gfs2_consist_rgrpd(rgd)) 248 fs_err(sdp, "unlinked inodes > inodes: %u\n", 249 count[2]); 250 return; 251 } 252 253 } 254 255 static inline int rgrp_contains_block(struct gfs2_rindex_host *ri, u64 block) 256 { 257 u64 first = ri->ri_data0; 258 u64 last = first + ri->ri_data; 259 return first <= block && block < last; 260 } 261 262 /** 263 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number 264 * @sdp: The GFS2 superblock 265 * @n: The data block number 266 * 267 * Returns: The resource group, or NULL if not found 268 */ 269 270 struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk) 271 { 272 struct gfs2_rgrpd *rgd; 273 274 spin_lock(&sdp->sd_rindex_spin); 275 276 list_for_each_entry(rgd, &sdp->sd_rindex_mru_list, rd_list_mru) { 277 if (rgrp_contains_block(&rgd->rd_ri, blk)) { 278 list_move(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list); 279 spin_unlock(&sdp->sd_rindex_spin); 280 return rgd; 281 } 282 } 283 284 spin_unlock(&sdp->sd_rindex_spin); 285 286 return NULL; 287 } 288 289 /** 290 * gfs2_rgrpd_get_first - get the first Resource Group in the filesystem 291 * @sdp: The GFS2 superblock 292 * 293 * Returns: The first rgrp in the filesystem 294 */ 295 296 struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp) 297 { 298 gfs2_assert(sdp, !list_empty(&sdp->sd_rindex_list)); 299 return list_entry(sdp->sd_rindex_list.next, struct gfs2_rgrpd, rd_list); 300 } 301 302 /** 303 * gfs2_rgrpd_get_next - get the next RG 304 * @rgd: A RG 305 * 306 * Returns: The next rgrp 307 */ 308 309 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd) 310 { 311 if (rgd->rd_list.next == &rgd->rd_sbd->sd_rindex_list) 312 return NULL; 313 return list_entry(rgd->rd_list.next, struct gfs2_rgrpd, rd_list); 314 } 315 316 static void clear_rgrpdi(struct gfs2_sbd *sdp) 317 { 318 struct list_head *head; 319 struct gfs2_rgrpd *rgd; 320 struct gfs2_glock *gl; 321 322 spin_lock(&sdp->sd_rindex_spin); 323 sdp->sd_rindex_forward = NULL; 324 head = &sdp->sd_rindex_recent_list; 325 while (!list_empty(head)) { 326 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent); 327 list_del(&rgd->rd_recent); 328 } 329 spin_unlock(&sdp->sd_rindex_spin); 330 331 head = &sdp->sd_rindex_list; 332 while (!list_empty(head)) { 333 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_list); 334 gl = rgd->rd_gl; 335 336 list_del(&rgd->rd_list); 337 list_del(&rgd->rd_list_mru); 338 339 if (gl) { 340 gl->gl_object = NULL; 341 gfs2_glock_put(gl); 342 } 343 344 kfree(rgd->rd_bits); 345 kfree(rgd); 346 } 347 } 348 349 void gfs2_clear_rgrpd(struct gfs2_sbd *sdp) 350 { 351 mutex_lock(&sdp->sd_rindex_mutex); 352 clear_rgrpdi(sdp); 353 mutex_unlock(&sdp->sd_rindex_mutex); 354 } 355 356 /** 357 * gfs2_compute_bitstructs - Compute the bitmap sizes 358 * @rgd: The resource group descriptor 359 * 360 * Calculates bitmap descriptors, one for each block that contains bitmap data 361 * 362 * Returns: errno 363 */ 364 365 static int compute_bitstructs(struct gfs2_rgrpd *rgd) 366 { 367 struct gfs2_sbd *sdp = rgd->rd_sbd; 368 struct gfs2_bitmap *bi; 369 u32 length = rgd->rd_ri.ri_length; /* # blocks in hdr & bitmap */ 370 u32 bytes_left, bytes; 371 int x; 372 373 if (!length) 374 return -EINVAL; 375 376 rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS); 377 if (!rgd->rd_bits) 378 return -ENOMEM; 379 380 bytes_left = rgd->rd_ri.ri_bitbytes; 381 382 for (x = 0; x < length; x++) { 383 bi = rgd->rd_bits + x; 384 385 /* small rgrp; bitmap stored completely in header block */ 386 if (length == 1) { 387 bytes = bytes_left; 388 bi->bi_offset = sizeof(struct gfs2_rgrp); 389 bi->bi_start = 0; 390 bi->bi_len = bytes; 391 /* header block */ 392 } else if (x == 0) { 393 bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp); 394 bi->bi_offset = sizeof(struct gfs2_rgrp); 395 bi->bi_start = 0; 396 bi->bi_len = bytes; 397 /* last block */ 398 } else if (x + 1 == length) { 399 bytes = bytes_left; 400 bi->bi_offset = sizeof(struct gfs2_meta_header); 401 bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left; 402 bi->bi_len = bytes; 403 /* other blocks */ 404 } else { 405 bytes = sdp->sd_sb.sb_bsize - 406 sizeof(struct gfs2_meta_header); 407 bi->bi_offset = sizeof(struct gfs2_meta_header); 408 bi->bi_start = rgd->rd_ri.ri_bitbytes - bytes_left; 409 bi->bi_len = bytes; 410 } 411 412 bytes_left -= bytes; 413 } 414 415 if (bytes_left) { 416 gfs2_consist_rgrpd(rgd); 417 return -EIO; 418 } 419 bi = rgd->rd_bits + (length - 1); 420 if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_ri.ri_data) { 421 if (gfs2_consist_rgrpd(rgd)) { 422 gfs2_rindex_print(&rgd->rd_ri); 423 fs_err(sdp, "start=%u len=%u offset=%u\n", 424 bi->bi_start, bi->bi_len, bi->bi_offset); 425 } 426 return -EIO; 427 } 428 429 return 0; 430 } 431 432 /** 433 * gfs2_ri_update - Pull in a new resource index from the disk 434 * @gl: The glock covering the rindex inode 435 * 436 * Returns: 0 on successful update, error code otherwise 437 */ 438 439 static int gfs2_ri_update(struct gfs2_inode *ip) 440 { 441 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 442 struct inode *inode = &ip->i_inode; 443 struct gfs2_rgrpd *rgd; 444 char buf[sizeof(struct gfs2_rindex)]; 445 struct file_ra_state ra_state; 446 u64 junk = ip->i_di.di_size; 447 int error; 448 449 if (do_div(junk, sizeof(struct gfs2_rindex))) { 450 gfs2_consist_inode(ip); 451 return -EIO; 452 } 453 454 clear_rgrpdi(sdp); 455 456 file_ra_state_init(&ra_state, inode->i_mapping); 457 for (sdp->sd_rgrps = 0;; sdp->sd_rgrps++) { 458 loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex); 459 error = gfs2_internal_read(ip, &ra_state, buf, &pos, 460 sizeof(struct gfs2_rindex)); 461 if (!error) 462 break; 463 if (error != sizeof(struct gfs2_rindex)) { 464 if (error > 0) 465 error = -EIO; 466 goto fail; 467 } 468 469 rgd = kzalloc(sizeof(struct gfs2_rgrpd), GFP_NOFS); 470 error = -ENOMEM; 471 if (!rgd) 472 goto fail; 473 474 mutex_init(&rgd->rd_mutex); 475 lops_init_le(&rgd->rd_le, &gfs2_rg_lops); 476 rgd->rd_sbd = sdp; 477 478 list_add_tail(&rgd->rd_list, &sdp->sd_rindex_list); 479 list_add_tail(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list); 480 481 gfs2_rindex_in(&rgd->rd_ri, buf); 482 error = compute_bitstructs(rgd); 483 if (error) 484 goto fail; 485 486 error = gfs2_glock_get(sdp, rgd->rd_ri.ri_addr, 487 &gfs2_rgrp_glops, CREATE, &rgd->rd_gl); 488 if (error) 489 goto fail; 490 491 rgd->rd_gl->gl_object = rgd; 492 rgd->rd_rg_vn = rgd->rd_gl->gl_vn - 1; 493 } 494 495 sdp->sd_rindex_vn = ip->i_gl->gl_vn; 496 return 0; 497 498 fail: 499 clear_rgrpdi(sdp); 500 return error; 501 } 502 503 /** 504 * gfs2_rindex_hold - Grab a lock on the rindex 505 * @sdp: The GFS2 superblock 506 * @ri_gh: the glock holder 507 * 508 * We grab a lock on the rindex inode to make sure that it doesn't 509 * change whilst we are performing an operation. We keep this lock 510 * for quite long periods of time compared to other locks. This 511 * doesn't matter, since it is shared and it is very, very rarely 512 * accessed in the exclusive mode (i.e. only when expanding the filesystem). 513 * 514 * This makes sure that we're using the latest copy of the resource index 515 * special file, which might have been updated if someone expanded the 516 * filesystem (via gfs2_grow utility), which adds new resource groups. 517 * 518 * Returns: 0 on success, error code otherwise 519 */ 520 521 int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh) 522 { 523 struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex); 524 struct gfs2_glock *gl = ip->i_gl; 525 int error; 526 527 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, ri_gh); 528 if (error) 529 return error; 530 531 /* Read new copy from disk if we don't have the latest */ 532 if (sdp->sd_rindex_vn != gl->gl_vn) { 533 mutex_lock(&sdp->sd_rindex_mutex); 534 if (sdp->sd_rindex_vn != gl->gl_vn) { 535 error = gfs2_ri_update(ip); 536 if (error) 537 gfs2_glock_dq_uninit(ri_gh); 538 } 539 mutex_unlock(&sdp->sd_rindex_mutex); 540 } 541 542 return error; 543 } 544 545 /** 546 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps 547 * @rgd: the struct gfs2_rgrpd describing the RG to read in 548 * 549 * Read in all of a Resource Group's header and bitmap blocks. 550 * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps. 551 * 552 * Returns: errno 553 */ 554 555 int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd) 556 { 557 struct gfs2_sbd *sdp = rgd->rd_sbd; 558 struct gfs2_glock *gl = rgd->rd_gl; 559 unsigned int length = rgd->rd_ri.ri_length; 560 struct gfs2_bitmap *bi; 561 unsigned int x, y; 562 int error; 563 564 mutex_lock(&rgd->rd_mutex); 565 566 spin_lock(&sdp->sd_rindex_spin); 567 if (rgd->rd_bh_count) { 568 rgd->rd_bh_count++; 569 spin_unlock(&sdp->sd_rindex_spin); 570 mutex_unlock(&rgd->rd_mutex); 571 return 0; 572 } 573 spin_unlock(&sdp->sd_rindex_spin); 574 575 for (x = 0; x < length; x++) { 576 bi = rgd->rd_bits + x; 577 error = gfs2_meta_read(gl, rgd->rd_ri.ri_addr + x, 0, &bi->bi_bh); 578 if (error) 579 goto fail; 580 } 581 582 for (y = length; y--;) { 583 bi = rgd->rd_bits + y; 584 error = gfs2_meta_wait(sdp, bi->bi_bh); 585 if (error) 586 goto fail; 587 if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB : 588 GFS2_METATYPE_RG)) { 589 error = -EIO; 590 goto fail; 591 } 592 } 593 594 if (rgd->rd_rg_vn != gl->gl_vn) { 595 gfs2_rgrp_in(&rgd->rd_rg, (rgd->rd_bits[0].bi_bh)->b_data); 596 rgd->rd_rg_vn = gl->gl_vn; 597 } 598 599 spin_lock(&sdp->sd_rindex_spin); 600 rgd->rd_free_clone = rgd->rd_rg.rg_free; 601 rgd->rd_bh_count++; 602 spin_unlock(&sdp->sd_rindex_spin); 603 604 mutex_unlock(&rgd->rd_mutex); 605 606 return 0; 607 608 fail: 609 while (x--) { 610 bi = rgd->rd_bits + x; 611 brelse(bi->bi_bh); 612 bi->bi_bh = NULL; 613 gfs2_assert_warn(sdp, !bi->bi_clone); 614 } 615 mutex_unlock(&rgd->rd_mutex); 616 617 return error; 618 } 619 620 void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd) 621 { 622 struct gfs2_sbd *sdp = rgd->rd_sbd; 623 624 spin_lock(&sdp->sd_rindex_spin); 625 gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count); 626 rgd->rd_bh_count++; 627 spin_unlock(&sdp->sd_rindex_spin); 628 } 629 630 /** 631 * gfs2_rgrp_bh_put - Release RG bitmaps read in with gfs2_rgrp_bh_get() 632 * @rgd: the struct gfs2_rgrpd describing the RG to read in 633 * 634 */ 635 636 void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd) 637 { 638 struct gfs2_sbd *sdp = rgd->rd_sbd; 639 int x, length = rgd->rd_ri.ri_length; 640 641 spin_lock(&sdp->sd_rindex_spin); 642 gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count); 643 if (--rgd->rd_bh_count) { 644 spin_unlock(&sdp->sd_rindex_spin); 645 return; 646 } 647 648 for (x = 0; x < length; x++) { 649 struct gfs2_bitmap *bi = rgd->rd_bits + x; 650 kfree(bi->bi_clone); 651 bi->bi_clone = NULL; 652 brelse(bi->bi_bh); 653 bi->bi_bh = NULL; 654 } 655 656 spin_unlock(&sdp->sd_rindex_spin); 657 } 658 659 void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd) 660 { 661 struct gfs2_sbd *sdp = rgd->rd_sbd; 662 unsigned int length = rgd->rd_ri.ri_length; 663 unsigned int x; 664 665 for (x = 0; x < length; x++) { 666 struct gfs2_bitmap *bi = rgd->rd_bits + x; 667 if (!bi->bi_clone) 668 continue; 669 memcpy(bi->bi_clone + bi->bi_offset, 670 bi->bi_bh->b_data + bi->bi_offset, bi->bi_len); 671 } 672 673 spin_lock(&sdp->sd_rindex_spin); 674 rgd->rd_free_clone = rgd->rd_rg.rg_free; 675 spin_unlock(&sdp->sd_rindex_spin); 676 } 677 678 /** 679 * gfs2_alloc_get - get the struct gfs2_alloc structure for an inode 680 * @ip: the incore GFS2 inode structure 681 * 682 * Returns: the struct gfs2_alloc 683 */ 684 685 struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip) 686 { 687 struct gfs2_alloc *al = &ip->i_alloc; 688 689 /* FIXME: Should assert that the correct locks are held here... */ 690 memset(al, 0, sizeof(*al)); 691 return al; 692 } 693 694 /** 695 * try_rgrp_fit - See if a given reservation will fit in a given RG 696 * @rgd: the RG data 697 * @al: the struct gfs2_alloc structure describing the reservation 698 * 699 * If there's room for the requested blocks to be allocated from the RG: 700 * Sets the $al_reserved_data field in @al. 701 * Sets the $al_reserved_meta field in @al. 702 * Sets the $al_rgd field in @al. 703 * 704 * Returns: 1 on success (it fits), 0 on failure (it doesn't fit) 705 */ 706 707 static int try_rgrp_fit(struct gfs2_rgrpd *rgd, struct gfs2_alloc *al) 708 { 709 struct gfs2_sbd *sdp = rgd->rd_sbd; 710 int ret = 0; 711 712 spin_lock(&sdp->sd_rindex_spin); 713 if (rgd->rd_free_clone >= al->al_requested) { 714 al->al_rgd = rgd; 715 ret = 1; 716 } 717 spin_unlock(&sdp->sd_rindex_spin); 718 719 return ret; 720 } 721 722 /** 723 * recent_rgrp_first - get first RG from "recent" list 724 * @sdp: The GFS2 superblock 725 * @rglast: address of the rgrp used last 726 * 727 * Returns: The first rgrp in the recent list 728 */ 729 730 static struct gfs2_rgrpd *recent_rgrp_first(struct gfs2_sbd *sdp, 731 u64 rglast) 732 { 733 struct gfs2_rgrpd *rgd = NULL; 734 735 spin_lock(&sdp->sd_rindex_spin); 736 737 if (list_empty(&sdp->sd_rindex_recent_list)) 738 goto out; 739 740 if (!rglast) 741 goto first; 742 743 list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) { 744 if (rgd->rd_ri.ri_addr == rglast) 745 goto out; 746 } 747 748 first: 749 rgd = list_entry(sdp->sd_rindex_recent_list.next, struct gfs2_rgrpd, 750 rd_recent); 751 out: 752 spin_unlock(&sdp->sd_rindex_spin); 753 return rgd; 754 } 755 756 /** 757 * recent_rgrp_next - get next RG from "recent" list 758 * @cur_rgd: current rgrp 759 * @remove: 760 * 761 * Returns: The next rgrp in the recent list 762 */ 763 764 static struct gfs2_rgrpd *recent_rgrp_next(struct gfs2_rgrpd *cur_rgd, 765 int remove) 766 { 767 struct gfs2_sbd *sdp = cur_rgd->rd_sbd; 768 struct list_head *head; 769 struct gfs2_rgrpd *rgd; 770 771 spin_lock(&sdp->sd_rindex_spin); 772 773 head = &sdp->sd_rindex_recent_list; 774 775 list_for_each_entry(rgd, head, rd_recent) { 776 if (rgd == cur_rgd) { 777 if (cur_rgd->rd_recent.next != head) 778 rgd = list_entry(cur_rgd->rd_recent.next, 779 struct gfs2_rgrpd, rd_recent); 780 else 781 rgd = NULL; 782 783 if (remove) 784 list_del(&cur_rgd->rd_recent); 785 786 goto out; 787 } 788 } 789 790 rgd = NULL; 791 if (!list_empty(head)) 792 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent); 793 794 out: 795 spin_unlock(&sdp->sd_rindex_spin); 796 return rgd; 797 } 798 799 /** 800 * recent_rgrp_add - add an RG to tail of "recent" list 801 * @new_rgd: The rgrp to add 802 * 803 */ 804 805 static void recent_rgrp_add(struct gfs2_rgrpd *new_rgd) 806 { 807 struct gfs2_sbd *sdp = new_rgd->rd_sbd; 808 struct gfs2_rgrpd *rgd; 809 unsigned int count = 0; 810 unsigned int max = sdp->sd_rgrps / gfs2_jindex_size(sdp); 811 812 spin_lock(&sdp->sd_rindex_spin); 813 814 list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) { 815 if (rgd == new_rgd) 816 goto out; 817 818 if (++count >= max) 819 goto out; 820 } 821 list_add_tail(&new_rgd->rd_recent, &sdp->sd_rindex_recent_list); 822 823 out: 824 spin_unlock(&sdp->sd_rindex_spin); 825 } 826 827 /** 828 * forward_rgrp_get - get an rgrp to try next from full list 829 * @sdp: The GFS2 superblock 830 * 831 * Returns: The rgrp to try next 832 */ 833 834 static struct gfs2_rgrpd *forward_rgrp_get(struct gfs2_sbd *sdp) 835 { 836 struct gfs2_rgrpd *rgd; 837 unsigned int journals = gfs2_jindex_size(sdp); 838 unsigned int rg = 0, x; 839 840 spin_lock(&sdp->sd_rindex_spin); 841 842 rgd = sdp->sd_rindex_forward; 843 if (!rgd) { 844 if (sdp->sd_rgrps >= journals) 845 rg = sdp->sd_rgrps * sdp->sd_jdesc->jd_jid / journals; 846 847 for (x = 0, rgd = gfs2_rgrpd_get_first(sdp); x < rg; 848 x++, rgd = gfs2_rgrpd_get_next(rgd)) 849 /* Do Nothing */; 850 851 sdp->sd_rindex_forward = rgd; 852 } 853 854 spin_unlock(&sdp->sd_rindex_spin); 855 856 return rgd; 857 } 858 859 /** 860 * forward_rgrp_set - set the forward rgrp pointer 861 * @sdp: the filesystem 862 * @rgd: The new forward rgrp 863 * 864 */ 865 866 static void forward_rgrp_set(struct gfs2_sbd *sdp, struct gfs2_rgrpd *rgd) 867 { 868 spin_lock(&sdp->sd_rindex_spin); 869 sdp->sd_rindex_forward = rgd; 870 spin_unlock(&sdp->sd_rindex_spin); 871 } 872 873 /** 874 * get_local_rgrp - Choose and lock a rgrp for allocation 875 * @ip: the inode to reserve space for 876 * @rgp: the chosen and locked rgrp 877 * 878 * Try to acquire rgrp in way which avoids contending with others. 879 * 880 * Returns: errno 881 */ 882 883 static int get_local_rgrp(struct gfs2_inode *ip) 884 { 885 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 886 struct gfs2_rgrpd *rgd, *begin = NULL; 887 struct gfs2_alloc *al = &ip->i_alloc; 888 int flags = LM_FLAG_TRY; 889 int skipped = 0; 890 int loops = 0; 891 int error; 892 893 /* Try recently successful rgrps */ 894 895 rgd = recent_rgrp_first(sdp, ip->i_last_rg_alloc); 896 897 while (rgd) { 898 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 899 LM_FLAG_TRY, &al->al_rgd_gh); 900 switch (error) { 901 case 0: 902 if (try_rgrp_fit(rgd, al)) 903 goto out; 904 gfs2_glock_dq_uninit(&al->al_rgd_gh); 905 rgd = recent_rgrp_next(rgd, 1); 906 break; 907 908 case GLR_TRYFAILED: 909 rgd = recent_rgrp_next(rgd, 0); 910 break; 911 912 default: 913 return error; 914 } 915 } 916 917 /* Go through full list of rgrps */ 918 919 begin = rgd = forward_rgrp_get(sdp); 920 921 for (;;) { 922 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, flags, 923 &al->al_rgd_gh); 924 switch (error) { 925 case 0: 926 if (try_rgrp_fit(rgd, al)) 927 goto out; 928 gfs2_glock_dq_uninit(&al->al_rgd_gh); 929 break; 930 931 case GLR_TRYFAILED: 932 skipped++; 933 break; 934 935 default: 936 return error; 937 } 938 939 rgd = gfs2_rgrpd_get_next(rgd); 940 if (!rgd) 941 rgd = gfs2_rgrpd_get_first(sdp); 942 943 if (rgd == begin) { 944 if (++loops >= 2 || !skipped) 945 return -ENOSPC; 946 flags = 0; 947 } 948 } 949 950 out: 951 ip->i_last_rg_alloc = rgd->rd_ri.ri_addr; 952 953 if (begin) { 954 recent_rgrp_add(rgd); 955 rgd = gfs2_rgrpd_get_next(rgd); 956 if (!rgd) 957 rgd = gfs2_rgrpd_get_first(sdp); 958 forward_rgrp_set(sdp, rgd); 959 } 960 961 return 0; 962 } 963 964 /** 965 * gfs2_inplace_reserve_i - Reserve space in the filesystem 966 * @ip: the inode to reserve space for 967 * 968 * Returns: errno 969 */ 970 971 int gfs2_inplace_reserve_i(struct gfs2_inode *ip, char *file, unsigned int line) 972 { 973 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 974 struct gfs2_alloc *al = &ip->i_alloc; 975 int error; 976 977 if (gfs2_assert_warn(sdp, al->al_requested)) 978 return -EINVAL; 979 980 error = gfs2_rindex_hold(sdp, &al->al_ri_gh); 981 if (error) 982 return error; 983 984 error = get_local_rgrp(ip); 985 if (error) { 986 gfs2_glock_dq_uninit(&al->al_ri_gh); 987 return error; 988 } 989 990 al->al_file = file; 991 al->al_line = line; 992 993 return 0; 994 } 995 996 /** 997 * gfs2_inplace_release - release an inplace reservation 998 * @ip: the inode the reservation was taken out on 999 * 1000 * Release a reservation made by gfs2_inplace_reserve(). 1001 */ 1002 1003 void gfs2_inplace_release(struct gfs2_inode *ip) 1004 { 1005 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1006 struct gfs2_alloc *al = &ip->i_alloc; 1007 1008 if (gfs2_assert_warn(sdp, al->al_alloced <= al->al_requested) == -1) 1009 fs_warn(sdp, "al_alloced = %u, al_requested = %u " 1010 "al_file = %s, al_line = %u\n", 1011 al->al_alloced, al->al_requested, al->al_file, 1012 al->al_line); 1013 1014 al->al_rgd = NULL; 1015 gfs2_glock_dq_uninit(&al->al_rgd_gh); 1016 gfs2_glock_dq_uninit(&al->al_ri_gh); 1017 } 1018 1019 /** 1020 * gfs2_get_block_type - Check a block in a RG is of given type 1021 * @rgd: the resource group holding the block 1022 * @block: the block number 1023 * 1024 * Returns: The block type (GFS2_BLKST_*) 1025 */ 1026 1027 unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block) 1028 { 1029 struct gfs2_bitmap *bi = NULL; 1030 u32 length, rgrp_block, buf_block; 1031 unsigned int buf; 1032 unsigned char type; 1033 1034 length = rgd->rd_ri.ri_length; 1035 rgrp_block = block - rgd->rd_ri.ri_data0; 1036 1037 for (buf = 0; buf < length; buf++) { 1038 bi = rgd->rd_bits + buf; 1039 if (rgrp_block < (bi->bi_start + bi->bi_len) * GFS2_NBBY) 1040 break; 1041 } 1042 1043 gfs2_assert(rgd->rd_sbd, buf < length); 1044 buf_block = rgrp_block - bi->bi_start * GFS2_NBBY; 1045 1046 type = gfs2_testbit(rgd, bi->bi_bh->b_data + bi->bi_offset, 1047 bi->bi_len, buf_block); 1048 1049 return type; 1050 } 1051 1052 /** 1053 * rgblk_search - find a block in @old_state, change allocation 1054 * state to @new_state 1055 * @rgd: the resource group descriptor 1056 * @goal: the goal block within the RG (start here to search for avail block) 1057 * @old_state: GFS2_BLKST_XXX the before-allocation state to find 1058 * @new_state: GFS2_BLKST_XXX the after-allocation block state 1059 * 1060 * Walk rgrp's bitmap to find bits that represent a block in @old_state. 1061 * Add the found bitmap buffer to the transaction. 1062 * Set the found bits to @new_state to change block's allocation state. 1063 * 1064 * This function never fails, because we wouldn't call it unless we 1065 * know (from reservation results, etc.) that a block is available. 1066 * 1067 * Scope of @goal and returned block is just within rgrp, not the whole 1068 * filesystem. 1069 * 1070 * Returns: the block number allocated 1071 */ 1072 1073 static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal, 1074 unsigned char old_state, unsigned char new_state) 1075 { 1076 struct gfs2_bitmap *bi = NULL; 1077 u32 length = rgd->rd_ri.ri_length; 1078 u32 blk = 0; 1079 unsigned int buf, x; 1080 1081 /* Find bitmap block that contains bits for goal block */ 1082 for (buf = 0; buf < length; buf++) { 1083 bi = rgd->rd_bits + buf; 1084 if (goal < (bi->bi_start + bi->bi_len) * GFS2_NBBY) 1085 break; 1086 } 1087 1088 gfs2_assert(rgd->rd_sbd, buf < length); 1089 1090 /* Convert scope of "goal" from rgrp-wide to within found bit block */ 1091 goal -= bi->bi_start * GFS2_NBBY; 1092 1093 /* Search (up to entire) bitmap in this rgrp for allocatable block. 1094 "x <= length", instead of "x < length", because we typically start 1095 the search in the middle of a bit block, but if we can't find an 1096 allocatable block anywhere else, we want to be able wrap around and 1097 search in the first part of our first-searched bit block. */ 1098 for (x = 0; x <= length; x++) { 1099 if (bi->bi_clone) 1100 blk = gfs2_bitfit(rgd, bi->bi_clone + bi->bi_offset, 1101 bi->bi_len, goal, old_state); 1102 else 1103 blk = gfs2_bitfit(rgd, 1104 bi->bi_bh->b_data + bi->bi_offset, 1105 bi->bi_len, goal, old_state); 1106 if (blk != BFITNOENT) 1107 break; 1108 1109 /* Try next bitmap block (wrap back to rgrp header if at end) */ 1110 buf = (buf + 1) % length; 1111 bi = rgd->rd_bits + buf; 1112 goal = 0; 1113 } 1114 1115 if (gfs2_assert_withdraw(rgd->rd_sbd, x <= length)) 1116 blk = 0; 1117 1118 gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1); 1119 gfs2_setbit(rgd, bi->bi_bh->b_data + bi->bi_offset, 1120 bi->bi_len, blk, new_state); 1121 if (bi->bi_clone) 1122 gfs2_setbit(rgd, bi->bi_clone + bi->bi_offset, 1123 bi->bi_len, blk, new_state); 1124 1125 return bi->bi_start * GFS2_NBBY + blk; 1126 } 1127 1128 /** 1129 * rgblk_free - Change alloc state of given block(s) 1130 * @sdp: the filesystem 1131 * @bstart: the start of a run of blocks to free 1132 * @blen: the length of the block run (all must lie within ONE RG!) 1133 * @new_state: GFS2_BLKST_XXX the after-allocation block state 1134 * 1135 * Returns: Resource group containing the block(s) 1136 */ 1137 1138 static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart, 1139 u32 blen, unsigned char new_state) 1140 { 1141 struct gfs2_rgrpd *rgd; 1142 struct gfs2_bitmap *bi = NULL; 1143 u32 length, rgrp_blk, buf_blk; 1144 unsigned int buf; 1145 1146 rgd = gfs2_blk2rgrpd(sdp, bstart); 1147 if (!rgd) { 1148 if (gfs2_consist(sdp)) 1149 fs_err(sdp, "block = %llu\n", (unsigned long long)bstart); 1150 return NULL; 1151 } 1152 1153 length = rgd->rd_ri.ri_length; 1154 1155 rgrp_blk = bstart - rgd->rd_ri.ri_data0; 1156 1157 while (blen--) { 1158 for (buf = 0; buf < length; buf++) { 1159 bi = rgd->rd_bits + buf; 1160 if (rgrp_blk < (bi->bi_start + bi->bi_len) * GFS2_NBBY) 1161 break; 1162 } 1163 1164 gfs2_assert(rgd->rd_sbd, buf < length); 1165 1166 buf_blk = rgrp_blk - bi->bi_start * GFS2_NBBY; 1167 rgrp_blk++; 1168 1169 if (!bi->bi_clone) { 1170 bi->bi_clone = kmalloc(bi->bi_bh->b_size, 1171 GFP_NOFS | __GFP_NOFAIL); 1172 memcpy(bi->bi_clone + bi->bi_offset, 1173 bi->bi_bh->b_data + bi->bi_offset, 1174 bi->bi_len); 1175 } 1176 gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1); 1177 gfs2_setbit(rgd, bi->bi_bh->b_data + bi->bi_offset, 1178 bi->bi_len, buf_blk, new_state); 1179 } 1180 1181 return rgd; 1182 } 1183 1184 /** 1185 * gfs2_alloc_data - Allocate a data block 1186 * @ip: the inode to allocate the data block for 1187 * 1188 * Returns: the allocated block 1189 */ 1190 1191 u64 gfs2_alloc_data(struct gfs2_inode *ip) 1192 { 1193 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1194 struct gfs2_alloc *al = &ip->i_alloc; 1195 struct gfs2_rgrpd *rgd = al->al_rgd; 1196 u32 goal, blk; 1197 u64 block; 1198 1199 if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_data)) 1200 goal = ip->i_di.di_goal_data - rgd->rd_ri.ri_data0; 1201 else 1202 goal = rgd->rd_last_alloc_data; 1203 1204 blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED); 1205 rgd->rd_last_alloc_data = blk; 1206 1207 block = rgd->rd_ri.ri_data0 + blk; 1208 ip->i_di.di_goal_data = block; 1209 1210 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free); 1211 rgd->rd_rg.rg_free--; 1212 1213 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1); 1214 gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data); 1215 1216 al->al_alloced++; 1217 1218 gfs2_statfs_change(sdp, 0, -1, 0); 1219 gfs2_quota_change(ip, +1, ip->i_inode.i_uid, ip->i_inode.i_gid); 1220 1221 spin_lock(&sdp->sd_rindex_spin); 1222 rgd->rd_free_clone--; 1223 spin_unlock(&sdp->sd_rindex_spin); 1224 1225 return block; 1226 } 1227 1228 /** 1229 * gfs2_alloc_meta - Allocate a metadata block 1230 * @ip: the inode to allocate the metadata block for 1231 * 1232 * Returns: the allocated block 1233 */ 1234 1235 u64 gfs2_alloc_meta(struct gfs2_inode *ip) 1236 { 1237 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1238 struct gfs2_alloc *al = &ip->i_alloc; 1239 struct gfs2_rgrpd *rgd = al->al_rgd; 1240 u32 goal, blk; 1241 u64 block; 1242 1243 if (rgrp_contains_block(&rgd->rd_ri, ip->i_di.di_goal_meta)) 1244 goal = ip->i_di.di_goal_meta - rgd->rd_ri.ri_data0; 1245 else 1246 goal = rgd->rd_last_alloc_meta; 1247 1248 blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED); 1249 rgd->rd_last_alloc_meta = blk; 1250 1251 block = rgd->rd_ri.ri_data0 + blk; 1252 ip->i_di.di_goal_meta = block; 1253 1254 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free); 1255 rgd->rd_rg.rg_free--; 1256 1257 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1); 1258 gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data); 1259 1260 al->al_alloced++; 1261 1262 gfs2_statfs_change(sdp, 0, -1, 0); 1263 gfs2_quota_change(ip, +1, ip->i_inode.i_uid, ip->i_inode.i_gid); 1264 gfs2_trans_add_unrevoke(sdp, block); 1265 1266 spin_lock(&sdp->sd_rindex_spin); 1267 rgd->rd_free_clone--; 1268 spin_unlock(&sdp->sd_rindex_spin); 1269 1270 return block; 1271 } 1272 1273 /** 1274 * gfs2_alloc_di - Allocate a dinode 1275 * @dip: the directory that the inode is going in 1276 * 1277 * Returns: the block allocated 1278 */ 1279 1280 u64 gfs2_alloc_di(struct gfs2_inode *dip, u64 *generation) 1281 { 1282 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode); 1283 struct gfs2_alloc *al = &dip->i_alloc; 1284 struct gfs2_rgrpd *rgd = al->al_rgd; 1285 u32 blk; 1286 u64 block; 1287 1288 blk = rgblk_search(rgd, rgd->rd_last_alloc_meta, 1289 GFS2_BLKST_FREE, GFS2_BLKST_DINODE); 1290 1291 rgd->rd_last_alloc_meta = blk; 1292 1293 block = rgd->rd_ri.ri_data0 + blk; 1294 1295 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free); 1296 rgd->rd_rg.rg_free--; 1297 rgd->rd_rg.rg_dinodes++; 1298 *generation = rgd->rd_rg.rg_igeneration++; 1299 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1); 1300 gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data); 1301 1302 al->al_alloced++; 1303 1304 gfs2_statfs_change(sdp, 0, -1, +1); 1305 gfs2_trans_add_unrevoke(sdp, block); 1306 1307 spin_lock(&sdp->sd_rindex_spin); 1308 rgd->rd_free_clone--; 1309 spin_unlock(&sdp->sd_rindex_spin); 1310 1311 return block; 1312 } 1313 1314 /** 1315 * gfs2_free_data - free a contiguous run of data block(s) 1316 * @ip: the inode these blocks are being freed from 1317 * @bstart: first block of a run of contiguous blocks 1318 * @blen: the length of the block run 1319 * 1320 */ 1321 1322 void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen) 1323 { 1324 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1325 struct gfs2_rgrpd *rgd; 1326 1327 rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE); 1328 if (!rgd) 1329 return; 1330 1331 rgd->rd_rg.rg_free += blen; 1332 1333 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1); 1334 gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data); 1335 1336 gfs2_trans_add_rg(rgd); 1337 1338 gfs2_statfs_change(sdp, 0, +blen, 0); 1339 gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid); 1340 } 1341 1342 /** 1343 * gfs2_free_meta - free a contiguous run of data block(s) 1344 * @ip: the inode these blocks are being freed from 1345 * @bstart: first block of a run of contiguous blocks 1346 * @blen: the length of the block run 1347 * 1348 */ 1349 1350 void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen) 1351 { 1352 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1353 struct gfs2_rgrpd *rgd; 1354 1355 rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE); 1356 if (!rgd) 1357 return; 1358 1359 rgd->rd_rg.rg_free += blen; 1360 1361 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1); 1362 gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data); 1363 1364 gfs2_trans_add_rg(rgd); 1365 1366 gfs2_statfs_change(sdp, 0, +blen, 0); 1367 gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid); 1368 gfs2_meta_wipe(ip, bstart, blen); 1369 } 1370 1371 void gfs2_unlink_di(struct inode *inode) 1372 { 1373 struct gfs2_inode *ip = GFS2_I(inode); 1374 struct gfs2_sbd *sdp = GFS2_SB(inode); 1375 struct gfs2_rgrpd *rgd; 1376 u64 blkno = ip->i_num.no_addr; 1377 1378 rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED); 1379 if (!rgd) 1380 return; 1381 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1); 1382 gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data); 1383 gfs2_trans_add_rg(rgd); 1384 } 1385 1386 static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno) 1387 { 1388 struct gfs2_sbd *sdp = rgd->rd_sbd; 1389 struct gfs2_rgrpd *tmp_rgd; 1390 1391 tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE); 1392 if (!tmp_rgd) 1393 return; 1394 gfs2_assert_withdraw(sdp, rgd == tmp_rgd); 1395 1396 if (!rgd->rd_rg.rg_dinodes) 1397 gfs2_consist_rgrpd(rgd); 1398 rgd->rd_rg.rg_dinodes--; 1399 rgd->rd_rg.rg_free++; 1400 1401 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1); 1402 gfs2_rgrp_out(&rgd->rd_rg, rgd->rd_bits[0].bi_bh->b_data); 1403 1404 gfs2_statfs_change(sdp, 0, +1, -1); 1405 gfs2_trans_add_rg(rgd); 1406 } 1407 1408 1409 void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip) 1410 { 1411 gfs2_free_uninit_di(rgd, ip->i_num.no_addr); 1412 gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid); 1413 gfs2_meta_wipe(ip, ip->i_num.no_addr, 1); 1414 } 1415 1416 /** 1417 * gfs2_rlist_add - add a RG to a list of RGs 1418 * @sdp: the filesystem 1419 * @rlist: the list of resource groups 1420 * @block: the block 1421 * 1422 * Figure out what RG a block belongs to and add that RG to the list 1423 * 1424 * FIXME: Don't use NOFAIL 1425 * 1426 */ 1427 1428 void gfs2_rlist_add(struct gfs2_sbd *sdp, struct gfs2_rgrp_list *rlist, 1429 u64 block) 1430 { 1431 struct gfs2_rgrpd *rgd; 1432 struct gfs2_rgrpd **tmp; 1433 unsigned int new_space; 1434 unsigned int x; 1435 1436 if (gfs2_assert_warn(sdp, !rlist->rl_ghs)) 1437 return; 1438 1439 rgd = gfs2_blk2rgrpd(sdp, block); 1440 if (!rgd) { 1441 if (gfs2_consist(sdp)) 1442 fs_err(sdp, "block = %llu\n", (unsigned long long)block); 1443 return; 1444 } 1445 1446 for (x = 0; x < rlist->rl_rgrps; x++) 1447 if (rlist->rl_rgd[x] == rgd) 1448 return; 1449 1450 if (rlist->rl_rgrps == rlist->rl_space) { 1451 new_space = rlist->rl_space + 10; 1452 1453 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *), 1454 GFP_NOFS | __GFP_NOFAIL); 1455 1456 if (rlist->rl_rgd) { 1457 memcpy(tmp, rlist->rl_rgd, 1458 rlist->rl_space * sizeof(struct gfs2_rgrpd *)); 1459 kfree(rlist->rl_rgd); 1460 } 1461 1462 rlist->rl_space = new_space; 1463 rlist->rl_rgd = tmp; 1464 } 1465 1466 rlist->rl_rgd[rlist->rl_rgrps++] = rgd; 1467 } 1468 1469 /** 1470 * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate 1471 * and initialize an array of glock holders for them 1472 * @rlist: the list of resource groups 1473 * @state: the lock state to acquire the RG lock in 1474 * @flags: the modifier flags for the holder structures 1475 * 1476 * FIXME: Don't use NOFAIL 1477 * 1478 */ 1479 1480 void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state, 1481 int flags) 1482 { 1483 unsigned int x; 1484 1485 rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder), 1486 GFP_NOFS | __GFP_NOFAIL); 1487 for (x = 0; x < rlist->rl_rgrps; x++) 1488 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl, 1489 state, flags, 1490 &rlist->rl_ghs[x]); 1491 } 1492 1493 /** 1494 * gfs2_rlist_free - free a resource group list 1495 * @list: the list of resource groups 1496 * 1497 */ 1498 1499 void gfs2_rlist_free(struct gfs2_rgrp_list *rlist) 1500 { 1501 unsigned int x; 1502 1503 kfree(rlist->rl_rgd); 1504 1505 if (rlist->rl_ghs) { 1506 for (x = 0; x < rlist->rl_rgrps; x++) 1507 gfs2_holder_uninit(&rlist->rl_ghs[x]); 1508 kfree(rlist->rl_ghs); 1509 } 1510 } 1511 1512