1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * balloc.c 4 * 5 * PURPOSE 6 * Block allocation handling routines for the OSTA-UDF(tm) filesystem. 7 * 8 * COPYRIGHT 9 * (C) 1999-2001 Ben Fennema 10 * (C) 1999 Stelias Computing Inc 11 * 12 * HISTORY 13 * 14 * 02/24/99 blf Created. 15 * 16 */ 17 18 #include "udfdecl.h" 19 20 #include <linux/bitops.h> 21 #include <linux/overflow.h> 22 23 #include "udf_i.h" 24 #include "udf_sb.h" 25 26 #define udf_clear_bit __test_and_clear_bit_le 27 #define udf_set_bit __test_and_set_bit_le 28 #define udf_test_bit test_bit_le 29 #define udf_find_next_one_bit find_next_bit_le 30 31 static int read_block_bitmap(struct super_block *sb, 32 struct udf_bitmap *bitmap, unsigned int block, 33 unsigned long bitmap_nr) 34 { 35 struct buffer_head *bh = NULL; 36 int i; 37 int max_bits, off, count; 38 struct kernel_lb_addr loc; 39 40 loc.logicalBlockNum = bitmap->s_extPosition; 41 loc.partitionReferenceNum = UDF_SB(sb)->s_partition; 42 43 bh = sb_bread(sb, udf_get_lb_pblock(sb, &loc, block)); 44 bitmap->s_block_bitmap[bitmap_nr] = bh; 45 if (!bh) 46 return -EIO; 47 48 /* Check consistency of Space Bitmap buffer. */ 49 max_bits = sb->s_blocksize * 8; 50 if (!bitmap_nr) { 51 off = sizeof(struct spaceBitmapDesc) << 3; 52 count = min(max_bits - off, bitmap->s_nr_groups); 53 } else { 54 /* 55 * Rough check if bitmap number is too big to have any bitmap 56 * blocks reserved. 57 */ 58 if (bitmap_nr > 59 (bitmap->s_nr_groups >> (sb->s_blocksize_bits + 3)) + 2) 60 return 0; 61 off = 0; 62 count = bitmap->s_nr_groups - bitmap_nr * max_bits + 63 (sizeof(struct spaceBitmapDesc) << 3); 64 count = min(count, max_bits); 65 } 66 67 for (i = 0; i < count; i++) 68 if (udf_test_bit(i + off, bh->b_data)) { 69 bitmap->s_block_bitmap[bitmap_nr] = 70 ERR_PTR(-EFSCORRUPTED); 71 brelse(bh); 72 return -EFSCORRUPTED; 73 } 74 return 0; 75 } 76 77 static int load_block_bitmap(struct super_block *sb, 78 struct udf_bitmap *bitmap, 79 unsigned int block_group) 80 { 81 int retval = 0; 82 int nr_groups = bitmap->s_nr_groups; 83 84 if (block_group >= nr_groups) { 85 udf_debug("block_group (%u) > nr_groups (%d)\n", 86 block_group, nr_groups); 87 } 88 89 if (bitmap->s_block_bitmap[block_group]) { 90 /* 91 * The bitmap failed verification in the past. No point in 92 * trying again. 93 */ 94 if (IS_ERR(bitmap->s_block_bitmap[block_group])) 95 return PTR_ERR(bitmap->s_block_bitmap[block_group]); 96 return block_group; 97 } 98 99 retval = read_block_bitmap(sb, bitmap, block_group, block_group); 100 if (retval < 0) 101 return retval; 102 103 return block_group; 104 } 105 106 static void udf_add_free_space(struct super_block *sb, u16 partition, u32 cnt) 107 { 108 struct udf_sb_info *sbi = UDF_SB(sb); 109 struct logicalVolIntegrityDesc *lvid; 110 111 if (!sbi->s_lvid_bh) 112 return; 113 114 lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data; 115 le32_add_cpu(&lvid->freeSpaceTable[partition], cnt); 116 udf_updated_lvid(sb); 117 } 118 119 static void udf_bitmap_free_blocks(struct super_block *sb, 120 struct udf_bitmap *bitmap, 121 struct kernel_lb_addr *bloc, 122 uint32_t offset, 123 uint32_t count) 124 { 125 struct udf_sb_info *sbi = UDF_SB(sb); 126 struct buffer_head *bh = NULL; 127 unsigned long block; 128 unsigned long block_group; 129 unsigned long bit; 130 unsigned long i; 131 int bitmap_nr; 132 unsigned long overflow; 133 134 mutex_lock(&sbi->s_alloc_mutex); 135 /* We make sure this cannot overflow when mounting the filesystem */ 136 block = bloc->logicalBlockNum + offset + 137 (sizeof(struct spaceBitmapDesc) << 3); 138 do { 139 overflow = 0; 140 block_group = block >> (sb->s_blocksize_bits + 3); 141 bit = block % (sb->s_blocksize << 3); 142 143 /* 144 * Check to see if we are freeing blocks across a group boundary. 145 */ 146 if (bit + count > (sb->s_blocksize << 3)) { 147 overflow = bit + count - (sb->s_blocksize << 3); 148 count -= overflow; 149 } 150 bitmap_nr = load_block_bitmap(sb, bitmap, block_group); 151 if (bitmap_nr < 0) 152 goto error_return; 153 154 bh = bitmap->s_block_bitmap[bitmap_nr]; 155 for (i = 0; i < count; i++) { 156 if (udf_set_bit(bit + i, bh->b_data)) { 157 udf_debug("bit %lu already set\n", bit + i); 158 udf_debug("byte=%2x\n", 159 ((__u8 *)bh->b_data)[(bit + i) >> 3]); 160 } 161 } 162 udf_add_free_space(sb, sbi->s_partition, count); 163 mark_buffer_dirty(bh); 164 if (overflow) { 165 block += count; 166 count = overflow; 167 } 168 } while (overflow); 169 170 error_return: 171 mutex_unlock(&sbi->s_alloc_mutex); 172 } 173 174 static int udf_bitmap_prealloc_blocks(struct super_block *sb, 175 struct udf_bitmap *bitmap, 176 uint16_t partition, uint32_t first_block, 177 uint32_t block_count) 178 { 179 struct udf_sb_info *sbi = UDF_SB(sb); 180 int alloc_count = 0; 181 int bit, block, block_group; 182 int bitmap_nr; 183 struct buffer_head *bh; 184 __u32 part_len; 185 186 mutex_lock(&sbi->s_alloc_mutex); 187 part_len = sbi->s_partmaps[partition].s_partition_len; 188 if (first_block >= part_len) 189 goto out; 190 191 if (first_block + block_count > part_len) 192 block_count = part_len - first_block; 193 194 do { 195 block = first_block + (sizeof(struct spaceBitmapDesc) << 3); 196 block_group = block >> (sb->s_blocksize_bits + 3); 197 198 bitmap_nr = load_block_bitmap(sb, bitmap, block_group); 199 if (bitmap_nr < 0) 200 goto out; 201 bh = bitmap->s_block_bitmap[bitmap_nr]; 202 203 bit = block % (sb->s_blocksize << 3); 204 205 while (bit < (sb->s_blocksize << 3) && block_count > 0) { 206 if (!udf_clear_bit(bit, bh->b_data)) 207 goto out; 208 block_count--; 209 alloc_count++; 210 bit++; 211 block++; 212 } 213 mark_buffer_dirty(bh); 214 } while (block_count > 0); 215 216 out: 217 udf_add_free_space(sb, partition, -alloc_count); 218 mutex_unlock(&sbi->s_alloc_mutex); 219 return alloc_count; 220 } 221 222 static udf_pblk_t udf_bitmap_new_block(struct super_block *sb, 223 struct udf_bitmap *bitmap, uint16_t partition, 224 uint32_t goal, int *err) 225 { 226 struct udf_sb_info *sbi = UDF_SB(sb); 227 int newbit, bit = 0; 228 udf_pblk_t block; 229 int block_group, group_start; 230 int end_goal, nr_groups, bitmap_nr, i; 231 struct buffer_head *bh = NULL; 232 char *ptr; 233 udf_pblk_t newblock = 0; 234 235 *err = -ENOSPC; 236 mutex_lock(&sbi->s_alloc_mutex); 237 238 repeat: 239 if (goal >= sbi->s_partmaps[partition].s_partition_len) 240 goal = 0; 241 242 nr_groups = bitmap->s_nr_groups; 243 block = goal + (sizeof(struct spaceBitmapDesc) << 3); 244 block_group = block >> (sb->s_blocksize_bits + 3); 245 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc); 246 247 bitmap_nr = load_block_bitmap(sb, bitmap, block_group); 248 if (bitmap_nr < 0) 249 goto error_return; 250 bh = bitmap->s_block_bitmap[bitmap_nr]; 251 ptr = memscan((char *)bh->b_data + group_start, 0xFF, 252 sb->s_blocksize - group_start); 253 254 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) { 255 bit = block % (sb->s_blocksize << 3); 256 if (udf_test_bit(bit, bh->b_data)) 257 goto got_block; 258 259 end_goal = (bit + 63) & ~63; 260 bit = udf_find_next_one_bit(bh->b_data, end_goal, bit); 261 if (bit < end_goal) 262 goto got_block; 263 264 ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF, 265 sb->s_blocksize - ((bit + 7) >> 3)); 266 newbit = (ptr - ((char *)bh->b_data)) << 3; 267 if (newbit < sb->s_blocksize << 3) { 268 bit = newbit; 269 goto search_back; 270 } 271 272 newbit = udf_find_next_one_bit(bh->b_data, 273 sb->s_blocksize << 3, bit); 274 if (newbit < sb->s_blocksize << 3) { 275 bit = newbit; 276 goto got_block; 277 } 278 } 279 280 for (i = 0; i < (nr_groups * 2); i++) { 281 block_group++; 282 if (block_group >= nr_groups) 283 block_group = 0; 284 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc); 285 286 bitmap_nr = load_block_bitmap(sb, bitmap, block_group); 287 if (bitmap_nr < 0) 288 goto error_return; 289 bh = bitmap->s_block_bitmap[bitmap_nr]; 290 if (i < nr_groups) { 291 ptr = memscan((char *)bh->b_data + group_start, 0xFF, 292 sb->s_blocksize - group_start); 293 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) { 294 bit = (ptr - ((char *)bh->b_data)) << 3; 295 break; 296 } 297 } else { 298 bit = udf_find_next_one_bit(bh->b_data, 299 sb->s_blocksize << 3, 300 group_start << 3); 301 if (bit < sb->s_blocksize << 3) 302 break; 303 } 304 } 305 if (i >= (nr_groups * 2)) { 306 mutex_unlock(&sbi->s_alloc_mutex); 307 return newblock; 308 } 309 if (bit < sb->s_blocksize << 3) 310 goto search_back; 311 else 312 bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, 313 group_start << 3); 314 if (bit >= sb->s_blocksize << 3) { 315 mutex_unlock(&sbi->s_alloc_mutex); 316 return 0; 317 } 318 319 search_back: 320 i = 0; 321 while (i < 7 && bit > (group_start << 3) && 322 udf_test_bit(bit - 1, bh->b_data)) { 323 ++i; 324 --bit; 325 } 326 327 got_block: 328 newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) - 329 (sizeof(struct spaceBitmapDesc) << 3); 330 331 if (newblock >= sbi->s_partmaps[partition].s_partition_len) { 332 /* 333 * Ran off the end of the bitmap, and bits following are 334 * non-compliant (not all zero) 335 */ 336 udf_err(sb, "bitmap for partition %d corrupted (block %u marked" 337 " as free, partition length is %u)\n", partition, 338 newblock, sbi->s_partmaps[partition].s_partition_len); 339 goto error_return; 340 } 341 342 if (!udf_clear_bit(bit, bh->b_data)) { 343 udf_debug("bit already cleared for block %d\n", bit); 344 goto repeat; 345 } 346 347 mark_buffer_dirty(bh); 348 349 udf_add_free_space(sb, partition, -1); 350 mutex_unlock(&sbi->s_alloc_mutex); 351 *err = 0; 352 return newblock; 353 354 error_return: 355 *err = -EIO; 356 mutex_unlock(&sbi->s_alloc_mutex); 357 return 0; 358 } 359 360 static void udf_table_free_blocks(struct super_block *sb, 361 struct inode *table, 362 struct kernel_lb_addr *bloc, 363 uint32_t offset, 364 uint32_t count) 365 { 366 struct udf_sb_info *sbi = UDF_SB(sb); 367 uint32_t start, end; 368 uint32_t elen; 369 struct kernel_lb_addr eloc; 370 struct extent_position oepos, epos; 371 int8_t etype; 372 struct udf_inode_info *iinfo; 373 int ret = 0; 374 375 mutex_lock(&sbi->s_alloc_mutex); 376 iinfo = UDF_I(table); 377 udf_add_free_space(sb, sbi->s_partition, count); 378 379 start = bloc->logicalBlockNum + offset; 380 end = bloc->logicalBlockNum + offset + count - 1; 381 382 epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry); 383 elen = 0; 384 epos.block = oepos.block = iinfo->i_location; 385 epos.bh = oepos.bh = NULL; 386 387 while (count) { 388 ret = udf_next_aext(table, &epos, &eloc, &elen, &etype, 1); 389 if (ret < 0) 390 goto error_return; 391 if (ret == 0) 392 break; 393 if (((eloc.logicalBlockNum + 394 (elen >> sb->s_blocksize_bits)) == start)) { 395 if ((0x3FFFFFFF - elen) < 396 (count << sb->s_blocksize_bits)) { 397 uint32_t tmp = ((0x3FFFFFFF - elen) >> 398 sb->s_blocksize_bits); 399 count -= tmp; 400 start += tmp; 401 elen = (etype << 30) | 402 (0x40000000 - sb->s_blocksize); 403 } else { 404 elen = (etype << 30) | 405 (elen + 406 (count << sb->s_blocksize_bits)); 407 start += count; 408 count = 0; 409 } 410 udf_write_aext(table, &oepos, &eloc, elen, 1); 411 } else if (eloc.logicalBlockNum == (end + 1)) { 412 if ((0x3FFFFFFF - elen) < 413 (count << sb->s_blocksize_bits)) { 414 uint32_t tmp = ((0x3FFFFFFF - elen) >> 415 sb->s_blocksize_bits); 416 count -= tmp; 417 end -= tmp; 418 eloc.logicalBlockNum -= tmp; 419 elen = (etype << 30) | 420 (0x40000000 - sb->s_blocksize); 421 } else { 422 eloc.logicalBlockNum = start; 423 elen = (etype << 30) | 424 (elen + 425 (count << sb->s_blocksize_bits)); 426 end -= count; 427 count = 0; 428 } 429 udf_write_aext(table, &oepos, &eloc, elen, 1); 430 } 431 432 if (epos.bh != oepos.bh) { 433 oepos.block = epos.block; 434 brelse(oepos.bh); 435 get_bh(epos.bh); 436 oepos.bh = epos.bh; 437 oepos.offset = 0; 438 } else { 439 oepos.offset = epos.offset; 440 } 441 } 442 443 if (count) { 444 /* 445 * NOTE: we CANNOT use udf_add_aext here, as it can try to 446 * allocate a new block, and since we hold the super block 447 * lock already very bad things would happen :) 448 * 449 * We copy the behavior of udf_add_aext, but instead of 450 * trying to allocate a new block close to the existing one, 451 * we just steal a block from the extent we are trying to add. 452 * 453 * It would be nice if the blocks were close together, but it 454 * isn't required. 455 */ 456 457 int adsize; 458 459 eloc.logicalBlockNum = start; 460 elen = EXT_RECORDED_ALLOCATED | 461 (count << sb->s_blocksize_bits); 462 463 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 464 adsize = sizeof(struct short_ad); 465 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 466 adsize = sizeof(struct long_ad); 467 else 468 goto error_return; 469 470 if (epos.offset + (2 * adsize) > sb->s_blocksize) { 471 /* Steal a block from the extent being free'd */ 472 udf_setup_indirect_aext(table, eloc.logicalBlockNum, 473 &epos); 474 475 eloc.logicalBlockNum++; 476 elen -= sb->s_blocksize; 477 } 478 479 /* It's possible that stealing the block emptied the extent */ 480 if (elen) 481 __udf_add_aext(table, &epos, &eloc, elen, 1); 482 } 483 484 error_return: 485 brelse(epos.bh); 486 brelse(oepos.bh); 487 488 mutex_unlock(&sbi->s_alloc_mutex); 489 return; 490 } 491 492 static int udf_table_prealloc_blocks(struct super_block *sb, 493 struct inode *table, uint16_t partition, 494 uint32_t first_block, uint32_t block_count) 495 { 496 struct udf_sb_info *sbi = UDF_SB(sb); 497 int alloc_count = 0; 498 uint32_t elen, adsize; 499 struct kernel_lb_addr eloc; 500 struct extent_position epos; 501 int8_t etype = -1; 502 struct udf_inode_info *iinfo; 503 int ret = 0; 504 505 if (first_block >= sbi->s_partmaps[partition].s_partition_len) 506 return 0; 507 508 iinfo = UDF_I(table); 509 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 510 adsize = sizeof(struct short_ad); 511 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 512 adsize = sizeof(struct long_ad); 513 else 514 return 0; 515 516 mutex_lock(&sbi->s_alloc_mutex); 517 epos.offset = sizeof(struct unallocSpaceEntry); 518 epos.block = iinfo->i_location; 519 epos.bh = NULL; 520 eloc.logicalBlockNum = 0xFFFFFFFF; 521 522 while (first_block != eloc.logicalBlockNum) { 523 ret = udf_next_aext(table, &epos, &eloc, &elen, &etype, 1); 524 if (ret < 0) 525 goto err_out; 526 if (ret == 0) 527 break; 528 udf_debug("eloc=%u, elen=%u, first_block=%u\n", 529 eloc.logicalBlockNum, elen, first_block); 530 } 531 532 if (first_block == eloc.logicalBlockNum) { 533 epos.offset -= adsize; 534 535 alloc_count = (elen >> sb->s_blocksize_bits); 536 if (alloc_count > block_count) { 537 alloc_count = block_count; 538 eloc.logicalBlockNum += alloc_count; 539 elen -= (alloc_count << sb->s_blocksize_bits); 540 udf_write_aext(table, &epos, &eloc, 541 (etype << 30) | elen, 1); 542 } else 543 udf_delete_aext(table, epos); 544 } else { 545 alloc_count = 0; 546 } 547 548 err_out: 549 brelse(epos.bh); 550 551 if (alloc_count) 552 udf_add_free_space(sb, partition, -alloc_count); 553 mutex_unlock(&sbi->s_alloc_mutex); 554 return alloc_count; 555 } 556 557 static udf_pblk_t udf_table_new_block(struct super_block *sb, 558 struct inode *table, uint16_t partition, 559 uint32_t goal, int *err) 560 { 561 struct udf_sb_info *sbi = UDF_SB(sb); 562 uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF; 563 udf_pblk_t newblock = 0; 564 uint32_t adsize; 565 uint32_t elen, goal_elen = 0; 566 struct kernel_lb_addr eloc, goal_eloc; 567 struct extent_position epos, goal_epos; 568 int8_t etype; 569 struct udf_inode_info *iinfo = UDF_I(table); 570 int ret = 0; 571 572 *err = -ENOSPC; 573 574 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT) 575 adsize = sizeof(struct short_ad); 576 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG) 577 adsize = sizeof(struct long_ad); 578 else 579 return newblock; 580 581 mutex_lock(&sbi->s_alloc_mutex); 582 if (goal >= sbi->s_partmaps[partition].s_partition_len) 583 goal = 0; 584 585 /* We search for the closest matching block to goal. If we find 586 a exact hit, we stop. Otherwise we keep going till we run out 587 of extents. We store the buffer_head, bloc, and extoffset 588 of the current closest match and use that when we are done. 589 */ 590 epos.offset = sizeof(struct unallocSpaceEntry); 591 epos.block = iinfo->i_location; 592 epos.bh = goal_epos.bh = NULL; 593 594 while (spread) { 595 ret = udf_next_aext(table, &epos, &eloc, &elen, &etype, 1); 596 if (ret <= 0) 597 break; 598 if (goal >= eloc.logicalBlockNum) { 599 if (goal < eloc.logicalBlockNum + 600 (elen >> sb->s_blocksize_bits)) 601 nspread = 0; 602 else 603 nspread = goal - eloc.logicalBlockNum - 604 (elen >> sb->s_blocksize_bits); 605 } else { 606 nspread = eloc.logicalBlockNum - goal; 607 } 608 609 if (nspread < spread) { 610 spread = nspread; 611 if (goal_epos.bh != epos.bh) { 612 brelse(goal_epos.bh); 613 goal_epos.bh = epos.bh; 614 get_bh(goal_epos.bh); 615 } 616 goal_epos.block = epos.block; 617 goal_epos.offset = epos.offset - adsize; 618 goal_eloc = eloc; 619 goal_elen = (etype << 30) | elen; 620 } 621 } 622 623 brelse(epos.bh); 624 625 if (ret < 0 || spread == 0xFFFFFFFF) { 626 brelse(goal_epos.bh); 627 mutex_unlock(&sbi->s_alloc_mutex); 628 if (ret < 0) 629 *err = ret; 630 return 0; 631 } 632 633 /* Only allocate blocks from the beginning of the extent. 634 That way, we only delete (empty) extents, never have to insert an 635 extent because of splitting */ 636 /* This works, but very poorly.... */ 637 638 newblock = goal_eloc.logicalBlockNum; 639 goal_eloc.logicalBlockNum++; 640 goal_elen -= sb->s_blocksize; 641 642 if (goal_elen) 643 udf_write_aext(table, &goal_epos, &goal_eloc, goal_elen, 1); 644 else 645 udf_delete_aext(table, goal_epos); 646 brelse(goal_epos.bh); 647 648 udf_add_free_space(sb, partition, -1); 649 650 mutex_unlock(&sbi->s_alloc_mutex); 651 *err = 0; 652 return newblock; 653 } 654 655 void udf_free_blocks(struct super_block *sb, struct inode *inode, 656 struct kernel_lb_addr *bloc, uint32_t offset, 657 uint32_t count) 658 { 659 uint16_t partition = bloc->partitionReferenceNum; 660 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition]; 661 uint32_t blk; 662 663 if (check_add_overflow(bloc->logicalBlockNum, offset, &blk) || 664 check_add_overflow(blk, count, &blk) || 665 bloc->logicalBlockNum + count > map->s_partition_len) { 666 udf_debug("Invalid request to free blocks: (%d, %u), off %u, " 667 "len %u, partition len %u\n", 668 partition, bloc->logicalBlockNum, offset, count, 669 map->s_partition_len); 670 return; 671 } 672 673 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) { 674 udf_bitmap_free_blocks(sb, map->s_uspace.s_bitmap, 675 bloc, offset, count); 676 } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) { 677 udf_table_free_blocks(sb, map->s_uspace.s_table, 678 bloc, offset, count); 679 } 680 681 if (inode) { 682 inode_sub_bytes(inode, 683 ((sector_t)count) << sb->s_blocksize_bits); 684 } 685 } 686 687 inline int udf_prealloc_blocks(struct super_block *sb, 688 struct inode *inode, 689 uint16_t partition, uint32_t first_block, 690 uint32_t block_count) 691 { 692 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition]; 693 int allocated; 694 695 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) 696 allocated = udf_bitmap_prealloc_blocks(sb, 697 map->s_uspace.s_bitmap, 698 partition, first_block, 699 block_count); 700 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) 701 allocated = udf_table_prealloc_blocks(sb, 702 map->s_uspace.s_table, 703 partition, first_block, 704 block_count); 705 else 706 return 0; 707 708 if (inode && allocated > 0) 709 inode_add_bytes(inode, allocated << sb->s_blocksize_bits); 710 return allocated; 711 } 712 713 inline udf_pblk_t udf_new_block(struct super_block *sb, 714 struct inode *inode, 715 uint16_t partition, uint32_t goal, int *err) 716 { 717 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition]; 718 udf_pblk_t block; 719 720 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) 721 block = udf_bitmap_new_block(sb, 722 map->s_uspace.s_bitmap, 723 partition, goal, err); 724 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) 725 block = udf_table_new_block(sb, 726 map->s_uspace.s_table, 727 partition, goal, err); 728 else { 729 *err = -EIO; 730 return 0; 731 } 732 if (inode && block) 733 inode_add_bytes(inode, sb->s_blocksize); 734 return block; 735 } 736