Commit 6af502de authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Christoph Hellwig
Browse files

hfsplus: fix HFSPLUS_I calling convention 



HFSPLUS_I doesn't return a pointer to the hfsplus-specific inode
information like all other FOO_I macros, but dereference the pointer in a way
that made it look like a direct struct derefence.  This only works as long
as the HFSPLUS_I macro is used directly and prevents us from keepig a local
hfsplus_inode_info pointer.  Fix the calling convention and introduce a local
hip variable in all functions that use it constantly.

Signed-off-by: default avatarChristoph Hellwig <hch@tuxera.com>
parent dd73a01a

fs/hfsplus/btree.c

+5 −4
Original line number Diff line number Diff line
@@ -192,17 +192,18 @@ struct hfs_bnode *hfs_bmap_alloc(struct hfs_btree *tree) 


	while (!tree->free_nodes) {

		struct inode *inode = tree->inode;

		struct hfsplus_inode_info *hip = HFSPLUS_I(inode);

		u32 count;

		int res;



		res = hfsplus_file_extend(inode);

		if (res)

			return ERR_PTR(res);

		HFSPLUS_I(inode).phys_size = inode->i_size =

				(loff_t)HFSPLUS_I(inode).alloc_blocks <<

		hip->phys_size = inode->i_size =

			(loff_t)hip->alloc_blocks <<

				HFSPLUS_SB(tree->sb)->alloc_blksz_shift;

		HFSPLUS_I(inode).fs_blocks = HFSPLUS_I(inode).alloc_blocks <<

					     HFSPLUS_SB(tree->sb)->fs_shift;

		hip->fs_blocks =

			hip->alloc_blocks << HFSPLUS_SB(tree->sb)->fs_shift;

		inode_set_bytes(inode, inode->i_size);

		count = inode->i_size >> tree->node_size_shift;

		tree->free_nodes = count - tree->node_count;

fs/hfsplus/catalog.c

+7 −7
Original line number Diff line number Diff line
@@ -77,8 +77,8 @@ static void hfsplus_set_perms(struct inode *inode, struct hfsplus_perm *perms) 
		perms->rootflags |= HFSPLUS_FLG_APPEND;

	else

		perms->rootflags &= ~HFSPLUS_FLG_APPEND;

	HFSPLUS_I(inode).rootflags = perms->rootflags;

	HFSPLUS_I(inode).userflags = perms->userflags;

	HFSPLUS_I(inode)->rootflags = perms->rootflags;

	HFSPLUS_I(inode)->userflags = perms->userflags;

	perms->mode = cpu_to_be16(inode->i_mode);

	perms->owner = cpu_to_be32(inode->i_uid);

	perms->group = cpu_to_be32(inode->i_gid);
@@ -95,7 +95,7 @@ static int hfsplus_cat_build_record(hfsplus_cat_entry *entry, u32 cnid, struct i 
		memset(folder, 0, sizeof(*folder));

		folder->type = cpu_to_be16(HFSPLUS_FOLDER);

		folder->id = cpu_to_be32(inode->i_ino);

		HFSPLUS_I(inode).create_date =

		HFSPLUS_I(inode)->create_date =

			folder->create_date =

			folder->content_mod_date =

			folder->attribute_mod_date =
@@ -113,7 +113,7 @@ static int hfsplus_cat_build_record(hfsplus_cat_entry *entry, u32 cnid, struct i 
		file->type = cpu_to_be16(HFSPLUS_FILE);

		file->flags = cpu_to_be16(HFSPLUS_FILE_THREAD_EXISTS);

		file->id = cpu_to_be32(cnid);

		HFSPLUS_I(inode).create_date =

		HFSPLUS_I(inode)->create_date =

			file->create_date =

			file->content_mod_date =

			file->attribute_mod_date =
@@ -133,8 +133,8 @@ static int hfsplus_cat_build_record(hfsplus_cat_entry *entry, u32 cnid, struct i 
			file->user_info.fdType = cpu_to_be32(HFSP_HARDLINK_TYPE);

			file->user_info.fdCreator = cpu_to_be32(HFSP_HFSPLUS_CREATOR);

			file->user_info.fdFlags = cpu_to_be16(0x100);

			file->create_date = HFSPLUS_I(sbi->hidden_dir).create_date;

			file->permissions.dev = cpu_to_be32(HFSPLUS_I(inode).dev);

			file->create_date = HFSPLUS_I(sbi->hidden_dir)->create_date;

			file->permissions.dev = cpu_to_be32(HFSPLUS_I(inode)->dev);

		}

		return sizeof(*file);

	}
@@ -279,7 +279,7 @@ int hfsplus_delete_cat(u32 cnid, struct inode *dir, struct qstr *str) 
		hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_RSRC);

	}



	list_for_each(pos, &HFSPLUS_I(dir).open_dir_list) {

	list_for_each(pos, &HFSPLUS_I(dir)->open_dir_list) {

		struct hfsplus_readdir_data *rd =

			list_entry(pos, struct hfsplus_readdir_data, list);

		if (fd.tree->keycmp(fd.search_key, (void *)&rd->key) < 0)

fs/hfsplus/dir.c

+7 −7
Original line number Diff line number Diff line
@@ -68,8 +68,8 @@ again: 
		cnid = be32_to_cpu(entry.file.id);

		if (entry.file.user_info.fdType == cpu_to_be32(HFSP_HARDLINK_TYPE) &&

		    entry.file.user_info.fdCreator == cpu_to_be32(HFSP_HFSPLUS_CREATOR) &&

		    (entry.file.create_date == HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir).create_date ||

		     entry.file.create_date == HFSPLUS_I(sb->s_root->d_inode).create_date) &&

		    (entry.file.create_date == HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->create_date ||

		     entry.file.create_date == HFSPLUS_I(sb->s_root->d_inode)->create_date) &&

		    HFSPLUS_SB(sb)->hidden_dir) {

			struct qstr str;

			char name[32];
@@ -102,7 +102,7 @@ again: 
	if (IS_ERR(inode))

		return ERR_CAST(inode);

	if (S_ISREG(inode->i_mode))

		HFSPLUS_I(inode).dev = linkid;

		HFSPLUS_I(inode)->dev = linkid;

out:

	d_add(dentry, inode);

	return NULL;
@@ -219,7 +219,7 @@ static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir) 
		}

		filp->private_data = rd;

		rd->file = filp;

		list_add(&rd->list, &HFSPLUS_I(inode).open_dir_list);

		list_add(&rd->list, &HFSPLUS_I(inode)->open_dir_list);

	}

	memcpy(&rd->key, fd.key, sizeof(struct hfsplus_cat_key));

out:
@@ -287,7 +287,7 @@ static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir, 
			if (res != -EEXIST)

				return res;

		}

		HFSPLUS_I(inode).dev = id;

		HFSPLUS_I(inode)->dev = id;

		cnid = sbi->next_cnid++;

		src_dentry->d_fsdata = (void *)(unsigned long)cnid;

		res = hfsplus_create_cat(cnid, src_dir, &src_dentry->d_name, inode);
@@ -326,7 +326,7 @@ static int hfsplus_unlink(struct inode *dir, struct dentry *dentry) 


	cnid = (u32)(unsigned long)dentry->d_fsdata;

	if (inode->i_ino == cnid &&

	    atomic_read(&HFSPLUS_I(inode).opencnt)) {

	    atomic_read(&HFSPLUS_I(inode)->opencnt)) {

		str.name = name;

		str.len = sprintf(name, "temp%lu", inode->i_ino);

		res = hfsplus_rename_cat(inode->i_ino,
@@ -347,7 +347,7 @@ static int hfsplus_unlink(struct inode *dir, struct dentry *dentry) 
	if (!inode->i_nlink) {

		if (inode->i_ino != cnid) {

			sbi->file_count--;

			if (!atomic_read(&HFSPLUS_I(inode).opencnt)) {

			if (!atomic_read(&HFSPLUS_I(inode)->opencnt)) {

				res = hfsplus_delete_cat(inode->i_ino,

							 sbi->hidden_dir,

							 NULL);

fs/hfsplus/extents.c

+92 −79
Original line number Diff line number Diff line
@@ -85,27 +85,32 @@ static u32 hfsplus_ext_lastblock(struct hfsplus_extent *ext) 


static void __hfsplus_ext_write_extent(struct inode *inode, struct hfs_find_data *fd)

{

	struct hfsplus_inode_info *hip = HFSPLUS_I(inode);

	int res;



	hfsplus_ext_build_key(fd->search_key, inode->i_ino, HFSPLUS_I(inode).cached_start,

			      HFSPLUS_IS_RSRC(inode) ?  HFSPLUS_TYPE_RSRC : HFSPLUS_TYPE_DATA);

	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);

	if (HFSPLUS_I(inode).flags & HFSPLUS_FLG_EXT_NEW) {

	if (hip->flags & HFSPLUS_FLG_EXT_NEW) {

		if (res != -ENOENT)

			return;

		hfs_brec_insert(fd, HFSPLUS_I(inode).cached_extents, sizeof(hfsplus_extent_rec));

		HFSPLUS_I(inode).flags &= ~(HFSPLUS_FLG_EXT_DIRTY | HFSPLUS_FLG_EXT_NEW);

		hfs_brec_insert(fd, hip->cached_extents,

				sizeof(hfsplus_extent_rec));

		hip->flags &= ~(HFSPLUS_FLG_EXT_DIRTY | HFSPLUS_FLG_EXT_NEW);

	} else {

		if (res)

			return;

		hfs_bnode_write(fd->bnode, HFSPLUS_I(inode).cached_extents, fd->entryoffset, fd->entrylength);

		HFSPLUS_I(inode).flags &= ~HFSPLUS_FLG_EXT_DIRTY;

		hfs_bnode_write(fd->bnode, hip->cached_extents,

				fd->entryoffset, fd->entrylength);

		hip->flags &= ~HFSPLUS_FLG_EXT_DIRTY;

	}

}



void hfsplus_ext_write_extent(struct inode *inode)

{

	if (HFSPLUS_I(inode).flags & HFSPLUS_FLG_EXT_DIRTY) {

	if (HFSPLUS_I(inode)->flags & HFSPLUS_FLG_EXT_DIRTY) {

		struct hfs_find_data fd;



		hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd);
@@ -136,30 +141,34 @@ static inline int __hfsplus_ext_read_extent(struct hfs_find_data *fd, 


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;



	if (HFSPLUS_I(inode).flags & HFSPLUS_FLG_EXT_DIRTY)

	if (hip->flags & HFSPLUS_FLG_EXT_DIRTY)

		__hfsplus_ext_write_extent(inode, fd);



	res = __hfsplus_ext_read_extent(fd, HFSPLUS_I(inode).cached_extents, inode->i_ino,

					block, HFSPLUS_IS_RSRC(inode) ? HFSPLUS_TYPE_RSRC : HFSPLUS_TYPE_DATA);

	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) {

		HFSPLUS_I(inode).cached_start = be32_to_cpu(fd->key->ext.start_block);

		HFSPLUS_I(inode).cached_blocks = hfsplus_ext_block_count(HFSPLUS_I(inode).cached_extents);

		hip->cached_start = be32_to_cpu(fd->key->ext.start_block);

		hip->cached_blocks = hfsplus_ext_block_count(hip->cached_extents);

	} else {

		HFSPLUS_I(inode).cached_start = HFSPLUS_I(inode).cached_blocks = 0;

		HFSPLUS_I(inode).flags &= ~(HFSPLUS_FLG_EXT_DIRTY | HFSPLUS_FLG_EXT_NEW);

		hip->cached_start = hip->cached_blocks = 0;

		hip->flags &= ~(HFSPLUS_FLG_EXT_DIRTY | HFSPLUS_FLG_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 >= HFSPLUS_I(inode).cached_start &&

	    block < HFSPLUS_I(inode).cached_start + HFSPLUS_I(inode).cached_blocks)

	if (block >= hip->cached_start &&

	    block < hip->cached_start + hip->cached_blocks)

		return 0;



	hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd);
@@ -174,6 +183,7 @@ int hfsplus_get_block(struct inode *inode, sector_t iblock, 
{

	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;

	int shift;
@@ -182,10 +192,10 @@ int hfsplus_get_block(struct inode *inode, sector_t iblock, 
	shift = sbi->alloc_blksz_shift - sb->s_blocksize_bits;

	ablock = iblock >> sbi->fs_shift;



	if (iblock >= HFSPLUS_I(inode).fs_blocks) {

		if (iblock > HFSPLUS_I(inode).fs_blocks || !create)

	if (iblock >= hip->fs_blocks) {

		if (iblock > hip->fs_blocks || !create)

			return -EIO;

		if (ablock >= HFSPLUS_I(inode).alloc_blocks) {

		if (ablock >= hip->alloc_blocks) {

			res = hfsplus_file_extend(inode);

			if (res)

				return res;
@@ -193,24 +203,24 @@ int hfsplus_get_block(struct inode *inode, sector_t iblock, 
	} else

		create = 0;



	if (ablock < HFSPLUS_I(inode).first_blocks) {

		dblock = hfsplus_ext_find_block(HFSPLUS_I(inode).first_extents, ablock);

	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(&HFSPLUS_I(inode).extents_lock);

	mutex_lock(&hip->extents_lock);

	res = hfsplus_ext_read_extent(inode, ablock);

	if (!res) {

		dblock = hfsplus_ext_find_block(HFSPLUS_I(inode).cached_extents, ablock -

					     HFSPLUS_I(inode).cached_start);

		dblock = hfsplus_ext_find_block(hip->cached_extents,

						ablock - hip->cached_start);

	} else {

		mutex_unlock(&HFSPLUS_I(inode).extents_lock);

		mutex_unlock(&hip->extents_lock);

		return -EIO;

	}

	mutex_unlock(&HFSPLUS_I(inode).extents_lock);

	mutex_unlock(&hip->extents_lock);



done:

	dprint(DBG_EXTENT, "get_block(%lu): %llu - %u\n", inode->i_ino, (long long)iblock, dblock);
@@ -218,8 +228,8 @@ done: 
	map_bh(bh_result, sb, (dblock << sbi->fs_shift) + sbi->blockoffset + (iblock & mask));

	if (create) {

		set_buffer_new(bh_result);

		HFSPLUS_I(inode).phys_size += sb->s_blocksize;

		HFSPLUS_I(inode).fs_blocks++;

		hip->phys_size += sb->s_blocksize;

		hip->fs_blocks++;

		inode_add_bytes(inode, sb->s_blocksize);

		mark_inode_dirty(inode);

	}
@@ -348,6 +358,7 @@ int hfsplus_file_extend(struct inode *inode) 
{

	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;
@@ -360,17 +371,17 @@ int hfsplus_file_extend(struct inode *inode) 
		return -ENOSPC;

	}



	mutex_lock(&HFSPLUS_I(inode).extents_lock);

	if (HFSPLUS_I(inode).alloc_blocks == HFSPLUS_I(inode).first_blocks)

		goal = hfsplus_ext_lastblock(HFSPLUS_I(inode).first_extents);

	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, HFSPLUS_I(inode).alloc_blocks);

		res = hfsplus_ext_read_extent(inode, hip->alloc_blocks);

		if (res)

			goto out;

		goal = hfsplus_ext_lastblock(HFSPLUS_I(inode).cached_extents);

		goal = hfsplus_ext_lastblock(hip->cached_extents);

	}



	len = HFSPLUS_I(inode).clump_blocks;

	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);
@@ -381,41 +392,41 @@ int hfsplus_file_extend(struct inode *inode) 
	}



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

	if (HFSPLUS_I(inode).alloc_blocks <= HFSPLUS_I(inode).first_blocks) {

		if (!HFSPLUS_I(inode).first_blocks) {



	if (hip->alloc_blocks <= hip->first_blocks) {

		if (!hip->first_blocks) {

			dprint(DBG_EXTENT, "first extents\n");

			/* no extents yet */

			HFSPLUS_I(inode).first_extents[0].start_block = cpu_to_be32(start);

			HFSPLUS_I(inode).first_extents[0].block_count = cpu_to_be32(len);

			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(HFSPLUS_I(inode).first_extents,

						 HFSPLUS_I(inode).alloc_blocks,

			res = hfsplus_add_extent(hip->first_extents,

						 hip->alloc_blocks,

						 start, len);

			if (res == -ENOSPC)

				goto insert_extent;

		}

		if (!res) {

			hfsplus_dump_extent(HFSPLUS_I(inode).first_extents);

			HFSPLUS_I(inode).first_blocks += len;

			hfsplus_dump_extent(hip->first_extents);

			hip->first_blocks += len;

		}

	} else {

		res = hfsplus_add_extent(HFSPLUS_I(inode).cached_extents,

					 HFSPLUS_I(inode).alloc_blocks -

					 HFSPLUS_I(inode).cached_start,

		res = hfsplus_add_extent(hip->cached_extents,

					 hip->alloc_blocks - hip->cached_start,

					 start, len);

		if (!res) {

			hfsplus_dump_extent(HFSPLUS_I(inode).cached_extents);

			HFSPLUS_I(inode).flags |= HFSPLUS_FLG_EXT_DIRTY;

			HFSPLUS_I(inode).cached_blocks += len;

			hfsplus_dump_extent(hip->cached_extents);

			hip->flags |= HFSPLUS_FLG_EXT_DIRTY;

			hip->cached_blocks += len;

		} else if (res == -ENOSPC)

			goto insert_extent;

	}

out:

	mutex_unlock(&HFSPLUS_I(inode).extents_lock);

	mutex_unlock(&hip->extents_lock);

	if (!res) {

		HFSPLUS_I(inode).alloc_blocks += len;

		hip->alloc_blocks += len;

		mark_inode_dirty(inode);

	}

	return res;
@@ -424,13 +435,13 @@ insert_extent: 
	dprint(DBG_EXTENT, "insert new extent\n");

	hfsplus_ext_write_extent(inode);



	memset(HFSPLUS_I(inode).cached_extents, 0, sizeof(hfsplus_extent_rec));

	HFSPLUS_I(inode).cached_extents[0].start_block = cpu_to_be32(start);

	HFSPLUS_I(inode).cached_extents[0].block_count = cpu_to_be32(len);

	hfsplus_dump_extent(HFSPLUS_I(inode).cached_extents);

	HFSPLUS_I(inode).flags |= HFSPLUS_FLG_EXT_DIRTY | HFSPLUS_FLG_EXT_NEW;

	HFSPLUS_I(inode).cached_start = HFSPLUS_I(inode).alloc_blocks;

	HFSPLUS_I(inode).cached_blocks = len;

	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->flags |= HFSPLUS_FLG_EXT_DIRTY | HFSPLUS_FLG_EXT_NEW;

	hip->cached_start = hip->alloc_blocks;

	hip->cached_blocks = len;



	res = 0;

	goto out;
@@ -439,13 +450,15 @@ insert_extent: 
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;



	dprint(DBG_INODE, "truncate: %lu, %Lu -> %Lu\n", inode->i_ino,

	       (long long)HFSPLUS_I(inode).phys_size, inode->i_size);

	if (inode->i_size > HFSPLUS_I(inode).phys_size) {

	dprint(DBG_INODE, "truncate: %lu, %Lu -> %Lu\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;
@@ -462,48 +475,48 @@ void hfsplus_file_truncate(struct inode *inode) 
			return;

		mark_inode_dirty(inode);

		return;

	} else if (inode->i_size == HFSPLUS_I(inode).phys_size)

	} 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;

	alloc_cnt = HFSPLUS_I(inode).alloc_blocks;

	alloc_cnt = hip->alloc_blocks;

	if (blk_cnt == alloc_cnt)

		goto out;



	mutex_lock(&HFSPLUS_I(inode).extents_lock);

	mutex_lock(&hip->extents_lock);

	hfs_find_init(HFSPLUS_SB(sb)->ext_tree, &fd);

	while (1) {

		if (alloc_cnt == HFSPLUS_I(inode).first_blocks) {

			hfsplus_free_extents(sb, HFSPLUS_I(inode).first_extents,

		if (alloc_cnt == hip->first_blocks) {

			hfsplus_free_extents(sb, hip->first_extents,

					     alloc_cnt, alloc_cnt - blk_cnt);

			hfsplus_dump_extent(HFSPLUS_I(inode).first_extents);

			HFSPLUS_I(inode).first_blocks = blk_cnt;

			hfsplus_dump_extent(hip->first_extents);

			hip->first_blocks = blk_cnt;

			break;

		}

		res = __hfsplus_ext_cache_extent(&fd, inode, alloc_cnt);

		if (res)

			break;

		start = HFSPLUS_I(inode).cached_start;

		hfsplus_free_extents(sb, HFSPLUS_I(inode).cached_extents,

		start = hip->cached_start;

		hfsplus_free_extents(sb, hip->cached_extents,

				     alloc_cnt - start, alloc_cnt - blk_cnt);

		hfsplus_dump_extent(HFSPLUS_I(inode).cached_extents);

		hfsplus_dump_extent(hip->cached_extents);

		if (blk_cnt > start) {

			HFSPLUS_I(inode).flags |= HFSPLUS_FLG_EXT_DIRTY;

			hip->flags |= HFSPLUS_FLG_EXT_DIRTY;

			break;

		}

		alloc_cnt = start;

		HFSPLUS_I(inode).cached_start = HFSPLUS_I(inode).cached_blocks = 0;

		HFSPLUS_I(inode).flags &= ~(HFSPLUS_FLG_EXT_DIRTY | HFSPLUS_FLG_EXT_NEW);

		hip->cached_start = hip->cached_blocks = 0;

		hip->flags &= ~(HFSPLUS_FLG_EXT_DIRTY | HFSPLUS_FLG_EXT_NEW);

		hfs_brec_remove(&fd);

	}

	hfs_find_exit(&fd);

	mutex_unlock(&HFSPLUS_I(inode).extents_lock);

	mutex_unlock(&hip->extents_lock);



	HFSPLUS_I(inode).alloc_blocks = blk_cnt;

	hip->alloc_blocks = blk_cnt;

out:

	HFSPLUS_I(inode).phys_size = inode->i_size;

	HFSPLUS_I(inode).fs_blocks = (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;

	inode_set_bytes(inode, HFSPLUS_I(inode).fs_blocks << sb->s_blocksize_bits);

	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);

	mark_inode_dirty(inode);

}

fs/hfsplus/hfsplus_fs.h

+3 −5
Original line number Diff line number Diff line
@@ -187,8 +187,8 @@ struct hfsplus_inode_info { 
#define HFSPLUS_FLG_EXT_DIRTY	0x0002

#define HFSPLUS_FLG_EXT_NEW	0x0004



#define HFSPLUS_IS_DATA(inode)   (!(HFSPLUS_I(inode).flags & HFSPLUS_FLG_RSRC))

#define HFSPLUS_IS_RSRC(inode)   (HFSPLUS_I(inode).flags & HFSPLUS_FLG_RSRC)

#define HFSPLUS_IS_DATA(inode)   (!(HFSPLUS_I(inode)->flags & HFSPLUS_FLG_RSRC))

#define HFSPLUS_IS_RSRC(inode)   (HFSPLUS_I(inode)->flags & HFSPLUS_FLG_RSRC)



struct hfs_find_data {

	/* filled by caller */
@@ -379,13 +379,11 @@ static inline struct hfsplus_sb_info *HFSPLUS_SB(struct super_block *sb) 
{

	return sb->s_fs_info;

}

/*



static inline struct hfsplus_inode_info *HFSPLUS_I(struct inode *inode)

{

	return list_entry(inode, struct hfsplus_inode_info, vfs_inode);

}

*/

#define HFSPLUS_I(inode)	(*list_entry(inode, struct hfsplus_inode_info, vfs_inode))



#if 1

#define hfsplus_kmap(p)		({ struct page *__p = (p); kmap(__p); })

CRA Git | Maintained and supported by SUSTech CRA and CCSE