[linux-2.6-block.git] / fs / hfsplus / extents.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/fs/hfsplus/extents.c
 *
 * Copyright (C) 2001
 * Brad Boyer (flar@allandria.com)
 * (C) 2003 Ardis Technologies <roman@ardistech.com>
 *
 * Handling of Extents both in catalog and extents overflow trees
 */

#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/pagemap.h>

#include "hfsplus_fs.h"
#include "hfsplus_raw.h"

/* Compare two extents keys, returns 0 on same, pos/neg for difference */
int hfsplus_ext_cmp_key(const hfsplus_btree_key *k1,
			const hfsplus_btree_key *k2)
{
	__be32 k1id, k2id;
	__be32 k1s, k2s;

	k1id = k1->ext.cnid;
	k2id = k2->ext.cnid;
	if (k1id != k2id)
		return be32_to_cpu(k1id) < be32_to_cpu(k2id) ? -1 : 1;

	if (k1->ext.fork_type != k2->ext.fork_type)
		return k1->ext.fork_type < k2->ext.fork_type ? -1 : 1;

	k1s = k1->ext.start_block;
	k2s = k2->ext.start_block;
	if (k1s == k2s)
		return 0;
	return be32_to_cpu(k1s) < be32_to_cpu(k2s) ? -1 : 1;
}

static void hfsplus_ext_build_key(hfsplus_btree_key *key, u32 cnid,
				  u32 block, u8 type)
{
	key->key_len = cpu_to_be16(HFSPLUS_EXT_KEYLEN - 2);
	key->ext.cnid = cpu_to_be32(cnid);
	key->ext.start_block = cpu_to_be32(block);
	key->ext.fork_type = type;
	key->ext.pad = 0;
}

static u32 hfsplus_ext_find_block(struct hfsplus_extent *ext, u32 off)
{
	int i;
	u32 count;

	for (i = 0; i < 8; ext++, i++) {
		count = be32_to_cpu(ext->block_count);
		if (off < count)
			return be32_to_cpu(ext->start_block) + off;
		off -= count;
	}
	/* panic? */
	return 0;
}

static int hfsplus_ext_block_count(struct hfsplus_extent *ext)
{
	int i;
	u32 count = 0;

	for (i = 0; i < 8; ext++, i++)
		count += be32_to_cpu(ext->block_count);
	return count;
}

static u32 hfsplus_ext_lastblock(struct hfsplus_extent *ext)
{
	int i;

	ext += 7;
	for (i = 0; i < 7; ext--, i++)
		if (ext->block_count)
			break;
	return be32_to_cpu(ext->start_block) + be32_to_cpu(ext->block_count);
}

static int __hfsplus_ext_write_extent(struct inode *inode,
		struct hfs_find_data *fd)
{
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	int res;

	WARN_ON(!mutex_is_locked(&hip->extents_lock));

	hfsplus_ext_build_key(fd->search_key, inode->i_ino, hip->cached_start,
			      HFSPLUS_IS_RSRC(inode) ?
				HFSPLUS_TYPE_RSRC : HFSPLUS_TYPE_DATA);

	res = hfs_brec_find(fd, hfs_find_rec_by_key);
	if (hip->extent_state & HFSPLUS_EXT_NEW) {
		if (res != -ENOENT)
			return res;
		/* Fail early and avoid ENOSPC during the btree operation */
		res = hfs_bmap_reserve(fd->tree, fd->tree->depth + 1);
		if (res)
			return res;
		hfs_brec_insert(fd, hip->cached_extents,
				sizeof(hfsplus_extent_rec));
		hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW);
	} else {
		if (res)
			return res;
		hfs_bnode_write(fd->bnode, hip->cached_extents,
				fd->entryoffset, fd->entrylength);
		hip->extent_state &= ~HFSPLUS_EXT_DIRTY;
	}

	/*
	 * We can't just use hfsplus_mark_inode_dirty here, because we
	 * also get called from hfsplus_write_inode, which should not
	 * redirty the inode.  Instead the callers have to be careful
	 * to explicily mark the inode dirty, too.
	 */
	set_bit(HFSPLUS_I_EXT_DIRTY, &hip->flags);

	return 0;
}

static int hfsplus_ext_write_extent_locked(struct inode *inode)
{
	int res = 0;

	if (HFSPLUS_I(inode)->extent_state & HFSPLUS_EXT_DIRTY) {
		struct hfs_find_data fd;

		res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd);
		if (res)
			return res;
		res = __hfsplus_ext_write_extent(inode, &fd);
		hfs_find_exit(&fd);
	}
	return res;
}

int hfsplus_ext_write_extent(struct inode *inode)
{
	int res;

	mutex_lock(&HFSPLUS_I(inode)->extents_lock);
	res = hfsplus_ext_write_extent_locked(inode);
	mutex_unlock(&HFSPLUS_I(inode)->extents_lock);

	return res;
}

static inline int __hfsplus_ext_read_extent(struct hfs_find_data *fd,
					    struct hfsplus_extent *extent,
					    u32 cnid, u32 block, u8 type)
{
	int res;

	hfsplus_ext_build_key(fd->search_key, cnid, block, type);
	fd->key->ext.cnid = 0;
	res = hfs_brec_find(fd, hfs_find_rec_by_key);
	if (res && res != -ENOENT)
		return res;
	if (fd->key->ext.cnid != fd->search_key->ext.cnid ||
	    fd->key->ext.fork_type != fd->search_key->ext.fork_type)
		return -ENOENT;
	if (fd->entrylength != sizeof(hfsplus_extent_rec))
		return -EIO;
	hfs_bnode_read(fd->bnode, extent, fd->entryoffset,
		sizeof(hfsplus_extent_rec));
	return 0;
}

static inline int __hfsplus_ext_cache_extent(struct hfs_find_data *fd,
		struct inode *inode, u32 block)
{
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	int res;

	WARN_ON(!mutex_is_locked(&hip->extents_lock));

	if (hip->extent_state & HFSPLUS_EXT_DIRTY) {
		res = __hfsplus_ext_write_extent(inode, fd);
		if (res)
			return res;
	}

	res = __hfsplus_ext_read_extent(fd, hip->cached_extents, inode->i_ino,
					block, HFSPLUS_IS_RSRC(inode) ?
						HFSPLUS_TYPE_RSRC :
						HFSPLUS_TYPE_DATA);
	if (!res) {
		hip->cached_start = be32_to_cpu(fd->key->ext.start_block);
		hip->cached_blocks =
			hfsplus_ext_block_count(hip->cached_extents);
	} else {
		hip->cached_start = hip->cached_blocks = 0;
		hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW);
	}
	return res;
}

static int hfsplus_ext_read_extent(struct inode *inode, u32 block)
{
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	struct hfs_find_data fd;
	int res;

	if (block >= hip->cached_start &&
	    block < hip->cached_start + hip->cached_blocks)
		return 0;

	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd);
	if (!res) {
		res = __hfsplus_ext_cache_extent(&fd, inode, block);
		hfs_find_exit(&fd);
	}
	return res;
}

/* Get a block at iblock for inode, possibly allocating if create */
int hfsplus_get_block(struct inode *inode, sector_t iblock,
		      struct buffer_head *bh_result, int create)
{
	struct super_block *sb = inode->i_sb;
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	int res = -EIO;
	u32 ablock, dblock, mask;
	sector_t sector;
	int was_dirty = 0;

	/* Convert inode block to disk allocation block */
	ablock = iblock >> sbi->fs_shift;

	if (iblock >= hip->fs_blocks) {
		if (!create)
			return 0;
		if (iblock > hip->fs_blocks)
			return -EIO;
		if (ablock >= hip->alloc_blocks) {
			res = hfsplus_file_extend(inode, false);
			if (res)
				return res;
		}
	} else
		create = 0;

	if (ablock < hip->first_blocks) {
		dblock = hfsplus_ext_find_block(hip->first_extents, ablock);
		goto done;
	}

	if (inode->i_ino == HFSPLUS_EXT_CNID)
		return -EIO;

	mutex_lock(&hip->extents_lock);

	/*
	 * hfsplus_ext_read_extent will write out a cached extent into
	 * the extents btree.  In that case we may have to mark the inode
	 * dirty even for a pure read of an extent here.
	 */
	was_dirty = (hip->extent_state & HFSPLUS_EXT_DIRTY);
	res = hfsplus_ext_read_extent(inode, ablock);
	if (res) {
		mutex_unlock(&hip->extents_lock);
		return -EIO;
	}
	dblock = hfsplus_ext_find_block(hip->cached_extents,
					ablock - hip->cached_start);
	mutex_unlock(&hip->extents_lock);

done:
	hfs_dbg(EXTENT, "get_block(%lu): %llu - %u\n",
		inode->i_ino, (long long)iblock, dblock);

	mask = (1 << sbi->fs_shift) - 1;
	sector = ((sector_t)dblock << sbi->fs_shift) +
		  sbi->blockoffset + (iblock & mask);
	map_bh(bh_result, sb, sector);

	if (create) {
		set_buffer_new(bh_result);
		hip->phys_size += sb->s_blocksize;
		hip->fs_blocks++;
		inode_add_bytes(inode, sb->s_blocksize);
	}
	if (create || was_dirty)
		mark_inode_dirty(inode);
	return 0;
}

static void hfsplus_dump_extent(struct hfsplus_extent *extent)
{
	int i;

	hfs_dbg(EXTENT, "   ");
	for (i = 0; i < 8; i++)
		hfs_dbg_cont(EXTENT, " %u:%u",
			     be32_to_cpu(extent[i].start_block),
			     be32_to_cpu(extent[i].block_count));
	hfs_dbg_cont(EXTENT, "\n");
}

static int hfsplus_add_extent(struct hfsplus_extent *extent, u32 offset,
			      u32 alloc_block, u32 block_count)
{
	u32 count, start;
	int i;

	hfsplus_dump_extent(extent);
	for (i = 0; i < 8; extent++, i++) {
		count = be32_to_cpu(extent->block_count);
		if (offset == count) {
			start = be32_to_cpu(extent->start_block);
			if (alloc_block != start + count) {
				if (++i >= 8)
					return -ENOSPC;
				extent++;
				extent->start_block = cpu_to_be32(alloc_block);
			} else
				block_count += count;
			extent->block_count = cpu_to_be32(block_count);
			return 0;
		} else if (offset < count)
			break;
		offset -= count;
	}
	/* panic? */
	return -EIO;
}

static int hfsplus_free_extents(struct super_block *sb,
				struct hfsplus_extent *extent,
				u32 offset, u32 block_nr)
{
	u32 count, start;
	int i;
	int err = 0;

	/* Mapping the allocation file may lock the extent tree */
	WARN_ON(mutex_is_locked(&HFSPLUS_SB(sb)->ext_tree->tree_lock));

	hfsplus_dump_extent(extent);
	for (i = 0; i < 8; extent++, i++) {
		count = be32_to_cpu(extent->block_count);
		if (offset == count)
			goto found;
		else if (offset < count)
			break;
		offset -= count;
	}
	/* panic? */
	return -EIO;
found:
	for (;;) {
		start = be32_to_cpu(extent->start_block);
		if (count <= block_nr) {
			err = hfsplus_block_free(sb, start, count);
			if (err) {
				pr_err("can't free extent\n");
				hfs_dbg(EXTENT, " start: %u count: %u\n",
					start, count);
			}
			extent->block_count = 0;
			extent->start_block = 0;
			block_nr -= count;
		} else {
			count -= block_nr;
			err = hfsplus_block_free(sb, start + count, block_nr);
			if (err) {
				pr_err("can't free extent\n");
				hfs_dbg(EXTENT, " start: %u count: %u\n",
					start, count);
			}
			extent->block_count = cpu_to_be32(count);
			block_nr = 0;
		}
		if (!block_nr || !i) {
			/*
			 * Try to free all extents and
			 * return only last error
			 */
			return err;
		}
		i--;
		extent--;
		count = be32_to_cpu(extent->block_count);
	}
}

int hfsplus_free_fork(struct super_block *sb, u32 cnid,
		struct hfsplus_fork_raw *fork, int type)
{
	struct hfs_find_data fd;
	hfsplus_extent_rec ext_entry;
	u32 total_blocks, blocks, start;
	int res, i;

	total_blocks = be32_to_cpu(fork->total_blocks);
	if (!total_blocks)
		return 0;

	blocks = 0;
	for (i = 0; i < 8; i++)
		blocks += be32_to_cpu(fork->extents[i].block_count);

	res = hfsplus_free_extents(sb, fork->extents, blocks, blocks);
	if (res)
		return res;
	if (total_blocks == blocks)
		return 0;

	res = hfs_find_init(HFSPLUS_SB(sb)->ext_tree, &fd);
	if (res)
		return res;
	do {
		res = __hfsplus_ext_read_extent(&fd, ext_entry, cnid,
						total_blocks, type);
		if (res)
			break;
		start = be32_to_cpu(fd.key->ext.start_block);
		hfs_brec_remove(&fd);

		mutex_unlock(&fd.tree->tree_lock);
		hfsplus_free_extents(sb, ext_entry, total_blocks - start,
				     total_blocks);
		total_blocks = start;
		mutex_lock(&fd.tree->tree_lock);
	} while (total_blocks > blocks);
	hfs_find_exit(&fd);

	return res;
}

int hfsplus_file_extend(struct inode *inode, bool zeroout)
{
	struct super_block *sb = inode->i_sb;
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	u32 start, len, goal;
	int res;

	if (sbi->alloc_file->i_size * 8 <
	    sbi->total_blocks - sbi->free_blocks + 8) {
		/* extend alloc file */
		pr_err_ratelimited("extend alloc file! (%llu,%u,%u)\n",
				   sbi->alloc_file->i_size * 8,
				   sbi->total_blocks, sbi->free_blocks);
		return -ENOSPC;
	}

	mutex_lock(&hip->extents_lock);
	if (hip->alloc_blocks == hip->first_blocks)
		goal = hfsplus_ext_lastblock(hip->first_extents);
	else {
		res = hfsplus_ext_read_extent(inode, hip->alloc_blocks);
		if (res)
			goto out;
		goal = hfsplus_ext_lastblock(hip->cached_extents);
	}

	len = hip->clump_blocks;
	start = hfsplus_block_allocate(sb, sbi->total_blocks, goal, &len);
	if (start >= sbi->total_blocks) {
		start = hfsplus_block_allocate(sb, goal, 0, &len);
		if (start >= goal) {
			res = -ENOSPC;
			goto out;
		}
	}

	if (zeroout) {
		res = sb_issue_zeroout(sb, start, len, GFP_NOFS);
		if (res)
			goto out;
	}

	hfs_dbg(EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);

	if (hip->alloc_blocks <= hip->first_blocks) {
		if (!hip->first_blocks) {
			hfs_dbg(EXTENT, "first extents\n");
			/* no extents yet */
			hip->first_extents[0].start_block = cpu_to_be32(start);
			hip->first_extents[0].block_count = cpu_to_be32(len);
			res = 0;
		} else {
			/* try to append to extents in inode */
			res = hfsplus_add_extent(hip->first_extents,
						 hip->alloc_blocks,
						 start, len);
			if (res == -ENOSPC)
				goto insert_extent;
		}
		if (!res) {
			hfsplus_dump_extent(hip->first_extents);
			hip->first_blocks += len;
		}
	} else {
		res = hfsplus_add_extent(hip->cached_extents,
					 hip->alloc_blocks - hip->cached_start,
					 start, len);
		if (!res) {
			hfsplus_dump_extent(hip->cached_extents);
			hip->extent_state |= HFSPLUS_EXT_DIRTY;
			hip->cached_blocks += len;
		} else if (res == -ENOSPC)
			goto insert_extent;
	}
out:
	if (!res) {
		hip->alloc_blocks += len;
		mutex_unlock(&hip->extents_lock);
		hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY);
		return 0;
	}
	mutex_unlock(&hip->extents_lock);
	return res;

insert_extent:
	hfs_dbg(EXTENT, "insert new extent\n");
	res = hfsplus_ext_write_extent_locked(inode);
	if (res)
		goto out;

	memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec));
	hip->cached_extents[0].start_block = cpu_to_be32(start);
	hip->cached_extents[0].block_count = cpu_to_be32(len);
	hfsplus_dump_extent(hip->cached_extents);
	hip->extent_state |= HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW;
	hip->cached_start = hip->alloc_blocks;
	hip->cached_blocks = len;

	res = 0;
	goto out;
}

void hfsplus_file_truncate(struct inode *inode)
{
	struct super_block *sb = inode->i_sb;
	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
	struct hfs_find_data fd;
	u32 alloc_cnt, blk_cnt, start;
	int res;

	hfs_dbg(INODE, "truncate: %lu, %llu -> %llu\n",
		inode->i_ino, (long long)hip->phys_size, inode->i_size);

	if (inode->i_size > hip->phys_size) {
		struct address_space *mapping = inode->i_mapping;
		struct page *page;
		void *fsdata = NULL;
		loff_t size = inode->i_size;

		res = hfsplus_write_begin(NULL, mapping, size, 0,
					  &page, &fsdata);
		if (res)
			return;
		res = generic_write_end(NULL, mapping, size, 0, 0,
					page, fsdata);
		if (res < 0)
			return;
		mark_inode_dirty(inode);
		return;
	} else if (inode->i_size == hip->phys_size)
		return;

	blk_cnt = (inode->i_size + HFSPLUS_SB(sb)->alloc_blksz - 1) >>
			HFSPLUS_SB(sb)->alloc_blksz_shift;

	mutex_lock(&hip->extents_lock);

	alloc_cnt = hip->alloc_blocks;
	if (blk_cnt == alloc_cnt)
		goto out_unlock;

	res = hfs_find_init(HFSPLUS_SB(sb)->ext_tree, &fd);
	if (res) {
		mutex_unlock(&hip->extents_lock);
		/* XXX: We lack error handling of hfsplus_file_truncate() */
		return;
	}
	while (1) {
		if (alloc_cnt == hip->first_blocks) {
			mutex_unlock(&fd.tree->tree_lock);
			hfsplus_free_extents(sb, hip->first_extents,
					     alloc_cnt, alloc_cnt - blk_cnt);
			hfsplus_dump_extent(hip->first_extents);
			hip->first_blocks = blk_cnt;
			mutex_lock(&fd.tree->tree_lock);
			break;
		}
		res = __hfsplus_ext_cache_extent(&fd, inode, alloc_cnt);
		if (res)
			break;

		start = hip->cached_start;
		if (blk_cnt <= start)
			hfs_brec_remove(&fd);
		mutex_unlock(&fd.tree->tree_lock);
		hfsplus_free_extents(sb, hip->cached_extents,
				     alloc_cnt - start, alloc_cnt - blk_cnt);
		hfsplus_dump_extent(hip->cached_extents);
		mutex_lock(&fd.tree->tree_lock);
		if (blk_cnt > start) {
			hip->extent_state |= HFSPLUS_EXT_DIRTY;
			break;
		}
		alloc_cnt = start;
		hip->cached_start = hip->cached_blocks = 0;
		hip->extent_state &= ~(HFSPLUS_EXT_DIRTY | HFSPLUS_EXT_NEW);
	}
	hfs_find_exit(&fd);

	hip->alloc_blocks = blk_cnt;
out_unlock:
	mutex_unlock(&hip->extents_lock);
	hip->phys_size = inode->i_size;
	hip->fs_blocks = (inode->i_size + sb->s_blocksize - 1) >>
		sb->s_blocksize_bits;
	inode_set_bytes(inode, hip->fs_blocks << sb->s_blocksize_bits);
	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY);
}
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,
2179d372 DE	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;
1da177e4 LT	92
7fcc99f4 CH	93	WARN_ON(!mutex_is_locked(&hip->extents_lock));
7fcc99f4 CH	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;
d92915c3 EF	103	/* Fail early and avoid ENOSPC during the btree operation */
	104	res = hfs_bmap_reserve(fd->tree, fd->tree->depth + 1);
	105	if (res)
	106	return res;
6af502de CH	107	hfs_brec_insert(fd, hip->cached_extents,
6af502de CH	108	sizeof(hfsplus_extent_rec));
b33b7921	109	hip->extent_state &= ~(HFSPLUS_EXT_DIRTY \| HFSPLUS_EXT_NEW);
1da177e4 LT	110	} else {
1da177e4 LT	111	if (res)
d7a475d0	112	return res;
6af502de CH	113	hfs_bnode_write(fd->bnode, hip->cached_extents,
6af502de CH	114	fd->entryoffset, fd->entrylength);
b33b7921	115	hip->extent_state &= ~HFSPLUS_EXT_DIRTY;
1da177e4	116	}
e3494705 CH	117
	118	/*
	119	* We can't just use hfsplus_mark_inode_dirty here, because we
	120	* also get called from hfsplus_write_inode, which should not
	121	* redirty the inode. Instead the callers have to be careful
	122	* to explicily mark the inode dirty, too.
	123	*/
	124	set_bit(HFSPLUS_I_EXT_DIRTY, &hip->flags);
d7a475d0 AK	125
d7a475d0 AK	126	return 0;
1da177e4 LT	127	}
1da177e4 LT	128
dd7f3d54	129	static int hfsplus_ext_write_extent_locked(struct inode *inode)
1da177e4	130	{
d7a475d0	131	int res = 0;
dd7f3d54	132
b33b7921	133	if (HFSPLUS_I(inode)->extent_state & HFSPLUS_EXT_DIRTY) {
1da177e4 LT	134	struct hfs_find_data fd;
1da177e4 LT	135
dd7f3d54 AK	136	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd);
	137	if (res)
	138	return res;
d7a475d0	139	res = __hfsplus_ext_write_extent(inode, &fd);
dd7f3d54	140	hfs_find_exit(&fd);
1da177e4	141	}
d7a475d0	142	return res;
1da177e4 LT	143	}
1da177e4 LT	144
dd7f3d54	145	int hfsplus_ext_write_extent(struct inode *inode)
7fcc99f4	146	{
dd7f3d54 AK	147	int res;
dd7f3d54 AK	148
7fcc99f4	149	mutex_lock(&HFSPLUS_I(inode)->extents_lock);
dd7f3d54	150	res = hfsplus_ext_write_extent_locked(inode);
7fcc99f4	151	mutex_unlock(&HFSPLUS_I(inode)->extents_lock);
dd7f3d54 AK	152
dd7f3d54 AK	153	return res;
7fcc99f4 CH	154	}
7fcc99f4 CH	155
1da177e4 LT	156	static inline int __hfsplus_ext_read_extent(struct hfs_find_data *fd,
	157	struct hfsplus_extent *extent,
	158	u32 cnid, u32 block, u8 type)
	159	{
	160	int res;
	161
	162	hfsplus_ext_build_key(fd->search_key, cnid, block, type);
	163	fd->key->ext.cnid = 0;
324ef39a	164	res = hfs_brec_find(fd, hfs_find_rec_by_key);
1da177e4 LT	165	if (res && res != -ENOENT)
	166	return res;
	167	if (fd->key->ext.cnid != fd->search_key->ext.cnid \|\|
	168	fd->key->ext.fork_type != fd->search_key->ext.fork_type)
	169	return -ENOENT;
	170	if (fd->entrylength != sizeof(hfsplus_extent_rec))
	171	return -EIO;
2753cc28 AS	172	hfs_bnode_read(fd->bnode, extent, fd->entryoffset,
2753cc28 AS	173	sizeof(hfsplus_extent_rec));
1da177e4 LT	174	return 0;
	175	}
	176
2753cc28 AS	177	static inline int __hfsplus_ext_cache_extent(struct hfs_find_data *fd,
2753cc28 AS	178	struct inode *inode, u32 block)
1da177e4	179	{
6af502de	180	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
1da177e4 LT	181	int res;
1da177e4 LT	182
7fcc99f4 CH	183	WARN_ON(!mutex_is_locked(&hip->extents_lock));
7fcc99f4 CH	184
d7a475d0 AK	185	if (hip->extent_state & HFSPLUS_EXT_DIRTY) {
	186	res = __hfsplus_ext_write_extent(inode, fd);
	187	if (res)
	188	return res;
	189	}
1da177e4	190
6af502de CH	191	res = __hfsplus_ext_read_extent(fd, hip->cached_extents, inode->i_ino,
	192	block, HFSPLUS_IS_RSRC(inode) ?
	193	HFSPLUS_TYPE_RSRC :
	194	HFSPLUS_TYPE_DATA);
1da177e4	195	if (!res) {
6af502de	196	hip->cached_start = be32_to_cpu(fd->key->ext.start_block);
2753cc28 AS	197	hip->cached_blocks =
2753cc28 AS	198	hfsplus_ext_block_count(hip->cached_extents);
1da177e4	199	} else {
6af502de	200	hip->cached_start = hip->cached_blocks = 0;
b33b7921	201	hip->extent_state &= ~(HFSPLUS_EXT_DIRTY \| HFSPLUS_EXT_NEW);
1da177e4 LT	202	}
	203	return res;
	204	}
	205
	206	static int hfsplus_ext_read_extent(struct inode *inode, u32 block)
	207	{
6af502de	208	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
1da177e4 LT	209	struct hfs_find_data fd;
	210	int res;
	211
6af502de CH	212	if (block >= hip->cached_start &&
6af502de CH	213	block < hip->cached_start + hip->cached_blocks)
1da177e4 LT	214	return 0;
1da177e4 LT	215
5bd9d99d AK	216	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd);
	217	if (!res) {
	218	res = __hfsplus_ext_cache_extent(&fd, inode, block);
	219	hfs_find_exit(&fd);
	220	}
1da177e4 LT	221	return res;
	222	}
	223
	224	/* Get a block at iblock for inode, possibly allocating if create */
	225	int hfsplus_get_block(struct inode *inode, sector_t iblock,
	226	struct buffer_head *bh_result, int create)
	227	{
dd73a01a CH	228	struct super_block *sb = inode->i_sb;
dd73a01a CH	229	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
6af502de	230	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
1da177e4 LT	231	int res = -EIO;
1da177e4 LT	232	u32 ablock, dblock, mask;
bf1a1b31	233	sector_t sector;
e3494705	234	int was_dirty = 0;
1da177e4	235
1da177e4	236	/* Convert inode block to disk allocation block */
dd73a01a	237	ablock = iblock >> sbi->fs_shift;
1da177e4	238
6af502de	239	if (iblock >= hip->fs_blocks) {
839c3a6a EF	240	if (!create)
	241	return 0;
	242	if (iblock > hip->fs_blocks)
1da177e4	243	return -EIO;
6af502de	244	if (ablock >= hip->alloc_blocks) {
2cd282a1	245	res = hfsplus_file_extend(inode, false);
1da177e4 LT	246	if (res)
	247	return res;
	248	}
	249	} else
	250	create = 0;
	251
6af502de CH	252	if (ablock < hip->first_blocks) {
6af502de CH	253	dblock = hfsplus_ext_find_block(hip->first_extents, ablock);
1da177e4 LT	254	goto done;
	255	}
	256
248736c2 ES	257	if (inode->i_ino == HFSPLUS_EXT_CNID)
	258	return -EIO;
	259
6af502de	260	mutex_lock(&hip->extents_lock);
e3494705 CH	261
	262	/*
	263	* hfsplus_ext_read_extent will write out a cached extent into
	264	* the extents btree. In that case we may have to mark the inode
	265	* dirty even for a pure read of an extent here.
	266	*/
	267	was_dirty = (hip->extent_state & HFSPLUS_EXT_DIRTY);
1da177e4	268	res = hfsplus_ext_read_extent(inode, ablock);
e3494705	269	if (res) {
6af502de	270	mutex_unlock(&hip->extents_lock);
1da177e4 LT	271	return -EIO;
1da177e4 LT	272	}
e3494705 CH	273	dblock = hfsplus_ext_find_block(hip->cached_extents,
e3494705 CH	274	ablock - hip->cached_start);
6af502de	275	mutex_unlock(&hip->extents_lock);
1da177e4 LT	276
1da177e4 LT	277	done:
c2b3e1f7	278	hfs_dbg(EXTENT, "get_block(%lu): %llu - %u\n",
2753cc28	279	inode->i_ino, (long long)iblock, dblock);
bf1a1b31	280
dd73a01a	281	mask = (1 << sbi->fs_shift) - 1;
bf1a1b31 CH	282	sector = ((sector_t)dblock << sbi->fs_shift) +
	283	sbi->blockoffset + (iblock & mask);
	284	map_bh(bh_result, sb, sector);
	285
1da177e4 LT	286	if (create) {
1da177e4 LT	287	set_buffer_new(bh_result);
6af502de CH	288	hip->phys_size += sb->s_blocksize;
6af502de CH	289	hip->fs_blocks++;
1da177e4	290	inode_add_bytes(inode, sb->s_blocksize);
1da177e4	291	}
e3494705 CH	292	if (create \|\| was_dirty)
e3494705 CH	293	mark_inode_dirty(inode);
1da177e4 LT	294	return 0;
	295	}
	296
	297	static void hfsplus_dump_extent(struct hfsplus_extent *extent)
	298	{
	299	int i;
	300
c2b3e1f7	301	hfs_dbg(EXTENT, " ");
1da177e4	302	for (i = 0; i < 8; i++)
c2b3e1f7 JP	303	hfs_dbg_cont(EXTENT, " %u:%u",
	304	be32_to_cpu(extent[i].start_block),
	305	be32_to_cpu(extent[i].block_count));
	306	hfs_dbg_cont(EXTENT, "\n");
1da177e4 LT	307	}
	308
	309	static int hfsplus_add_extent(struct hfsplus_extent *extent, u32 offset,
	310	u32 alloc_block, u32 block_count)
	311	{
	312	u32 count, start;
	313	int i;
	314
	315	hfsplus_dump_extent(extent);
	316	for (i = 0; i < 8; extent++, i++) {
	317	count = be32_to_cpu(extent->block_count);
	318	if (offset == count) {
	319	start = be32_to_cpu(extent->start_block);
	320	if (alloc_block != start + count) {
	321	if (++i >= 8)
	322	return -ENOSPC;
	323	extent++;
	324	extent->start_block = cpu_to_be32(alloc_block);
	325	} else
	326	block_count += count;
	327	extent->block_count = cpu_to_be32(block_count);
	328	return 0;
	329	} else if (offset < count)
	330	break;
	331	offset -= count;
	332	}
	333	/* panic? */
	334	return -EIO;
	335	}
	336
	337	static int hfsplus_free_extents(struct super_block *sb,
	338	struct hfsplus_extent *extent,
	339	u32 offset, u32 block_nr)
	340	{
	341	u32 count, start;
	342	int i;
1b243fd3	343	int err = 0;
1da177e4	344
31651c60 EF	345	/* Mapping the allocation file may lock the extent tree */
	346	WARN_ON(mutex_is_locked(&HFSPLUS_SB(sb)->ext_tree->tree_lock));
	347
1da177e4 LT	348	hfsplus_dump_extent(extent);
	349	for (i = 0; i < 8; extent++, i++) {
	350	count = be32_to_cpu(extent->block_count);
	351	if (offset == count)
	352	goto found;
	353	else if (offset < count)
	354	break;
	355	offset -= count;
	356	}
	357	/* panic? */
	358	return -EIO;
	359	found:
	360	for (;;) {
	361	start = be32_to_cpu(extent->start_block);
	362	if (count <= block_nr) {
1b243fd3 VD	363	err = hfsplus_block_free(sb, start, count);
1b243fd3 VD	364	if (err) {
d6142673	365	pr_err("can't free extent\n");
c2b3e1f7	366	hfs_dbg(EXTENT, " start: %u count: %u\n",
1b243fd3 VD	367	start, count);
1b243fd3 VD	368	}
1da177e4 LT	369	extent->block_count = 0;
	370	extent->start_block = 0;
	371	block_nr -= count;
	372	} else {
	373	count -= block_nr;
1b243fd3 VD	374	err = hfsplus_block_free(sb, start + count, block_nr);
1b243fd3 VD	375	if (err) {
d6142673	376	pr_err("can't free extent\n");
c2b3e1f7	377	hfs_dbg(EXTENT, " start: %u count: %u\n",
1b243fd3 VD	378	start, count);
1b243fd3 VD	379	}
1da177e4 LT	380	extent->block_count = cpu_to_be32(count);
	381	block_nr = 0;
	382	}
1b243fd3 VD	383	if (!block_nr \|\| !i) {
	384	/*
	385	* Try to free all extents and
	386	* return only last error
	387	*/
	388	return err;
	389	}
1da177e4 LT	390	i--;
	391	extent--;
	392	count = be32_to_cpu(extent->block_count);
	393	}
	394	}
	395
2753cc28 AS	396	int hfsplus_free_fork(struct super_block *sb, u32 cnid,
2753cc28 AS	397	struct hfsplus_fork_raw *fork, int type)
1da177e4 LT	398	{
	399	struct hfs_find_data fd;
	400	hfsplus_extent_rec ext_entry;
	401	u32 total_blocks, blocks, start;
	402	int res, i;
	403
	404	total_blocks = be32_to_cpu(fork->total_blocks);
	405	if (!total_blocks)
	406	return 0;
	407
	408	blocks = 0;
	409	for (i = 0; i < 8; i++)
	410	blocks += be32_to_cpu(fork->extents[i].block_count);
	411
	412	res = hfsplus_free_extents(sb, fork->extents, blocks, blocks);
	413	if (res)
	414	return res;
	415	if (total_blocks == blocks)
	416	return 0;
	417
5bd9d99d AK	418	res = hfs_find_init(HFSPLUS_SB(sb)->ext_tree, &fd);
	419	if (res)
	420	return res;
1da177e4 LT	421	do {
	422	res = __hfsplus_ext_read_extent(&fd, ext_entry, cnid,
	423	total_blocks, type);
	424	if (res)
	425	break;
	426	start = be32_to_cpu(fd.key->ext.start_block);
1da177e4	427	hfs_brec_remove(&fd);
31651c60 EF	428
	429	mutex_unlock(&fd.tree->tree_lock);
	430	hfsplus_free_extents(sb, ext_entry, total_blocks - start,
	431	total_blocks);
1da177e4	432	total_blocks = start;
31651c60	433	mutex_lock(&fd.tree->tree_lock);
1da177e4 LT	434	} while (total_blocks > blocks);
	435	hfs_find_exit(&fd);
	436
	437	return res;
	438	}
	439
2cd282a1	440	int hfsplus_file_extend(struct inode *inode, bool zeroout)
1da177e4 LT	441	{
1da177e4 LT	442	struct super_block *sb = inode->i_sb;
dd73a01a	443	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
6af502de	444	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
1da177e4 LT	445	u32 start, len, goal;
	446	int res;
	447
1065348d CH	448	if (sbi->alloc_file->i_size * 8 <
1065348d CH	449	sbi->total_blocks - sbi->free_blocks + 8) {
21f2296a	450	/* extend alloc file */
d9efb07d CIK	451	pr_err_ratelimited("extend alloc file! (%llu,%u,%u)\n",
	452	sbi->alloc_file->i_size * 8,
	453	sbi->total_blocks, sbi->free_blocks);
1da177e4	454	return -ENOSPC;
1da177e4 LT	455	}
1da177e4 LT	456
6af502de CH	457	mutex_lock(&hip->extents_lock);
	458	if (hip->alloc_blocks == hip->first_blocks)
	459	goal = hfsplus_ext_lastblock(hip->first_extents);
1da177e4	460	else {
6af502de	461	res = hfsplus_ext_read_extent(inode, hip->alloc_blocks);
1da177e4 LT	462	if (res)
1da177e4 LT	463	goto out;
6af502de	464	goal = hfsplus_ext_lastblock(hip->cached_extents);
1da177e4 LT	465	}
1da177e4 LT	466
6af502de	467	len = hip->clump_blocks;
dd73a01a CH	468	start = hfsplus_block_allocate(sb, sbi->total_blocks, goal, &len);
dd73a01a CH	469	if (start >= sbi->total_blocks) {
1da177e4 LT	470	start = hfsplus_block_allocate(sb, goal, 0, &len);
	471	if (start >= goal) {
	472	res = -ENOSPC;
	473	goto out;
	474	}
	475	}
	476
2cd282a1 SA	477	if (zeroout) {
	478	res = sb_issue_zeroout(sb, start, len, GFP_NOFS);
	479	if (res)
	480	goto out;
	481	}
	482
c2b3e1f7	483	hfs_dbg(EXTENT, "extend %lu: %u,%u\n", inode->i_ino, start, len);
6af502de CH	484
	485	if (hip->alloc_blocks <= hip->first_blocks) {
	486	if (!hip->first_blocks) {
c2b3e1f7	487	hfs_dbg(EXTENT, "first extents\n");
1da177e4	488	/* no extents yet */
6af502de CH	489	hip->first_extents[0].start_block = cpu_to_be32(start);
6af502de CH	490	hip->first_extents[0].block_count = cpu_to_be32(len);
1da177e4 LT	491	res = 0;
	492	} else {
	493	/* try to append to extents in inode */
6af502de CH	494	res = hfsplus_add_extent(hip->first_extents,
6af502de CH	495	hip->alloc_blocks,
1da177e4 LT	496	start, len);
	497	if (res == -ENOSPC)
	498	goto insert_extent;
	499	}
	500	if (!res) {
6af502de CH	501	hfsplus_dump_extent(hip->first_extents);
6af502de CH	502	hip->first_blocks += len;
1da177e4 LT	503	}
1da177e4 LT	504	} else {
6af502de CH	505	res = hfsplus_add_extent(hip->cached_extents,
6af502de CH	506	hip->alloc_blocks - hip->cached_start,
1da177e4 LT	507	start, len);
1da177e4 LT	508	if (!res) {
6af502de	509	hfsplus_dump_extent(hip->cached_extents);
b33b7921	510	hip->extent_state \|= HFSPLUS_EXT_DIRTY;
6af502de	511	hip->cached_blocks += len;
1da177e4 LT	512	} else if (res == -ENOSPC)
	513	goto insert_extent;
	514	}
	515	out:
1da177e4	516	if (!res) {
6af502de	517	hip->alloc_blocks += len;
d7bdb996	518	mutex_unlock(&hip->extents_lock);
e3494705	519	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY);
d7bdb996	520	return 0;
1da177e4	521	}
d7bdb996	522	mutex_unlock(&hip->extents_lock);
1da177e4 LT	523	return res;
	524
	525	insert_extent:
c2b3e1f7	526	hfs_dbg(EXTENT, "insert new extent\n");
dd7f3d54 AK	527	res = hfsplus_ext_write_extent_locked(inode);
	528	if (res)
	529	goto out;
1da177e4	530
6af502de CH	531	memset(hip->cached_extents, 0, sizeof(hfsplus_extent_rec));
	532	hip->cached_extents[0].start_block = cpu_to_be32(start);
	533	hip->cached_extents[0].block_count = cpu_to_be32(len);
	534	hfsplus_dump_extent(hip->cached_extents);
b33b7921	535	hip->extent_state \|= HFSPLUS_EXT_DIRTY \| HFSPLUS_EXT_NEW;
6af502de CH	536	hip->cached_start = hip->alloc_blocks;
6af502de CH	537	hip->cached_blocks = len;
1da177e4 LT	538
	539	res = 0;
	540	goto out;
	541	}
	542
	543	void hfsplus_file_truncate(struct inode *inode)
	544	{
	545	struct super_block *sb = inode->i_sb;
6af502de	546	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);
1da177e4 LT	547	struct hfs_find_data fd;
	548	u32 alloc_cnt, blk_cnt, start;
	549	int res;
	550
c2b3e1f7 JP	551	hfs_dbg(INODE, "truncate: %lu, %llu -> %llu\n",
c2b3e1f7 JP	552	inode->i_ino, (long long)hip->phys_size, inode->i_size);
6af502de CH	553
6af502de CH	554	if (inode->i_size > hip->phys_size) {
1da177e4 LT	555	struct address_space *mapping = inode->i_mapping;
1da177e4 LT	556	struct page *page;
74b7046d	557	void *fsdata = NULL;
12f267a2	558	loff_t size = inode->i_size;
1da177e4	559
07a31f72 MWO	560	res = hfsplus_write_begin(NULL, mapping, size, 0,
07a31f72 MWO	561	&page, &fsdata);
1da177e4	562	if (res)
7c0efc62	563	return;
07a31f72 MWO	564	res = generic_write_end(NULL, mapping, size, 0, 0,
07a31f72 MWO	565	page, fsdata);
7c0efc62 NP	566	if (res < 0)
7c0efc62 NP	567	return;
1da177e4 LT	568	mark_inode_dirty(inode);
1da177e4 LT	569	return;
6af502de	570	} else if (inode->i_size == hip->phys_size)
f76d28d2 RZ	571	return;
f76d28d2 RZ	572
dd73a01a CH	573	blk_cnt = (inode->i_size + HFSPLUS_SB(sb)->alloc_blksz - 1) >>
dd73a01a CH	574	HFSPLUS_SB(sb)->alloc_blksz_shift;
d7bdb996 SS	575
	576	mutex_lock(&hip->extents_lock);
	577
6af502de	578	alloc_cnt = hip->alloc_blocks;
1da177e4	579	if (blk_cnt == alloc_cnt)
d7bdb996	580	goto out_unlock;
1da177e4	581
5bd9d99d AK	582	res = hfs_find_init(HFSPLUS_SB(sb)->ext_tree, &fd);
	583	if (res) {
	584	mutex_unlock(&hip->extents_lock);
	585	/* XXX: We lack error handling of hfsplus_file_truncate() */
	586	return;
	587	}
1da177e4	588	while (1) {
6af502de	589	if (alloc_cnt == hip->first_blocks) {
31651c60	590	mutex_unlock(&fd.tree->tree_lock);
6af502de	591	hfsplus_free_extents(sb, hip->first_extents,
1da177e4	592	alloc_cnt, alloc_cnt - blk_cnt);
6af502de CH	593	hfsplus_dump_extent(hip->first_extents);
6af502de CH	594	hip->first_blocks = blk_cnt;
31651c60	595	mutex_lock(&fd.tree->tree_lock);
1da177e4 LT	596	break;
	597	}
	598	res = __hfsplus_ext_cache_extent(&fd, inode, alloc_cnt);
	599	if (res)
	600	break;
31651c60	601
6af502de	602	start = hip->cached_start;
c3187cf3 JR	603	if (blk_cnt <= start)
	604	hfs_brec_remove(&fd);
	605	mutex_unlock(&fd.tree->tree_lock);
6af502de	606	hfsplus_free_extents(sb, hip->cached_extents,
1da177e4	607	alloc_cnt - start, alloc_cnt - blk_cnt);
6af502de	608	hfsplus_dump_extent(hip->cached_extents);
c3187cf3	609	mutex_lock(&fd.tree->tree_lock);
1da177e4	610	if (blk_cnt > start) {
b33b7921	611	hip->extent_state \|= HFSPLUS_EXT_DIRTY;
1da177e4 LT	612	break;
	613	}
	614	alloc_cnt = start;
6af502de	615	hip->cached_start = hip->cached_blocks = 0;
b33b7921	616	hip->extent_state &= ~(HFSPLUS_EXT_DIRTY \| HFSPLUS_EXT_NEW);
1da177e4 LT	617	}
1da177e4 LT	618	hfs_find_exit(&fd);
1da177e4	619
6af502de	620	hip->alloc_blocks = blk_cnt;
d7bdb996 SS	621	out_unlock:
d7bdb996 SS	622	mutex_unlock(&hip->extents_lock);
6af502de	623	hip->phys_size = inode->i_size;
2753cc28 AS	624	hip->fs_blocks = (inode->i_size + sb->s_blocksize - 1) >>
2753cc28 AS	625	sb->s_blocksize_bits;
6af502de	626	inode_set_bytes(inode, hip->fs_blocks << sb->s_blocksize_bits);
e3494705	627	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ALLOC_DIRTY);
1da177e4	628	}