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