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