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