1 /* 2 * linux/fs/ufs/balloc.c 3 * 4 * Copyright (C) 1998 5 * Daniel Pirkl <daniel.pirkl@email.cz> 6 * Charles University, Faculty of Mathematics and Physics 7 * 8 * UFS2 write support Evgeniy Dushistov <dushistov@mail.ru>, 2007 9 */ 10 11 #include <linux/fs.h> 12 #include <linux/stat.h> 13 #include <linux/time.h> 14 #include <linux/string.h> 15 #include <linux/quotaops.h> 16 #include <linux/buffer_head.h> 17 #include <linux/capability.h> 18 #include <linux/bitops.h> 19 #include <asm/byteorder.h> 20 21 #include "ufs_fs.h" 22 #include "ufs.h" 23 #include "swab.h" 24 #include "util.h" 25 26 #define INVBLOCK ((u64)-1L) 27 28 static u64 ufs_add_fragments(struct inode *, u64, unsigned, unsigned, int *); 29 static u64 ufs_alloc_fragments(struct inode *, unsigned, u64, unsigned, int *); 30 static u64 ufs_alloccg_block(struct inode *, struct ufs_cg_private_info *, u64, int *); 31 static u64 ufs_bitmap_search (struct super_block *, struct ufs_cg_private_info *, u64, unsigned); 32 static unsigned char ufs_fragtable_8fpb[], ufs_fragtable_other[]; 33 static void ufs_clusteracct(struct super_block *, struct ufs_cg_private_info *, unsigned, int); 34 35 /* 36 * Free 'count' fragments from fragment number 'fragment' 37 */ 38 void ufs_free_fragments(struct inode *inode, u64 fragment, unsigned count) 39 { 40 struct super_block * sb; 41 struct ufs_sb_private_info * uspi; 42 struct ufs_super_block_first * usb1; 43 struct ufs_cg_private_info * ucpi; 44 struct ufs_cylinder_group * ucg; 45 unsigned cgno, bit, end_bit, bbase, blkmap, i; 46 u64 blkno; 47 48 sb = inode->i_sb; 49 uspi = UFS_SB(sb)->s_uspi; 50 usb1 = ubh_get_usb_first(uspi); 51 52 UFSD("ENTER, fragment %llu, count %u\n", 53 (unsigned long long)fragment, count); 54 55 if (ufs_fragnum(fragment) + count > uspi->s_fpg) 56 ufs_error (sb, "ufs_free_fragments", "internal error"); 57 58 lock_super(sb); 59 60 cgno = ufs_dtog(uspi, fragment); 61 bit = ufs_dtogd(uspi, fragment); 62 if (cgno >= uspi->s_ncg) { 63 ufs_panic (sb, "ufs_free_fragments", "freeing blocks are outside device"); 64 goto failed; 65 } 66 67 ucpi = ufs_load_cylinder (sb, cgno); 68 if (!ucpi) 69 goto failed; 70 ucg = ubh_get_ucg (UCPI_UBH(ucpi)); 71 if (!ufs_cg_chkmagic(sb, ucg)) { 72 ufs_panic (sb, "ufs_free_fragments", "internal error, bad magic number on cg %u", cgno); 73 goto failed; 74 } 75 76 end_bit = bit + count; 77 bbase = ufs_blknum (bit); 78 blkmap = ubh_blkmap (UCPI_UBH(ucpi), ucpi->c_freeoff, bbase); 79 ufs_fragacct (sb, blkmap, ucg->cg_frsum, -1); 80 for (i = bit; i < end_bit; i++) { 81 if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, i)) 82 ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, i); 83 else 84 ufs_error (sb, "ufs_free_fragments", 85 "bit already cleared for fragment %u", i); 86 } 87 88 DQUOT_FREE_BLOCK (inode, count); 89 90 91 fs32_add(sb, &ucg->cg_cs.cs_nffree, count); 92 uspi->cs_total.cs_nffree += count; 93 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count); 94 blkmap = ubh_blkmap (UCPI_UBH(ucpi), ucpi->c_freeoff, bbase); 95 ufs_fragacct(sb, blkmap, ucg->cg_frsum, 1); 96 97 /* 98 * Trying to reassemble free fragments into block 99 */ 100 blkno = ufs_fragstoblks (bbase); 101 if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno)) { 102 fs32_sub(sb, &ucg->cg_cs.cs_nffree, uspi->s_fpb); 103 uspi->cs_total.cs_nffree -= uspi->s_fpb; 104 fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, uspi->s_fpb); 105 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD) 106 ufs_clusteracct (sb, ucpi, blkno, 1); 107 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1); 108 uspi->cs_total.cs_nbfree++; 109 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nbfree, 1); 110 if (uspi->fs_magic != UFS2_MAGIC) { 111 unsigned cylno = ufs_cbtocylno (bbase); 112 113 fs16_add(sb, &ubh_cg_blks(ucpi, cylno, 114 ufs_cbtorpos(bbase)), 1); 115 fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1); 116 } 117 } 118 119 ubh_mark_buffer_dirty (USPI_UBH(uspi)); 120 ubh_mark_buffer_dirty (UCPI_UBH(ucpi)); 121 if (sb->s_flags & MS_SYNCHRONOUS) { 122 ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi)); 123 ubh_wait_on_buffer (UCPI_UBH(ucpi)); 124 } 125 sb->s_dirt = 1; 126 127 unlock_super (sb); 128 UFSD("EXIT\n"); 129 return; 130 131 failed: 132 unlock_super (sb); 133 UFSD("EXIT (FAILED)\n"); 134 return; 135 } 136 137 /* 138 * Free 'count' fragments from fragment number 'fragment' (free whole blocks) 139 */ 140 void ufs_free_blocks(struct inode *inode, u64 fragment, unsigned count) 141 { 142 struct super_block * sb; 143 struct ufs_sb_private_info * uspi; 144 struct ufs_super_block_first * usb1; 145 struct ufs_cg_private_info * ucpi; 146 struct ufs_cylinder_group * ucg; 147 unsigned overflow, cgno, bit, end_bit, i; 148 u64 blkno; 149 150 sb = inode->i_sb; 151 uspi = UFS_SB(sb)->s_uspi; 152 usb1 = ubh_get_usb_first(uspi); 153 154 UFSD("ENTER, fragment %llu, count %u\n", 155 (unsigned long long)fragment, count); 156 157 if ((fragment & uspi->s_fpbmask) || (count & uspi->s_fpbmask)) { 158 ufs_error (sb, "ufs_free_blocks", "internal error, " 159 "fragment %llu, count %u\n", 160 (unsigned long long)fragment, count); 161 goto failed; 162 } 163 164 lock_super(sb); 165 166 do_more: 167 overflow = 0; 168 cgno = ufs_dtog(uspi, fragment); 169 bit = ufs_dtogd(uspi, fragment); 170 if (cgno >= uspi->s_ncg) { 171 ufs_panic (sb, "ufs_free_blocks", "freeing blocks are outside device"); 172 goto failed_unlock; 173 } 174 end_bit = bit + count; 175 if (end_bit > uspi->s_fpg) { 176 overflow = bit + count - uspi->s_fpg; 177 count -= overflow; 178 end_bit -= overflow; 179 } 180 181 ucpi = ufs_load_cylinder (sb, cgno); 182 if (!ucpi) 183 goto failed_unlock; 184 ucg = ubh_get_ucg (UCPI_UBH(ucpi)); 185 if (!ufs_cg_chkmagic(sb, ucg)) { 186 ufs_panic (sb, "ufs_free_blocks", "internal error, bad magic number on cg %u", cgno); 187 goto failed_unlock; 188 } 189 190 for (i = bit; i < end_bit; i += uspi->s_fpb) { 191 blkno = ufs_fragstoblks(i); 192 if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno)) { 193 ufs_error(sb, "ufs_free_blocks", "freeing free fragment"); 194 } 195 ubh_setblock(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno); 196 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD) 197 ufs_clusteracct (sb, ucpi, blkno, 1); 198 DQUOT_FREE_BLOCK(inode, uspi->s_fpb); 199 200 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1); 201 uspi->cs_total.cs_nbfree++; 202 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nbfree, 1); 203 204 if (uspi->fs_magic != UFS2_MAGIC) { 205 unsigned cylno = ufs_cbtocylno(i); 206 207 fs16_add(sb, &ubh_cg_blks(ucpi, cylno, 208 ufs_cbtorpos(i)), 1); 209 fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1); 210 } 211 } 212 213 ubh_mark_buffer_dirty (USPI_UBH(uspi)); 214 ubh_mark_buffer_dirty (UCPI_UBH(ucpi)); 215 if (sb->s_flags & MS_SYNCHRONOUS) { 216 ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi)); 217 ubh_wait_on_buffer (UCPI_UBH(ucpi)); 218 } 219 220 if (overflow) { 221 fragment += count; 222 count = overflow; 223 goto do_more; 224 } 225 226 sb->s_dirt = 1; 227 unlock_super (sb); 228 UFSD("EXIT\n"); 229 return; 230 231 failed_unlock: 232 unlock_super (sb); 233 failed: 234 UFSD("EXIT (FAILED)\n"); 235 return; 236 } 237 238 /* 239 * Modify inode page cache in such way: 240 * have - blocks with b_blocknr equal to oldb...oldb+count-1 241 * get - blocks with b_blocknr equal to newb...newb+count-1 242 * also we suppose that oldb...oldb+count-1 blocks 243 * situated at the end of file. 244 * 245 * We can come here from ufs_writepage or ufs_prepare_write, 246 * locked_page is argument of these functions, so we already lock it. 247 */ 248 static void ufs_change_blocknr(struct inode *inode, sector_t beg, 249 unsigned int count, sector_t oldb, 250 sector_t newb, struct page *locked_page) 251 { 252 const unsigned blks_per_page = 253 1 << (PAGE_CACHE_SHIFT - inode->i_blkbits); 254 const unsigned mask = blks_per_page - 1; 255 struct address_space * const mapping = inode->i_mapping; 256 pgoff_t index, cur_index, last_index; 257 unsigned pos, j, lblock; 258 sector_t end, i; 259 struct page *page; 260 struct buffer_head *head, *bh; 261 262 UFSD("ENTER, ino %lu, count %u, oldb %llu, newb %llu\n", 263 inode->i_ino, count, 264 (unsigned long long)oldb, (unsigned long long)newb); 265 266 BUG_ON(!locked_page); 267 BUG_ON(!PageLocked(locked_page)); 268 269 cur_index = locked_page->index; 270 end = count + beg; 271 last_index = end >> (PAGE_CACHE_SHIFT - inode->i_blkbits); 272 for (i = beg; i < end; i = (i | mask) + 1) { 273 index = i >> (PAGE_CACHE_SHIFT - inode->i_blkbits); 274 275 if (likely(cur_index != index)) { 276 page = ufs_get_locked_page(mapping, index); 277 if (!page)/* it was truncated */ 278 continue; 279 if (IS_ERR(page)) {/* or EIO */ 280 ufs_error(inode->i_sb, __func__, 281 "read of page %llu failed\n", 282 (unsigned long long)index); 283 continue; 284 } 285 } else 286 page = locked_page; 287 288 head = page_buffers(page); 289 bh = head; 290 pos = i & mask; 291 for (j = 0; j < pos; ++j) 292 bh = bh->b_this_page; 293 294 295 if (unlikely(index == last_index)) 296 lblock = end & mask; 297 else 298 lblock = blks_per_page; 299 300 do { 301 if (j >= lblock) 302 break; 303 pos = (i - beg) + j; 304 305 if (!buffer_mapped(bh)) 306 map_bh(bh, inode->i_sb, oldb + pos); 307 if (!buffer_uptodate(bh)) { 308 ll_rw_block(READ, 1, &bh); 309 wait_on_buffer(bh); 310 if (!buffer_uptodate(bh)) { 311 ufs_error(inode->i_sb, __func__, 312 "read of block failed\n"); 313 break; 314 } 315 } 316 317 UFSD(" change from %llu to %llu, pos %u\n", 318 (unsigned long long)(pos + oldb), 319 (unsigned long long)(pos + newb), pos); 320 321 bh->b_blocknr = newb + pos; 322 unmap_underlying_metadata(bh->b_bdev, 323 bh->b_blocknr); 324 mark_buffer_dirty(bh); 325 ++j; 326 bh = bh->b_this_page; 327 } while (bh != head); 328 329 if (likely(cur_index != index)) 330 ufs_put_locked_page(page); 331 } 332 UFSD("EXIT\n"); 333 } 334 335 static void ufs_clear_frags(struct inode *inode, sector_t beg, unsigned int n, 336 int sync) 337 { 338 struct buffer_head *bh; 339 sector_t end = beg + n; 340 341 for (; beg < end; ++beg) { 342 bh = sb_getblk(inode->i_sb, beg); 343 lock_buffer(bh); 344 memset(bh->b_data, 0, inode->i_sb->s_blocksize); 345 set_buffer_uptodate(bh); 346 mark_buffer_dirty(bh); 347 unlock_buffer(bh); 348 if (IS_SYNC(inode) || sync) 349 sync_dirty_buffer(bh); 350 brelse(bh); 351 } 352 } 353 354 u64 ufs_new_fragments(struct inode *inode, void *p, u64 fragment, 355 u64 goal, unsigned count, int *err, 356 struct page *locked_page) 357 { 358 struct super_block * sb; 359 struct ufs_sb_private_info * uspi; 360 struct ufs_super_block_first * usb1; 361 unsigned cgno, oldcount, newcount; 362 u64 tmp, request, result; 363 364 UFSD("ENTER, ino %lu, fragment %llu, goal %llu, count %u\n", 365 inode->i_ino, (unsigned long long)fragment, 366 (unsigned long long)goal, count); 367 368 sb = inode->i_sb; 369 uspi = UFS_SB(sb)->s_uspi; 370 usb1 = ubh_get_usb_first(uspi); 371 *err = -ENOSPC; 372 373 lock_super (sb); 374 tmp = ufs_data_ptr_to_cpu(sb, p); 375 376 if (count + ufs_fragnum(fragment) > uspi->s_fpb) { 377 ufs_warning(sb, "ufs_new_fragments", "internal warning" 378 " fragment %llu, count %u", 379 (unsigned long long)fragment, count); 380 count = uspi->s_fpb - ufs_fragnum(fragment); 381 } 382 oldcount = ufs_fragnum (fragment); 383 newcount = oldcount + count; 384 385 /* 386 * Somebody else has just allocated our fragments 387 */ 388 if (oldcount) { 389 if (!tmp) { 390 ufs_error(sb, "ufs_new_fragments", "internal error, " 391 "fragment %llu, tmp %llu\n", 392 (unsigned long long)fragment, 393 (unsigned long long)tmp); 394 unlock_super(sb); 395 return INVBLOCK; 396 } 397 if (fragment < UFS_I(inode)->i_lastfrag) { 398 UFSD("EXIT (ALREADY ALLOCATED)\n"); 399 unlock_super (sb); 400 return 0; 401 } 402 } 403 else { 404 if (tmp) { 405 UFSD("EXIT (ALREADY ALLOCATED)\n"); 406 unlock_super(sb); 407 return 0; 408 } 409 } 410 411 /* 412 * There is not enough space for user on the device 413 */ 414 if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(uspi, UFS_MINFREE) <= 0) { 415 unlock_super (sb); 416 UFSD("EXIT (FAILED)\n"); 417 return 0; 418 } 419 420 if (goal >= uspi->s_size) 421 goal = 0; 422 if (goal == 0) 423 cgno = ufs_inotocg (inode->i_ino); 424 else 425 cgno = ufs_dtog(uspi, goal); 426 427 /* 428 * allocate new fragment 429 */ 430 if (oldcount == 0) { 431 result = ufs_alloc_fragments (inode, cgno, goal, count, err); 432 if (result) { 433 ufs_cpu_to_data_ptr(sb, p, result); 434 *err = 0; 435 UFS_I(inode)->i_lastfrag = 436 max_t(u32, UFS_I(inode)->i_lastfrag, 437 fragment + count); 438 ufs_clear_frags(inode, result + oldcount, 439 newcount - oldcount, locked_page != NULL); 440 } 441 unlock_super(sb); 442 UFSD("EXIT, result %llu\n", (unsigned long long)result); 443 return result; 444 } 445 446 /* 447 * resize block 448 */ 449 result = ufs_add_fragments (inode, tmp, oldcount, newcount, err); 450 if (result) { 451 *err = 0; 452 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count); 453 ufs_clear_frags(inode, result + oldcount, newcount - oldcount, 454 locked_page != NULL); 455 unlock_super(sb); 456 UFSD("EXIT, result %llu\n", (unsigned long long)result); 457 return result; 458 } 459 460 /* 461 * allocate new block and move data 462 */ 463 switch (fs32_to_cpu(sb, usb1->fs_optim)) { 464 case UFS_OPTSPACE: 465 request = newcount; 466 if (uspi->s_minfree < 5 || uspi->cs_total.cs_nffree 467 > uspi->s_dsize * uspi->s_minfree / (2 * 100)) 468 break; 469 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME); 470 break; 471 default: 472 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME); 473 474 case UFS_OPTTIME: 475 request = uspi->s_fpb; 476 if (uspi->cs_total.cs_nffree < uspi->s_dsize * 477 (uspi->s_minfree - 2) / 100) 478 break; 479 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME); 480 break; 481 } 482 result = ufs_alloc_fragments (inode, cgno, goal, request, err); 483 if (result) { 484 ufs_clear_frags(inode, result + oldcount, newcount - oldcount, 485 locked_page != NULL); 486 ufs_change_blocknr(inode, fragment - oldcount, oldcount, 487 uspi->s_sbbase + tmp, 488 uspi->s_sbbase + result, locked_page); 489 ufs_cpu_to_data_ptr(sb, p, result); 490 *err = 0; 491 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count); 492 unlock_super(sb); 493 if (newcount < request) 494 ufs_free_fragments (inode, result + newcount, request - newcount); 495 ufs_free_fragments (inode, tmp, oldcount); 496 UFSD("EXIT, result %llu\n", (unsigned long long)result); 497 return result; 498 } 499 500 unlock_super(sb); 501 UFSD("EXIT (FAILED)\n"); 502 return 0; 503 } 504 505 static u64 ufs_add_fragments(struct inode *inode, u64 fragment, 506 unsigned oldcount, unsigned newcount, int *err) 507 { 508 struct super_block * sb; 509 struct ufs_sb_private_info * uspi; 510 struct ufs_super_block_first * usb1; 511 struct ufs_cg_private_info * ucpi; 512 struct ufs_cylinder_group * ucg; 513 unsigned cgno, fragno, fragoff, count, fragsize, i; 514 515 UFSD("ENTER, fragment %llu, oldcount %u, newcount %u\n", 516 (unsigned long long)fragment, oldcount, newcount); 517 518 sb = inode->i_sb; 519 uspi = UFS_SB(sb)->s_uspi; 520 usb1 = ubh_get_usb_first (uspi); 521 count = newcount - oldcount; 522 523 cgno = ufs_dtog(uspi, fragment); 524 if (fs32_to_cpu(sb, UFS_SB(sb)->fs_cs(cgno).cs_nffree) < count) 525 return 0; 526 if ((ufs_fragnum (fragment) + newcount) > uspi->s_fpb) 527 return 0; 528 ucpi = ufs_load_cylinder (sb, cgno); 529 if (!ucpi) 530 return 0; 531 ucg = ubh_get_ucg (UCPI_UBH(ucpi)); 532 if (!ufs_cg_chkmagic(sb, ucg)) { 533 ufs_panic (sb, "ufs_add_fragments", 534 "internal error, bad magic number on cg %u", cgno); 535 return 0; 536 } 537 538 fragno = ufs_dtogd(uspi, fragment); 539 fragoff = ufs_fragnum (fragno); 540 for (i = oldcount; i < newcount; i++) 541 if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i)) 542 return 0; 543 /* 544 * Block can be extended 545 */ 546 ucg->cg_time = cpu_to_fs32(sb, get_seconds()); 547 for (i = newcount; i < (uspi->s_fpb - fragoff); i++) 548 if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i)) 549 break; 550 fragsize = i - oldcount; 551 if (!fs32_to_cpu(sb, ucg->cg_frsum[fragsize])) 552 ufs_panic (sb, "ufs_add_fragments", 553 "internal error or corrupted bitmap on cg %u", cgno); 554 fs32_sub(sb, &ucg->cg_frsum[fragsize], 1); 555 if (fragsize != count) 556 fs32_add(sb, &ucg->cg_frsum[fragsize - count], 1); 557 for (i = oldcount; i < newcount; i++) 558 ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i); 559 if(DQUOT_ALLOC_BLOCK(inode, count)) { 560 *err = -EDQUOT; 561 return 0; 562 } 563 564 fs32_sub(sb, &ucg->cg_cs.cs_nffree, count); 565 fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count); 566 uspi->cs_total.cs_nffree -= count; 567 568 ubh_mark_buffer_dirty (USPI_UBH(uspi)); 569 ubh_mark_buffer_dirty (UCPI_UBH(ucpi)); 570 if (sb->s_flags & MS_SYNCHRONOUS) { 571 ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi)); 572 ubh_wait_on_buffer (UCPI_UBH(ucpi)); 573 } 574 sb->s_dirt = 1; 575 576 UFSD("EXIT, fragment %llu\n", (unsigned long long)fragment); 577 578 return fragment; 579 } 580 581 #define UFS_TEST_FREE_SPACE_CG \ 582 ucg = (struct ufs_cylinder_group *) UFS_SB(sb)->s_ucg[cgno]->b_data; \ 583 if (fs32_to_cpu(sb, ucg->cg_cs.cs_nbfree)) \ 584 goto cg_found; \ 585 for (k = count; k < uspi->s_fpb; k++) \ 586 if (fs32_to_cpu(sb, ucg->cg_frsum[k])) \ 587 goto cg_found; 588 589 static u64 ufs_alloc_fragments(struct inode *inode, unsigned cgno, 590 u64 goal, unsigned count, int *err) 591 { 592 struct super_block * sb; 593 struct ufs_sb_private_info * uspi; 594 struct ufs_super_block_first * usb1; 595 struct ufs_cg_private_info * ucpi; 596 struct ufs_cylinder_group * ucg; 597 unsigned oldcg, i, j, k, allocsize; 598 u64 result; 599 600 UFSD("ENTER, ino %lu, cgno %u, goal %llu, count %u\n", 601 inode->i_ino, cgno, (unsigned long long)goal, count); 602 603 sb = inode->i_sb; 604 uspi = UFS_SB(sb)->s_uspi; 605 usb1 = ubh_get_usb_first(uspi); 606 oldcg = cgno; 607 608 /* 609 * 1. searching on preferred cylinder group 610 */ 611 UFS_TEST_FREE_SPACE_CG 612 613 /* 614 * 2. quadratic rehash 615 */ 616 for (j = 1; j < uspi->s_ncg; j *= 2) { 617 cgno += j; 618 if (cgno >= uspi->s_ncg) 619 cgno -= uspi->s_ncg; 620 UFS_TEST_FREE_SPACE_CG 621 } 622 623 /* 624 * 3. brute force search 625 * We start at i = 2 ( 0 is checked at 1.step, 1 at 2.step ) 626 */ 627 cgno = (oldcg + 1) % uspi->s_ncg; 628 for (j = 2; j < uspi->s_ncg; j++) { 629 cgno++; 630 if (cgno >= uspi->s_ncg) 631 cgno = 0; 632 UFS_TEST_FREE_SPACE_CG 633 } 634 635 UFSD("EXIT (FAILED)\n"); 636 return 0; 637 638 cg_found: 639 ucpi = ufs_load_cylinder (sb, cgno); 640 if (!ucpi) 641 return 0; 642 ucg = ubh_get_ucg (UCPI_UBH(ucpi)); 643 if (!ufs_cg_chkmagic(sb, ucg)) 644 ufs_panic (sb, "ufs_alloc_fragments", 645 "internal error, bad magic number on cg %u", cgno); 646 ucg->cg_time = cpu_to_fs32(sb, get_seconds()); 647 648 if (count == uspi->s_fpb) { 649 result = ufs_alloccg_block (inode, ucpi, goal, err); 650 if (result == INVBLOCK) 651 return 0; 652 goto succed; 653 } 654 655 for (allocsize = count; allocsize < uspi->s_fpb; allocsize++) 656 if (fs32_to_cpu(sb, ucg->cg_frsum[allocsize]) != 0) 657 break; 658 659 if (allocsize == uspi->s_fpb) { 660 result = ufs_alloccg_block (inode, ucpi, goal, err); 661 if (result == INVBLOCK) 662 return 0; 663 goal = ufs_dtogd(uspi, result); 664 for (i = count; i < uspi->s_fpb; i++) 665 ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, goal + i); 666 i = uspi->s_fpb - count; 667 DQUOT_FREE_BLOCK(inode, i); 668 669 fs32_add(sb, &ucg->cg_cs.cs_nffree, i); 670 uspi->cs_total.cs_nffree += i; 671 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, i); 672 fs32_add(sb, &ucg->cg_frsum[i], 1); 673 goto succed; 674 } 675 676 result = ufs_bitmap_search (sb, ucpi, goal, allocsize); 677 if (result == INVBLOCK) 678 return 0; 679 if(DQUOT_ALLOC_BLOCK(inode, count)) { 680 *err = -EDQUOT; 681 return 0; 682 } 683 for (i = 0; i < count; i++) 684 ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, result + i); 685 686 fs32_sub(sb, &ucg->cg_cs.cs_nffree, count); 687 uspi->cs_total.cs_nffree -= count; 688 fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count); 689 fs32_sub(sb, &ucg->cg_frsum[allocsize], 1); 690 691 if (count != allocsize) 692 fs32_add(sb, &ucg->cg_frsum[allocsize - count], 1); 693 694 succed: 695 ubh_mark_buffer_dirty (USPI_UBH(uspi)); 696 ubh_mark_buffer_dirty (UCPI_UBH(ucpi)); 697 if (sb->s_flags & MS_SYNCHRONOUS) { 698 ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi)); 699 ubh_wait_on_buffer (UCPI_UBH(ucpi)); 700 } 701 sb->s_dirt = 1; 702 703 result += cgno * uspi->s_fpg; 704 UFSD("EXIT3, result %llu\n", (unsigned long long)result); 705 return result; 706 } 707 708 static u64 ufs_alloccg_block(struct inode *inode, 709 struct ufs_cg_private_info *ucpi, 710 u64 goal, int *err) 711 { 712 struct super_block * sb; 713 struct ufs_sb_private_info * uspi; 714 struct ufs_super_block_first * usb1; 715 struct ufs_cylinder_group * ucg; 716 u64 result, blkno; 717 718 UFSD("ENTER, goal %llu\n", (unsigned long long)goal); 719 720 sb = inode->i_sb; 721 uspi = UFS_SB(sb)->s_uspi; 722 usb1 = ubh_get_usb_first(uspi); 723 ucg = ubh_get_ucg(UCPI_UBH(ucpi)); 724 725 if (goal == 0) { 726 goal = ucpi->c_rotor; 727 goto norot; 728 } 729 goal = ufs_blknum (goal); 730 goal = ufs_dtogd(uspi, goal); 731 732 /* 733 * If the requested block is available, use it. 734 */ 735 if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, ufs_fragstoblks(goal))) { 736 result = goal; 737 goto gotit; 738 } 739 740 norot: 741 result = ufs_bitmap_search (sb, ucpi, goal, uspi->s_fpb); 742 if (result == INVBLOCK) 743 return INVBLOCK; 744 ucpi->c_rotor = result; 745 gotit: 746 blkno = ufs_fragstoblks(result); 747 ubh_clrblock (UCPI_UBH(ucpi), ucpi->c_freeoff, blkno); 748 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD) 749 ufs_clusteracct (sb, ucpi, blkno, -1); 750 if(DQUOT_ALLOC_BLOCK(inode, uspi->s_fpb)) { 751 *err = -EDQUOT; 752 return INVBLOCK; 753 } 754 755 fs32_sub(sb, &ucg->cg_cs.cs_nbfree, 1); 756 uspi->cs_total.cs_nbfree--; 757 fs32_sub(sb, &UFS_SB(sb)->fs_cs(ucpi->c_cgx).cs_nbfree, 1); 758 759 if (uspi->fs_magic != UFS2_MAGIC) { 760 unsigned cylno = ufs_cbtocylno((unsigned)result); 761 762 fs16_sub(sb, &ubh_cg_blks(ucpi, cylno, 763 ufs_cbtorpos((unsigned)result)), 1); 764 fs32_sub(sb, &ubh_cg_blktot(ucpi, cylno), 1); 765 } 766 767 UFSD("EXIT, result %llu\n", (unsigned long long)result); 768 769 return result; 770 } 771 772 static unsigned ubh_scanc(struct ufs_sb_private_info *uspi, 773 struct ufs_buffer_head *ubh, 774 unsigned begin, unsigned size, 775 unsigned char *table, unsigned char mask) 776 { 777 unsigned rest, offset; 778 unsigned char *cp; 779 780 781 offset = begin & ~uspi->s_fmask; 782 begin >>= uspi->s_fshift; 783 for (;;) { 784 if ((offset + size) < uspi->s_fsize) 785 rest = size; 786 else 787 rest = uspi->s_fsize - offset; 788 size -= rest; 789 cp = ubh->bh[begin]->b_data + offset; 790 while ((table[*cp++] & mask) == 0 && --rest) 791 ; 792 if (rest || !size) 793 break; 794 begin++; 795 offset = 0; 796 } 797 return (size + rest); 798 } 799 800 /* 801 * Find a block of the specified size in the specified cylinder group. 802 * @sp: pointer to super block 803 * @ucpi: pointer to cylinder group info 804 * @goal: near which block we want find new one 805 * @count: specified size 806 */ 807 static u64 ufs_bitmap_search(struct super_block *sb, 808 struct ufs_cg_private_info *ucpi, 809 u64 goal, unsigned count) 810 { 811 /* 812 * Bit patterns for identifying fragments in the block map 813 * used as ((map & mask_arr) == want_arr) 814 */ 815 static const int mask_arr[9] = { 816 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff 817 }; 818 static const int want_arr[9] = { 819 0x0, 0x2, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe 820 }; 821 struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi; 822 struct ufs_super_block_first *usb1; 823 struct ufs_cylinder_group *ucg; 824 unsigned start, length, loc; 825 unsigned pos, want, blockmap, mask, end; 826 u64 result; 827 828 UFSD("ENTER, cg %u, goal %llu, count %u\n", ucpi->c_cgx, 829 (unsigned long long)goal, count); 830 831 usb1 = ubh_get_usb_first (uspi); 832 ucg = ubh_get_ucg(UCPI_UBH(ucpi)); 833 834 if (goal) 835 start = ufs_dtogd(uspi, goal) >> 3; 836 else 837 start = ucpi->c_frotor >> 3; 838 839 length = ((uspi->s_fpg + 7) >> 3) - start; 840 loc = ubh_scanc(uspi, UCPI_UBH(ucpi), ucpi->c_freeoff + start, length, 841 (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : ufs_fragtable_other, 842 1 << (count - 1 + (uspi->s_fpb & 7))); 843 if (loc == 0) { 844 length = start + 1; 845 loc = ubh_scanc(uspi, UCPI_UBH(ucpi), ucpi->c_freeoff, length, 846 (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : 847 ufs_fragtable_other, 848 1 << (count - 1 + (uspi->s_fpb & 7))); 849 if (loc == 0) { 850 ufs_error(sb, "ufs_bitmap_search", 851 "bitmap corrupted on cg %u, start %u," 852 " length %u, count %u, freeoff %u\n", 853 ucpi->c_cgx, start, length, count, 854 ucpi->c_freeoff); 855 return INVBLOCK; 856 } 857 start = 0; 858 } 859 result = (start + length - loc) << 3; 860 ucpi->c_frotor = result; 861 862 /* 863 * found the byte in the map 864 */ 865 866 for (end = result + 8; result < end; result += uspi->s_fpb) { 867 blockmap = ubh_blkmap(UCPI_UBH(ucpi), ucpi->c_freeoff, result); 868 blockmap <<= 1; 869 mask = mask_arr[count]; 870 want = want_arr[count]; 871 for (pos = 0; pos <= uspi->s_fpb - count; pos++) { 872 if ((blockmap & mask) == want) { 873 UFSD("EXIT, result %llu\n", 874 (unsigned long long)result); 875 return result + pos; 876 } 877 mask <<= 1; 878 want <<= 1; 879 } 880 } 881 882 ufs_error(sb, "ufs_bitmap_search", "block not in map on cg %u\n", 883 ucpi->c_cgx); 884 UFSD("EXIT (FAILED)\n"); 885 return INVBLOCK; 886 } 887 888 static void ufs_clusteracct(struct super_block * sb, 889 struct ufs_cg_private_info * ucpi, unsigned blkno, int cnt) 890 { 891 struct ufs_sb_private_info * uspi; 892 int i, start, end, forw, back; 893 894 uspi = UFS_SB(sb)->s_uspi; 895 if (uspi->s_contigsumsize <= 0) 896 return; 897 898 if (cnt > 0) 899 ubh_setbit(UCPI_UBH(ucpi), ucpi->c_clusteroff, blkno); 900 else 901 ubh_clrbit(UCPI_UBH(ucpi), ucpi->c_clusteroff, blkno); 902 903 /* 904 * Find the size of the cluster going forward. 905 */ 906 start = blkno + 1; 907 end = start + uspi->s_contigsumsize; 908 if ( end >= ucpi->c_nclusterblks) 909 end = ucpi->c_nclusterblks; 910 i = ubh_find_next_zero_bit (UCPI_UBH(ucpi), ucpi->c_clusteroff, end, start); 911 if (i > end) 912 i = end; 913 forw = i - start; 914 915 /* 916 * Find the size of the cluster going backward. 917 */ 918 start = blkno - 1; 919 end = start - uspi->s_contigsumsize; 920 if (end < 0 ) 921 end = -1; 922 i = ubh_find_last_zero_bit (UCPI_UBH(ucpi), ucpi->c_clusteroff, start, end); 923 if ( i < end) 924 i = end; 925 back = start - i; 926 927 /* 928 * Account for old cluster and the possibly new forward and 929 * back clusters. 930 */ 931 i = back + forw + 1; 932 if (i > uspi->s_contigsumsize) 933 i = uspi->s_contigsumsize; 934 fs32_add(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (i << 2)), cnt); 935 if (back > 0) 936 fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (back << 2)), cnt); 937 if (forw > 0) 938 fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (forw << 2)), cnt); 939 } 940 941 942 static unsigned char ufs_fragtable_8fpb[] = { 943 0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x02, 0x04, 0x01, 0x01, 0x01, 0x03, 0x02, 0x03, 0x04, 0x08, 944 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x02, 0x03, 0x03, 0x02, 0x04, 0x05, 0x08, 0x10, 945 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09, 946 0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, 0x04, 0x05, 0x05, 0x06, 0x08, 0x09, 0x10, 0x20, 947 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09, 948 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11, 949 0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, 0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0A, 950 0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04, 0x08, 0x09, 0x09, 0x0A, 0x10, 0x11, 0x20, 0x40, 951 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09, 952 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x03, 0x03, 0x03, 0x03, 0x05, 0x05, 0x09, 0x11, 953 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x03, 0x05, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x05, 0x09, 954 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x05, 0x05, 0x05, 0x07, 0x09, 0x09, 0x11, 0x21, 955 0x02, 0x03, 0x03, 0x02, 0x03, 0x03, 0x02, 0x06, 0x03, 0x03, 0x03, 0x03, 0x02, 0x03, 0x06, 0x0A, 956 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x07, 0x02, 0x03, 0x03, 0x02, 0x06, 0x07, 0x0A, 0x12, 957 0x04, 0x05, 0x05, 0x06, 0x05, 0x05, 0x06, 0x04, 0x05, 0x05, 0x05, 0x07, 0x06, 0x07, 0x04, 0x0C, 958 0x08, 0x09, 0x09, 0x0A, 0x09, 0x09, 0x0A, 0x0C, 0x10, 0x11, 0x11, 0x12, 0x20, 0x21, 0x40, 0x80, 959 }; 960 961 static unsigned char ufs_fragtable_other[] = { 962 0x00, 0x16, 0x16, 0x2A, 0x16, 0x16, 0x26, 0x4E, 0x16, 0x16, 0x16, 0x3E, 0x2A, 0x3E, 0x4E, 0x8A, 963 0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E, 964 0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E, 965 0x2A, 0x3E, 0x3E, 0x2A, 0x3E, 0x3E, 0x2E, 0x6E, 0x3E, 0x3E, 0x3E, 0x3E, 0x2A, 0x3E, 0x6E, 0xAA, 966 0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E, 967 0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E, 968 0x26, 0x36, 0x36, 0x2E, 0x36, 0x36, 0x26, 0x6E, 0x36, 0x36, 0x36, 0x3E, 0x2E, 0x3E, 0x6E, 0xAE, 969 0x4E, 0x5E, 0x5E, 0x6E, 0x5E, 0x5E, 0x6E, 0x4E, 0x5E, 0x5E, 0x5E, 0x7E, 0x6E, 0x7E, 0x4E, 0xCE, 970 0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E, 971 0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E, 972 0x16, 0x16, 0x16, 0x3E, 0x16, 0x16, 0x36, 0x5E, 0x16, 0x16, 0x16, 0x3E, 0x3E, 0x3E, 0x5E, 0x9E, 973 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0xBE, 974 0x2A, 0x3E, 0x3E, 0x2A, 0x3E, 0x3E, 0x2E, 0x6E, 0x3E, 0x3E, 0x3E, 0x3E, 0x2A, 0x3E, 0x6E, 0xAA, 975 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x3E, 0x7E, 0xBE, 976 0x4E, 0x5E, 0x5E, 0x6E, 0x5E, 0x5E, 0x6E, 0x4E, 0x5E, 0x5E, 0x5E, 0x7E, 0x6E, 0x7E, 0x4E, 0xCE, 977 0x8A, 0x9E, 0x9E, 0xAA, 0x9E, 0x9E, 0xAE, 0xCE, 0x9E, 0x9E, 0x9E, 0xBE, 0xAA, 0xBE, 0xCE, 0x8A, 978 }; 979