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
 34static 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
 53static 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
 75static 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
 92static 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
105static 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
167error_return:
168	mutex_unlock(&sbi->s_alloc_mutex);
169}
170
171static 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
213out:
214	udf_add_free_space(sb, partition, -alloc_count);
215	mutex_unlock(&sbi->s_alloc_mutex);
216	return alloc_count;
217}
218
219static 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
235repeat:
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
316search_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
324got_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
351error_return:
352	*err = -EIO;
353	mutex_unlock(&sbi->s_alloc_mutex);
354	return 0;
355}
356
357static 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
493error_return:
494	mutex_unlock(&sbi->s_alloc_mutex);
495	return;
496}
497
498static 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
558static 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, 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
651void 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
672inline 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
698inline 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}