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