blob: 1e068535b58bfc78b0970dc3ccb34e03cc7c1ecb [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * balloc.c
3 *
4 * PURPOSE
5 * Block allocation handling routines for the OSTA-UDF(tm) filesystem.
6 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * 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
Marcin Slusarz4b111112008-02-08 04:20:36 -080031#define udf_clear_bit(nr, addr) ext2_clear_bit(nr, addr)
32#define udf_set_bit(nr, addr) ext2_set_bit(nr, addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#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)
Marcin Slusarz4b111112008-02-08 04:20:36 -080035#define udf_find_next_one_bit(addr, size, offset) \
36 find_next_one_bit(addr, size, offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38#define leBPL_to_cpup(x) leNUM_to_cpup(BITS_PER_LONG, x)
Marcin Slusarz4b111112008-02-08 04:20:36 -080039#define leNUM_to_cpup(x, y) xleNUM_to_cpup(x, y)
40#define xleNUM_to_cpup(x, y) (le ## x ## _to_cpup(y))
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#define uintBPL_t uint(BITS_PER_LONG)
42#define uint(x) xuint(x)
43#define xuint(x) __le ## x
44
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070045static inline int find_next_one_bit(void *addr, int size, int offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -070046{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070047 uintBPL_t *p = ((uintBPL_t *) addr) + (offset / BITS_PER_LONG);
48 int result = offset & ~(BITS_PER_LONG - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 unsigned long tmp;
50
51 if (offset >= size)
52 return size;
53 size -= result;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070054 offset &= (BITS_PER_LONG - 1);
55 if (offset) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 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 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070065 while (size & ~(BITS_PER_LONG - 1)) {
Marcin Slusarz4b111112008-02-08 04:20:36 -080066 tmp = leBPL_to_cpup(p++);
67 if (tmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 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);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070075found_first:
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070076 tmp &= ~0UL >> (BITS_PER_LONG - size);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070077found_middle:
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 return result + ffz(~tmp);
79}
80
81#define find_first_one_bit(addr, size)\
82 find_next_one_bit((addr), (size), 0)
83
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070084static int read_block_bitmap(struct super_block *sb,
85 struct udf_bitmap *bitmap, unsigned int block,
86 unsigned long bitmap_nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
88 struct buffer_head *bh = NULL;
89 int retval = 0;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +020090 struct kernel_lb_addr loc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091
92 loc.logicalBlockNum = bitmap->s_extPosition;
Marcin Slusarz6c79e982008-02-08 04:20:30 -080093 loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Pekka Enberg97e961f2008-10-15 12:29:03 +020095 bh = udf_tread(sb, udf_get_lb_pblock(sb, &loc, block));
Marcin Slusarz4b111112008-02-08 04:20:36 -080096 if (!bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 retval = -EIO;
Marcin Slusarz4b111112008-02-08 04:20:36 -080098
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 bitmap->s_block_bitmap[bitmap_nr] = bh;
100 return retval;
101}
102
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700103static int __load_block_bitmap(struct super_block *sb,
104 struct udf_bitmap *bitmap,
105 unsigned int block_group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106{
107 int retval = 0;
108 int nr_groups = bitmap->s_nr_groups;
109
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700110 if (block_group >= nr_groups) {
111 udf_debug("block_group (%d) > nr_groups (%d)\n", block_group,
112 nr_groups);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 }
114
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700115 if (bitmap->s_block_bitmap[block_group]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 return block_group;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700117 } else {
118 retval = read_block_bitmap(sb, bitmap, block_group,
119 block_group);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 if (retval < 0)
121 return retval;
122 return block_group;
123 }
124}
125
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700126static inline int load_block_bitmap(struct super_block *sb,
127 struct udf_bitmap *bitmap,
128 unsigned int block_group)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
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
Jan Kara146bca72009-03-16 18:27:37 +0100143static void udf_add_free_space(struct super_block *sb, u16 partition, u32 cnt)
Marcin Slusarz742ba022008-02-08 04:20:40 -0800144{
Jan Kara146bca72009-03-16 18:27:37 +0100145 struct udf_sb_info *sbi = UDF_SB(sb);
Marcin Slusarz742ba022008-02-08 04:20:40 -0800146 struct logicalVolIntegrityDesc *lvid;
147
Jan Kara146bca72009-03-16 18:27:37 +0100148 if (!sbi->s_lvid_bh)
149 return;
Marcin Slusarz742ba022008-02-08 04:20:40 -0800150
151 lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
marcin.slusarz@gmail.comc2104fd2008-01-30 22:03:57 +0100152 le32_add_cpu(&lvid->freeSpaceTable[partition], cnt);
Jan Kara146bca72009-03-16 18:27:37 +0100153 udf_updated_lvid(sb);
Marcin Slusarz742ba022008-02-08 04:20:40 -0800154}
155
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700156static void udf_bitmap_free_blocks(struct super_block *sb,
157 struct inode *inode,
158 struct udf_bitmap *bitmap,
Pekka Enberg97e961f2008-10-15 12:29:03 +0200159 struct kernel_lb_addr *bloc,
160 uint32_t offset,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700161 uint32_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162{
163 struct udf_sb_info *sbi = UDF_SB(sb);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700164 struct buffer_head *bh = NULL;
Pekka Enberg97e961f2008-10-15 12:29:03 +0200165 struct udf_part_map *partmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 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
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800173 mutex_lock(&sbi->s_alloc_mutex);
Pekka Enberg97e961f2008-10-15 12:29:03 +0200174 partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
175 if (bloc->logicalBlockNum < 0 ||
176 (bloc->logicalBlockNum + count) >
177 partmap->s_partition_len) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700178 udf_debug("%d < %d || %d + %d > %d\n",
Pekka Enberg97e961f2008-10-15 12:29:03 +0200179 bloc->logicalBlockNum, 0, bloc->logicalBlockNum,
180 count, partmap->s_partition_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 goto error_return;
182 }
183
Pekka Enberg97e961f2008-10-15 12:29:03 +0200184 block = bloc->logicalBlockNum + offset +
Marcin Slusarz4b111112008-02-08 04:20:36 -0800185 (sizeof(struct spaceBitmapDesc) << 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800187 do {
188 overflow = 0;
189 block_group = block >> (sb->s_blocksize_bits + 3);
190 bit = block % (sb->s_blocksize << 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800192 /*
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 }
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800199 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)
Jan Karabacfb7c2009-01-26 17:20:46 +0100211 vfs_dq_free_block(inode, 1);
Jan Kara146bca72009-03-16 18:27:37 +0100212 udf_add_free_space(sb, sbi->s_partition, 1);
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800213 }
214 }
215 mark_buffer_dirty(bh);
216 if (overflow) {
217 block += count;
218 count = overflow;
219 }
220 } while (overflow);
221
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700222error_return:
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800223 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224}
225
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700226static 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
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;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800237 __u32 part_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800239 mutex_lock(&sbi->s_alloc_mutex);
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800240 part_len = sbi->s_partmaps[partition].s_partition_len;
Roel Kluin3391faa2009-06-22 23:12:29 +0200241 if (first_block >= part_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 goto out;
243
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800244 if (first_block + block_count > part_len)
245 block_count = part_len - first_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800247 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800253 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];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800258 bit = block % (sb->s_blocksize << 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800260 while (bit < (sb->s_blocksize << 3) && block_count > 0) {
261 if (!udf_test_bit(bit, bh->b_data))
262 goto out;
Jan Karabacfb7c2009-01-26 17:20:46 +0100263 else if (vfs_dq_prealloc_block(inode, 1))
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800264 goto out;
265 else if (!udf_clear_bit(bit, bh->b_data)) {
266 udf_debug("bit already cleared for block %d\n", bit);
Jan Karabacfb7c2009-01-26 17:20:46 +0100267 vfs_dq_free_block(inode, 1);
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800268 goto out;
269 }
270 block_count--;
271 alloc_count++;
272 bit++;
273 block++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 }
Marcin Slusarz4daa1b82008-02-08 04:20:41 -0800275 mark_buffer_dirty(bh);
276 } while (block_count > 0);
277
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700278out:
Jan Kara146bca72009-03-16 18:27:37 +0100279 udf_add_free_space(sb, partition, -alloc_count);
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800280 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return alloc_count;
282}
283
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700284static 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
289 struct udf_sb_info *sbi = UDF_SB(sb);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700290 int newbit, bit = 0, block, block_group, group_start;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 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;
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800297 mutex_lock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700299repeat:
Roel Kluin3391faa2009-06-22 23:12:29 +0200300 if (goal >= sbi->s_partmaps[partition].s_partition_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 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];
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700312 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
313 sb->s_blocksize - group_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700315 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 bit = block % (sb->s_blocksize << 3);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700317 if (udf_test_bit(bit, bh->b_data))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 goto got_block;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 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;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700324
Marcin Slusarz4b111112008-02-08 04:20:36 -0800325 ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF,
326 sb->s_blocksize - ((bit + 7) >> 3));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 newbit = (ptr - ((char *)bh->b_data)) << 3;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700328 if (newbit < sb->s_blocksize << 3) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 bit = newbit;
330 goto search_back;
331 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700332
Marcin Slusarz4b111112008-02-08 04:20:36 -0800333 newbit = udf_find_next_one_bit(bh->b_data,
334 sb->s_blocksize << 3, bit);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700335 if (newbit < sb->s_blocksize << 3) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 bit = newbit;
337 goto got_block;
338 }
339 }
340
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700341 for (i = 0; i < (nr_groups * 2); i++) {
342 block_group++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 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];
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700351 if (i < nr_groups) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700352 ptr = memscan((char *)bh->b_data + group_start, 0xFF,
353 sb->s_blocksize - group_start);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700354 if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 bit = (ptr - ((char *)bh->b_data)) << 3;
356 break;
357 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700358 } else {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700359 bit = udf_find_next_one_bit((char *)bh->b_data,
360 sb->s_blocksize << 3,
361 group_start << 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (bit < sb->s_blocksize << 3)
363 break;
364 }
365 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700366 if (i >= (nr_groups * 2)) {
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800367 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 return newblock;
369 }
370 if (bit < sb->s_blocksize << 3)
371 goto search_back;
372 else
Marcin Slusarz4b111112008-02-08 04:20:36 -0800373 bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
374 group_start << 3);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700375 if (bit >= sb->s_blocksize << 3) {
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800376 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 return 0;
378 }
379
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700380search_back:
Marcin Slusarz4b111112008-02-08 04:20:36 -0800381 i = 0;
382 while (i < 7 && bit > (group_start << 3) &&
383 udf_test_bit(bit - 1, bh->b_data)) {
384 ++i;
385 --bit;
386 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700388got_block:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
390 /*
391 * Check quota for allocation of this block.
392 */
Jan Karabacfb7c2009-01-26 17:20:46 +0100393 if (inode && vfs_dq_alloc_block(inode, 1)) {
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800394 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 *err = -EDQUOT;
396 return 0;
397 }
398
399 newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700400 (sizeof(struct spaceBitmapDesc) << 3);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700402 if (!udf_clear_bit(bit, bh->b_data)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 udf_debug("bit already cleared for block %d\n", bit);
404 goto repeat;
405 }
406
407 mark_buffer_dirty(bh);
408
Jan Kara146bca72009-03-16 18:27:37 +0100409 udf_add_free_space(sb, partition, -1);
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800410 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 *err = 0;
412 return newblock;
413
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700414error_return:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 *err = -EIO;
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800416 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 return 0;
418}
419
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700420static void udf_table_free_blocks(struct super_block *sb,
421 struct inode *inode,
422 struct inode *table,
Pekka Enberg97e961f2008-10-15 12:29:03 +0200423 struct kernel_lb_addr *bloc,
424 uint32_t offset,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700425 uint32_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
427 struct udf_sb_info *sbi = UDF_SB(sb);
Pekka Enberg97e961f2008-10-15 12:29:03 +0200428 struct udf_part_map *partmap;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 uint32_t start, end;
Jan Karaff116fc2007-05-08 00:35:14 -0700430 uint32_t elen;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200431 struct kernel_lb_addr eloc;
Jan Karaff116fc2007-05-08 00:35:14 -0700432 struct extent_position oepos, epos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 int8_t etype;
434 int i;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800435 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800437 mutex_lock(&sbi->s_alloc_mutex);
Pekka Enberg97e961f2008-10-15 12:29:03 +0200438 partmap = &sbi->s_partmaps[bloc->partitionReferenceNum];
439 if (bloc->logicalBlockNum < 0 ||
440 (bloc->logicalBlockNum + count) >
441 partmap->s_partition_len) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700442 udf_debug("%d < %d || %d + %d > %d\n",
443 bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
Pekka Enberg97e961f2008-10-15 12:29:03 +0200444 partmap->s_partition_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 goto error_return;
446 }
447
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800448 iinfo = UDF_I(table);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800449 /* We do this up front - There are some error conditions that
450 could occure, but.. oh well */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 if (inode)
Jan Karabacfb7c2009-01-26 17:20:46 +0100452 vfs_dq_free_block(inode, count);
Jan Kara146bca72009-03-16 18:27:37 +0100453 udf_add_free_space(sb, sbi->s_partition, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Pekka Enberg97e961f2008-10-15 12:29:03 +0200455 start = bloc->logicalBlockNum + offset;
456 end = bloc->logicalBlockNum + offset + count - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
Jan Karaff116fc2007-05-08 00:35:14 -0700458 epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 elen = 0;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800460 epos.block = oepos.block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700461 epos.bh = oepos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700463 while (count &&
464 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800465 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);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700475 } else {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800476 elen = (etype << 30) |
477 (elen +
478 (count << sb->s_blocksize_bits));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 start += count;
480 count = 0;
481 }
Pekka Enberg97e961f2008-10-15 12:29:03 +0200482 udf_write_aext(table, &oepos, &eloc, elen, 1);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700483 } else if (eloc.logicalBlockNum == (end + 1)) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800484 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);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700493 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 eloc.logicalBlockNum = start;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800495 elen = (etype << 30) |
496 (elen +
497 (count << sb->s_blocksize_bits));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 end -= count;
499 count = 0;
500 }
Pekka Enberg97e961f2008-10-15 12:29:03 +0200501 udf_write_aext(table, &oepos, &eloc, elen, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 }
503
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700504 if (epos.bh != oepos.bh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 i = -1;
Jan Karaff116fc2007-05-08 00:35:14 -0700506 oepos.block = epos.block;
Jan Kara3bf25cb2007-05-08 00:35:16 -0700507 brelse(oepos.bh);
508 get_bh(epos.bh);
Jan Karaff116fc2007-05-08 00:35:14 -0700509 oepos.bh = epos.bh;
510 oepos.offset = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700511 } else {
Jan Karaff116fc2007-05-08 00:35:14 -0700512 oepos.offset = epos.offset;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700513 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 }
515
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700516 if (count) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700517 /*
Marcin Slusarz4b111112008-02-08 04:20:36 -0800518 * 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 :)
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700521 *
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.
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700528 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
530 int adsize;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200531 struct short_ad *sad = NULL;
532 struct long_ad *lad = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 struct allocExtDesc *aed;
534
535 eloc.logicalBlockNum = start;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700536 elen = EXT_RECORDED_ALLOCATED |
537 (count << sb->s_blocksize_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800539 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200540 adsize = sizeof(struct short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800541 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200542 adsize = sizeof(struct long_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800543 else {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700544 brelse(oepos.bh);
545 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 goto error_return;
547 }
548
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700549 if (epos.offset + (2 * adsize) > sb->s_blocksize) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 char *sptr, *dptr;
551 int loffset;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700552
Jan Kara3bf25cb2007-05-08 00:35:16 -0700553 brelse(oepos.bh);
Jan Karaff116fc2007-05-08 00:35:14 -0700554 oepos = epos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
556 /* Steal a block from the extent being free'd */
Jan Karaff116fc2007-05-08 00:35:14 -0700557 epos.block.logicalBlockNum = eloc.logicalBlockNum;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700558 eloc.logicalBlockNum++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 elen -= sb->s_blocksize;
560
Marcin Slusarz4b111112008-02-08 04:20:36 -0800561 epos.bh = udf_tread(sb,
Pekka Enberg97e961f2008-10-15 12:29:03 +0200562 udf_get_lb_pblock(sb, &epos.block, 0));
Marcin Slusarz4b111112008-02-08 04:20:36 -0800563 if (!epos.bh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700564 brelse(oepos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 goto error_return;
566 }
Jan Karaff116fc2007-05-08 00:35:14 -0700567 aed = (struct allocExtDesc *)(epos.bh->b_data);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800568 aed->previousAllocExtLocation =
569 cpu_to_le32(oepos.block.logicalBlockNum);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700570 if (epos.offset + adsize > sb->s_blocksize) {
Jan Karaff116fc2007-05-08 00:35:14 -0700571 loffset = epos.offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 aed->lengthAllocDescs = cpu_to_le32(adsize);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800573 sptr = iinfo->i_ext.i_data + epos.offset
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800574 - adsize;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800575 dptr = epos.bh->b_data +
576 sizeof(struct allocExtDesc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 memcpy(dptr, sptr, adsize);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800578 epos.offset = sizeof(struct allocExtDesc) +
579 adsize;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700580 } else {
Jan Karaff116fc2007-05-08 00:35:14 -0700581 loffset = epos.offset + adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 aed->lengthAllocDescs = cpu_to_le32(0);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700583 if (oepos.bh) {
Jan Karaf5cc15d2007-08-30 23:56:22 -0700584 sptr = oepos.bh->b_data + epos.offset;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800585 aed = (struct allocExtDesc *)
586 oepos.bh->b_data;
marcin.slusarz@gmail.comc2104fd2008-01-30 22:03:57 +0100587 le32_add_cpu(&aed->lengthAllocDescs,
588 adsize);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700589 } else {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800590 sptr = iinfo->i_ext.i_data +
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800591 epos.offset;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800592 iinfo->i_lenAlloc += adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 mark_inode_dirty(table);
594 }
Jan Karaf5cc15d2007-08-30 23:56:22 -0700595 epos.offset = sizeof(struct allocExtDesc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 }
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800597 if (sbi->s_udfrev >= 0x0200)
Marcin Slusarz4b111112008-02-08 04:20:36 -0800598 udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
599 3, 1, epos.block.logicalBlockNum,
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200600 sizeof(struct tag));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 else
Marcin Slusarz4b111112008-02-08 04:20:36 -0800602 udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
603 2, 1, epos.block.logicalBlockNum,
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200604 sizeof(struct tag));
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700605
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800606 switch (iinfo->i_alloc_type) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800607 case ICBTAG_FLAG_AD_SHORT:
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200608 sad = (struct short_ad *)sptr;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800609 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:
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200616 lad = (struct long_ad *)sptr;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800617 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700624 if (oepos.bh) {
Jan Karaff116fc2007-05-08 00:35:14 -0700625 udf_update_tag(oepos.bh->b_data, loffset);
626 mark_buffer_dirty(oepos.bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700627 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 mark_inode_dirty(table);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700629 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 }
631
Marcin Slusarz4b111112008-02-08 04:20:36 -0800632 /* It's possible that stealing the block emptied the extent */
633 if (elen) {
Pekka Enberg97e961f2008-10-15 12:29:03 +0200634 udf_write_aext(table, &epos, &eloc, elen, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700636 if (!epos.bh) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800637 iinfo->i_lenAlloc += adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 mark_inode_dirty(table);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700639 } else {
Jan Karaff116fc2007-05-08 00:35:14 -0700640 aed = (struct allocExtDesc *)epos.bh->b_data;
marcin.slusarz@gmail.comc2104fd2008-01-30 22:03:57 +0100641 le32_add_cpu(&aed->lengthAllocDescs, adsize);
Jan Karaff116fc2007-05-08 00:35:14 -0700642 udf_update_tag(epos.bh->b_data, epos.offset);
643 mark_buffer_dirty(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 }
645 }
646 }
647
Jan Kara3bf25cb2007-05-08 00:35:16 -0700648 brelse(epos.bh);
649 brelse(oepos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700651error_return:
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800652 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 return;
654}
655
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700656static 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660{
661 struct udf_sb_info *sbi = UDF_SB(sb);
662 int alloc_count = 0;
Jan Karaff116fc2007-05-08 00:35:14 -0700663 uint32_t elen, adsize;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200664 struct kernel_lb_addr eloc;
Jan Karaff116fc2007-05-08 00:35:14 -0700665 struct extent_position epos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 int8_t etype = -1;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800667 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
Roel Kluin3391faa2009-06-22 23:12:29 +0200669 if (first_block >= sbi->s_partmaps[partition].s_partition_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 return 0;
671
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800672 iinfo = UDF_I(table);
673 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200674 adsize = sizeof(struct short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800675 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200676 adsize = sizeof(struct long_ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 else
678 return 0;
679
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800680 mutex_lock(&sbi->s_alloc_mutex);
Jan Karaff116fc2007-05-08 00:35:14 -0700681 epos.offset = sizeof(struct unallocSpaceEntry);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800682 epos.block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700683 epos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 eloc.logicalBlockNum = 0xFFFFFFFF;
685
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700686 while (first_block != eloc.logicalBlockNum &&
687 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 udf_debug("eloc=%d, elen=%d, first_block=%d\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700689 eloc.logicalBlockNum, elen, first_block);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700690 ; /* empty loop body */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 }
692
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700693 if (first_block == eloc.logicalBlockNum) {
Jan Karaff116fc2007-05-08 00:35:14 -0700694 epos.offset -= adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 alloc_count = (elen >> sb->s_blocksize_bits);
Jan Karabacfb7c2009-01-26 17:20:46 +0100697 if (inode && vfs_dq_prealloc_block(inode,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800698 alloc_count > block_count ? block_count : alloc_count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 alloc_count = 0;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800700 else if (alloc_count > block_count) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 alloc_count = block_count;
702 eloc.logicalBlockNum += alloc_count;
703 elen -= (alloc_count << sb->s_blocksize_bits);
Pekka Enberg97e961f2008-10-15 12:29:03 +0200704 udf_write_aext(table, &epos, &eloc,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800705 (etype << 30) | elen, 1);
706 } else
707 udf_delete_aext(table, epos, eloc,
708 (etype << 30) | elen);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700709 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 alloc_count = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700711 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Jan Kara3bf25cb2007-05-08 00:35:16 -0700713 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Jan Kara146bca72009-03-16 18:27:37 +0100715 if (alloc_count)
716 udf_add_free_space(sb, partition, -alloc_count);
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800717 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 return alloc_count;
719}
720
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700721static 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725{
726 struct udf_sb_info *sbi = UDF_SB(sb);
727 uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
728 uint32_t newblock = 0, adsize;
Jan Karaff116fc2007-05-08 00:35:14 -0700729 uint32_t elen, goal_elen = 0;
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200730 struct kernel_lb_addr eloc, uninitialized_var(goal_eloc);
Jan Karaff116fc2007-05-08 00:35:14 -0700731 struct extent_position epos, goal_epos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 int8_t etype;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800733 struct udf_inode_info *iinfo = UDF_I(table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 *err = -ENOSPC;
736
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800737 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200738 adsize = sizeof(struct short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800739 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Pekka Enberg5ca4e4b2008-10-15 12:28:03 +0200740 adsize = sizeof(struct long_ad);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 else
742 return newblock;
743
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800744 mutex_lock(&sbi->s_alloc_mutex);
Roel Kluin3391faa2009-06-22 23:12:29 +0200745 if (goal >= sbi->s_partmaps[partition].s_partition_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 goal = 0;
747
Marcin Slusarz4b111112008-02-08 04:20:36 -0800748 /* 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.
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700752 */
Jan Karaff116fc2007-05-08 00:35:14 -0700753 epos.offset = sizeof(struct unallocSpaceEntry);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800754 epos.block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700755 epos.bh = goal_epos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700757 while (spread &&
758 (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700759 if (goal >= eloc.logicalBlockNum) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800760 if (goal < eloc.logicalBlockNum +
761 (elen >> sb->s_blocksize_bits))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 nspread = 0;
763 else
764 nspread = goal - eloc.logicalBlockNum -
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700765 (elen >> sb->s_blocksize_bits);
766 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 nspread = eloc.logicalBlockNum - goal;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700768 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700770 if (nspread < spread) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 spread = nspread;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700772 if (goal_epos.bh != epos.bh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700773 brelse(goal_epos.bh);
Jan Karaff116fc2007-05-08 00:35:14 -0700774 goal_epos.bh = epos.bh;
Jan Kara3bf25cb2007-05-08 00:35:16 -0700775 get_bh(goal_epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 }
Jan Karaff116fc2007-05-08 00:35:14 -0700777 goal_epos.block = epos.block;
778 goal_epos.offset = epos.offset - adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 goal_eloc = eloc;
780 goal_elen = (etype << 30) | elen;
781 }
782 }
783
Jan Kara3bf25cb2007-05-08 00:35:16 -0700784 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700786 if (spread == 0xFFFFFFFF) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700787 brelse(goal_epos.bh);
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800788 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 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;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700798 goal_eloc.logicalBlockNum++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 goal_elen -= sb->s_blocksize;
800
Jan Karabacfb7c2009-01-26 17:20:46 +0100801 if (inode && vfs_dq_alloc_block(inode, 1)) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700802 brelse(goal_epos.bh);
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800803 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 *err = -EDQUOT;
805 return 0;
806 }
807
808 if (goal_elen)
Pekka Enberg97e961f2008-10-15 12:29:03 +0200809 udf_write_aext(table, &goal_epos, &goal_eloc, goal_elen, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 else
Jan Karaff116fc2007-05-08 00:35:14 -0700811 udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700812 brelse(goal_epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Jan Kara146bca72009-03-16 18:27:37 +0100814 udf_add_free_space(sb, partition, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Ingo Molnar1e7933d2006-03-23 03:00:44 -0800816 mutex_unlock(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 *err = 0;
818 return newblock;
819}
820
Pekka Enberg97e961f2008-10-15 12:29:03 +0200821void udf_free_blocks(struct super_block *sb, struct inode *inode,
822 struct kernel_lb_addr *bloc, uint32_t offset,
823 uint32_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824{
Pekka Enberg97e961f2008-10-15 12:29:03 +0200825 uint16_t partition = bloc->partitionReferenceNum;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800826 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800828 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
Jan Karae650b942008-12-01 13:06:10 +0100829 udf_bitmap_free_blocks(sb, inode, map->s_uspace.s_bitmap,
830 bloc, offset, count);
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800831 } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
Jan Karae650b942008-12-01 13:06:10 +0100832 udf_table_free_blocks(sb, inode, map->s_uspace.s_table,
833 bloc, offset, count);
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800834 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
Jan Karae650b942008-12-01 13:06:10 +0100835 udf_bitmap_free_blocks(sb, inode, map->s_fspace.s_bitmap,
836 bloc, offset, count);
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800837 } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
Jan Karae650b942008-12-01 13:06:10 +0100838 udf_table_free_blocks(sb, inode, map->s_fspace.s_table,
839 bloc, offset, count);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700840 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841}
842
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700843inline 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847{
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800848 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
849
Marcin Slusarz4b111112008-02-08 04:20:36 -0800850 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 return udf_bitmap_prealloc_blocks(sb, inode,
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800852 map->s_uspace.s_bitmap,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800853 partition, first_block,
854 block_count);
855 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 return udf_table_prealloc_blocks(sb, inode,
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800857 map->s_uspace.s_table,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800858 partition, first_block,
859 block_count);
860 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 return udf_bitmap_prealloc_blocks(sb, inode,
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800862 map->s_fspace.s_bitmap,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800863 partition, first_block,
864 block_count);
865 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 return udf_table_prealloc_blocks(sb, inode,
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800867 map->s_fspace.s_table,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800868 partition, first_block,
869 block_count);
870 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 return 0;
872}
873
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700874inline int udf_new_block(struct super_block *sb,
875 struct inode *inode,
876 uint16_t partition, uint32_t goal, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877{
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800878 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
Jan Kara3bf25cb2007-05-08 00:35:16 -0700879
Marcin Slusarz4b111112008-02-08 04:20:36 -0800880 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
881 return udf_bitmap_new_block(sb, inode,
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800882 map->s_uspace.s_bitmap,
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700883 partition, goal, err);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800884 else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 return udf_table_new_block(sb, inode,
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800886 map->s_uspace.s_table,
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700887 partition, goal, err);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800888 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 return udf_bitmap_new_block(sb, inode,
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800890 map->s_fspace.s_bitmap,
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700891 partition, goal, err);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800892 else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 return udf_table_new_block(sb, inode,
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800894 map->s_fspace.s_table,
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700895 partition, goal, err);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800896 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 *err = -EIO;
898 return 0;
899 }
900}