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