?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nfsd4: typo logical vs bitwise negate for want_mask
[linux-btrfs-devel.git] / fs / udf / balloc.c
blob95518a9f589e395fac2adb4d6bb46d335b977e11
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", block_group,
63 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, bloc->logicalBlockNum,
130 count, partmap->s_partition_len);
131 goto error_return;
132 }
133
134 block = bloc->logicalBlockNum + offset +
135 (sizeof(struct spaceBitmapDesc) << 3);
136
137 do {
138 overflow = 0;
139 block_group = block >> (sb->s_blocksize_bits + 3);
140 bit = block % (sb->s_blocksize << 3);
141
142 /*
143 * Check to see if we are freeing blocks across a group boundary.
144 */
145 if (bit + count > (sb->s_blocksize << 3)) {
146 overflow = bit + count - (sb->s_blocksize << 3);
147 count -= overflow;
148 }
149 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
150 if (bitmap_nr < 0)
151 goto error_return;
152
153 bh = bitmap->s_block_bitmap[bitmap_nr];
154 for (i = 0; i < count; i++) {
155 if (udf_set_bit(bit + i, bh->b_data)) {
156 udf_debug("bit %ld already set\n", bit + i);
157 udf_debug("byte=%2x\n",
158 ((char *)bh->b_data)[(bit + i) >> 3]);
159 }
160 }
161 udf_add_free_space(sb, sbi->s_partition, count);
162 mark_buffer_dirty(bh);
163 if (overflow) {
164 block += count;
165 count = overflow;
166 }
167 } while (overflow);
168
169 error_return:
170 mutex_unlock(&sbi->s_alloc_mutex);
171 }
172
173 static int udf_bitmap_prealloc_blocks(struct super_block *sb,
174 struct inode *inode,
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, group_start;
182 int nr_groups, 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 nr_groups = udf_compute_nr_groups(sb, partition);
196 block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
197 block_group = block >> (sb->s_blocksize_bits + 3);
198 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
199
200 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
201 if (bitmap_nr < 0)
202 goto out;
203 bh = bitmap->s_block_bitmap[bitmap_nr];
204
205 bit = block % (sb->s_blocksize << 3);
206
207 while (bit < (sb->s_blocksize << 3) && block_count > 0) {
208 if (!udf_clear_bit(bit, bh->b_data))
209 goto out;
210 block_count--;
211 alloc_count++;
212 bit++;
213 block++;
214 }
215 mark_buffer_dirty(bh);
216 } while (block_count > 0);
217
218 out:
219 udf_add_free_space(sb, partition, -alloc_count);
220 mutex_unlock(&sbi->s_alloc_mutex);
221 return alloc_count;
222 }
223
224 static int udf_bitmap_new_block(struct super_block *sb,
225 struct inode *inode,
226 struct udf_bitmap *bitmap, uint16_t partition,
227 uint32_t goal, int *err)
228 {
229 struct udf_sb_info *sbi = UDF_SB(sb);
230 int newbit, bit = 0, block, block_group, group_start;
231 int end_goal, nr_groups, bitmap_nr, i;
232 struct buffer_head *bh = NULL;
233 char *ptr;
234 int newblock = 0;
235
236 *err = -ENOSPC;
237 mutex_lock(&sbi->s_alloc_mutex);
238
239 repeat:
240 if (goal >= sbi->s_partmaps[partition].s_partition_len)
241 goal = 0;
242
243 nr_groups = bitmap->s_nr_groups;
244 block = goal + (sizeof(struct spaceBitmapDesc) << 3);
245 block_group = block >> (sb->s_blocksize_bits + 3);
246 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
247
248 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
249 if (bitmap_nr < 0)
250 goto error_return;
251 bh = bitmap->s_block_bitmap[bitmap_nr];
252 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
253 sb->s_blocksize - group_start);
254
255 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
256 bit = block % (sb->s_blocksize << 3);
257 if (udf_test_bit(bit, bh->b_data))
258 goto got_block;
259
260 end_goal = (bit + 63) & ~63;
261 bit = udf_find_next_one_bit(bh->b_data, end_goal, bit);
262 if (bit < end_goal)
263 goto got_block;
264
265 ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF,
266 sb->s_blocksize - ((bit + 7) >> 3));
267 newbit = (ptr - ((char *)bh->b_data)) << 3;
268 if (newbit < sb->s_blocksize << 3) {
269 bit = newbit;
270 goto search_back;
271 }
272
273 newbit = udf_find_next_one_bit(bh->b_data,
274 sb->s_blocksize << 3, bit);
275 if (newbit < sb->s_blocksize << 3) {
276 bit = newbit;
277 goto got_block;
278 }
279 }
280
281 for (i = 0; i < (nr_groups * 2); i++) {
282 block_group++;
283 if (block_group >= nr_groups)
284 block_group = 0;
285 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
286
287 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
288 if (bitmap_nr < 0)
289 goto error_return;
290 bh = bitmap->s_block_bitmap[bitmap_nr];
291 if (i < nr_groups) {
292 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
293 sb->s_blocksize - group_start);
294 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
295 bit = (ptr - ((char *)bh->b_data)) << 3;
296 break;
297 }
298 } else {
299 bit = udf_find_next_one_bit(bh->b_data,
300 sb->s_blocksize << 3,
301 group_start << 3);
302 if (bit < sb->s_blocksize << 3)
303 break;
304 }
305 }
306 if (i >= (nr_groups * 2)) {
307 mutex_unlock(&sbi->s_alloc_mutex);
308 return newblock;
309 }
310 if (bit < sb->s_blocksize << 3)
311 goto search_back;
312 else
313 bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
314 group_start << 3);
315 if (bit >= sb->s_blocksize << 3) {
316 mutex_unlock(&sbi->s_alloc_mutex);
317 return 0;
318 }
319
320 search_back:
321 i = 0;
322 while (i < 7 && bit > (group_start << 3) &&
323 udf_test_bit(bit - 1, bh->b_data)) {
324 ++i;
325 --bit;
326 }
327
328 got_block:
329 newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
330 (sizeof(struct spaceBitmapDesc) << 3);
331
332 if (!udf_clear_bit(bit, bh->b_data)) {
333 udf_debug("bit already cleared for block %d\n", bit);
334 goto repeat;
335 }
336
337 mark_buffer_dirty(bh);
338
339 udf_add_free_space(sb, partition, -1);
340 mutex_unlock(&sbi->s_alloc_mutex);
341 *err = 0;
342 return newblock;
343
344 error_return:
345 *err = -EIO;
346 mutex_unlock(&sbi->s_alloc_mutex);
347 return 0;
348 }
349
350 static void udf_table_free_blocks(struct super_block *sb,
351 struct inode *inode,
352 struct inode *table,
353 struct kernel_lb_addr *bloc,
354 uint32_t offset,
355 uint32_t count)
356 {
357 struct udf_sb_info *sbi = UDF_SB(sb);
358 struct udf_part_map *partmap;
359 uint32_t start, end;
360 uint32_t elen;
361 struct kernel_lb_addr eloc;
362 struct extent_position oepos, epos;
363 int8_t etype;
364 int i;
365 struct udf_inode_info *iinfo;
366
367 mutex_lock(&sbi->s_alloc_mutex);
368 partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
369 if (bloc->logicalBlockNum + count < count ||
370 (bloc->logicalBlockNum + count) > partmap->s_partition_len) {
371 udf_debug("%d < %d || %d + %d > %d\n",
372 bloc->logicalBlockNum, 0, bloc->logicalBlockNum, count,
373 partmap->s_partition_len);
374 goto error_return;
375 }
376
377 iinfo = UDF_I(table);
378 udf_add_free_space(sb, sbi->s_partition, count);
379
380 start = bloc->logicalBlockNum + offset;
381 end = bloc->logicalBlockNum + offset + count - 1;
382
383 epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
384 elen = 0;
385 epos.block = oepos.block = iinfo->i_location;
386 epos.bh = oepos.bh = NULL;
387
388 while (count &&
389 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
390 if (((eloc.logicalBlockNum +
391 (elen >> sb->s_blocksize_bits)) == start)) {
392 if ((0x3FFFFFFF - elen) <
393 (count << sb->s_blocksize_bits)) {
394 uint32_t tmp = ((0x3FFFFFFF - elen) >>
395 sb->s_blocksize_bits);
396 count -= tmp;
397 start += tmp;
398 elen = (etype << 30) |
399 (0x40000000 - sb->s_blocksize);
400 } else {
401 elen = (etype << 30) |
402 (elen +
403 (count << sb->s_blocksize_bits));
404 start += count;
405 count = 0;
406 }
407 udf_write_aext(table, &oepos, &eloc, elen, 1);
408 } else if (eloc.logicalBlockNum == (end + 1)) {
409 if ((0x3FFFFFFF - elen) <
410 (count << sb->s_blocksize_bits)) {
411 uint32_t tmp = ((0x3FFFFFFF - elen) >>
412 sb->s_blocksize_bits);
413 count -= tmp;
414 end -= tmp;
415 eloc.logicalBlockNum -= tmp;
416 elen = (etype << 30) |
417 (0x40000000 - sb->s_blocksize);
418 } else {
419 eloc.logicalBlockNum = start;
420 elen = (etype << 30) |
421 (elen +
422 (count << sb->s_blocksize_bits));
423 end -= count;
424 count = 0;
425 }
426 udf_write_aext(table, &oepos, &eloc, elen, 1);
427 }
428
429 if (epos.bh != oepos.bh) {
430 i = -1;
431 oepos.block = epos.block;
432 brelse(oepos.bh);
433 get_bh(epos.bh);
434 oepos.bh = epos.bh;
435 oepos.offset = 0;
436 } else {
437 oepos.offset = epos.offset;
438 }
439 }
440
441 if (count) {
442 /*
443 * NOTE: we CANNOT use udf_add_aext here, as it can try to
444 * allocate a new block, and since we hold the super block
445 * lock already very bad things would happen :)
446 *
447 * We copy the behavior of udf_add_aext, but instead of
448 * trying to allocate a new block close to the existing one,
449 * we just steal a block from the extent we are trying to add.
450 *
451 * It would be nice if the blocks were close together, but it
452 * isn't required.
453 */
454
455 int adsize;
456 struct short_ad *sad = NULL;
457 struct long_ad *lad = NULL;
458 struct allocExtDesc *aed;
459
460 eloc.logicalBlockNum = start;
461 elen = EXT_RECORDED_ALLOCATED |
462 (count << sb->s_blocksize_bits);
463
464 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
465 adsize = sizeof(struct short_ad);
466 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
467 adsize = sizeof(struct long_ad);
468 else {
469 brelse(oepos.bh);
470 brelse(epos.bh);
471 goto error_return;
472 }
473
474 if (epos.offset + (2 * adsize) > sb->s_blocksize) {
475 unsigned char *sptr, *dptr;
476 int loffset;
477
478 brelse(oepos.bh);
479 oepos = epos;
480
481 /* Steal a block from the extent being free'd */
482 epos.block.logicalBlockNum = eloc.logicalBlockNum;
483 eloc.logicalBlockNum++;
484 elen -= sb->s_blocksize;
485
486 epos.bh = udf_tread(sb,
487 udf_get_lb_pblock(sb, &epos.block, 0));
488 if (!epos.bh) {
489 brelse(oepos.bh);
490 goto error_return;
491 }
492 aed = (struct allocExtDesc *)(epos.bh->b_data);
493 aed->previousAllocExtLocation =
494 cpu_to_le32(oepos.block.logicalBlockNum);
495 if (epos.offset + adsize > sb->s_blocksize) {
496 loffset = epos.offset;
497 aed->lengthAllocDescs = cpu_to_le32(adsize);
498 sptr = iinfo->i_ext.i_data + epos.offset
499 - adsize;
500 dptr = epos.bh->b_data +
501 sizeof(struct allocExtDesc);
502 memcpy(dptr, sptr, adsize);
503 epos.offset = sizeof(struct allocExtDesc) +
504 adsize;
505 } else {
506 loffset = epos.offset + adsize;
507 aed->lengthAllocDescs = cpu_to_le32(0);
508 if (oepos.bh) {
509 sptr = oepos.bh->b_data + epos.offset;
510 aed = (struct allocExtDesc *)
511 oepos.bh->b_data;
512 le32_add_cpu(&aed->lengthAllocDescs,
513 adsize);
514 } else {
515 sptr = iinfo->i_ext.i_data +
516 epos.offset;
517 iinfo->i_lenAlloc += adsize;
518 mark_inode_dirty(table);
519 }
520 epos.offset = sizeof(struct allocExtDesc);
521 }
522 if (sbi->s_udfrev >= 0x0200)
523 udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
524 3, 1, epos.block.logicalBlockNum,
525 sizeof(struct tag));
526 else
527 udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
528 2, 1, epos.block.logicalBlockNum,
529 sizeof(struct tag));
530
531 switch (iinfo->i_alloc_type) {
532 case ICBTAG_FLAG_AD_SHORT:
533 sad = (struct short_ad *)sptr;
534 sad->extLength = cpu_to_le32(
535 EXT_NEXT_EXTENT_ALLOCDECS |
536 sb->s_blocksize);
537 sad->extPosition =
538 cpu_to_le32(epos.block.logicalBlockNum);
539 break;
540 case ICBTAG_FLAG_AD_LONG:
541 lad = (struct long_ad *)sptr;
542 lad->extLength = cpu_to_le32(
543 EXT_NEXT_EXTENT_ALLOCDECS |
544 sb->s_blocksize);
545 lad->extLocation =
546 cpu_to_lelb(epos.block);
547 break;
548 }
549 if (oepos.bh) {
550 udf_update_tag(oepos.bh->b_data, loffset);
551 mark_buffer_dirty(oepos.bh);
552 } else {
553 mark_inode_dirty(table);
554 }
555 }
556
557 /* It's possible that stealing the block emptied the extent */
558 if (elen) {
559 udf_write_aext(table, &epos, &eloc, elen, 1);
560
561 if (!epos.bh) {
562 iinfo->i_lenAlloc += adsize;
563 mark_inode_dirty(table);
564 } else {
565 aed = (struct allocExtDesc *)epos.bh->b_data;
566 le32_add_cpu(&aed->lengthAllocDescs, adsize);
567 udf_update_tag(epos.bh->b_data, epos.offset);
568 mark_buffer_dirty(epos.bh);
569 }
570 }
571 }
572
573 brelse(epos.bh);
574 brelse(oepos.bh);
575
576 error_return:
577 mutex_unlock(&sbi->s_alloc_mutex);
578 return;
579 }
580
581 static int udf_table_prealloc_blocks(struct super_block *sb,
582 struct inode *inode,
583 struct inode *table, uint16_t partition,
584 uint32_t first_block, uint32_t block_count)
585 {
586 struct udf_sb_info *sbi = UDF_SB(sb);
587 int alloc_count = 0;
588 uint32_t elen, adsize;
589 struct kernel_lb_addr eloc;
590 struct extent_position epos;
591 int8_t etype = -1;
592 struct udf_inode_info *iinfo;
593
594 if (first_block >= sbi->s_partmaps[partition].s_partition_len)
595 return 0;
596
597 iinfo = UDF_I(table);
598 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
599 adsize = sizeof(struct short_ad);
600 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
601 adsize = sizeof(struct long_ad);
602 else
603 return 0;
604
605 mutex_lock(&sbi->s_alloc_mutex);
606 epos.offset = sizeof(struct unallocSpaceEntry);
607 epos.block = iinfo->i_location;
608 epos.bh = NULL;
609 eloc.logicalBlockNum = 0xFFFFFFFF;
610
611 while (first_block != eloc.logicalBlockNum &&
612 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
613 udf_debug("eloc=%d, elen=%d, first_block=%d\n",
614 eloc.logicalBlockNum, elen, first_block);
615 ; /* empty loop body */
616 }
617
618 if (first_block == eloc.logicalBlockNum) {
619 epos.offset -= adsize;
620
621 alloc_count = (elen >> sb->s_blocksize_bits);
622 if (alloc_count > block_count) {
623 alloc_count = block_count;
624 eloc.logicalBlockNum += alloc_count;
625 elen -= (alloc_count << sb->s_blocksize_bits);
626 udf_write_aext(table, &epos, &eloc,
627 (etype << 30) | elen, 1);
628 } else
629 udf_delete_aext(table, epos, eloc,
630 (etype << 30) | elen);
631 } else {
632 alloc_count = 0;
633 }
634
635 brelse(epos.bh);
636
637 if (alloc_count)
638 udf_add_free_space(sb, partition, -alloc_count);
639 mutex_unlock(&sbi->s_alloc_mutex);
640 return alloc_count;
641 }
642
643 static int udf_table_new_block(struct super_block *sb,
644 struct inode *inode,
645 struct inode *table, uint16_t partition,
646 uint32_t goal, int *err)
647 {
648 struct udf_sb_info *sbi = UDF_SB(sb);
649 uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
650 uint32_t newblock = 0, adsize;
651 uint32_t elen, goal_elen = 0;
652 struct kernel_lb_addr eloc, uninitialized_var(goal_eloc);
653 struct extent_position epos, goal_epos;
654 int8_t etype;
655 struct udf_inode_info *iinfo = UDF_I(table);
656
657 *err = -ENOSPC;
658
659 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
660 adsize = sizeof(struct short_ad);
661 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
662 adsize = sizeof(struct long_ad);
663 else
664 return newblock;
665
666 mutex_lock(&sbi->s_alloc_mutex);
667 if (goal >= sbi->s_partmaps[partition].s_partition_len)
668 goal = 0;
669
670 /* We search for the closest matching block to goal. If we find
671 a exact hit, we stop. Otherwise we keep going till we run out
672 of extents. We store the buffer_head, bloc, and extoffset
673 of the current closest match and use that when we are done.
674 */
675 epos.offset = sizeof(struct unallocSpaceEntry);
676 epos.block = iinfo->i_location;
677 epos.bh = goal_epos.bh = NULL;
678
679 while (spread &&
680 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
681 if (goal >= eloc.logicalBlockNum) {
682 if (goal < eloc.logicalBlockNum +
683 (elen >> sb->s_blocksize_bits))
684 nspread = 0;
685 else
686 nspread = goal - eloc.logicalBlockNum -
687 (elen >> sb->s_blocksize_bits);
688 } else {
689 nspread = eloc.logicalBlockNum - goal;
690 }
691
692 if (nspread < spread) {
693 spread = nspread;
694 if (goal_epos.bh != epos.bh) {
695 brelse(goal_epos.bh);
696 goal_epos.bh = epos.bh;
697 get_bh(goal_epos.bh);
698 }
699 goal_epos.block = epos.block;
700 goal_epos.offset = epos.offset - adsize;
701 goal_eloc = eloc;
702 goal_elen = (etype << 30) | elen;
703 }
704 }
705
706 brelse(epos.bh);
707
708 if (spread == 0xFFFFFFFF) {
709 brelse(goal_epos.bh);
710 mutex_unlock(&sbi->s_alloc_mutex);
711 return 0;
712 }
713
714 /* Only allocate blocks from the beginning of the extent.
715 That way, we only delete (empty) extents, never have to insert an
716 extent because of splitting */
717 /* This works, but very poorly.... */
718
719 newblock = goal_eloc.logicalBlockNum;
720 goal_eloc.logicalBlockNum++;
721 goal_elen -= sb->s_blocksize;
722
723 if (goal_elen)
724 udf_write_aext(table, &goal_epos, &goal_eloc, goal_elen, 1);
725 else
726 udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
727 brelse(goal_epos.bh);
728
729 udf_add_free_space(sb, partition, -1);
730
731 mutex_unlock(&sbi->s_alloc_mutex);
732 *err = 0;
733 return newblock;
734 }
735
736 void udf_free_blocks(struct super_block *sb, struct inode *inode,
737 struct kernel_lb_addr *bloc, uint32_t offset,
738 uint32_t count)
739 {
740 uint16_t partition = bloc->partitionReferenceNum;
741 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
742
743 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
744 udf_bitmap_free_blocks(sb, inode, map->s_uspace.s_bitmap,
745 bloc, offset, count);
746 } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
747 udf_table_free_blocks(sb, inode, map->s_uspace.s_table,
748 bloc, offset, count);
749 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
750 udf_bitmap_free_blocks(sb, inode, map->s_fspace.s_bitmap,
751 bloc, offset, count);
752 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
753 udf_table_free_blocks(sb, inode, map->s_fspace.s_table,
754 bloc, offset, count);
755 }
756 }
757
758 inline int udf_prealloc_blocks(struct super_block *sb,
759 struct inode *inode,
760 uint16_t partition, uint32_t first_block,
761 uint32_t block_count)
762 {
763 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
764
765 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
766 return udf_bitmap_prealloc_blocks(sb, inode,
767 map->s_uspace.s_bitmap,
768 partition, first_block,
769 block_count);
770 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
771 return udf_table_prealloc_blocks(sb, inode,
772 map->s_uspace.s_table,
773 partition, first_block,
774 block_count);
775 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
776 return udf_bitmap_prealloc_blocks(sb, inode,
777 map->s_fspace.s_bitmap,
778 partition, first_block,
779 block_count);
780 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
781 return udf_table_prealloc_blocks(sb, inode,
782 map->s_fspace.s_table,
783 partition, first_block,
784 block_count);
785 else
786 return 0;
787 }
788
789 inline int udf_new_block(struct super_block *sb,
790 struct inode *inode,
791 uint16_t partition, uint32_t goal, int *err)
792 {
793 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
794
795 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
796 return udf_bitmap_new_block(sb, inode,
797 map->s_uspace.s_bitmap,
798 partition, goal, err);
799 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
800 return udf_table_new_block(sb, inode,
801 map->s_uspace.s_table,
802 partition, goal, err);
803 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
804 return udf_bitmap_new_block(sb, inode,
805 map->s_fspace.s_bitmap,
806 partition, goal, err);
807 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
808 return udf_table_new_block(sb, inode,
809 map->s_fspace.s_table,
810 partition, goal, err);
811 else {
812 *err = -EIO;
813 return 0;
814 }
815 }
Linux Btrfs Development