?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Use dentry_path() to create full path to inode object
[pohmelfs.git] / fs / udf / balloc.c
blob987585bb0a1da594fef277e8b6e0374adaed6547
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/buffer_head.h>
25 #include <linux/bitops.h>
26
27 #include "udf_i.h"
28 #include "udf_sb.h"
29
30 #define udf_clear_bit __test_and_clear_bit_le
31 #define udf_set_bit __test_and_set_bit_le
32 #define udf_test_bit test_bit_le
33 #define udf_find_next_one_bit find_next_bit_le
34
35 static int read_block_bitmap(struct super_block *sb,
36 struct udf_bitmap *bitmap, unsigned int block,
37 unsigned long bitmap_nr)
38 {
39 struct buffer_head *bh = NULL;
40 int retval = 0;
41 struct kernel_lb_addr loc;
42
43 loc.logicalBlockNum = bitmap->s_extPosition;
44 loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
45
46 bh = udf_tread(sb, udf_get_lb_pblock(sb, &loc, block));
47 if (!bh)
48 retval = -EIO;
49
50 bitmap->s_block_bitmap[bitmap_nr] = bh;
51 return retval;
52 }
53
54 static int __load_block_bitmap(struct super_block *sb,
55 struct udf_bitmap *bitmap,
56 unsigned int block_group)
57 {
58 int retval = 0;
59 int nr_groups = bitmap->s_nr_groups;
60
61 if (block_group >= nr_groups) {
62 udf_debug("block_group (%d) > nr_groups (%d)\n",
63 block_group, nr_groups);
64 }
65
66 if (bitmap->s_block_bitmap[block_group]) {
67 return block_group;
68 } else {
69 retval = read_block_bitmap(sb, bitmap, block_group,
70 block_group);
71 if (retval < 0)
72 return retval;
73 return block_group;
74 }
75 }
76
77 static inline int load_block_bitmap(struct super_block *sb,
78 struct udf_bitmap *bitmap,
79 unsigned int block_group)
80 {
81 int slot;
82
83 slot = __load_block_bitmap(sb, bitmap, block_group);
84
85 if (slot < 0)
86 return slot;
87
88 if (!bitmap->s_block_bitmap[slot])
89 return -EIO;
90
91 return slot;
92 }
93
94 static void udf_add_free_space(struct super_block *sb, u16 partition, u32 cnt)
95 {
96 struct udf_sb_info *sbi = UDF_SB(sb);
97 struct logicalVolIntegrityDesc *lvid;
98
99 if (!sbi->s_lvid_bh)
100 return;
101
102 lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
103 le32_add_cpu(&lvid->freeSpaceTable[partition], cnt);
104 udf_updated_lvid(sb);
105 }
106
107 static void udf_bitmap_free_blocks(struct super_block *sb,
108 struct inode *inode,
109 struct udf_bitmap *bitmap,
110 struct kernel_lb_addr *bloc,
111 uint32_t offset,
112 uint32_t count)
113 {
114 struct udf_sb_info *sbi = UDF_SB(sb);
115 struct buffer_head *bh = NULL;
116 struct udf_part_map *partmap;
117 unsigned long block;
118 unsigned long block_group;
119 unsigned long bit;
120 unsigned long i;
121 int bitmap_nr;
122 unsigned long overflow;
123
124 mutex_lock(&sbi->s_alloc_mutex);
125 partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
126 if (bloc->logicalBlockNum + count < count ||
127 (bloc->logicalBlockNum + count) > partmap->s_partition_len) {
128 udf_debug("%d < %d || %d + %d > %d\n",
129 bloc->logicalBlockNum, 0,
130 bloc->logicalBlockNum, count,
131 partmap->s_partition_len);
132 goto error_return;
133 }
134
135 block = bloc->logicalBlockNum + offset +
136 (sizeof(struct spaceBitmapDesc) << 3);
137
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 %ld already set\n", bit + i);
158 udf_debug("byte=%2x\n",
159 ((char *)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 inode *inode,
176 struct udf_bitmap *bitmap,
177 uint16_t partition, uint32_t first_block,
178 uint32_t block_count)
179 {
180 struct udf_sb_info *sbi = UDF_SB(sb);
181 int alloc_count = 0;
182 int bit, block, block_group, group_start;
183 int nr_groups, bitmap_nr;
184 struct buffer_head *bh;
185 __u32 part_len;
186
187 mutex_lock(&sbi->s_alloc_mutex);
188 part_len = sbi->s_partmaps[partition].s_partition_len;
189 if (first_block >= part_len)
190 goto out;
191
192 if (first_block + block_count > part_len)
193 block_count = part_len - first_block;
194
195 do {
196 nr_groups = udf_compute_nr_groups(sb, partition);
197 block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
198 block_group = block >> (sb->s_blocksize_bits + 3);
199 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
200
201 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
202 if (bitmap_nr < 0)
203 goto out;
204 bh = bitmap->s_block_bitmap[bitmap_nr];
205
206 bit = block % (sb->s_blocksize << 3);
207
208 while (bit < (sb->s_blocksize << 3) && block_count > 0) {
209 if (!udf_clear_bit(bit, bh->b_data))
210 goto out;
211 block_count--;
212 alloc_count++;
213 bit++;
214 block++;
215 }
216 mark_buffer_dirty(bh);
217 } while (block_count > 0);
218
219 out:
220 udf_add_free_space(sb, partition, -alloc_count);
221 mutex_unlock(&sbi->s_alloc_mutex);
222 return alloc_count;
223 }
224
225 static int udf_bitmap_new_block(struct super_block *sb,
226 struct inode *inode,
227 struct udf_bitmap *bitmap, uint16_t partition,
228 uint32_t goal, int *err)
229 {
230 struct udf_sb_info *sbi = UDF_SB(sb);
231 int newbit, bit = 0, block, block_group, group_start;
232 int end_goal, nr_groups, bitmap_nr, i;
233 struct buffer_head *bh = NULL;
234 char *ptr;
235 int newblock = 0;
236
237 *err = -ENOSPC;
238 mutex_lock(&sbi->s_alloc_mutex);
239
240 repeat:
241 if (goal >= sbi->s_partmaps[partition].s_partition_len)
242 goal = 0;
243
244 nr_groups = bitmap->s_nr_groups;
245 block = goal + (sizeof(struct spaceBitmapDesc) << 3);
246 block_group = block >> (sb->s_blocksize_bits + 3);
247 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
248
249 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
250 if (bitmap_nr < 0)
251 goto error_return;
252 bh = bitmap->s_block_bitmap[bitmap_nr];
253 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
254 sb->s_blocksize - group_start);
255
256 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
257 bit = block % (sb->s_blocksize << 3);
258 if (udf_test_bit(bit, bh->b_data))
259 goto got_block;
260
261 end_goal = (bit + 63) & ~63;
262 bit = udf_find_next_one_bit(bh->b_data, end_goal, bit);
263 if (bit < end_goal)
264 goto got_block;
265
266 ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF,
267 sb->s_blocksize - ((bit + 7) >> 3));
268 newbit = (ptr - ((char *)bh->b_data)) << 3;
269 if (newbit < sb->s_blocksize << 3) {
270 bit = newbit;
271 goto search_back;
272 }
273
274 newbit = udf_find_next_one_bit(bh->b_data,
275 sb->s_blocksize << 3, bit);
276 if (newbit < sb->s_blocksize << 3) {
277 bit = newbit;
278 goto got_block;
279 }
280 }
281
282 for (i = 0; i < (nr_groups * 2); i++) {
283 block_group++;
284 if (block_group >= nr_groups)
285 block_group = 0;
286 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
287
288 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
289 if (bitmap_nr < 0)
290 goto error_return;
291 bh = bitmap->s_block_bitmap[bitmap_nr];
292 if (i < nr_groups) {
293 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
294 sb->s_blocksize - group_start);
295 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
296 bit = (ptr - ((char *)bh->b_data)) << 3;
297 break;
298 }
299 } else {
300 bit = udf_find_next_one_bit(bh->b_data,
301 sb->s_blocksize << 3,
302 group_start << 3);
303 if (bit < sb->s_blocksize << 3)
304 break;
305 }
306 }
307 if (i >= (nr_groups * 2)) {
308 mutex_unlock(&sbi->s_alloc_mutex);
309 return newblock;
310 }
311 if (bit < sb->s_blocksize << 3)
312 goto search_back;
313 else
314 bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
315 group_start << 3);
316 if (bit >= sb->s_blocksize << 3) {
317 mutex_unlock(&sbi->s_alloc_mutex);
318 return 0;
319 }
320
321 search_back:
322 i = 0;
323 while (i < 7 && bit > (group_start << 3) &&
324 udf_test_bit(bit - 1, bh->b_data)) {
325 ++i;
326 --bit;
327 }
328
329 got_block:
330 newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
331 (sizeof(struct spaceBitmapDesc) << 3);
332
333 if (!udf_clear_bit(bit, bh->b_data)) {
334 udf_debug("bit already cleared for block %d\n", bit);
335 goto repeat;
336 }
337
338 mark_buffer_dirty(bh);
339
340 udf_add_free_space(sb, partition, -1);
341 mutex_unlock(&sbi->s_alloc_mutex);
342 *err = 0;
343 return newblock;
344
345 error_return:
346 *err = -EIO;
347 mutex_unlock(&sbi->s_alloc_mutex);
348 return 0;
349 }
350
351 static void udf_table_free_blocks(struct super_block *sb,
352 struct inode *inode,
353 struct inode *table,
354 struct kernel_lb_addr *bloc,
355 uint32_t offset,
356 uint32_t count)
357 {
358 struct udf_sb_info *sbi = UDF_SB(sb);
359 struct udf_part_map *partmap;
360 uint32_t start, end;
361 uint32_t elen;
362 struct kernel_lb_addr eloc;
363 struct extent_position oepos, epos;
364 int8_t etype;
365 int i;
366 struct udf_inode_info *iinfo;
367
368 mutex_lock(&sbi->s_alloc_mutex);
369 partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
370 if (bloc->logicalBlockNum + count < count ||
371 (bloc->logicalBlockNum + count) > partmap->s_partition_len) {
372 udf_debug("%d < %d || %d + %d > %d\n",
373 bloc->logicalBlockNum, 0,
374 bloc->logicalBlockNum, count,
375 partmap->s_partition_len);
376 goto error_return;
377 }
378
379 iinfo = UDF_I(table);
380 udf_add_free_space(sb, sbi->s_partition, count);
381
382 start = bloc->logicalBlockNum + offset;
383 end = bloc->logicalBlockNum + offset + count - 1;
384
385 epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
386 elen = 0;
387 epos.block = oepos.block = iinfo->i_location;
388 epos.bh = oepos.bh = NULL;
389
390 while (count &&
391 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
392 if (((eloc.logicalBlockNum +
393 (elen >> sb->s_blocksize_bits)) == start)) {
394 if ((0x3FFFFFFF - elen) <
395 (count << sb->s_blocksize_bits)) {
396 uint32_t tmp = ((0x3FFFFFFF - elen) >>
397 sb->s_blocksize_bits);
398 count -= tmp;
399 start += tmp;
400 elen = (etype << 30) |
401 (0x40000000 - sb->s_blocksize);
402 } else {
403 elen = (etype << 30) |
404 (elen +
405 (count << sb->s_blocksize_bits));
406 start += count;
407 count = 0;
408 }
409 udf_write_aext(table, &oepos, &eloc, elen, 1);
410 } else if (eloc.logicalBlockNum == (end + 1)) {
411 if ((0x3FFFFFFF - elen) <
412 (count << sb->s_blocksize_bits)) {
413 uint32_t tmp = ((0x3FFFFFFF - elen) >>
414 sb->s_blocksize_bits);
415 count -= tmp;
416 end -= tmp;
417 eloc.logicalBlockNum -= tmp;
418 elen = (etype << 30) |
419 (0x40000000 - sb->s_blocksize);
420 } else {
421 eloc.logicalBlockNum = start;
422 elen = (etype << 30) |
423 (elen +
424 (count << sb->s_blocksize_bits));
425 end -= count;
426 count = 0;
427 }
428 udf_write_aext(table, &oepos, &eloc, elen, 1);
429 }
430
431 if (epos.bh != oepos.bh) {
432 i = -1;
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 struct short_ad *sad = NULL;
459 struct long_ad *lad = NULL;
460 struct allocExtDesc *aed;
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 unsigned char *sptr, *dptr;
478 int loffset;
479
480 brelse(oepos.bh);
481 oepos = epos;
482
483 /* Steal a block from the extent being free'd */
484 epos.block.logicalBlockNum = eloc.logicalBlockNum;
485 eloc.logicalBlockNum++;
486 elen -= sb->s_blocksize;
487
488 epos.bh = udf_tread(sb,
489 udf_get_lb_pblock(sb, &epos.block, 0));
490 if (!epos.bh) {
491 brelse(oepos.bh);
492 goto error_return;
493 }
494 aed = (struct allocExtDesc *)(epos.bh->b_data);
495 aed->previousAllocExtLocation =
496 cpu_to_le32(oepos.block.logicalBlockNum);
497 if (epos.offset + adsize > sb->s_blocksize) {
498 loffset = epos.offset;
499 aed->lengthAllocDescs = cpu_to_le32(adsize);
500 sptr = iinfo->i_ext.i_data + epos.offset
501 - adsize;
502 dptr = epos.bh->b_data +
503 sizeof(struct allocExtDesc);
504 memcpy(dptr, sptr, adsize);
505 epos.offset = sizeof(struct allocExtDesc) +
506 adsize;
507 } else {
508 loffset = epos.offset + adsize;
509 aed->lengthAllocDescs = cpu_to_le32(0);
510 if (oepos.bh) {
511 sptr = oepos.bh->b_data + epos.offset;
512 aed = (struct allocExtDesc *)
513 oepos.bh->b_data;
514 le32_add_cpu(&aed->lengthAllocDescs,
515 adsize);
516 } else {
517 sptr = iinfo->i_ext.i_data +
518 epos.offset;
519 iinfo->i_lenAlloc += adsize;
520 mark_inode_dirty(table);
521 }
522 epos.offset = sizeof(struct allocExtDesc);
523 }
524 if (sbi->s_udfrev >= 0x0200)
525 udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
526 3, 1, epos.block.logicalBlockNum,
527 sizeof(struct tag));
528 else
529 udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
530 2, 1, epos.block.logicalBlockNum,
531 sizeof(struct tag));
532
533 switch (iinfo->i_alloc_type) {
534 case ICBTAG_FLAG_AD_SHORT:
535 sad = (struct short_ad *)sptr;
536 sad->extLength = cpu_to_le32(
537 EXT_NEXT_EXTENT_ALLOCDECS |
538 sb->s_blocksize);
539 sad->extPosition =
540 cpu_to_le32(epos.block.logicalBlockNum);
541 break;
542 case ICBTAG_FLAG_AD_LONG:
543 lad = (struct long_ad *)sptr;
544 lad->extLength = cpu_to_le32(
545 EXT_NEXT_EXTENT_ALLOCDECS |
546 sb->s_blocksize);
547 lad->extLocation =
548 cpu_to_lelb(epos.block);
549 break;
550 }
551 if (oepos.bh) {
552 udf_update_tag(oepos.bh->b_data, loffset);
553 mark_buffer_dirty(oepos.bh);
554 } else {
555 mark_inode_dirty(table);
556 }
557 }
558
559 /* It's possible that stealing the block emptied the extent */
560 if (elen) {
561 udf_write_aext(table, &epos, &eloc, elen, 1);
562
563 if (!epos.bh) {
564 iinfo->i_lenAlloc += adsize;
565 mark_inode_dirty(table);
566 } else {
567 aed = (struct allocExtDesc *)epos.bh->b_data;
568 le32_add_cpu(&aed->lengthAllocDescs, adsize);
569 udf_update_tag(epos.bh->b_data, epos.offset);
570 mark_buffer_dirty(epos.bh);
571 }
572 }
573 }
574
575 brelse(epos.bh);
576 brelse(oepos.bh);
577
578 error_return:
579 mutex_unlock(&sbi->s_alloc_mutex);
580 return;
581 }
582
583 static int udf_table_prealloc_blocks(struct super_block *sb,
584 struct inode *inode,
585 struct inode *table, uint16_t partition,
586 uint32_t first_block, uint32_t block_count)
587 {
588 struct udf_sb_info *sbi = UDF_SB(sb);
589 int alloc_count = 0;
590 uint32_t elen, adsize;
591 struct kernel_lb_addr eloc;
592 struct extent_position epos;
593 int8_t etype = -1;
594 struct udf_inode_info *iinfo;
595
596 if (first_block >= sbi->s_partmaps[partition].s_partition_len)
597 return 0;
598
599 iinfo = UDF_I(table);
600 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
601 adsize = sizeof(struct short_ad);
602 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
603 adsize = sizeof(struct long_ad);
604 else
605 return 0;
606
607 mutex_lock(&sbi->s_alloc_mutex);
608 epos.offset = sizeof(struct unallocSpaceEntry);
609 epos.block = iinfo->i_location;
610 epos.bh = NULL;
611 eloc.logicalBlockNum = 0xFFFFFFFF;
612
613 while (first_block != eloc.logicalBlockNum &&
614 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
615 udf_debug("eloc=%d, elen=%d, first_block=%d\n",
616 eloc.logicalBlockNum, elen, first_block);
617 ; /* empty loop body */
618 }
619
620 if (first_block == eloc.logicalBlockNum) {
621 epos.offset -= adsize;
622
623 alloc_count = (elen >> sb->s_blocksize_bits);
624 if (alloc_count > block_count) {
625 alloc_count = block_count;
626 eloc.logicalBlockNum += alloc_count;
627 elen -= (alloc_count << sb->s_blocksize_bits);
628 udf_write_aext(table, &epos, &eloc,
629 (etype << 30) | elen, 1);
630 } else
631 udf_delete_aext(table, epos, eloc,
632 (etype << 30) | elen);
633 } else {
634 alloc_count = 0;
635 }
636
637 brelse(epos.bh);
638
639 if (alloc_count)
640 udf_add_free_space(sb, partition, -alloc_count);
641 mutex_unlock(&sbi->s_alloc_mutex);
642 return alloc_count;
643 }
644
645 static int udf_table_new_block(struct super_block *sb,
646 struct inode *inode,
647 struct inode *table, uint16_t partition,
648 uint32_t goal, int *err)
649 {
650 struct udf_sb_info *sbi = UDF_SB(sb);
651 uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
652 uint32_t newblock = 0, adsize;
653 uint32_t elen, goal_elen = 0;
654 struct kernel_lb_addr eloc, uninitialized_var(goal_eloc);
655 struct extent_position epos, goal_epos;
656 int8_t etype;
657 struct udf_inode_info *iinfo = UDF_I(table);
658
659 *err = -ENOSPC;
660
661 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
662 adsize = sizeof(struct short_ad);
663 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
664 adsize = sizeof(struct long_ad);
665 else
666 return newblock;
667
668 mutex_lock(&sbi->s_alloc_mutex);
669 if (goal >= sbi->s_partmaps[partition].s_partition_len)
670 goal = 0;
671
672 /* We search for the closest matching block to goal. If we find
673 a exact hit, we stop. Otherwise we keep going till we run out
674 of extents. We store the buffer_head, bloc, and extoffset
675 of the current closest match and use that when we are done.
676 */
677 epos.offset = sizeof(struct unallocSpaceEntry);
678 epos.block = iinfo->i_location;
679 epos.bh = goal_epos.bh = NULL;
680
681 while (spread &&
682 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
683 if (goal >= eloc.logicalBlockNum) {
684 if (goal < eloc.logicalBlockNum +
685 (elen >> sb->s_blocksize_bits))
686 nspread = 0;
687 else
688 nspread = goal - eloc.logicalBlockNum -
689 (elen >> sb->s_blocksize_bits);
690 } else {
691 nspread = eloc.logicalBlockNum - goal;
692 }
693
694 if (nspread < spread) {
695 spread = nspread;
696 if (goal_epos.bh != epos.bh) {
697 brelse(goal_epos.bh);
698 goal_epos.bh = epos.bh;
699 get_bh(goal_epos.bh);
700 }
701 goal_epos.block = epos.block;
702 goal_epos.offset = epos.offset - adsize;
703 goal_eloc = eloc;
704 goal_elen = (etype << 30) | elen;
705 }
706 }
707
708 brelse(epos.bh);
709
710 if (spread == 0xFFFFFFFF) {
711 brelse(goal_epos.bh);
712 mutex_unlock(&sbi->s_alloc_mutex);
713 return 0;
714 }
715
716 /* Only allocate blocks from the beginning of the extent.
717 That way, we only delete (empty) extents, never have to insert an
718 extent because of splitting */
719 /* This works, but very poorly.... */
720
721 newblock = goal_eloc.logicalBlockNum;
722 goal_eloc.logicalBlockNum++;
723 goal_elen -= sb->s_blocksize;
724
725 if (goal_elen)
726 udf_write_aext(table, &goal_epos, &goal_eloc, goal_elen, 1);
727 else
728 udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
729 brelse(goal_epos.bh);
730
731 udf_add_free_space(sb, partition, -1);
732
733 mutex_unlock(&sbi->s_alloc_mutex);
734 *err = 0;
735 return newblock;
736 }
737
738 void udf_free_blocks(struct super_block *sb, struct inode *inode,
739 struct kernel_lb_addr *bloc, uint32_t offset,
740 uint32_t count)
741 {
742 uint16_t partition = bloc->partitionReferenceNum;
743 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
744
745 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
746 udf_bitmap_free_blocks(sb, inode, map->s_uspace.s_bitmap,
747 bloc, offset, count);
748 } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
749 udf_table_free_blocks(sb, inode, map->s_uspace.s_table,
750 bloc, offset, count);
751 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
752 udf_bitmap_free_blocks(sb, inode, map->s_fspace.s_bitmap,
753 bloc, offset, count);
754 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
755 udf_table_free_blocks(sb, inode, map->s_fspace.s_table,
756 bloc, offset, count);
757 }
758 }
759
760 inline int udf_prealloc_blocks(struct super_block *sb,
761 struct inode *inode,
762 uint16_t partition, uint32_t first_block,
763 uint32_t block_count)
764 {
765 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
766
767 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
768 return udf_bitmap_prealloc_blocks(sb, inode,
769 map->s_uspace.s_bitmap,
770 partition, first_block,
771 block_count);
772 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
773 return udf_table_prealloc_blocks(sb, inode,
774 map->s_uspace.s_table,
775 partition, first_block,
776 block_count);
777 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
778 return udf_bitmap_prealloc_blocks(sb, inode,
779 map->s_fspace.s_bitmap,
780 partition, first_block,
781 block_count);
782 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
783 return udf_table_prealloc_blocks(sb, inode,
784 map->s_fspace.s_table,
785 partition, first_block,
786 block_count);
787 else
788 return 0;
789 }
790
791 inline int udf_new_block(struct super_block *sb,
792 struct inode *inode,
793 uint16_t partition, uint32_t goal, int *err)
794 {
795 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
796
797 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
798 return udf_bitmap_new_block(sb, inode,
799 map->s_uspace.s_bitmap,
800 partition, goal, err);
801 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
802 return udf_table_new_block(sb, inode,
803 map->s_uspace.s_table,
804 partition, goal, err);
805 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
806 return udf_bitmap_new_block(sb, inode,
807 map->s_fspace.s_bitmap,
808 partition, goal, err);
809 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
810 return udf_table_new_block(sb, inode,
811 map->s_fspace.s_table,
812 partition, goal, err);
813 else {
814 *err = -EIO;
815 return 0;
816 }
817 }