?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
IRQ: Change __softirq_pending to unsigned int in asm-generic/hardirq.h.
[linux/fpc-iii.git] / fs / udf / balloc.c
blob1e068535b58bfc78b0970dc3ccb34e03cc7c1ecb
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/quotaops.h>
25 #include <linux/buffer_head.h>
26 #include <linux/bitops.h>
27
28 #include "udf_i.h"
29 #include "udf_sb.h"
30
31 #define udf_clear_bit(nr, addr) ext2_clear_bit(nr, addr)
32 #define udf_set_bit(nr, addr) ext2_set_bit(nr, addr)
33 #define udf_test_bit(nr, addr) ext2_test_bit(nr, addr)
34 #define udf_find_first_one_bit(addr, size) find_first_one_bit(addr, size)
35 #define udf_find_next_one_bit(addr, size, offset) \
36 find_next_one_bit(addr, size, offset)
37
38 #define leBPL_to_cpup(x) leNUM_to_cpup(BITS_PER_LONG, x)
39 #define leNUM_to_cpup(x, y) xleNUM_to_cpup(x, y)
40 #define xleNUM_to_cpup(x, y) (le ## x ## _to_cpup(y))
41 #define uintBPL_t uint(BITS_PER_LONG)
42 #define uint(x) xuint(x)
43 #define xuint(x) __le ## x
44
45 static inline int find_next_one_bit(void *addr, int size, int offset)
46 {
47 uintBPL_t *p = ((uintBPL_t *) addr) + (offset / BITS_PER_LONG);
48 int result = offset & ~(BITS_PER_LONG - 1);
49 unsigned long tmp;
50
51 if (offset >= size)
52 return size;
53 size -= result;
54 offset &= (BITS_PER_LONG - 1);
55 if (offset) {
56 tmp = leBPL_to_cpup(p++);
57 tmp &= ~0UL << offset;
58 if (size < BITS_PER_LONG)
59 goto found_first;
60 if (tmp)
61 goto found_middle;
62 size -= BITS_PER_LONG;
63 result += BITS_PER_LONG;
64 }
65 while (size & ~(BITS_PER_LONG - 1)) {
66 tmp = leBPL_to_cpup(p++);
67 if (tmp)
68 goto found_middle;
69 result += BITS_PER_LONG;
70 size -= BITS_PER_LONG;
71 }
72 if (!size)
73 return result;
74 tmp = leBPL_to_cpup(p);
75 found_first:
76 tmp &= ~0UL >> (BITS_PER_LONG - size);
77 found_middle:
78 return result + ffz(~tmp);
79 }
80
81 #define find_first_one_bit(addr, size)\
82 find_next_one_bit((addr), (size), 0)
83
84 static int read_block_bitmap(struct super_block *sb,
85 struct udf_bitmap *bitmap, unsigned int block,
86 unsigned long bitmap_nr)
87 {
88 struct buffer_head *bh = NULL;
89 int retval = 0;
90 struct kernel_lb_addr loc;
91
92 loc.logicalBlockNum = bitmap->s_extPosition;
93 loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
94
95 bh = udf_tread(sb, udf_get_lb_pblock(sb, &loc, block));
96 if (!bh)
97 retval = -EIO;
98
99 bitmap->s_block_bitmap[bitmap_nr] = bh;
100 return retval;
101 }
102
103 static int __load_block_bitmap(struct super_block *sb,
104 struct udf_bitmap *bitmap,
105 unsigned int block_group)
106 {
107 int retval = 0;
108 int nr_groups = bitmap->s_nr_groups;
109
110 if (block_group >= nr_groups) {
111 udf_debug("block_group (%d) > nr_groups (%d)\n", block_group,
112 nr_groups);
113 }
114
115 if (bitmap->s_block_bitmap[block_group]) {
116 return block_group;
117 } else {
118 retval = read_block_bitmap(sb, bitmap, block_group,
119 block_group);
120 if (retval < 0)
121 return retval;
122 return block_group;
123 }
124 }
125
126 static inline int load_block_bitmap(struct super_block *sb,
127 struct udf_bitmap *bitmap,
128 unsigned int block_group)
129 {
130 int slot;
131
132 slot = __load_block_bitmap(sb, bitmap, block_group);
133
134 if (slot < 0)
135 return slot;
136
137 if (!bitmap->s_block_bitmap[slot])
138 return -EIO;
139
140 return slot;
141 }
142
143 static void udf_add_free_space(struct super_block *sb, u16 partition, u32 cnt)
144 {
145 struct udf_sb_info *sbi = UDF_SB(sb);
146 struct logicalVolIntegrityDesc *lvid;
147
148 if (!sbi->s_lvid_bh)
149 return;
150
151 lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
152 le32_add_cpu(&lvid->freeSpaceTable[partition], cnt);
153 udf_updated_lvid(sb);
154 }
155
156 static void udf_bitmap_free_blocks(struct super_block *sb,
157 struct inode *inode,
158 struct udf_bitmap *bitmap,
159 struct kernel_lb_addr *bloc,
160 uint32_t offset,
161 uint32_t count)
162 {
163 struct udf_sb_info *sbi = UDF_SB(sb);
164 struct buffer_head *bh = NULL;
165 struct udf_part_map *partmap;
166 unsigned long block;
167 unsigned long block_group;
168 unsigned long bit;
169 unsigned long i;
170 int bitmap_nr;
171 unsigned long overflow;
172
173 mutex_lock(&sbi->s_alloc_mutex);
174 partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
175 if (bloc->logicalBlockNum < 0 ||
176 (bloc->logicalBlockNum + count) >
177 partmap->s_partition_len) {
178 udf_debug("%d < %d || %d + %d > %d\n",
179 bloc->logicalBlockNum, 0, bloc->logicalBlockNum,
180 count, partmap->s_partition_len);
181 goto error_return;
182 }
183
184 block = bloc->logicalBlockNum + offset +
185 (sizeof(struct spaceBitmapDesc) << 3);
186
187 do {
188 overflow = 0;
189 block_group = block >> (sb->s_blocksize_bits + 3);
190 bit = block % (sb->s_blocksize << 3);
191
192 /*
193 * Check to see if we are freeing blocks across a group boundary.
194 */
195 if (bit + count > (sb->s_blocksize << 3)) {
196 overflow = bit + count - (sb->s_blocksize << 3);
197 count -= overflow;
198 }
199 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
200 if (bitmap_nr < 0)
201 goto error_return;
202
203 bh = bitmap->s_block_bitmap[bitmap_nr];
204 for (i = 0; i < count; i++) {
205 if (udf_set_bit(bit + i, bh->b_data)) {
206 udf_debug("bit %ld already set\n", bit + i);
207 udf_debug("byte=%2x\n",
208 ((char *)bh->b_data)[(bit + i) >> 3]);
209 } else {
210 if (inode)
211 vfs_dq_free_block(inode, 1);
212 udf_add_free_space(sb, sbi->s_partition, 1);
213 }
214 }
215 mark_buffer_dirty(bh);
216 if (overflow) {
217 block += count;
218 count = overflow;
219 }
220 } while (overflow);
221
222 error_return:
223 mutex_unlock(&sbi->s_alloc_mutex);
224 }
225
226 static int udf_bitmap_prealloc_blocks(struct super_block *sb,
227 struct inode *inode,
228 struct udf_bitmap *bitmap,
229 uint16_t partition, uint32_t first_block,
230 uint32_t block_count)
231 {
232 struct udf_sb_info *sbi = UDF_SB(sb);
233 int alloc_count = 0;
234 int bit, block, block_group, group_start;
235 int nr_groups, bitmap_nr;
236 struct buffer_head *bh;
237 __u32 part_len;
238
239 mutex_lock(&sbi->s_alloc_mutex);
240 part_len = sbi->s_partmaps[partition].s_partition_len;
241 if (first_block >= part_len)
242 goto out;
243
244 if (first_block + block_count > part_len)
245 block_count = part_len - first_block;
246
247 do {
248 nr_groups = udf_compute_nr_groups(sb, partition);
249 block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
250 block_group = block >> (sb->s_blocksize_bits + 3);
251 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
252
253 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
254 if (bitmap_nr < 0)
255 goto out;
256 bh = bitmap->s_block_bitmap[bitmap_nr];
257
258 bit = block % (sb->s_blocksize << 3);
259
260 while (bit < (sb->s_blocksize << 3) && block_count > 0) {
261 if (!udf_test_bit(bit, bh->b_data))
262 goto out;
263 else if (vfs_dq_prealloc_block(inode, 1))
264 goto out;
265 else if (!udf_clear_bit(bit, bh->b_data)) {
266 udf_debug("bit already cleared for block %d\n", bit);
267 vfs_dq_free_block(inode, 1);
268 goto out;
269 }
270 block_count--;
271 alloc_count++;
272 bit++;
273 block++;
274 }
275 mark_buffer_dirty(bh);
276 } while (block_count > 0);
277
278 out:
279 udf_add_free_space(sb, partition, -alloc_count);
280 mutex_unlock(&sbi->s_alloc_mutex);
281 return alloc_count;
282 }
283
284 static int udf_bitmap_new_block(struct super_block *sb,
285 struct inode *inode,
286 struct udf_bitmap *bitmap, uint16_t partition,
287 uint32_t goal, int *err)
288 {
289 struct udf_sb_info *sbi = UDF_SB(sb);
290 int newbit, bit = 0, block, block_group, group_start;
291 int end_goal, nr_groups, bitmap_nr, i;
292 struct buffer_head *bh = NULL;
293 char *ptr;
294 int newblock = 0;
295
296 *err = -ENOSPC;
297 mutex_lock(&sbi->s_alloc_mutex);
298
299 repeat:
300 if (goal >= sbi->s_partmaps[partition].s_partition_len)
301 goal = 0;
302
303 nr_groups = bitmap->s_nr_groups;
304 block = goal + (sizeof(struct spaceBitmapDesc) << 3);
305 block_group = block >> (sb->s_blocksize_bits + 3);
306 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
307
308 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
309 if (bitmap_nr < 0)
310 goto error_return;
311 bh = bitmap->s_block_bitmap[bitmap_nr];
312 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
313 sb->s_blocksize - group_start);
314
315 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
316 bit = block % (sb->s_blocksize << 3);
317 if (udf_test_bit(bit, bh->b_data))
318 goto got_block;
319
320 end_goal = (bit + 63) & ~63;
321 bit = udf_find_next_one_bit(bh->b_data, end_goal, bit);
322 if (bit < end_goal)
323 goto got_block;
324
325 ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF,
326 sb->s_blocksize - ((bit + 7) >> 3));
327 newbit = (ptr - ((char *)bh->b_data)) << 3;
328 if (newbit < sb->s_blocksize << 3) {
329 bit = newbit;
330 goto search_back;
331 }
332
333 newbit = udf_find_next_one_bit(bh->b_data,
334 sb->s_blocksize << 3, bit);
335 if (newbit < sb->s_blocksize << 3) {
336 bit = newbit;
337 goto got_block;
338 }
339 }
340
341 for (i = 0; i < (nr_groups * 2); i++) {
342 block_group++;
343 if (block_group >= nr_groups)
344 block_group = 0;
345 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
346
347 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
348 if (bitmap_nr < 0)
349 goto error_return;
350 bh = bitmap->s_block_bitmap[bitmap_nr];
351 if (i < nr_groups) {
352 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
353 sb->s_blocksize - group_start);
354 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
355 bit = (ptr - ((char *)bh->b_data)) << 3;
356 break;
357 }
358 } else {
359 bit = udf_find_next_one_bit((char *)bh->b_data,
360 sb->s_blocksize << 3,
361 group_start << 3);
362 if (bit < sb->s_blocksize << 3)
363 break;
364 }
365 }
366 if (i >= (nr_groups * 2)) {
367 mutex_unlock(&sbi->s_alloc_mutex);
368 return newblock;
369 }
370 if (bit < sb->s_blocksize << 3)
371 goto search_back;
372 else
373 bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
374 group_start << 3);
375 if (bit >= sb->s_blocksize << 3) {
376 mutex_unlock(&sbi->s_alloc_mutex);
377 return 0;
378 }
379
380 search_back:
381 i = 0;
382 while (i < 7 && bit > (group_start << 3) &&
383 udf_test_bit(bit - 1, bh->b_data)) {
384 ++i;
385 --bit;
386 }
387
388 got_block:
389
390 /*
391 * Check quota for allocation of this block.
392 */
393 if (inode && vfs_dq_alloc_block(inode, 1)) {
394 mutex_unlock(&sbi->s_alloc_mutex);
395 *err = -EDQUOT;
396 return 0;
397 }
398
399 newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
400 (sizeof(struct spaceBitmapDesc) << 3);
401
402 if (!udf_clear_bit(bit, bh->b_data)) {
403 udf_debug("bit already cleared for block %d\n", bit);
404 goto repeat;
405 }
406
407 mark_buffer_dirty(bh);
408
409 udf_add_free_space(sb, partition, -1);
410 mutex_unlock(&sbi->s_alloc_mutex);
411 *err = 0;
412 return newblock;
413
414 error_return:
415 *err = -EIO;
416 mutex_unlock(&sbi->s_alloc_mutex);
417 return 0;
418 }
419
420 static void udf_table_free_blocks(struct super_block *sb,
421 struct inode *inode,
422 struct inode *table,
423 struct kernel_lb_addr *bloc,
424 uint32_t offset,
425 uint32_t count)
426 {
427 struct udf_sb_info *sbi = UDF_SB(sb);
428 struct udf_part_map *partmap;
429 uint32_t start, end;
430 uint32_t elen;
431 struct kernel_lb_addr eloc;
432 struct extent_position oepos, epos;
433 int8_t etype;
434 int i;
435 struct udf_inode_info *iinfo;
436
437 mutex_lock(&sbi->s_alloc_mutex);
438 partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
439 if (bloc->logicalBlockNum < 0 ||
440 (bloc->logicalBlockNum + count) >
441 partmap->s_partition_len) {
442 udf_debug("%d < %d || %d + %d > %d\n",
443 bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
444 partmap->s_partition_len);
445 goto error_return;
446 }
447
448 iinfo = UDF_I(table);
449 /* We do this up front - There are some error conditions that
450 could occure, but.. oh well */
451 if (inode)
452 vfs_dq_free_block(inode, count);
453 udf_add_free_space(sb, sbi->s_partition, count);
454
455 start = bloc->logicalBlockNum + offset;
456 end = bloc->logicalBlockNum + offset + count - 1;
457
458 epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
459 elen = 0;
460 epos.block = oepos.block = iinfo->i_location;
461 epos.bh = oepos.bh = NULL;
462
463 while (count &&
464 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
465 if (((eloc.logicalBlockNum +
466 (elen >> sb->s_blocksize_bits)) == start)) {
467 if ((0x3FFFFFFF - elen) <
468 (count << sb->s_blocksize_bits)) {
469 uint32_t tmp = ((0x3FFFFFFF - elen) >>
470 sb->s_blocksize_bits);
471 count -= tmp;
472 start += tmp;
473 elen = (etype << 30) |
474 (0x40000000 - sb->s_blocksize);
475 } else {
476 elen = (etype << 30) |
477 (elen +
478 (count << sb->s_blocksize_bits));
479 start += count;
480 count = 0;
481 }
482 udf_write_aext(table, &oepos, &eloc, elen, 1);
483 } else if (eloc.logicalBlockNum == (end + 1)) {
484 if ((0x3FFFFFFF - elen) <
485 (count << sb->s_blocksize_bits)) {
486 uint32_t tmp = ((0x3FFFFFFF - elen) >>
487 sb->s_blocksize_bits);
488 count -= tmp;
489 end -= tmp;
490 eloc.logicalBlockNum -= tmp;
491 elen = (etype << 30) |
492 (0x40000000 - sb->s_blocksize);
493 } else {
494 eloc.logicalBlockNum = start;
495 elen = (etype << 30) |
496 (elen +
497 (count << sb->s_blocksize_bits));
498 end -= count;
499 count = 0;
500 }
501 udf_write_aext(table, &oepos, &eloc, elen, 1);
502 }
503
504 if (epos.bh != oepos.bh) {
505 i = -1;
506 oepos.block = epos.block;
507 brelse(oepos.bh);
508 get_bh(epos.bh);
509 oepos.bh = epos.bh;
510 oepos.offset = 0;
511 } else {
512 oepos.offset = epos.offset;
513 }
514 }
515
516 if (count) {
517 /*
518 * NOTE: we CANNOT use udf_add_aext here, as it can try to
519 * allocate a new block, and since we hold the super block
520 * lock already very bad things would happen :)
521 *
522 * We copy the behavior of udf_add_aext, but instead of
523 * trying to allocate a new block close to the existing one,
524 * we just steal a block from the extent we are trying to add.
525 *
526 * It would be nice if the blocks were close together, but it
527 * isn't required.
528 */
529
530 int adsize;
531 struct short_ad *sad = NULL;
532 struct long_ad *lad = NULL;
533 struct allocExtDesc *aed;
534
535 eloc.logicalBlockNum = start;
536 elen = EXT_RECORDED_ALLOCATED |
537 (count << sb->s_blocksize_bits);
538
539 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
540 adsize = sizeof(struct short_ad);
541 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
542 adsize = sizeof(struct long_ad);
543 else {
544 brelse(oepos.bh);
545 brelse(epos.bh);
546 goto error_return;
547 }
548
549 if (epos.offset + (2 * adsize) > sb->s_blocksize) {
550 char *sptr, *dptr;
551 int loffset;
552
553 brelse(oepos.bh);
554 oepos = epos;
555
556 /* Steal a block from the extent being free'd */
557 epos.block.logicalBlockNum = eloc.logicalBlockNum;
558 eloc.logicalBlockNum++;
559 elen -= sb->s_blocksize;
560
561 epos.bh = udf_tread(sb,
562 udf_get_lb_pblock(sb, &epos.block, 0));
563 if (!epos.bh) {
564 brelse(oepos.bh);
565 goto error_return;
566 }
567 aed = (struct allocExtDesc *)(epos.bh->b_data);
568 aed->previousAllocExtLocation =
569 cpu_to_le32(oepos.block.logicalBlockNum);
570 if (epos.offset + adsize > sb->s_blocksize) {
571 loffset = epos.offset;
572 aed->lengthAllocDescs = cpu_to_le32(adsize);
573 sptr = iinfo->i_ext.i_data + epos.offset
574 - adsize;
575 dptr = epos.bh->b_data +
576 sizeof(struct allocExtDesc);
577 memcpy(dptr, sptr, adsize);
578 epos.offset = sizeof(struct allocExtDesc) +
579 adsize;
580 } else {
581 loffset = epos.offset + adsize;
582 aed->lengthAllocDescs = cpu_to_le32(0);
583 if (oepos.bh) {
584 sptr = oepos.bh->b_data + epos.offset;
585 aed = (struct allocExtDesc *)
586 oepos.bh->b_data;
587 le32_add_cpu(&aed->lengthAllocDescs,
588 adsize);
589 } else {
590 sptr = iinfo->i_ext.i_data +
591 epos.offset;
592 iinfo->i_lenAlloc += adsize;
593 mark_inode_dirty(table);
594 }
595 epos.offset = sizeof(struct allocExtDesc);
596 }
597 if (sbi->s_udfrev >= 0x0200)
598 udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
599 3, 1, epos.block.logicalBlockNum,
600 sizeof(struct tag));
601 else
602 udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
603 2, 1, epos.block.logicalBlockNum,
604 sizeof(struct tag));
605
606 switch (iinfo->i_alloc_type) {
607 case ICBTAG_FLAG_AD_SHORT:
608 sad = (struct short_ad *)sptr;
609 sad->extLength = cpu_to_le32(
610 EXT_NEXT_EXTENT_ALLOCDECS |
611 sb->s_blocksize);
612 sad->extPosition =
613 cpu_to_le32(epos.block.logicalBlockNum);
614 break;
615 case ICBTAG_FLAG_AD_LONG:
616 lad = (struct long_ad *)sptr;
617 lad->extLength = cpu_to_le32(
618 EXT_NEXT_EXTENT_ALLOCDECS |
619 sb->s_blocksize);
620 lad->extLocation =
621 cpu_to_lelb(epos.block);
622 break;
623 }
624 if (oepos.bh) {
625 udf_update_tag(oepos.bh->b_data, loffset);
626 mark_buffer_dirty(oepos.bh);
627 } else {
628 mark_inode_dirty(table);
629 }
630 }
631
632 /* It's possible that stealing the block emptied the extent */
633 if (elen) {
634 udf_write_aext(table, &epos, &eloc, elen, 1);
635
636 if (!epos.bh) {
637 iinfo->i_lenAlloc += adsize;
638 mark_inode_dirty(table);
639 } else {
640 aed = (struct allocExtDesc *)epos.bh->b_data;
641 le32_add_cpu(&aed->lengthAllocDescs, adsize);
642 udf_update_tag(epos.bh->b_data, epos.offset);
643 mark_buffer_dirty(epos.bh);
644 }
645 }
646 }
647
648 brelse(epos.bh);
649 brelse(oepos.bh);
650
651 error_return:
652 mutex_unlock(&sbi->s_alloc_mutex);
653 return;
654 }
655
656 static int udf_table_prealloc_blocks(struct super_block *sb,
657 struct inode *inode,
658 struct inode *table, uint16_t partition,
659 uint32_t first_block, uint32_t block_count)
660 {
661 struct udf_sb_info *sbi = UDF_SB(sb);
662 int alloc_count = 0;
663 uint32_t elen, adsize;
664 struct kernel_lb_addr eloc;
665 struct extent_position epos;
666 int8_t etype = -1;
667 struct udf_inode_info *iinfo;
668
669 if (first_block >= sbi->s_partmaps[partition].s_partition_len)
670 return 0;
671
672 iinfo = UDF_I(table);
673 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
674 adsize = sizeof(struct short_ad);
675 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
676 adsize = sizeof(struct long_ad);
677 else
678 return 0;
679
680 mutex_lock(&sbi->s_alloc_mutex);
681 epos.offset = sizeof(struct unallocSpaceEntry);
682 epos.block = iinfo->i_location;
683 epos.bh = NULL;
684 eloc.logicalBlockNum = 0xFFFFFFFF;
685
686 while (first_block != eloc.logicalBlockNum &&
687 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
688 udf_debug("eloc=%d, elen=%d, first_block=%d\n",
689 eloc.logicalBlockNum, elen, first_block);
690 ; /* empty loop body */
691 }
692
693 if (first_block == eloc.logicalBlockNum) {
694 epos.offset -= adsize;
695
696 alloc_count = (elen >> sb->s_blocksize_bits);
697 if (inode && vfs_dq_prealloc_block(inode,
698 alloc_count > block_count ? block_count : alloc_count))
699 alloc_count = 0;
700 else if (alloc_count > block_count) {
701 alloc_count = block_count;
702 eloc.logicalBlockNum += alloc_count;
703 elen -= (alloc_count << sb->s_blocksize_bits);
704 udf_write_aext(table, &epos, &eloc,
705 (etype << 30) | elen, 1);
706 } else
707 udf_delete_aext(table, epos, eloc,
708 (etype << 30) | elen);
709 } else {
710 alloc_count = 0;
711 }
712
713 brelse(epos.bh);
714
715 if (alloc_count)
716 udf_add_free_space(sb, partition, -alloc_count);
717 mutex_unlock(&sbi->s_alloc_mutex);
718 return alloc_count;
719 }
720
721 static int udf_table_new_block(struct super_block *sb,
722 struct inode *inode,
723 struct inode *table, uint16_t partition,
724 uint32_t goal, int *err)
725 {
726 struct udf_sb_info *sbi = UDF_SB(sb);
727 uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
728 uint32_t newblock = 0, adsize;
729 uint32_t elen, goal_elen = 0;
730 struct kernel_lb_addr eloc, uninitialized_var(goal_eloc);
731 struct extent_position epos, goal_epos;
732 int8_t etype;
733 struct udf_inode_info *iinfo = UDF_I(table);
734
735 *err = -ENOSPC;
736
737 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
738 adsize = sizeof(struct short_ad);
739 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
740 adsize = sizeof(struct long_ad);
741 else
742 return newblock;
743
744 mutex_lock(&sbi->s_alloc_mutex);
745 if (goal >= sbi->s_partmaps[partition].s_partition_len)
746 goal = 0;
747
748 /* We search for the closest matching block to goal. If we find
749 a exact hit, we stop. Otherwise we keep going till we run out
750 of extents. We store the buffer_head, bloc, and extoffset
751 of the current closest match and use that when we are done.
752 */
753 epos.offset = sizeof(struct unallocSpaceEntry);
754 epos.block = iinfo->i_location;
755 epos.bh = goal_epos.bh = NULL;
756
757 while (spread &&
758 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
759 if (goal >= eloc.logicalBlockNum) {
760 if (goal < eloc.logicalBlockNum +
761 (elen >> sb->s_blocksize_bits))
762 nspread = 0;
763 else
764 nspread = goal - eloc.logicalBlockNum -
765 (elen >> sb->s_blocksize_bits);
766 } else {
767 nspread = eloc.logicalBlockNum - goal;
768 }
769
770 if (nspread < spread) {
771 spread = nspread;
772 if (goal_epos.bh != epos.bh) {
773 brelse(goal_epos.bh);
774 goal_epos.bh = epos.bh;
775 get_bh(goal_epos.bh);
776 }
777 goal_epos.block = epos.block;
778 goal_epos.offset = epos.offset - adsize;
779 goal_eloc = eloc;
780 goal_elen = (etype << 30) | elen;
781 }
782 }
783
784 brelse(epos.bh);
785
786 if (spread == 0xFFFFFFFF) {
787 brelse(goal_epos.bh);
788 mutex_unlock(&sbi->s_alloc_mutex);
789 return 0;
790 }
791
792 /* Only allocate blocks from the beginning of the extent.
793 That way, we only delete (empty) extents, never have to insert an
794 extent because of splitting */
795 /* This works, but very poorly.... */
796
797 newblock = goal_eloc.logicalBlockNum;
798 goal_eloc.logicalBlockNum++;
799 goal_elen -= sb->s_blocksize;
800
801 if (inode && vfs_dq_alloc_block(inode, 1)) {
802 brelse(goal_epos.bh);
803 mutex_unlock(&sbi->s_alloc_mutex);
804 *err = -EDQUOT;
805 return 0;
806 }
807
808 if (goal_elen)
809 udf_write_aext(table, &goal_epos, &goal_eloc, goal_elen, 1);
810 else
811 udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
812 brelse(goal_epos.bh);
813
814 udf_add_free_space(sb, partition, -1);
815
816 mutex_unlock(&sbi->s_alloc_mutex);
817 *err = 0;
818 return newblock;
819 }
820
821 void udf_free_blocks(struct super_block *sb, struct inode *inode,
822 struct kernel_lb_addr *bloc, uint32_t offset,
823 uint32_t count)
824 {
825 uint16_t partition = bloc->partitionReferenceNum;
826 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
827
828 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
829 udf_bitmap_free_blocks(sb, inode, map->s_uspace.s_bitmap,
830 bloc, offset, count);
831 } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
832 udf_table_free_blocks(sb, inode, map->s_uspace.s_table,
833 bloc, offset, count);
834 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
835 udf_bitmap_free_blocks(sb, inode, map->s_fspace.s_bitmap,
836 bloc, offset, count);
837 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
838 udf_table_free_blocks(sb, inode, map->s_fspace.s_table,
839 bloc, offset, count);
840 }
841 }
842
843 inline int udf_prealloc_blocks(struct super_block *sb,
844 struct inode *inode,
845 uint16_t partition, uint32_t first_block,
846 uint32_t block_count)
847 {
848 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
849
850 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
851 return udf_bitmap_prealloc_blocks(sb, inode,
852 map->s_uspace.s_bitmap,
853 partition, first_block,
854 block_count);
855 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
856 return udf_table_prealloc_blocks(sb, inode,
857 map->s_uspace.s_table,
858 partition, first_block,
859 block_count);
860 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
861 return udf_bitmap_prealloc_blocks(sb, inode,
862 map->s_fspace.s_bitmap,
863 partition, first_block,
864 block_count);
865 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
866 return udf_table_prealloc_blocks(sb, inode,
867 map->s_fspace.s_table,
868 partition, first_block,
869 block_count);
870 else
871 return 0;
872 }
873
874 inline int udf_new_block(struct super_block *sb,
875 struct inode *inode,
876 uint16_t partition, uint32_t goal, int *err)
877 {
878 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
879
880 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
881 return udf_bitmap_new_block(sb, inode,
882 map->s_uspace.s_bitmap,
883 partition, goal, err);
884 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
885 return udf_table_new_block(sb, inode,
886 map->s_uspace.s_table,
887 partition, goal, err);
888 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
889 return udf_bitmap_new_block(sb, inode,
890 map->s_fspace.s_bitmap,
891 partition, goal, err);
892 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
893 return udf_table_new_block(sb, inode,
894 map->s_fspace.s_table,
895 partition, goal, err);
896 else {
897 *err = -EIO;
898 return 0;
899 }
900 }
Linux with added FPC-III support