xref: /linux/fs/udf/balloc.c (revision f4db95b68ae68ebaf91d35cc0487ac1cbd04261e)
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