11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds * linux/fs/hfs/extent.c
31da177e4SLinus Torvalds *
41da177e4SLinus Torvalds * Copyright (C) 1995-1997 Paul H. Hargrove
51da177e4SLinus Torvalds * (C) 2003 Ardis Technologies <roman@ardistech.com>
61da177e4SLinus Torvalds * This file may be distributed under the terms of the GNU General Public License.
71da177e4SLinus Torvalds *
81da177e4SLinus Torvalds * This file contains the functions related to the extents B-tree.
91da177e4SLinus Torvalds */
101da177e4SLinus Torvalds
111da177e4SLinus Torvalds #include <linux/pagemap.h>
121da177e4SLinus Torvalds
131da177e4SLinus Torvalds #include "hfs_fs.h"
141da177e4SLinus Torvalds #include "btree.h"
151da177e4SLinus Torvalds
161da177e4SLinus Torvalds /*================ File-local functions ================*/
171da177e4SLinus Torvalds
181da177e4SLinus Torvalds /*
191da177e4SLinus Torvalds * build_key
201da177e4SLinus Torvalds */
hfs_ext_build_key(hfs_btree_key * key,u32 cnid,u16 block,u8 type)211da177e4SLinus Torvalds static void hfs_ext_build_key(hfs_btree_key *key, u32 cnid, u16 block, u8 type)
221da177e4SLinus Torvalds {
231da177e4SLinus Torvalds key->key_len = 7;
241da177e4SLinus Torvalds key->ext.FkType = type;
251da177e4SLinus Torvalds key->ext.FNum = cpu_to_be32(cnid);
261da177e4SLinus Torvalds key->ext.FABN = cpu_to_be16(block);
271da177e4SLinus Torvalds }
281da177e4SLinus Torvalds
291da177e4SLinus Torvalds /*
301da177e4SLinus Torvalds * hfs_ext_compare()
311da177e4SLinus Torvalds *
321da177e4SLinus Torvalds * Description:
331da177e4SLinus Torvalds * This is the comparison function used for the extents B-tree. In
341da177e4SLinus Torvalds * comparing extent B-tree entries, the file id is the most
351da177e4SLinus Torvalds * significant field (compared as unsigned ints); the fork type is
361da177e4SLinus Torvalds * the second most significant field (compared as unsigned chars);
371da177e4SLinus Torvalds * and the allocation block number field is the least significant
381da177e4SLinus Torvalds * (compared as unsigned ints).
391da177e4SLinus Torvalds * Input Variable(s):
401da177e4SLinus Torvalds * struct hfs_ext_key *key1: pointer to the first key to compare
411da177e4SLinus Torvalds * struct hfs_ext_key *key2: pointer to the second key to compare
421da177e4SLinus Torvalds * Output Variable(s):
431da177e4SLinus Torvalds * NONE
441da177e4SLinus Torvalds * Returns:
451da177e4SLinus Torvalds * int: negative if key1<key2, positive if key1>key2, and 0 if key1==key2
461da177e4SLinus Torvalds * Preconditions:
471da177e4SLinus Torvalds * key1 and key2 point to "valid" (struct hfs_ext_key)s.
481da177e4SLinus Torvalds * Postconditions:
491da177e4SLinus Torvalds * This function has no side-effects */
hfs_ext_keycmp(const btree_key * key1,const btree_key * key2)501da177e4SLinus Torvalds int hfs_ext_keycmp(const btree_key *key1, const btree_key *key2)
511da177e4SLinus Torvalds {
521da177e4SLinus Torvalds __be32 fnum1, fnum2;
531da177e4SLinus Torvalds __be16 block1, block2;
541da177e4SLinus Torvalds
551da177e4SLinus Torvalds fnum1 = key1->ext.FNum;
561da177e4SLinus Torvalds fnum2 = key2->ext.FNum;
571da177e4SLinus Torvalds if (fnum1 != fnum2)
581da177e4SLinus Torvalds return be32_to_cpu(fnum1) < be32_to_cpu(fnum2) ? -1 : 1;
591da177e4SLinus Torvalds if (key1->ext.FkType != key2->ext.FkType)
601da177e4SLinus Torvalds return key1->ext.FkType < key2->ext.FkType ? -1 : 1;
611da177e4SLinus Torvalds
621da177e4SLinus Torvalds block1 = key1->ext.FABN;
631da177e4SLinus Torvalds block2 = key2->ext.FABN;
641da177e4SLinus Torvalds if (block1 == block2)
651da177e4SLinus Torvalds return 0;
661da177e4SLinus Torvalds return be16_to_cpu(block1) < be16_to_cpu(block2) ? -1 : 1;
671da177e4SLinus Torvalds }
681da177e4SLinus Torvalds
691da177e4SLinus Torvalds /*
701da177e4SLinus Torvalds * hfs_ext_find_block
711da177e4SLinus Torvalds *
721da177e4SLinus Torvalds * Find a block within an extent record
731da177e4SLinus Torvalds */
hfs_ext_find_block(struct hfs_extent * ext,u16 off)741da177e4SLinus Torvalds static u16 hfs_ext_find_block(struct hfs_extent *ext, u16 off)
751da177e4SLinus Torvalds {
761da177e4SLinus Torvalds int i;
771da177e4SLinus Torvalds u16 count;
781da177e4SLinus Torvalds
791da177e4SLinus Torvalds for (i = 0; i < 3; ext++, i++) {
801da177e4SLinus Torvalds count = be16_to_cpu(ext->count);
811da177e4SLinus Torvalds if (off < count)
821da177e4SLinus Torvalds return be16_to_cpu(ext->block) + off;
831da177e4SLinus Torvalds off -= count;
841da177e4SLinus Torvalds }
851da177e4SLinus Torvalds /* panic? */
861da177e4SLinus Torvalds return 0;
871da177e4SLinus Torvalds }
881da177e4SLinus Torvalds
hfs_ext_block_count(struct hfs_extent * ext)891da177e4SLinus Torvalds static int hfs_ext_block_count(struct hfs_extent *ext)
901da177e4SLinus Torvalds {
911da177e4SLinus Torvalds int i;
921da177e4SLinus Torvalds u16 count = 0;
931da177e4SLinus Torvalds
941da177e4SLinus Torvalds for (i = 0; i < 3; ext++, i++)
951da177e4SLinus Torvalds count += be16_to_cpu(ext->count);
961da177e4SLinus Torvalds return count;
971da177e4SLinus Torvalds }
981da177e4SLinus Torvalds
hfs_ext_lastblock(struct hfs_extent * ext)991da177e4SLinus Torvalds static u16 hfs_ext_lastblock(struct hfs_extent *ext)
1001da177e4SLinus Torvalds {
1011da177e4SLinus Torvalds int i;
1021da177e4SLinus Torvalds
1031da177e4SLinus Torvalds ext += 2;
1041da177e4SLinus Torvalds for (i = 0; i < 2; ext--, i++)
1051da177e4SLinus Torvalds if (ext->count)
1061da177e4SLinus Torvalds break;
1071da177e4SLinus Torvalds return be16_to_cpu(ext->block) + be16_to_cpu(ext->count);
1081da177e4SLinus Torvalds }
1091da177e4SLinus Torvalds
__hfs_ext_write_extent(struct inode * inode,struct hfs_find_data * fd)1109509f178SAlexey Khoroshilov static int __hfs_ext_write_extent(struct inode *inode, struct hfs_find_data *fd)
1111da177e4SLinus Torvalds {
1121da177e4SLinus Torvalds int res;
1131da177e4SLinus Torvalds
1141da177e4SLinus Torvalds hfs_ext_build_key(fd->search_key, inode->i_ino, HFS_I(inode)->cached_start,
1151da177e4SLinus Torvalds HFS_IS_RSRC(inode) ? HFS_FK_RSRC : HFS_FK_DATA);
1161da177e4SLinus Torvalds res = hfs_brec_find(fd);
1171da177e4SLinus Torvalds if (HFS_I(inode)->flags & HFS_FLG_EXT_NEW) {
1181da177e4SLinus Torvalds if (res != -ENOENT)
1199509f178SAlexey Khoroshilov return res;
12054640c75SErnesto A. Fernández /* Fail early and avoid ENOSPC during the btree operation */
12154640c75SErnesto A. Fernández res = hfs_bmap_reserve(fd->tree, fd->tree->depth + 1);
12254640c75SErnesto A. Fernández if (res)
12354640c75SErnesto A. Fernández return res;
1241da177e4SLinus Torvalds hfs_brec_insert(fd, HFS_I(inode)->cached_extents, sizeof(hfs_extent_rec));
1251da177e4SLinus Torvalds HFS_I(inode)->flags &= ~(HFS_FLG_EXT_DIRTY|HFS_FLG_EXT_NEW);
1261da177e4SLinus Torvalds } else {
1271da177e4SLinus Torvalds if (res)
1289509f178SAlexey Khoroshilov return res;
1291da177e4SLinus Torvalds hfs_bnode_write(fd->bnode, HFS_I(inode)->cached_extents, fd->entryoffset, fd->entrylength);
1301da177e4SLinus Torvalds HFS_I(inode)->flags &= ~HFS_FLG_EXT_DIRTY;
1311da177e4SLinus Torvalds }
1329509f178SAlexey Khoroshilov return 0;
1331da177e4SLinus Torvalds }
1341da177e4SLinus Torvalds
hfs_ext_write_extent(struct inode * inode)1359509f178SAlexey Khoroshilov int hfs_ext_write_extent(struct inode *inode)
1361da177e4SLinus Torvalds {
1371da177e4SLinus Torvalds struct hfs_find_data fd;
1389509f178SAlexey Khoroshilov int res = 0;
1391da177e4SLinus Torvalds
1401da177e4SLinus Torvalds if (HFS_I(inode)->flags & HFS_FLG_EXT_DIRTY) {
1419509f178SAlexey Khoroshilov res = hfs_find_init(HFS_SB(inode->i_sb)->ext_tree, &fd);
1429509f178SAlexey Khoroshilov if (res)
1439509f178SAlexey Khoroshilov return res;
1449509f178SAlexey Khoroshilov res = __hfs_ext_write_extent(inode, &fd);
1451da177e4SLinus Torvalds hfs_find_exit(&fd);
1461da177e4SLinus Torvalds }
1479509f178SAlexey Khoroshilov return res;
1481da177e4SLinus Torvalds }
1491da177e4SLinus Torvalds
__hfs_ext_read_extent(struct hfs_find_data * fd,struct hfs_extent * extent,u32 cnid,u32 block,u8 type)1501da177e4SLinus Torvalds static inline int __hfs_ext_read_extent(struct hfs_find_data *fd, struct hfs_extent *extent,
1511da177e4SLinus Torvalds u32 cnid, u32 block, u8 type)
1521da177e4SLinus Torvalds {
1531da177e4SLinus Torvalds int res;
1541da177e4SLinus Torvalds
1551da177e4SLinus Torvalds hfs_ext_build_key(fd->search_key, cnid, block, type);
1561da177e4SLinus Torvalds fd->key->ext.FNum = 0;
1571da177e4SLinus Torvalds res = hfs_brec_find(fd);
1581da177e4SLinus Torvalds if (res && res != -ENOENT)
1591da177e4SLinus Torvalds return res;
1601da177e4SLinus Torvalds if (fd->key->ext.FNum != fd->search_key->ext.FNum ||
1611da177e4SLinus Torvalds fd->key->ext.FkType != fd->search_key->ext.FkType)
1621da177e4SLinus Torvalds return -ENOENT;
1631da177e4SLinus Torvalds if (fd->entrylength != sizeof(hfs_extent_rec))
1641da177e4SLinus Torvalds return -EIO;
1651da177e4SLinus Torvalds hfs_bnode_read(fd->bnode, extent, fd->entryoffset, sizeof(hfs_extent_rec));
1661da177e4SLinus Torvalds return 0;
1671da177e4SLinus Torvalds }
1681da177e4SLinus Torvalds
__hfs_ext_cache_extent(struct hfs_find_data * fd,struct inode * inode,u32 block)1691da177e4SLinus Torvalds static inline int __hfs_ext_cache_extent(struct hfs_find_data *fd, struct inode *inode, u32 block)
1701da177e4SLinus Torvalds {
1711da177e4SLinus Torvalds int res;
1721da177e4SLinus Torvalds
1739509f178SAlexey Khoroshilov if (HFS_I(inode)->flags & HFS_FLG_EXT_DIRTY) {
1749509f178SAlexey Khoroshilov res = __hfs_ext_write_extent(inode, fd);
1759509f178SAlexey Khoroshilov if (res)
1769509f178SAlexey Khoroshilov return res;
1779509f178SAlexey Khoroshilov }
1781da177e4SLinus Torvalds
1791da177e4SLinus Torvalds res = __hfs_ext_read_extent(fd, HFS_I(inode)->cached_extents, inode->i_ino,
1801da177e4SLinus Torvalds block, HFS_IS_RSRC(inode) ? HFS_FK_RSRC : HFS_FK_DATA);
1811da177e4SLinus Torvalds if (!res) {
1821da177e4SLinus Torvalds HFS_I(inode)->cached_start = be16_to_cpu(fd->key->ext.FABN);
1831da177e4SLinus Torvalds HFS_I(inode)->cached_blocks = hfs_ext_block_count(HFS_I(inode)->cached_extents);
1841da177e4SLinus Torvalds } else {
1851da177e4SLinus Torvalds HFS_I(inode)->cached_start = HFS_I(inode)->cached_blocks = 0;
1861da177e4SLinus Torvalds HFS_I(inode)->flags &= ~(HFS_FLG_EXT_DIRTY|HFS_FLG_EXT_NEW);
1871da177e4SLinus Torvalds }
1881da177e4SLinus Torvalds return res;
1891da177e4SLinus Torvalds }
1901da177e4SLinus Torvalds
hfs_ext_read_extent(struct inode * inode,u16 block)1911da177e4SLinus Torvalds static int hfs_ext_read_extent(struct inode *inode, u16 block)
1921da177e4SLinus Torvalds {
1931da177e4SLinus Torvalds struct hfs_find_data fd;
1941da177e4SLinus Torvalds int res;
1951da177e4SLinus Torvalds
1961da177e4SLinus Torvalds if (block >= HFS_I(inode)->cached_start &&
1971da177e4SLinus Torvalds block < HFS_I(inode)->cached_start + HFS_I(inode)->cached_blocks)
1981da177e4SLinus Torvalds return 0;
1991da177e4SLinus Torvalds
2009509f178SAlexey Khoroshilov res = hfs_find_init(HFS_SB(inode->i_sb)->ext_tree, &fd);
2019509f178SAlexey Khoroshilov if (!res) {
2021da177e4SLinus Torvalds res = __hfs_ext_cache_extent(&fd, inode, block);
2031da177e4SLinus Torvalds hfs_find_exit(&fd);
2049509f178SAlexey Khoroshilov }
2051da177e4SLinus Torvalds return res;
2061da177e4SLinus Torvalds }
2071da177e4SLinus Torvalds
hfs_dump_extent(struct hfs_extent * extent)2081da177e4SLinus Torvalds static void hfs_dump_extent(struct hfs_extent *extent)
2091da177e4SLinus Torvalds {
2101da177e4SLinus Torvalds int i;
2111da177e4SLinus Torvalds
212c2b3e1f7SJoe Perches hfs_dbg(EXTENT, " ");
2131da177e4SLinus Torvalds for (i = 0; i < 3; i++)
214c2b3e1f7SJoe Perches hfs_dbg_cont(EXTENT, " %u:%u",
215c2b3e1f7SJoe Perches be16_to_cpu(extent[i].block),
2161da177e4SLinus Torvalds be16_to_cpu(extent[i].count));
217c2b3e1f7SJoe Perches hfs_dbg_cont(EXTENT, "\n");
2181da177e4SLinus Torvalds }
2191da177e4SLinus Torvalds
hfs_add_extent(struct hfs_extent * extent,u16 offset,u16 alloc_block,u16 block_count)2201da177e4SLinus Torvalds static int hfs_add_extent(struct hfs_extent *extent, u16 offset,
2211da177e4SLinus Torvalds u16 alloc_block, u16 block_count)
2221da177e4SLinus Torvalds {
2231da177e4SLinus Torvalds u16 count, start;
2241da177e4SLinus Torvalds int i;
2251da177e4SLinus Torvalds
2261da177e4SLinus Torvalds hfs_dump_extent(extent);
2271da177e4SLinus Torvalds for (i = 0; i < 3; extent++, i++) {
2281da177e4SLinus Torvalds count = be16_to_cpu(extent->count);
2291da177e4SLinus Torvalds if (offset == count) {
2301da177e4SLinus Torvalds start = be16_to_cpu(extent->block);
2311da177e4SLinus Torvalds if (alloc_block != start + count) {
2321da177e4SLinus Torvalds if (++i >= 3)
2331da177e4SLinus Torvalds return -ENOSPC;
2341da177e4SLinus Torvalds extent++;
2351da177e4SLinus Torvalds extent->block = cpu_to_be16(alloc_block);
2361da177e4SLinus Torvalds } else
2371da177e4SLinus Torvalds block_count += count;
2381da177e4SLinus Torvalds extent->count = cpu_to_be16(block_count);
2391da177e4SLinus Torvalds return 0;
2401da177e4SLinus Torvalds } else if (offset < count)
2411da177e4SLinus Torvalds break;
2421da177e4SLinus Torvalds offset -= count;
2431da177e4SLinus Torvalds }
2441da177e4SLinus Torvalds /* panic? */
2451da177e4SLinus Torvalds return -EIO;
2461da177e4SLinus Torvalds }
2471da177e4SLinus Torvalds
hfs_free_extents(struct super_block * sb,struct hfs_extent * extent,u16 offset,u16 block_nr)2481da177e4SLinus Torvalds static int hfs_free_extents(struct super_block *sb, struct hfs_extent *extent,
2491da177e4SLinus Torvalds u16 offset, u16 block_nr)
2501da177e4SLinus Torvalds {
2511da177e4SLinus Torvalds u16 count, start;
2521da177e4SLinus Torvalds int i;
2531da177e4SLinus Torvalds
2541da177e4SLinus Torvalds hfs_dump_extent(extent);
2551da177e4SLinus Torvalds for (i = 0; i < 3; extent++, i++) {
2561da177e4SLinus Torvalds count = be16_to_cpu(extent->count);
2571da177e4SLinus Torvalds if (offset == count)
2581da177e4SLinus Torvalds goto found;
2591da177e4SLinus Torvalds else if (offset < count)
2601da177e4SLinus Torvalds break;
2611da177e4SLinus Torvalds offset -= count;
2621da177e4SLinus Torvalds }
2631da177e4SLinus Torvalds /* panic? */
2641da177e4SLinus Torvalds return -EIO;
2651da177e4SLinus Torvalds found:
2661da177e4SLinus Torvalds for (;;) {
2671da177e4SLinus Torvalds start = be16_to_cpu(extent->block);
2681da177e4SLinus Torvalds if (count <= block_nr) {
2691da177e4SLinus Torvalds hfs_clear_vbm_bits(sb, start, count);
2701da177e4SLinus Torvalds extent->block = 0;
2711da177e4SLinus Torvalds extent->count = 0;
2721da177e4SLinus Torvalds block_nr -= count;
2731da177e4SLinus Torvalds } else {
2741da177e4SLinus Torvalds count -= block_nr;
2751da177e4SLinus Torvalds hfs_clear_vbm_bits(sb, start + count, block_nr);
2761da177e4SLinus Torvalds extent->count = cpu_to_be16(count);
2771da177e4SLinus Torvalds block_nr = 0;
2781da177e4SLinus Torvalds }
2791da177e4SLinus Torvalds if (!block_nr || !i)
2801da177e4SLinus Torvalds return 0;
2811da177e4SLinus Torvalds i--;
2821da177e4SLinus Torvalds extent--;
2831da177e4SLinus Torvalds count = be16_to_cpu(extent->count);
2841da177e4SLinus Torvalds }
2851da177e4SLinus Torvalds }
2861da177e4SLinus Torvalds
hfs_free_fork(struct super_block * sb,struct hfs_cat_file * file,int type)2871da177e4SLinus Torvalds int hfs_free_fork(struct super_block *sb, struct hfs_cat_file *file, int type)
2881da177e4SLinus Torvalds {
2891da177e4SLinus Torvalds struct hfs_find_data fd;
2901da177e4SLinus Torvalds u32 total_blocks, blocks, start;
2911da177e4SLinus Torvalds u32 cnid = be32_to_cpu(file->FlNum);
2921da177e4SLinus Torvalds struct hfs_extent *extent;
2931da177e4SLinus Torvalds int res, i;
2941da177e4SLinus Torvalds
2951da177e4SLinus Torvalds if (type == HFS_FK_DATA) {
2961da177e4SLinus Torvalds total_blocks = be32_to_cpu(file->PyLen);
2971da177e4SLinus Torvalds extent = file->ExtRec;
2981da177e4SLinus Torvalds } else {
2991da177e4SLinus Torvalds total_blocks = be32_to_cpu(file->RPyLen);
3001da177e4SLinus Torvalds extent = file->RExtRec;
3011da177e4SLinus Torvalds }
3021da177e4SLinus Torvalds total_blocks /= HFS_SB(sb)->alloc_blksz;
3031da177e4SLinus Torvalds if (!total_blocks)
3041da177e4SLinus Torvalds return 0;
3051da177e4SLinus Torvalds
3061da177e4SLinus Torvalds blocks = 0;
3076c9a3f84SColin Ian King for (i = 0; i < 3; i++)
3081da177e4SLinus Torvalds blocks += be16_to_cpu(extent[i].count);
3091da177e4SLinus Torvalds
3101da177e4SLinus Torvalds res = hfs_free_extents(sb, extent, blocks, blocks);
3111da177e4SLinus Torvalds if (res)
3121da177e4SLinus Torvalds return res;
3131da177e4SLinus Torvalds if (total_blocks == blocks)
3141da177e4SLinus Torvalds return 0;
3151da177e4SLinus Torvalds
3169509f178SAlexey Khoroshilov res = hfs_find_init(HFS_SB(sb)->ext_tree, &fd);
3179509f178SAlexey Khoroshilov if (res)
3189509f178SAlexey Khoroshilov return res;
3191da177e4SLinus Torvalds do {
3201da177e4SLinus Torvalds res = __hfs_ext_read_extent(&fd, extent, cnid, total_blocks, type);
3211da177e4SLinus Torvalds if (res)
3221da177e4SLinus Torvalds break;
3231da177e4SLinus Torvalds start = be16_to_cpu(fd.key->ext.FABN);
3241da177e4SLinus Torvalds hfs_free_extents(sb, extent, total_blocks - start, total_blocks);
3251da177e4SLinus Torvalds hfs_brec_remove(&fd);
3261da177e4SLinus Torvalds total_blocks = start;
3271da177e4SLinus Torvalds } while (total_blocks > blocks);
3281da177e4SLinus Torvalds hfs_find_exit(&fd);
3291da177e4SLinus Torvalds
3301da177e4SLinus Torvalds return res;
3311da177e4SLinus Torvalds }
3321da177e4SLinus Torvalds
3331da177e4SLinus Torvalds /*
3341da177e4SLinus Torvalds * hfs_get_block
3351da177e4SLinus Torvalds */
hfs_get_block(struct inode * inode,sector_t block,struct buffer_head * bh_result,int create)3361da177e4SLinus Torvalds int hfs_get_block(struct inode *inode, sector_t block,
3371da177e4SLinus Torvalds struct buffer_head *bh_result, int create)
3381da177e4SLinus Torvalds {
3391da177e4SLinus Torvalds struct super_block *sb;
3401da177e4SLinus Torvalds u16 dblock, ablock;
3411da177e4SLinus Torvalds int res;
3421da177e4SLinus Torvalds
3431da177e4SLinus Torvalds sb = inode->i_sb;
3441da177e4SLinus Torvalds /* Convert inode block to disk allocation block */
3451da177e4SLinus Torvalds ablock = (u32)block / HFS_SB(sb)->fs_div;
3461da177e4SLinus Torvalds
3471da177e4SLinus Torvalds if (block >= HFS_I(inode)->fs_blocks) {
3481267a07bSErnesto A. Fernández if (!create)
3491267a07bSErnesto A. Fernández return 0;
3501267a07bSErnesto A. Fernández if (block > HFS_I(inode)->fs_blocks)
3511da177e4SLinus Torvalds return -EIO;
3521da177e4SLinus Torvalds if (ablock >= HFS_I(inode)->alloc_blocks) {
3531da177e4SLinus Torvalds res = hfs_extend_file(inode);
3541da177e4SLinus Torvalds if (res)
3551da177e4SLinus Torvalds return res;
3561da177e4SLinus Torvalds }
3571da177e4SLinus Torvalds } else
3581da177e4SLinus Torvalds create = 0;
3591da177e4SLinus Torvalds
3601da177e4SLinus Torvalds if (ablock < HFS_I(inode)->first_blocks) {
3611da177e4SLinus Torvalds dblock = hfs_ext_find_block(HFS_I(inode)->first_extents, ablock);
3621da177e4SLinus Torvalds goto done;
3631da177e4SLinus Torvalds }
3641da177e4SLinus Torvalds
36539f8d472SMatthias Kaehlcke mutex_lock(&HFS_I(inode)->extents_lock);
3661da177e4SLinus Torvalds res = hfs_ext_read_extent(inode, ablock);
3671da177e4SLinus Torvalds if (!res)
3681da177e4SLinus Torvalds dblock = hfs_ext_find_block(HFS_I(inode)->cached_extents,
3691da177e4SLinus Torvalds ablock - HFS_I(inode)->cached_start);
3701da177e4SLinus Torvalds else {
37139f8d472SMatthias Kaehlcke mutex_unlock(&HFS_I(inode)->extents_lock);
3721da177e4SLinus Torvalds return -EIO;
3731da177e4SLinus Torvalds }
37439f8d472SMatthias Kaehlcke mutex_unlock(&HFS_I(inode)->extents_lock);
3751da177e4SLinus Torvalds
3761da177e4SLinus Torvalds done:
3771da177e4SLinus Torvalds map_bh(bh_result, sb, HFS_SB(sb)->fs_start +
3781da177e4SLinus Torvalds dblock * HFS_SB(sb)->fs_div +
3791da177e4SLinus Torvalds (u32)block % HFS_SB(sb)->fs_div);
3801da177e4SLinus Torvalds
3811da177e4SLinus Torvalds if (create) {
3821da177e4SLinus Torvalds set_buffer_new(bh_result);
3831da177e4SLinus Torvalds HFS_I(inode)->phys_size += sb->s_blocksize;
3841da177e4SLinus Torvalds HFS_I(inode)->fs_blocks++;
3851da177e4SLinus Torvalds inode_add_bytes(inode, sb->s_blocksize);
3861da177e4SLinus Torvalds mark_inode_dirty(inode);
3871da177e4SLinus Torvalds }
3881da177e4SLinus Torvalds return 0;
3891da177e4SLinus Torvalds }
3901da177e4SLinus Torvalds
hfs_extend_file(struct inode * inode)3911da177e4SLinus Torvalds int hfs_extend_file(struct inode *inode)
3921da177e4SLinus Torvalds {
3931da177e4SLinus Torvalds struct super_block *sb = inode->i_sb;
3941da177e4SLinus Torvalds u32 start, len, goal;
3951da177e4SLinus Torvalds int res;
3961da177e4SLinus Torvalds
39739f8d472SMatthias Kaehlcke mutex_lock(&HFS_I(inode)->extents_lock);
3981da177e4SLinus Torvalds if (HFS_I(inode)->alloc_blocks == HFS_I(inode)->first_blocks)
3991da177e4SLinus Torvalds goal = hfs_ext_lastblock(HFS_I(inode)->first_extents);
4001da177e4SLinus Torvalds else {
4011da177e4SLinus Torvalds res = hfs_ext_read_extent(inode, HFS_I(inode)->alloc_blocks);
4021da177e4SLinus Torvalds if (res)
4031da177e4SLinus Torvalds goto out;
4041da177e4SLinus Torvalds goal = hfs_ext_lastblock(HFS_I(inode)->cached_extents);
4051da177e4SLinus Torvalds }
4061da177e4SLinus Torvalds
4071da177e4SLinus Torvalds len = HFS_I(inode)->clump_blocks;
4081da177e4SLinus Torvalds start = hfs_vbm_search_free(sb, goal, &len);
4091da177e4SLinus Torvalds if (!len) {
4101da177e4SLinus Torvalds res = -ENOSPC;
4111da177e4SLinus Torvalds goto out;
4121da177e4SLinus Torvalds }
4131da177e4SLinus Torvalds
414c2b3e1f7SJoe Perches hfs_dbg(EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
4151da177e4SLinus Torvalds if (HFS_I(inode)->alloc_blocks == HFS_I(inode)->first_blocks) {
4161da177e4SLinus Torvalds if (!HFS_I(inode)->first_blocks) {
417c2b3e1f7SJoe Perches hfs_dbg(EXTENT, "first extents\n");
4181da177e4SLinus Torvalds /* no extents yet */
4191da177e4SLinus Torvalds HFS_I(inode)->first_extents[0].block = cpu_to_be16(start);
4201da177e4SLinus Torvalds HFS_I(inode)->first_extents[0].count = cpu_to_be16(len);
4211da177e4SLinus Torvalds res = 0;
4221da177e4SLinus Torvalds } else {
4231da177e4SLinus Torvalds /* try to append to extents in inode */
4241da177e4SLinus Torvalds res = hfs_add_extent(HFS_I(inode)->first_extents,
4251da177e4SLinus Torvalds HFS_I(inode)->alloc_blocks,
4261da177e4SLinus Torvalds start, len);
4271da177e4SLinus Torvalds if (res == -ENOSPC)
4281da177e4SLinus Torvalds goto insert_extent;
4291da177e4SLinus Torvalds }
4301da177e4SLinus Torvalds if (!res) {
4311da177e4SLinus Torvalds hfs_dump_extent(HFS_I(inode)->first_extents);
4321da177e4SLinus Torvalds HFS_I(inode)->first_blocks += len;
4331da177e4SLinus Torvalds }
4341da177e4SLinus Torvalds } else {
4351da177e4SLinus Torvalds res = hfs_add_extent(HFS_I(inode)->cached_extents,
4361da177e4SLinus Torvalds HFS_I(inode)->alloc_blocks -
4371da177e4SLinus Torvalds HFS_I(inode)->cached_start,
4381da177e4SLinus Torvalds start, len);
4391da177e4SLinus Torvalds if (!res) {
4401da177e4SLinus Torvalds hfs_dump_extent(HFS_I(inode)->cached_extents);
4411da177e4SLinus Torvalds HFS_I(inode)->flags |= HFS_FLG_EXT_DIRTY;
4421da177e4SLinus Torvalds HFS_I(inode)->cached_blocks += len;
4431da177e4SLinus Torvalds } else if (res == -ENOSPC)
4441da177e4SLinus Torvalds goto insert_extent;
4451da177e4SLinus Torvalds }
4461da177e4SLinus Torvalds out:
44739f8d472SMatthias Kaehlcke mutex_unlock(&HFS_I(inode)->extents_lock);
4481da177e4SLinus Torvalds if (!res) {
4491da177e4SLinus Torvalds HFS_I(inode)->alloc_blocks += len;
4501da177e4SLinus Torvalds mark_inode_dirty(inode);
4511da177e4SLinus Torvalds if (inode->i_ino < HFS_FIRSTUSER_CNID)
4521da177e4SLinus Torvalds set_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags);
4531da177e4SLinus Torvalds set_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags);
4545687b578SArtem Bityutskiy hfs_mark_mdb_dirty(sb);
4551da177e4SLinus Torvalds }
4561da177e4SLinus Torvalds return res;
4571da177e4SLinus Torvalds
4581da177e4SLinus Torvalds insert_extent:
459c2b3e1f7SJoe Perches hfs_dbg(EXTENT, "insert new extent\n");
4609509f178SAlexey Khoroshilov res = hfs_ext_write_extent(inode);
4619509f178SAlexey Khoroshilov if (res)
4629509f178SAlexey Khoroshilov goto out;
4631da177e4SLinus Torvalds
4641da177e4SLinus Torvalds memset(HFS_I(inode)->cached_extents, 0, sizeof(hfs_extent_rec));
4651da177e4SLinus Torvalds HFS_I(inode)->cached_extents[0].block = cpu_to_be16(start);
4661da177e4SLinus Torvalds HFS_I(inode)->cached_extents[0].count = cpu_to_be16(len);
4671da177e4SLinus Torvalds hfs_dump_extent(HFS_I(inode)->cached_extents);
4681da177e4SLinus Torvalds HFS_I(inode)->flags |= HFS_FLG_EXT_DIRTY|HFS_FLG_EXT_NEW;
4691da177e4SLinus Torvalds HFS_I(inode)->cached_start = HFS_I(inode)->alloc_blocks;
4701da177e4SLinus Torvalds HFS_I(inode)->cached_blocks = len;
4711da177e4SLinus Torvalds
4721da177e4SLinus Torvalds res = 0;
4731da177e4SLinus Torvalds goto out;
4741da177e4SLinus Torvalds }
4751da177e4SLinus Torvalds
hfs_file_truncate(struct inode * inode)4761da177e4SLinus Torvalds void hfs_file_truncate(struct inode *inode)
4771da177e4SLinus Torvalds {
4781da177e4SLinus Torvalds struct super_block *sb = inode->i_sb;
4791da177e4SLinus Torvalds struct hfs_find_data fd;
4801da177e4SLinus Torvalds u16 blk_cnt, alloc_cnt, start;
4811da177e4SLinus Torvalds u32 size;
4821da177e4SLinus Torvalds int res;
4831da177e4SLinus Torvalds
484c2b3e1f7SJoe Perches hfs_dbg(INODE, "truncate: %lu, %Lu -> %Lu\n",
485c2b3e1f7SJoe Perches inode->i_ino, (long long)HFS_I(inode)->phys_size,
486c2b3e1f7SJoe Perches inode->i_size);
4871da177e4SLinus Torvalds if (inode->i_size > HFS_I(inode)->phys_size) {
4881da177e4SLinus Torvalds struct address_space *mapping = inode->i_mapping;
489*e52a418dSAlexander Potapenko void *fsdata = NULL;
4901da177e4SLinus Torvalds struct page *page;
4911da177e4SLinus Torvalds
4927903d9eeSNick Piggin /* XXX: Can use generic_cont_expand? */
4931da177e4SLinus Torvalds size = inode->i_size - 1;
494cfef1f7bSMatthew Wilcox (Oracle) res = hfs_write_begin(NULL, mapping, size + 1, 0, &page,
495cfef1f7bSMatthew Wilcox (Oracle) &fsdata);
4967903d9eeSNick Piggin if (!res) {
497cfef1f7bSMatthew Wilcox (Oracle) res = generic_write_end(NULL, mapping, size + 1, 0, 0,
4987903d9eeSNick Piggin page, fsdata);
4997903d9eeSNick Piggin }
5001da177e4SLinus Torvalds if (res)
5011da177e4SLinus Torvalds inode->i_size = HFS_I(inode)->phys_size;
5021da177e4SLinus Torvalds return;
503f76d28d2SRoman Zippel } else if (inode->i_size == HFS_I(inode)->phys_size)
504f76d28d2SRoman Zippel return;
5051da177e4SLinus Torvalds size = inode->i_size + HFS_SB(sb)->alloc_blksz - 1;
5061da177e4SLinus Torvalds blk_cnt = size / HFS_SB(sb)->alloc_blksz;
5071da177e4SLinus Torvalds alloc_cnt = HFS_I(inode)->alloc_blocks;
5081da177e4SLinus Torvalds if (blk_cnt == alloc_cnt)
5091da177e4SLinus Torvalds goto out;
5101da177e4SLinus Torvalds
51139f8d472SMatthias Kaehlcke mutex_lock(&HFS_I(inode)->extents_lock);
5129509f178SAlexey Khoroshilov res = hfs_find_init(HFS_SB(sb)->ext_tree, &fd);
5139509f178SAlexey Khoroshilov if (res) {
5149509f178SAlexey Khoroshilov mutex_unlock(&HFS_I(inode)->extents_lock);
5159509f178SAlexey Khoroshilov /* XXX: We lack error handling of hfs_file_truncate() */
5169509f178SAlexey Khoroshilov return;
5179509f178SAlexey Khoroshilov }
5181da177e4SLinus Torvalds while (1) {
5191da177e4SLinus Torvalds if (alloc_cnt == HFS_I(inode)->first_blocks) {
5201da177e4SLinus Torvalds hfs_free_extents(sb, HFS_I(inode)->first_extents,
5211da177e4SLinus Torvalds alloc_cnt, alloc_cnt - blk_cnt);
5221da177e4SLinus Torvalds hfs_dump_extent(HFS_I(inode)->first_extents);
5231da177e4SLinus Torvalds HFS_I(inode)->first_blocks = blk_cnt;
5241da177e4SLinus Torvalds break;
5251da177e4SLinus Torvalds }
5261da177e4SLinus Torvalds res = __hfs_ext_cache_extent(&fd, inode, alloc_cnt);
5271da177e4SLinus Torvalds if (res)
5281da177e4SLinus Torvalds break;
5291da177e4SLinus Torvalds start = HFS_I(inode)->cached_start;
5301da177e4SLinus Torvalds hfs_free_extents(sb, HFS_I(inode)->cached_extents,
5311da177e4SLinus Torvalds alloc_cnt - start, alloc_cnt - blk_cnt);
5321da177e4SLinus Torvalds hfs_dump_extent(HFS_I(inode)->cached_extents);
5331da177e4SLinus Torvalds if (blk_cnt > start) {
5341da177e4SLinus Torvalds HFS_I(inode)->flags |= HFS_FLG_EXT_DIRTY;
5351da177e4SLinus Torvalds break;
5361da177e4SLinus Torvalds }
5371da177e4SLinus Torvalds alloc_cnt = start;
5381da177e4SLinus Torvalds HFS_I(inode)->cached_start = HFS_I(inode)->cached_blocks = 0;
5391da177e4SLinus Torvalds HFS_I(inode)->flags &= ~(HFS_FLG_EXT_DIRTY|HFS_FLG_EXT_NEW);
5401da177e4SLinus Torvalds hfs_brec_remove(&fd);
5411da177e4SLinus Torvalds }
5421da177e4SLinus Torvalds hfs_find_exit(&fd);
54339f8d472SMatthias Kaehlcke mutex_unlock(&HFS_I(inode)->extents_lock);
5441da177e4SLinus Torvalds
5451da177e4SLinus Torvalds HFS_I(inode)->alloc_blocks = blk_cnt;
5461da177e4SLinus Torvalds out:
5471da177e4SLinus Torvalds HFS_I(inode)->phys_size = inode->i_size;
5481da177e4SLinus Torvalds HFS_I(inode)->fs_blocks = (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
5491da177e4SLinus Torvalds inode_set_bytes(inode, HFS_I(inode)->fs_blocks << sb->s_blocksize_bits);
5501da177e4SLinus Torvalds mark_inode_dirty(inode);
5511da177e4SLinus Torvalds }
552