Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/fs/hfsplus/extents.c | |
3 | * | |
4 | * Copyright (C) 2001 | |
5 | * Brad Boyer (flar@allandria.com) | |
6 | * (C) 2003 Ardis Technologies <roman@ardistech.com> | |
7 | * | |
8 | * Handling of Extents both in catalog and extents overflow trees | |
9 | */ | |
10 | ||
11 | #include <linux/errno.h> | |
12 | #include <linux/fs.h> | |
13 | #include <linux/pagemap.h> | |
1da177e4 LT |
14 | |
15 | #include "hfsplus_fs.h" | |
16 | #include "hfsplus_raw.h" | |
17 | ||
18 | /* Compare two extents keys, returns 0 on same, pos/neg for difference */ | |
2179d372 DE |
19 | int hfsplus_ext_cmp_key(const hfsplus_btree_key *k1, |
20 | const hfsplus_btree_key *k2) | |
1da177e4 LT |
21 | { |
22 | __be32 k1id, k2id; | |
23 | __be32 k1s, k2s; | |
24 | ||
25 | k1id = k1->ext.cnid; | |
26 | k2id = k2->ext.cnid; | |
27 | if (k1id != k2id) | |
28 | return be32_to_cpu(k1id) < be32_to_cpu(k2id) ? -1 : 1; | |
29 | ||
30 | if (k1->ext.fork_type != k2->ext.fork_type) | |
31 | return k1->ext.fork_type < k2->ext.fork_type ? -1 : 1; | |
32 | ||
33 | k1s = k1->ext.start_block; | |
34 | k2s = k2->ext.start_block; | |
35 | if (k1s == k2s) | |
36 | return 0; | |
37 | return be32_to_cpu(k1s) < be32_to_cpu(k2s) ? -1 : 1; | |
38 | } | |
39 | ||
40 | static void hfsplus_ext_build_key(hfsplus_btree_key *key, u32 cnid, | |
41 | u32 block, u8 type) | |
42 | { | |
43 | key->key_len = cpu_to_be16(HFSPLUS_EXT_KEYLEN - 2); | |
44 | key->ext.cnid = cpu_to_be32(cnid); | |
45 | key->ext.start_block = cpu_to_be32(block); | |
46 | key->ext.fork_type = type; | |
47 | key->ext.pad = 0; | |
48 | } | |
49 | ||
50 | static u32 hfsplus_ext_find_block(struct hfsplus_extent *ext, u32 off) | |
51 | { | |
52 | int i; | |
53 | u32 count; | |
54 | ||
55 | for (i = 0; i < 8; ext++, i++) { | |
56 | count = be32_to_cpu(ext->block_count); | |
57 | if (off < count) | |
58 | return be32_to_cpu(ext->start_block) + off; | |
59 | off -= count; | |
60 | } | |
61 | /* panic? */ | |
62 | return 0; | |
63 | } | |
64 | ||
65 | static int hfsplus_ext_block_count(struct hfsplus_extent *ext) | |
66 | { | |
67 | int i; | |
68 | u32 count = 0; | |
69 | ||
70 | for (i = 0; i < 8; ext++, i++) | |
71 | count += be32_to_cpu(ext->block_count); | |
72 | return count; | |
73 | } | |
74 | ||
75 | static u32 hfsplus_ext_lastblock(struct hfsplus_extent *ext) | |
76 | { | |
77 | int i; | |
78 | ||
79 | ext += 7; | |
80 | for (i = 0; i < 7; ext--, i++) | |
81 | if (ext->block_count) | |
82 | break; | |
83 | return be32_to_cpu(ext->start_block) + be32_to_cpu(ext->block_count); | |
84 | } | |
85 | ||
2753cc28 AS |
86 | static void __hfsplus_ext_write_extent(struct inode *inode, |
87 | struct hfs_find_data *fd) | |
1da177e4 | 88 | { |
6af502de | 89 | struct hfsplus_inode_info *hip = HFSPLUS_I(inode); |
1da177e4 LT |
90 | int res; |
91 | ||
7fcc99f4 CH |
92 | WARN_ON(!mutex_is_locked(&hip->extents_lock)); |
93 | ||
6af502de CH |
94 | hfsplus_ext_build_key(fd->search_key, inode->i_ino, hip->cached_start, |
95 | HFSPLUS_IS_RSRC(inode) ? | |
96 | HFSPLUS_TYPE_RSRC : HFSPLUS_TYPE_DATA); | |
97 | ||
1da177e4 | 98 | res = hfs_brec_find(fd); |
b33b7921 | 99 | if (hip->extent_state & HFSPLUS_EXT_NEW) { |
1da177e4 LT |
100 | if (res != -ENOENT) |
101 | return; | |
6af502de CH |
102 | hfs_brec_insert(fd, hip->cached_extents, |
103 | sizeof(hfsplus_extent_rec)); | |
b33b7921 | 104 | hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW); |
1da177e4 LT |
105 | } else { |
106 | if (res) | |
107 | return; | |
6af502de CH |
108 | hfs_bnode_write(fd->bnode, hip->cached_extents, |
109 | fd->entryoffset, fd->entrylength); | |
b33b7921 | 110 | hip->extent_state &= ~HFSPLUS_EXT_DIRTY; |
1da177e4 | 111 | } |
e3494705 CH |
112 | |
113 | /* | |
114 | * We can't just use hfsplus_mark_inode_dirty here, because we | |
115 | * also get called from hfsplus_write_inode, which should not | |
116 | * redirty the inode. Instead the callers have to be careful | |
117 | * to explicily mark the inode dirty, too. | |
118 | */ | |
119 | set_bit(HFSPLUS_I_EXT_DIRTY, &hip->flags); | |
1da177e4 LT |
120 | } |
121 | ||
dd7f3d54 | 122 | static int hfsplus_ext_write_extent_locked(struct inode *inode) |
1da177e4 | 123 | { |
dd7f3d54 AK |
124 | int res; |
125 | ||
b33b7921 | 126 | if (HFSPLUS_I(inode)->extent_state & HFSPLUS_EXT_DIRTY) { |
1da177e4 LT |
127 | struct hfs_find_data fd; |
128 | ||
dd7f3d54 AK |
129 | res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd); |
130 | if (res) | |
131 | return res; | |
132 | __hfsplus_ext_write_extent(inode, &fd); | |
133 | hfs_find_exit(&fd); | |
1da177e4 | 134 | } |
dd7f3d54 | 135 | return 0; |
1da177e4 LT |
136 | } |
137 | ||
dd7f3d54 | 138 | int hfsplus_ext_write_extent(struct inode *inode) |
7fcc99f4 | 139 | { |
dd7f3d54 AK |
140 | int res; |
141 | ||
7fcc99f4 | 142 | mutex_lock(&HFSPLUS_I(inode)->extents_lock); |
dd7f3d54 | 143 | res = hfsplus_ext_write_extent_locked(inode); |
7fcc99f4 | 144 | mutex_unlock(&HFSPLUS_I(inode)->extents_lock); |
dd7f3d54 AK |
145 | |
146 | return res; | |
7fcc99f4 CH |
147 | } |
148 | ||
1da177e4 LT |
149 | static inline int __hfsplus_ext_read_extent(struct hfs_find_data *fd, |
150 | struct hfsplus_extent *extent, | |
151 | u32 cnid, u32 block, u8 type) | |
152 | { | |
153 | int res; | |
154 | ||
155 | hfsplus_ext_build_key(fd->search_key, cnid, block, type); | |
156 | fd->key->ext.cnid = 0; | |
157 | res = hfs_brec_find(fd); | |
158 | if (res && res != -ENOENT) | |
159 | return res; | |
160 | if (fd->key->ext.cnid != fd->search_key->ext.cnid || | |
161 | fd->key->ext.fork_type != fd->search_key->ext.fork_type) | |
162 | return -ENOENT; | |
163 | if (fd->entrylength != sizeof(hfsplus_extent_rec)) | |
164 | return -EIO; | |
2753cc28 AS |
165 | hfs_bnode_read(fd->bnode, extent, fd->entryoffset, |
166 | sizeof(hfsplus_extent_rec)); | |
1da177e4 LT |
167 | return 0; |
168 | } | |
169 | ||
2753cc28 AS |
170 | static inline int __hfsplus_ext_cache_extent(struct hfs_find_data *fd, |
171 | struct inode *inode, u32 block) | |
1da177e4 | 172 | { |
6af502de | 173 | struct hfsplus_inode_info *hip = HFSPLUS_I(inode); |
1da177e4 LT |
174 | int res; |
175 | ||
7fcc99f4 CH |
176 | WARN_ON(!mutex_is_locked(&hip->extents_lock)); |
177 | ||
b33b7921 | 178 | if (hip->extent_state & HFSPLUS_EXT_DIRTY) |
1da177e4 LT |
179 | __hfsplus_ext_write_extent(inode, fd); |
180 | ||
6af502de CH |
181 | res = __hfsplus_ext_read_extent(fd, hip->cached_extents, inode->i_ino, |
182 | block, HFSPLUS_IS_RSRC(inode) ? | |
183 | HFSPLUS_TYPE_RSRC : | |
184 | HFSPLUS_TYPE_DATA); | |
1da177e4 | 185 | if (!res) { |
6af502de | 186 | hip->cached_start = be32_to_cpu(fd->key->ext.start_block); |
2753cc28 AS |
187 | hip->cached_blocks = |
188 | hfsplus_ext_block_count(hip->cached_extents); | |
1da177e4 | 189 | } else { |
6af502de | 190 | hip->cached_start = hip->cached_blocks = 0; |
b33b7921 | 191 | hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW); |
1da177e4 LT |
192 | } |
193 | return res; | |
194 | } | |
195 | ||
196 | static int hfsplus_ext_read_extent(struct inode *inode, u32 block) | |
197 | { | |
6af502de | 198 | struct hfsplus_inode_info *hip = HFSPLUS_I(inode); |
1da177e4 LT |
199 | struct hfs_find_data fd; |
200 | int res; | |
201 | ||
6af502de CH |
202 | if (block >= hip->cached_start && |
203 | block < hip->cached_start + hip->cached_blocks) | |
1da177e4 LT |
204 | return 0; |
205 | ||
5bd9d99d AK |
206 | res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd); |
207 | if (!res) { | |
208 | res = __hfsplus_ext_cache_extent(&fd, inode, block); | |
209 | hfs_find_exit(&fd); | |
210 | } | |
1da177e4 LT |
211 | return res; |
212 | } | |
213 | ||
214 | /* Get a block at iblock for inode, possibly allocating if create */ | |
215 | int hfsplus_get_block(struct inode *inode, sector_t iblock, | |
216 | struct buffer_head *bh_result, int create) | |
217 | { | |
dd73a01a CH |
218 | struct super_block *sb = inode->i_sb; |
219 | struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb); | |
6af502de | 220 | struct hfsplus_inode_info *hip = HFSPLUS_I(inode); |
1da177e4 LT |
221 | int res = -EIO; |
222 | u32 ablock, dblock, mask; | |
bf1a1b31 | 223 | sector_t sector; |
e3494705 | 224 | int was_dirty = 0; |
1da177e4 LT |
225 | int shift; |
226 | ||
1da177e4 | 227 | /* Convert inode block to disk allocation block */ |
dd73a01a CH |
228 | shift = sbi->alloc_blksz_shift - sb->s_blocksize_bits; |
229 | ablock = iblock >> sbi->fs_shift; | |
1da177e4 | 230 | |
6af502de CH |
231 | if (iblock >= hip->fs_blocks) { |
232 | if (iblock > hip->fs_blocks || !create) | |
1da177e4 | 233 | return -EIO; |
6af502de | 234 | if (ablock >= hip->alloc_blocks) { |
1da177e4 LT |
235 | res = hfsplus_file_extend(inode); |
236 | if (res) | |
237 | return res; | |
238 | } | |
239 | } else | |
240 | create = 0; | |
241 | ||
6af502de CH |
242 | if (ablock < hip->first_blocks) { |
243 | dblock = hfsplus_ext_find_block(hip->first_extents, ablock); | |
1da177e4 LT |
244 | goto done; |
245 | } | |
246 | ||
248736c2 ES |
247 | if (inode->i_ino == HFSPLUS_EXT_CNID) |
248 | return -EIO; | |
249 | ||
6af502de | 250 | mutex_lock(&hip->extents_lock); |
e3494705 CH |
251 | |
252 | /* | |
253 | * hfsplus_ext_read_extent will write out a cached extent into | |
254 | * the extents btree. In that case we may have to mark the inode | |
255 | * dirty even for a pure read of an extent here. | |
256 | */ | |
257 | was_dirty = (hip->extent_state & HFSPLUS_EXT_DIRTY); | |
1da177e4 | 258 | res = hfsplus_ext_read_extent(inode, ablock); |
e3494705 | 259 | if (res) { |
6af502de | 260 | mutex_unlock(&hip->extents_lock); |
1da177e4 LT |
261 | return -EIO; |
262 | } | |
e3494705 CH |
263 | dblock = hfsplus_ext_find_block(hip->cached_extents, |
264 | ablock - hip->cached_start); | |
6af502de | 265 | mutex_unlock(&hip->extents_lock); |
1da177e4 LT |
266 | |
267 | done: | |
2753cc28 AS |
268 | dprint(DBG_EXTENT, "get_block(%lu): %llu - %u\n", |
269 | inode->i_ino, (long long)iblock, dblock); | |
bf1a1b31 | 270 | |
dd73a01a | 271 | mask = (1 << sbi->fs_shift) - 1; |
bf1a1b31 CH |
272 | sector = ((sector_t)dblock << sbi->fs_shift) + |
273 | sbi->blockoffset + (iblock & mask); | |
274 | map_bh(bh_result, sb, sector); | |
275 | ||
1da177e4 LT |
276 | if (create) { |
277 | set_buffer_new(bh_result); | |
6af502de CH |
278 | hip->phys_size += sb->s_blocksize; |
279 | hip->fs_blocks++; | |
1da177e4 | 280 | inode_add_bytes(inode, sb->s_blocksize); |
1da177e4 | 281 | } |
e3494705 CH |
282 | if (create || was_dirty) |
283 | mark_inode_dirty(inode); | |
1da177e4 LT |
284 | return 0; |
285 | } | |
286 | ||
287 | static void hfsplus_dump_extent(struct hfsplus_extent *extent) | |
288 | { | |
289 | int i; | |
290 | ||
291 | dprint(DBG_EXTENT, " "); | |
292 | for (i = 0; i < 8; i++) | |
293 | dprint(DBG_EXTENT, " %u:%u", be32_to_cpu(extent[i].start_block), | |
294 | be32_to_cpu(extent[i].block_count)); | |
295 | dprint(DBG_EXTENT, "\n"); | |
296 | } | |
297 | ||
298 | static int hfsplus_add_extent(struct hfsplus_extent *extent, u32 offset, | |
299 | u32 alloc_block, u32 block_count) | |
300 | { | |
301 | u32 count, start; | |
302 | int i; | |
303 | ||
304 | hfsplus_dump_extent(extent); | |
305 | for (i = 0; i < 8; extent++, i++) { | |
306 | count = be32_to_cpu(extent->block_count); | |
307 | if (offset == count) { | |
308 | start = be32_to_cpu(extent->start_block); | |
309 | if (alloc_block != start + count) { | |
310 | if (++i >= 8) | |
311 | return -ENOSPC; | |
312 | extent++; | |
313 | extent->start_block = cpu_to_be32(alloc_block); | |
314 | } else | |
315 | block_count += count; | |
316 | extent->block_count = cpu_to_be32(block_count); | |
317 | return 0; | |
318 | } else if (offset < count) | |
319 | break; | |
320 | offset -= count; | |
321 | } | |
322 | /* panic? */ | |
323 | return -EIO; | |
324 | } | |
325 | ||
326 | static int hfsplus_free_extents(struct super_block *sb, | |
327 | struct hfsplus_extent *extent, | |
328 | u32 offset, u32 block_nr) | |
329 | { | |
330 | u32 count, start; | |
331 | int i; | |
332 | ||
333 | hfsplus_dump_extent(extent); | |
334 | for (i = 0; i < 8; extent++, i++) { | |
335 | count = be32_to_cpu(extent->block_count); | |
336 | if (offset == count) | |
337 | goto found; | |
338 | else if (offset < count) | |
339 | break; | |
340 | offset -= count; | |
341 | } | |
342 | /* panic? */ | |
343 | return -EIO; | |
344 | found: | |
345 | for (;;) { | |
346 | start = be32_to_cpu(extent->start_block); | |
347 | if (count <= block_nr) { | |
348 | hfsplus_block_free(sb, start, count); | |
349 | extent->block_count = 0; | |
350 | extent->start_block = 0; | |
351 | block_nr -= count; | |
352 | } else { | |
353 | count -= block_nr; | |
354 | hfsplus_block_free(sb, start + count, block_nr); | |
355 | extent->block_count = cpu_to_be32(count); | |
356 | block_nr = 0; | |
357 | } | |
358 | if (!block_nr || !i) | |
359 | return 0; | |
360 | i--; | |
361 | extent--; | |
362 | count = be32_to_cpu(extent->block_count); | |
363 | } | |
364 | } | |
365 | ||
2753cc28 AS |
366 | int hfsplus_free_fork(struct super_block *sb, u32 cnid, |
367 | struct hfsplus_fork_raw *fork, int type) | |
1da177e4 LT |
368 | { |
369 | struct hfs_find_data fd; | |
370 | hfsplus_extent_rec ext_entry; | |
371 | u32 total_blocks, blocks, start; | |
372 | int res, i; | |
373 | ||
374 | total_blocks = be32_to_cpu(fork->total_blocks); | |
375 | if (!total_blocks) | |
376 | return 0; | |
377 | ||
378 | blocks = 0; | |
379 | for (i = 0; i < 8; i++) | |
380 | blocks += be32_to_cpu(fork->extents[i].block_count); | |
381 | ||
382 | res = hfsplus_free_extents(sb, fork->extents, blocks, blocks); | |
383 | if (res) | |
384 | return res; | |
385 | if (total_blocks == blocks) | |
386 | return 0; | |
387 | ||
5bd9d99d AK |
388 | res = hfs_find_init(HFSPLUS_SB(sb)->ext_tree, &fd); |
389 | if (res) | |
390 | return res; | |
1da177e4 LT |
391 | do { |
392 | res = __hfsplus_ext_read_extent(&fd, ext_entry, cnid, | |
393 | total_blocks, type); | |
394 | if (res) | |
395 | break; | |
396 | start = be32_to_cpu(fd.key->ext.start_block); | |
397 | hfsplus_free_extents(sb, ext_entry, | |
398 | total_blocks - start, | |
399 | total_blocks); | |
400 | hfs_brec_remove(&fd); | |
401 | total_blocks = start; | |
402 | } while (total_blocks > blocks); | |
403 | hfs_find_exit(&fd); | |
404 | ||
405 | return res; | |
406 | } | |
407 | ||
408 | int hfsplus_file_extend(struct inode *inode) | |
409 | { | |
410 | struct super_block *sb = inode->i_sb; | |
dd73a01a | 411 | struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb); |
6af502de | 412 | struct hfsplus_inode_info *hip = HFSPLUS_I(inode); |
1da177e4 LT |
413 | u32 start, len, goal; |
414 | int res; | |
415 | ||
1065348d CH |
416 | if (sbi->alloc_file->i_size * 8 < |
417 | sbi->total_blocks - sbi->free_blocks + 8) { | |
21f2296a | 418 | /* extend alloc file */ |
b2837fcf AS |
419 | printk(KERN_ERR "hfs: extend alloc file! " |
420 | "(%llu,%u,%u)\n", | |
421 | sbi->alloc_file->i_size * 8, | |
422 | sbi->total_blocks, sbi->free_blocks); | |
1da177e4 | 423 | return -ENOSPC; |
1da177e4 LT |
424 | } |
425 | ||
6af502de CH |
426 | mutex_lock(&hip->extents_lock); |
427 | if (hip->alloc_blocks == hip->first_blocks) | |
428 | goal = hfsplus_ext_lastblock(hip->first_extents); | |
1da177e4 | 429 | else { |
6af502de | 430 | res = hfsplus_ext_read_extent(inode, hip->alloc_blocks); |
1da177e4 LT |
431 | if (res) |
432 | goto out; | |
6af502de | 433 | goal = hfsplus_ext_lastblock(hip->cached_extents); |
1da177e4 LT |
434 | } |
435 | ||
6af502de | 436 | len = hip->clump_blocks; |
dd73a01a CH |
437 | start = hfsplus_block_allocate(sb, sbi->total_blocks, goal, &len); |
438 | if (start >= sbi->total_blocks) { | |
1da177e4 LT |
439 | start = hfsplus_block_allocate(sb, goal, 0, &len); |
440 | if (start >= goal) { | |
441 | res = -ENOSPC; | |
442 | goto out; | |
443 | } | |
444 | } | |
445 | ||
446 | dprint(DBG_EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len); | |
6af502de CH |
447 | |
448 | if (hip->alloc_blocks <= hip->first_blocks) { | |
449 | if (!hip->first_blocks) { | |
1da177e4 LT |
450 | dprint(DBG_EXTENT, "first extents\n"); |
451 | /* no extents yet */ | |
6af502de CH |
452 | hip->first_extents[0].start_block = cpu_to_be32(start); |
453 | hip->first_extents[0].block_count = cpu_to_be32(len); | |
1da177e4 LT |
454 | res = 0; |
455 | } else { | |
456 | /* try to append to extents in inode */ | |
6af502de CH |
457 | res = hfsplus_add_extent(hip->first_extents, |
458 | hip->alloc_blocks, | |
1da177e4 LT |
459 | start, len); |
460 | if (res == -ENOSPC) | |
461 | goto insert_extent; | |
462 | } | |
463 | if (!res) { | |
6af502de CH |
464 | hfsplus_dump_extent(hip->first_extents); |
465 | hip->first_blocks += len; | |
1da177e4 LT |
466 | } |
467 | } else { | |
6af502de CH |
468 | res = hfsplus_add_extent(hip->cached_extents, |
469 | hip->alloc_blocks - hip->cached_start, | |
1da177e4 LT |
470 | start, len); |
471 | if (!res) { | |
6af502de | 472 | hfsplus_dump_extent(hip->cached_extents); |
b33b7921 | 473 | hip->extent_state |= HFSPLUS_EXT_DIRTY; |
6af502de | 474 | hip->cached_blocks += len; |
1da177e4 LT |
475 | } else if (res == -ENOSPC) |
476 | goto insert_extent; | |
477 | } | |
478 | out: | |
6af502de | 479 | mutex_unlock(&hip->extents_lock); |
1da177e4 | 480 | if (!res) { |
6af502de | 481 | hip->alloc_blocks += len; |
e3494705 | 482 | hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY); |
1da177e4 LT |
483 | } |
484 | return res; | |
485 | ||
486 | insert_extent: | |
487 | dprint(DBG_EXTENT, "insert new extent\n"); | |
dd7f3d54 AK |
488 | res = hfsplus_ext_write_extent_locked(inode); |
489 | if (res) | |
490 | goto out; | |
1da177e4 | 491 | |
6af502de CH |
492 | memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec)); |
493 | hip->cached_extents[0].start_block = cpu_to_be32(start); | |
494 | hip->cached_extents[0].block_count = cpu_to_be32(len); | |
495 | hfsplus_dump_extent(hip->cached_extents); | |
b33b7921 | 496 | hip->extent_state |= HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW; |
6af502de CH |
497 | hip->cached_start = hip->alloc_blocks; |
498 | hip->cached_blocks = len; | |
1da177e4 LT |
499 | |
500 | res = 0; | |
501 | goto out; | |
502 | } | |
503 | ||
504 | void hfsplus_file_truncate(struct inode *inode) | |
505 | { | |
506 | struct super_block *sb = inode->i_sb; | |
6af502de | 507 | struct hfsplus_inode_info *hip = HFSPLUS_I(inode); |
1da177e4 LT |
508 | struct hfs_find_data fd; |
509 | u32 alloc_cnt, blk_cnt, start; | |
510 | int res; | |
511 | ||
b2837fcf AS |
512 | dprint(DBG_INODE, "truncate: %lu, %llu -> %llu\n", |
513 | inode->i_ino, (long long)hip->phys_size, | |
514 | inode->i_size); | |
6af502de CH |
515 | |
516 | if (inode->i_size > hip->phys_size) { | |
1da177e4 LT |
517 | struct address_space *mapping = inode->i_mapping; |
518 | struct page *page; | |
7c0efc62 NP |
519 | void *fsdata; |
520 | u32 size = inode->i_size; | |
1da177e4 | 521 | |
7c0efc62 NP |
522 | res = pagecache_write_begin(NULL, mapping, size, 0, |
523 | AOP_FLAG_UNINTERRUPTIBLE, | |
524 | &page, &fsdata); | |
1da177e4 | 525 | if (res) |
7c0efc62 | 526 | return; |
2753cc28 AS |
527 | res = pagecache_write_end(NULL, mapping, size, |
528 | 0, 0, page, fsdata); | |
7c0efc62 NP |
529 | if (res < 0) |
530 | return; | |
1da177e4 LT |
531 | mark_inode_dirty(inode); |
532 | return; | |
6af502de | 533 | } else if (inode->i_size == hip->phys_size) |
f76d28d2 RZ |
534 | return; |
535 | ||
dd73a01a CH |
536 | blk_cnt = (inode->i_size + HFSPLUS_SB(sb)->alloc_blksz - 1) >> |
537 | HFSPLUS_SB(sb)->alloc_blksz_shift; | |
6af502de | 538 | alloc_cnt = hip->alloc_blocks; |
1da177e4 LT |
539 | if (blk_cnt == alloc_cnt) |
540 | goto out; | |
541 | ||
6af502de | 542 | mutex_lock(&hip->extents_lock); |
5bd9d99d AK |
543 | res = hfs_find_init(HFSPLUS_SB(sb)->ext_tree, &fd); |
544 | if (res) { | |
545 | mutex_unlock(&hip->extents_lock); | |
546 | /* XXX: We lack error handling of hfsplus_file_truncate() */ | |
547 | return; | |
548 | } | |
1da177e4 | 549 | while (1) { |
6af502de CH |
550 | if (alloc_cnt == hip->first_blocks) { |
551 | hfsplus_free_extents(sb, hip->first_extents, | |
1da177e4 | 552 | alloc_cnt, alloc_cnt - blk_cnt); |
6af502de CH |
553 | hfsplus_dump_extent(hip->first_extents); |
554 | hip->first_blocks = blk_cnt; | |
1da177e4 LT |
555 | break; |
556 | } | |
557 | res = __hfsplus_ext_cache_extent(&fd, inode, alloc_cnt); | |
558 | if (res) | |
559 | break; | |
6af502de CH |
560 | start = hip->cached_start; |
561 | hfsplus_free_extents(sb, hip->cached_extents, | |
1da177e4 | 562 | alloc_cnt - start, alloc_cnt - blk_cnt); |
6af502de | 563 | hfsplus_dump_extent(hip->cached_extents); |
1da177e4 | 564 | if (blk_cnt > start) { |
b33b7921 | 565 | hip->extent_state |= HFSPLUS_EXT_DIRTY; |
1da177e4 LT |
566 | break; |
567 | } | |
568 | alloc_cnt = start; | |
6af502de | 569 | hip->cached_start = hip->cached_blocks = 0; |
b33b7921 | 570 | hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW); |
1da177e4 LT |
571 | hfs_brec_remove(&fd); |
572 | } | |
573 | hfs_find_exit(&fd); | |
6af502de | 574 | mutex_unlock(&hip->extents_lock); |
1da177e4 | 575 | |
6af502de | 576 | hip->alloc_blocks = blk_cnt; |
1da177e4 | 577 | out: |
6af502de | 578 | hip->phys_size = inode->i_size; |
2753cc28 AS |
579 | hip->fs_blocks = (inode->i_size + sb->s_blocksize - 1) >> |
580 | sb->s_blocksize_bits; | |
6af502de | 581 | inode_set_bytes(inode, hip->fs_blocks << sb->s_blocksize_bits); |
e3494705 | 582 | hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY); |
1da177e4 | 583 | } |