]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/udf/balloc.c
Merge tag 'arc-4.6-rc6-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vgupta/arc
[mirror_ubuntu-bionic-kernel.git] / fs / udf / balloc.c
CommitLineData
1da177e4
LT
1/*
2 * balloc.c
3 *
4 * PURPOSE
5 * Block allocation handling routines for the OSTA-UDF(tm) filesystem.
6 *
1da177e4
LT
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
1da177e4
LT
24#include <linux/bitops.h>
25
26#include "udf_i.h"
27#include "udf_sb.h"
28
9ad1e1e4
AM
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
1da177e4 33
cb00ea35
CG
34static int read_block_bitmap(struct super_block *sb,
35 struct udf_bitmap *bitmap, unsigned int block,
36 unsigned long bitmap_nr)
1da177e4
LT
37{
38 struct buffer_head *bh = NULL;
39 int retval = 0;
5ca4e4be 40 struct kernel_lb_addr loc;
1da177e4
LT
41
42 loc.logicalBlockNum = bitmap->s_extPosition;
6c79e987 43 loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
1da177e4 44
97e961fd 45 bh = udf_tread(sb, udf_get_lb_pblock(sb, &loc, block));
4b11111a 46 if (!bh)
1da177e4 47 retval = -EIO;
4b11111a 48
1da177e4
LT
49 bitmap->s_block_bitmap[bitmap_nr] = bh;
50 return retval;
51}
52
cb00ea35
CG
53static int __load_block_bitmap(struct super_block *sb,
54 struct udf_bitmap *bitmap,
55 unsigned int block_group)
1da177e4
LT
56{
57 int retval = 0;
58 int nr_groups = bitmap->s_nr_groups;
59
cb00ea35 60 if (block_group >= nr_groups) {
a983f368
JP
61 udf_debug("block_group (%d) > nr_groups (%d)\n",
62 block_group, nr_groups);
1da177e4
LT
63 }
64
6fbaad87 65 if (bitmap->s_block_bitmap[block_group])
1da177e4 66 return block_group;
6fbaad87
FF
67
68 retval = read_block_bitmap(sb, bitmap, block_group, block_group);
69 if (retval < 0)
70 return retval;
71
72 return block_group;
1da177e4
LT
73}
74
cb00ea35
CG
75static inline int load_block_bitmap(struct super_block *sb,
76 struct udf_bitmap *bitmap,
77 unsigned int block_group)
1da177e4
LT
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
146bca72 92static void udf_add_free_space(struct super_block *sb, u16 partition, u32 cnt)
742ba02a 93{
146bca72 94 struct udf_sb_info *sbi = UDF_SB(sb);
742ba02a
MS
95 struct logicalVolIntegrityDesc *lvid;
96
146bca72
JK
97 if (!sbi->s_lvid_bh)
98 return;
742ba02a
MS
99
100 lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
c2104fda 101 le32_add_cpu(&lvid->freeSpaceTable[partition], cnt);
146bca72 102 udf_updated_lvid(sb);
742ba02a
MS
103}
104
cb00ea35 105static void udf_bitmap_free_blocks(struct super_block *sb,
cb00ea35 106 struct udf_bitmap *bitmap,
97e961fd
PE
107 struct kernel_lb_addr *bloc,
108 uint32_t offset,
cb00ea35 109 uint32_t count)
1da177e4
LT
110{
111 struct udf_sb_info *sbi = UDF_SB(sb);
cb00ea35 112 struct buffer_head *bh = NULL;
97e961fd 113 struct udf_part_map *partmap;
1da177e4
LT
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
1e7933de 121 mutex_lock(&sbi->s_alloc_mutex);
97e961fd 122 partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
69ecbbed
DC
123 if (bloc->logicalBlockNum + count < count ||
124 (bloc->logicalBlockNum + count) > partmap->s_partition_len) {
28de7948 125 udf_debug("%d < %d || %d + %d > %d\n",
a983f368
JP
126 bloc->logicalBlockNum, 0,
127 bloc->logicalBlockNum, count,
128 partmap->s_partition_len);
1da177e4
LT
129 goto error_return;
130 }
131
97e961fd 132 block = bloc->logicalBlockNum + offset +
4b11111a 133 (sizeof(struct spaceBitmapDesc) << 3);
1da177e4 134
4daa1b87
MS
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;
1da177e4 146 }
4daa1b87
MS
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 %ld already set\n", bit + i);
155 udf_debug("byte=%2x\n",
a983f368 156 ((char *)bh->b_data)[(bit + i) >> 3]);
4daa1b87
MS
157 }
158 }
7abc2e45 159 udf_add_free_space(sb, sbi->s_partition, count);
4daa1b87
MS
160 mark_buffer_dirty(bh);
161 if (overflow) {
162 block += count;
163 count = overflow;
164 }
165 } while (overflow);
166
28de7948 167error_return:
1e7933de 168 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
169}
170
cb00ea35 171static int udf_bitmap_prealloc_blocks(struct super_block *sb,
cb00ea35
CG
172 struct udf_bitmap *bitmap,
173 uint16_t partition, uint32_t first_block,
174 uint32_t block_count)
1da177e4
LT
175{
176 struct udf_sb_info *sbi = UDF_SB(sb);
177 int alloc_count = 0;
178 int bit, block, block_group, group_start;
179 int nr_groups, bitmap_nr;
180 struct buffer_head *bh;
6c79e987 181 __u32 part_len;
1da177e4 182
1e7933de 183 mutex_lock(&sbi->s_alloc_mutex);
6c79e987 184 part_len = sbi->s_partmaps[partition].s_partition_len;
3391faa4 185 if (first_block >= part_len)
1da177e4
LT
186 goto out;
187
6c79e987
MS
188 if (first_block + block_count > part_len)
189 block_count = part_len - first_block;
1da177e4 190
4daa1b87
MS
191 do {
192 nr_groups = udf_compute_nr_groups(sb, partition);
193 block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
194 block_group = block >> (sb->s_blocksize_bits + 3);
195 group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
1da177e4 196
4daa1b87
MS
197 bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
198 if (bitmap_nr < 0)
199 goto out;
200 bh = bitmap->s_block_bitmap[bitmap_nr];
1da177e4 201
4daa1b87 202 bit = block % (sb->s_blocksize << 3);
1da177e4 203
4daa1b87 204 while (bit < (sb->s_blocksize << 3) && block_count > 0) {
36350462 205 if (!udf_clear_bit(bit, bh->b_data))
4daa1b87 206 goto out;
4daa1b87
MS
207 block_count--;
208 alloc_count++;
209 bit++;
210 block++;
1da177e4 211 }
4daa1b87
MS
212 mark_buffer_dirty(bh);
213 } while (block_count > 0);
214
28de7948 215out:
146bca72 216 udf_add_free_space(sb, partition, -alloc_count);
1e7933de 217 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
218 return alloc_count;
219}
220
cb00ea35 221static int udf_bitmap_new_block(struct super_block *sb,
cb00ea35
CG
222 struct udf_bitmap *bitmap, uint16_t partition,
223 uint32_t goal, int *err)
1da177e4
LT
224{
225 struct udf_sb_info *sbi = UDF_SB(sb);
cb00ea35 226 int newbit, bit = 0, block, block_group, group_start;
1da177e4
LT
227 int end_goal, nr_groups, bitmap_nr, i;
228 struct buffer_head *bh = NULL;
229 char *ptr;
230 int newblock = 0;
231
232 *err = -ENOSPC;
1e7933de 233 mutex_lock(&sbi->s_alloc_mutex);
1da177e4 234
28de7948 235repeat:
3391faa4 236 if (goal >= sbi->s_partmaps[partition].s_partition_len)
1da177e4
LT
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];
28de7948
CG
248 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
249 sb->s_blocksize - group_start);
1da177e4 250
cb00ea35 251 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
1da177e4 252 bit = block % (sb->s_blocksize << 3);
28de7948 253 if (udf_test_bit(bit, bh->b_data))
1da177e4 254 goto got_block;
28de7948 255
1da177e4
LT
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;
28de7948 260
4b11111a
MS
261 ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF,
262 sb->s_blocksize - ((bit + 7) >> 3));
1da177e4 263 newbit = (ptr - ((char *)bh->b_data)) << 3;
cb00ea35 264 if (newbit < sb->s_blocksize << 3) {
1da177e4
LT
265 bit = newbit;
266 goto search_back;
267 }
28de7948 268
4b11111a
MS
269 newbit = udf_find_next_one_bit(bh->b_data,
270 sb->s_blocksize << 3, bit);
cb00ea35 271 if (newbit < sb->s_blocksize << 3) {
1da177e4
LT
272 bit = newbit;
273 goto got_block;
274 }
275 }
276
cb00ea35
CG
277 for (i = 0; i < (nr_groups * 2); i++) {
278 block_group++;
1da177e4
LT
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];
cb00ea35 287 if (i < nr_groups) {
28de7948
CG
288 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
289 sb->s_blocksize - group_start);
cb00ea35 290 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
1da177e4
LT
291 bit = (ptr - ((char *)bh->b_data)) << 3;
292 break;
293 }
cb00ea35 294 } else {
6f644e5f 295 bit = udf_find_next_one_bit(bh->b_data,
28de7948
CG
296 sb->s_blocksize << 3,
297 group_start << 3);
1da177e4
LT
298 if (bit < sb->s_blocksize << 3)
299 break;
300 }
301 }
cb00ea35 302 if (i >= (nr_groups * 2)) {
1e7933de 303 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
304 return newblock;
305 }
306 if (bit < sb->s_blocksize << 3)
307 goto search_back;
308 else
4b11111a
MS
309 bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
310 group_start << 3);
cb00ea35 311 if (bit >= sb->s_blocksize << 3) {
1e7933de 312 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
313 return 0;
314 }
315
28de7948 316search_back:
4b11111a
MS
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 }
1da177e4 323
28de7948 324got_block:
1da177e4 325 newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
28de7948 326 (sizeof(struct spaceBitmapDesc) << 3);
1da177e4 327
cb00ea35 328 if (!udf_clear_bit(bit, bh->b_data)) {
1da177e4
LT
329 udf_debug("bit already cleared for block %d\n", bit);
330 goto repeat;
331 }
332
333 mark_buffer_dirty(bh);
334
146bca72 335 udf_add_free_space(sb, partition, -1);
1e7933de 336 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
337 *err = 0;
338 return newblock;
339
28de7948 340error_return:
1da177e4 341 *err = -EIO;
1e7933de 342 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
343 return 0;
344}
345
cb00ea35 346static void udf_table_free_blocks(struct super_block *sb,
cb00ea35 347 struct inode *table,
97e961fd
PE
348 struct kernel_lb_addr *bloc,
349 uint32_t offset,
cb00ea35 350 uint32_t count)
1da177e4
LT
351{
352 struct udf_sb_info *sbi = UDF_SB(sb);
97e961fd 353 struct udf_part_map *partmap;
1da177e4 354 uint32_t start, end;
ff116fc8 355 uint32_t elen;
5ca4e4be 356 struct kernel_lb_addr eloc;
ff116fc8 357 struct extent_position oepos, epos;
1da177e4 358 int8_t etype;
48d6d8ff 359 struct udf_inode_info *iinfo;
1da177e4 360
1e7933de 361 mutex_lock(&sbi->s_alloc_mutex);
97e961fd 362 partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
69ecbbed
DC
363 if (bloc->logicalBlockNum + count < count ||
364 (bloc->logicalBlockNum + count) > partmap->s_partition_len) {
28de7948 365 udf_debug("%d < %d || %d + %d > %d\n",
a983f368
JP
366 bloc->logicalBlockNum, 0,
367 bloc->logicalBlockNum, count,
97e961fd 368 partmap->s_partition_len);
1da177e4
LT
369 goto error_return;
370 }
371
48d6d8ff 372 iinfo = UDF_I(table);
146bca72 373 udf_add_free_space(sb, sbi->s_partition, count);
1da177e4 374
97e961fd
PE
375 start = bloc->logicalBlockNum + offset;
376 end = bloc->logicalBlockNum + offset + count - 1;
1da177e4 377
ff116fc8 378 epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
1da177e4 379 elen = 0;
48d6d8ff 380 epos.block = oepos.block = iinfo->i_location;
ff116fc8 381 epos.bh = oepos.bh = NULL;
1da177e4 382
28de7948
CG
383 while (count &&
384 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
4b11111a
MS
385 if (((eloc.logicalBlockNum +
386 (elen >> sb->s_blocksize_bits)) == start)) {
387 if ((0x3FFFFFFF - elen) <
388 (count << sb->s_blocksize_bits)) {
389 uint32_t tmp = ((0x3FFFFFFF - elen) >>
390 sb->s_blocksize_bits);
391 count -= tmp;
392 start += tmp;
393 elen = (etype << 30) |
394 (0x40000000 - sb->s_blocksize);
cb00ea35 395 } else {
4b11111a
MS
396 elen = (etype << 30) |
397 (elen +
398 (count << sb->s_blocksize_bits));
1da177e4
LT
399 start += count;
400 count = 0;
401 }
97e961fd 402 udf_write_aext(table, &oepos, &eloc, elen, 1);
cb00ea35 403 } else if (eloc.logicalBlockNum == (end + 1)) {
4b11111a
MS
404 if ((0x3FFFFFFF - elen) <
405 (count << sb->s_blocksize_bits)) {
406 uint32_t tmp = ((0x3FFFFFFF - elen) >>
407 sb->s_blocksize_bits);
408 count -= tmp;
409 end -= tmp;
410 eloc.logicalBlockNum -= tmp;
411 elen = (etype << 30) |
412 (0x40000000 - sb->s_blocksize);
cb00ea35 413 } else {
1da177e4 414 eloc.logicalBlockNum = start;
4b11111a
MS
415 elen = (etype << 30) |
416 (elen +
417 (count << sb->s_blocksize_bits));
1da177e4
LT
418 end -= count;
419 count = 0;
420 }
97e961fd 421 udf_write_aext(table, &oepos, &eloc, elen, 1);
1da177e4
LT
422 }
423
cb00ea35 424 if (epos.bh != oepos.bh) {
ff116fc8 425 oepos.block = epos.block;
3bf25cb4
JK
426 brelse(oepos.bh);
427 get_bh(epos.bh);
ff116fc8
JK
428 oepos.bh = epos.bh;
429 oepos.offset = 0;
28de7948 430 } else {
ff116fc8 431 oepos.offset = epos.offset;
28de7948 432 }
1da177e4
LT
433 }
434
cb00ea35 435 if (count) {
28de7948 436 /*
4b11111a
MS
437 * NOTE: we CANNOT use udf_add_aext here, as it can try to
438 * allocate a new block, and since we hold the super block
439 * lock already very bad things would happen :)
28de7948
CG
440 *
441 * We copy the behavior of udf_add_aext, but instead of
442 * trying to allocate a new block close to the existing one,
443 * we just steal a block from the extent we are trying to add.
444 *
445 * It would be nice if the blocks were close together, but it
446 * isn't required.
cb00ea35 447 */
1da177e4
LT
448
449 int adsize;
1da177e4
LT
450
451 eloc.logicalBlockNum = start;
28de7948
CG
452 elen = EXT_RECORDED_ALLOCATED |
453 (count << sb->s_blocksize_bits);
1da177e4 454
48d6d8ff 455 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
5ca4e4be 456 adsize = sizeof(struct short_ad);
48d6d8ff 457 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
5ca4e4be 458 adsize = sizeof(struct long_ad);
48d6d8ff 459 else {
3bf25cb4
JK
460 brelse(oepos.bh);
461 brelse(epos.bh);
1da177e4
LT
462 goto error_return;
463 }
464
cb00ea35 465 if (epos.offset + (2 * adsize) > sb->s_blocksize) {
1da177e4 466 /* Steal a block from the extent being free'd */
fcea62ba
JK
467 udf_setup_indirect_aext(table, eloc.logicalBlockNum,
468 &epos);
469
cb00ea35 470 eloc.logicalBlockNum++;
1da177e4 471 elen -= sb->s_blocksize;
1da177e4
LT
472 }
473
4b11111a 474 /* It's possible that stealing the block emptied the extent */
fcea62ba
JK
475 if (elen)
476 __udf_add_aext(table, &epos, &eloc, elen, 1);
1da177e4
LT
477 }
478
3bf25cb4
JK
479 brelse(epos.bh);
480 brelse(oepos.bh);
1da177e4 481
28de7948 482error_return:
1e7933de 483 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
484 return;
485}
486
cb00ea35 487static int udf_table_prealloc_blocks(struct super_block *sb,
cb00ea35
CG
488 struct inode *table, uint16_t partition,
489 uint32_t first_block, uint32_t block_count)
1da177e4
LT
490{
491 struct udf_sb_info *sbi = UDF_SB(sb);
492 int alloc_count = 0;
ff116fc8 493 uint32_t elen, adsize;
5ca4e4be 494 struct kernel_lb_addr eloc;
ff116fc8 495 struct extent_position epos;
1da177e4 496 int8_t etype = -1;
48d6d8ff 497 struct udf_inode_info *iinfo;
1da177e4 498
3391faa4 499 if (first_block >= sbi->s_partmaps[partition].s_partition_len)
1da177e4
LT
500 return 0;
501
48d6d8ff
MS
502 iinfo = UDF_I(table);
503 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
5ca4e4be 504 adsize = sizeof(struct short_ad);
48d6d8ff 505 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
5ca4e4be 506 adsize = sizeof(struct long_ad);
1da177e4
LT
507 else
508 return 0;
509
1e7933de 510 mutex_lock(&sbi->s_alloc_mutex);
ff116fc8 511 epos.offset = sizeof(struct unallocSpaceEntry);
48d6d8ff 512 epos.block = iinfo->i_location;
ff116fc8 513 epos.bh = NULL;
1da177e4
LT
514 eloc.logicalBlockNum = 0xFFFFFFFF;
515
28de7948
CG
516 while (first_block != eloc.logicalBlockNum &&
517 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
1da177e4 518 udf_debug("eloc=%d, elen=%d, first_block=%d\n",
cb00ea35 519 eloc.logicalBlockNum, elen, first_block);
28de7948 520 ; /* empty loop body */
1da177e4
LT
521 }
522
cb00ea35 523 if (first_block == eloc.logicalBlockNum) {
ff116fc8 524 epos.offset -= adsize;
1da177e4
LT
525
526 alloc_count = (elen >> sb->s_blocksize_bits);
36350462 527 if (alloc_count > block_count) {
1da177e4
LT
528 alloc_count = block_count;
529 eloc.logicalBlockNum += alloc_count;
530 elen -= (alloc_count << sb->s_blocksize_bits);
97e961fd 531 udf_write_aext(table, &epos, &eloc,
4b11111a
MS
532 (etype << 30) | elen, 1);
533 } else
534 udf_delete_aext(table, epos, eloc,
535 (etype << 30) | elen);
28de7948 536 } else {
1da177e4 537 alloc_count = 0;
28de7948 538 }
1da177e4 539
3bf25cb4 540 brelse(epos.bh);
1da177e4 541
146bca72
JK
542 if (alloc_count)
543 udf_add_free_space(sb, partition, -alloc_count);
1e7933de 544 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
545 return alloc_count;
546}
547
cb00ea35 548static int udf_table_new_block(struct super_block *sb,
cb00ea35
CG
549 struct inode *table, uint16_t partition,
550 uint32_t goal, int *err)
1da177e4
LT
551{
552 struct udf_sb_info *sbi = UDF_SB(sb);
553 uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
554 uint32_t newblock = 0, adsize;
ff116fc8 555 uint32_t elen, goal_elen = 0;
5ca4e4be 556 struct kernel_lb_addr eloc, uninitialized_var(goal_eloc);
ff116fc8 557 struct extent_position epos, goal_epos;
1da177e4 558 int8_t etype;
48d6d8ff 559 struct udf_inode_info *iinfo = UDF_I(table);
1da177e4
LT
560
561 *err = -ENOSPC;
562
48d6d8ff 563 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
5ca4e4be 564 adsize = sizeof(struct short_ad);
48d6d8ff 565 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
5ca4e4be 566 adsize = sizeof(struct long_ad);
1da177e4
LT
567 else
568 return newblock;
569
1e7933de 570 mutex_lock(&sbi->s_alloc_mutex);
3391faa4 571 if (goal >= sbi->s_partmaps[partition].s_partition_len)
1da177e4
LT
572 goal = 0;
573
4b11111a
MS
574 /* We search for the closest matching block to goal. If we find
575 a exact hit, we stop. Otherwise we keep going till we run out
576 of extents. We store the buffer_head, bloc, and extoffset
577 of the current closest match and use that when we are done.
cb00ea35 578 */
ff116fc8 579 epos.offset = sizeof(struct unallocSpaceEntry);
48d6d8ff 580 epos.block = iinfo->i_location;
ff116fc8 581 epos.bh = goal_epos.bh = NULL;
1da177e4 582
28de7948
CG
583 while (spread &&
584 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
cb00ea35 585 if (goal >= eloc.logicalBlockNum) {
4b11111a
MS
586 if (goal < eloc.logicalBlockNum +
587 (elen >> sb->s_blocksize_bits))
1da177e4
LT
588 nspread = 0;
589 else
590 nspread = goal - eloc.logicalBlockNum -
28de7948
CG
591 (elen >> sb->s_blocksize_bits);
592 } else {
1da177e4 593 nspread = eloc.logicalBlockNum - goal;
28de7948 594 }
1da177e4 595
cb00ea35 596 if (nspread < spread) {
1da177e4 597 spread = nspread;
cb00ea35 598 if (goal_epos.bh != epos.bh) {
3bf25cb4 599 brelse(goal_epos.bh);
ff116fc8 600 goal_epos.bh = epos.bh;
3bf25cb4 601 get_bh(goal_epos.bh);
1da177e4 602 }
ff116fc8
JK
603 goal_epos.block = epos.block;
604 goal_epos.offset = epos.offset - adsize;
1da177e4
LT
605 goal_eloc = eloc;
606 goal_elen = (etype << 30) | elen;
607 }
608 }
609
3bf25cb4 610 brelse(epos.bh);
1da177e4 611
cb00ea35 612 if (spread == 0xFFFFFFFF) {
3bf25cb4 613 brelse(goal_epos.bh);
1e7933de 614 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
615 return 0;
616 }
617
618 /* Only allocate blocks from the beginning of the extent.
619 That way, we only delete (empty) extents, never have to insert an
620 extent because of splitting */
621 /* This works, but very poorly.... */
622
623 newblock = goal_eloc.logicalBlockNum;
cb00ea35 624 goal_eloc.logicalBlockNum++;
1da177e4 625 goal_elen -= sb->s_blocksize;
1da177e4
LT
626
627 if (goal_elen)
97e961fd 628 udf_write_aext(table, &goal_epos, &goal_eloc, goal_elen, 1);
1da177e4 629 else
ff116fc8 630 udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
3bf25cb4 631 brelse(goal_epos.bh);
1da177e4 632
146bca72 633 udf_add_free_space(sb, partition, -1);
1da177e4 634
1e7933de 635 mutex_unlock(&sbi->s_alloc_mutex);
1da177e4
LT
636 *err = 0;
637 return newblock;
638}
639
97e961fd
PE
640void udf_free_blocks(struct super_block *sb, struct inode *inode,
641 struct kernel_lb_addr *bloc, uint32_t offset,
642 uint32_t count)
1da177e4 643{
97e961fd 644 uint16_t partition = bloc->partitionReferenceNum;
6c79e987 645 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
1da177e4 646
6c79e987 647 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
fd4287db 648 udf_bitmap_free_blocks(sb, map->s_uspace.s_bitmap,
e650b94a 649 bloc, offset, count);
6c79e987 650 } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
fd4287db 651 udf_table_free_blocks(sb, map->s_uspace.s_table,
e650b94a 652 bloc, offset, count);
6c79e987 653 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
fd4287db 654 udf_bitmap_free_blocks(sb, map->s_fspace.s_bitmap,
e650b94a 655 bloc, offset, count);
6c79e987 656 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
fd4287db 657 udf_table_free_blocks(sb, map->s_fspace.s_table,
e650b94a 658 bloc, offset, count);
28de7948 659 }
fd4287db
JK
660
661 if (inode) {
662 inode_sub_bytes(inode,
663 ((sector_t)count) << sb->s_blocksize_bits);
664 }
1da177e4
LT
665}
666
cb00ea35
CG
667inline int udf_prealloc_blocks(struct super_block *sb,
668 struct inode *inode,
669 uint16_t partition, uint32_t first_block,
670 uint32_t block_count)
1da177e4 671{
6c79e987 672 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
1be440de 673 int allocated;
6c79e987 674
4b11111a 675 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
fd4287db
JK
676 allocated = udf_bitmap_prealloc_blocks(sb,
677 map->s_uspace.s_bitmap,
678 partition, first_block,
679 block_count);
4b11111a 680 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
fd4287db
JK
681 allocated = udf_table_prealloc_blocks(sb,
682 map->s_uspace.s_table,
683 partition, first_block,
684 block_count);
4b11111a 685 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
fd4287db
JK
686 allocated = udf_bitmap_prealloc_blocks(sb,
687 map->s_fspace.s_bitmap,
688 partition, first_block,
689 block_count);
4b11111a 690 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
fd4287db
JK
691 allocated = udf_table_prealloc_blocks(sb,
692 map->s_fspace.s_table,
693 partition, first_block,
694 block_count);
4b11111a 695 else
1da177e4 696 return 0;
fd4287db
JK
697
698 if (inode && allocated > 0)
699 inode_add_bytes(inode, allocated << sb->s_blocksize_bits);
700 return allocated;
1da177e4
LT
701}
702
cb00ea35
CG
703inline int udf_new_block(struct super_block *sb,
704 struct inode *inode,
705 uint16_t partition, uint32_t goal, int *err)
1da177e4 706{
6c79e987 707 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
fd4287db 708 int block;
3bf25cb4 709
4b11111a 710 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
fd4287db
JK
711 block = udf_bitmap_new_block(sb,
712 map->s_uspace.s_bitmap,
713 partition, goal, err);
4b11111a 714 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
fd4287db
JK
715 block = udf_table_new_block(sb,
716 map->s_uspace.s_table,
28de7948 717 partition, goal, err);
fd4287db
JK
718 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
719 block = udf_bitmap_new_block(sb,
720 map->s_fspace.s_bitmap,
721 partition, goal, err);
4b11111a 722 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
fd4287db
JK
723 block = udf_table_new_block(sb,
724 map->s_fspace.s_table,
725 partition, goal, err);
4b11111a 726 else {
1da177e4
LT
727 *err = -EIO;
728 return 0;
729 }
fd4287db
JK
730 if (inode && block)
731 inode_add_bytes(inode, sb->s_blocksize);
732 return block;
1da177e4 733}