自学教程：C++ HFSPLUS_SB函数代码示例

int hfsplus_show_options(struct seq_file *seq, struct vfsmount *mnt)#endif{#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,5,0)	struct hfsplus_sb_info *sbi = HFSPLUS_SB(root->d_sb);#else	struct hfsplus_sb_info *sbi = HFSPLUS_SB(mnt->mnt_sb);#endif	if (sbi->creator != HFSPLUS_DEF_CR_TYPE)		seq_printf(seq, ",creator=%.4s", (char *)&sbi->creator);	if (sbi->type != HFSPLUS_DEF_CR_TYPE)		seq_printf(seq, ",type=%.4s", (char *)&sbi->type);	seq_printf(seq, ",umask=%o,uid=%u,gid=%u", sbi->umask,#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)			from_kuid_munged(&init_user_ns, sbi->uid),			from_kgid_munged(&init_user_ns, sbi->gid));#else			sbi->uid, sbi->gid);#endif	if (sbi->part >= 0)		seq_printf(seq, ",part=%u", sbi->part);	if (sbi->session >= 0)		seq_printf(seq, ",session=%u", sbi->session);	if (sbi->nls)		seq_printf(seq, ",nls=%s", sbi->nls->charset);	if (test_bit(HFSPLUS_SB_NODECOMPOSE, &sbi->flags))		seq_printf(seq, ",nodecompose");	if (test_bit(HFSPLUS_SB_NOBARRIER, &sbi->flags))		seq_printf(seq, ",nobarrier");	return 0;}

int hfs_part_find(struct super_block *sb,		  sector_t *part_start, sector_t *part_size){	struct buffer_head *bh;	__be16 *data;	int i, size, res;	res = -ENOENT;	bh = sb_bread512(sb, *part_start + HFS_PMAP_BLK, data);	if (!bh)		return -EIO;	switch (be16_to_cpu(*data)) {	case HFS_OLD_PMAP_MAGIC:	  {		struct old_pmap *pm;		struct old_pmap_entry *p;		pm = (struct old_pmap *)bh->b_data;		p = pm->pdEntry;		size = 42;		for (i = 0; i < size; p++, i++) {			if (p->pdStart && p->pdSize &&			    p->pdFSID == cpu_to_be32(0x54465331)/*"TFS1"*/ &&			    (HFSPLUS_SB(sb).part < 0 || HFSPLUS_SB(sb).part == i)) {				*part_start += be32_to_cpu(p->pdStart);				*part_size = be32_to_cpu(p->pdSize);				res = 0;			}		}		break;	  }	case HFS_NEW_PMAP_MAGIC:	  {		struct new_pmap *pm;		pm = (struct new_pmap *)bh->b_data;		size = be32_to_cpu(pm->pmMapBlkCnt);		for (i = 0; i < size;) {			if (!memcmp(pm->pmPartType,"Apple_HFS", 9) &&			    (HFSPLUS_SB(sb).part < 0 || HFSPLUS_SB(sb).part == i)) {				*part_start += be32_to_cpu(pm->pmPyPartStart);				*part_size = be32_to_cpu(pm->pmPartBlkCnt);				res = 0;				break;			}			brelse(bh);			bh = sb_bread512(sb, *part_start + HFS_PMAP_BLK + ++i, pm);			if (!bh)				return -EIO;			if (pm->pmSig != cpu_to_be16(HFS_NEW_PMAP_MAGIC))				break;		}		break;	  }	}	brelse(bh);	return res;}

static int hfsplus_get_last_session(struct super_block *sb,                                    sector_t *start, sector_t *size){    struct cdrom_multisession ms_info;    struct cdrom_tocentry te;    int res;    /* default values */    *start = 0;    *size = sb->s_bdev->bd_inode->i_size >> 9;    if (HFSPLUS_SB(sb)->session >= 0) {        te.cdte_track = HFSPLUS_SB(sb)->session;        te.cdte_format = CDROM_LBA;        res = ioctl_by_bdev(sb->s_bdev,                            CDROMREADTOCENTRY, (unsigned long)&te);        if (!res && (te.cdte_ctrl & CDROM_DATA_TRACK) == 4) {            *start = (sector_t)te.cdte_addr.lba << 2;            return 0;        }        pr_err("invalid session number or type of track/n");        return -EINVAL;    }    ms_info.addr_format = CDROM_LBA;    res = ioctl_by_bdev(sb->s_bdev, CDROMMULTISESSION,                        (unsigned long)&ms_info);    if (!res && ms_info.xa_flag)        *start = (sector_t)ms_info.addr.lba << 2;    return 0;}

static int hfsplus_unlink(struct inode *dir, struct dentry *dentry){	struct super_block *sb = dir->i_sb;	struct inode *inode = dentry->d_inode;	struct qstr str;	char name[32];	u32 cnid;	int res;	hfsplus_handle_t hfsplus_handle;	if (HFSPLUS_IS_RSRC(inode))		return -EPERM;	if ((res = hfsplus_journal_start(__FUNCTION__, dir->i_sb, &hfsplus_handle)))		return res;	cnid = (u32)(unsigned long)dentry->d_fsdata;	if (inode->i_ino == cnid &&	    atomic_read(&HFSPLUS_I(inode).opencnt)) {		str.name = name;		str.len = sprintf(name, "temp%lu", inode->i_ino);		res = hfsplus_rename_cat(&hfsplus_handle, inode->i_ino,					 dir, &dentry->d_name,					 HFSPLUS_SB(sb).hidden_dir, &str);		if (!res)			inode->i_flags |= S_DEAD;		hfsplus_journal_stop(&hfsplus_handle);		return res;	}	res = hfsplus_delete_cat(&hfsplus_handle, cnid, dir, &dentry->d_name);	if (res) {		hfsplus_journal_stop(&hfsplus_handle);		return res;	}	if (inode->i_nlink > 0)		drop_nlink(inode);	if (inode->i_ino == cnid)		clear_nlink(inode);	if (!inode->i_nlink) {		if (inode->i_ino != cnid) {			HFSPLUS_SB(sb).file_count--;			if (!atomic_read(&HFSPLUS_I(inode).opencnt)) {			res = hfsplus_delete_cat(&hfsplus_handle, inode->i_ino, HFSPLUS_SB(sb).hidden_dir, NULL);				if (!res)				hfsplus_delete_inode(&hfsplus_handle, inode);			} else				inode->i_flags |= S_DEAD;		} else			hfsplus_delete_inode(&hfsplus_handle,inode);	} else		HFSPLUS_SB(sb).file_count--;	inode->i_ctime = CURRENT_TIME_SEC;	res = hfsplus_journalled_mark_inode_dirty(__FUNCTION__, &hfsplus_handle, inode);	hfsplus_journal_stop(&hfsplus_handle);	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;	int res = -EIO;	u32 ablock, dblock, mask;	int shift;	sb = inode->i_sb;	/* Convert inode block to disk allocation block */	shift = HFSPLUS_SB(sb).alloc_blksz_shift - sb->s_blocksize_bits;	ablock = iblock >> HFSPLUS_SB(sb).fs_shift;	if (iblock >= inode->i_blocks) {		if (iblock > inode->i_blocks || !create)			return -EIO;		if (ablock >= HFSPLUS_I(inode).alloc_blocks) {			res = hfsplus_file_extend(inode);			if (res)				return res;		}	} else		create = 0;	if (ablock < HFSPLUS_I(inode).first_blocks) {		dblock = hfsplus_ext_find_block(HFSPLUS_I(inode).first_extents, ablock);		goto done;	}	down(&HFSPLUS_I(inode).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);	} else {		up(&HFSPLUS_I(inode).extents_lock);		return -EIO;	}	up(&HFSPLUS_I(inode).extents_lock);done:	dprint(DBG_EXTENT, "get_block(%lu): %llu - %u/n", inode->i_ino, (long long)iblock, dblock);	mask = (1 << HFSPLUS_SB(sb).fs_shift) - 1;	map_bh(bh_result, sb, (dblock << HFSPLUS_SB(sb).fs_shift) + HFSPLUS_SB(sb).blockoffset + (iblock & mask));	if (create) {		set_buffer_new(bh_result);		HFSPLUS_I(inode).phys_size += sb->s_blocksize;		inode->i_blocks++;		mark_inode_dirty(inode);	}	return 0;}

static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,			struct dentry *dst_dentry){	struct super_block *sb = dst_dir->i_sb;	struct inode *inode = src_dentry->d_inode;	struct inode *src_dir = src_dentry->d_parent->d_inode;	struct qstr str;	char name[32];	u32 cnid, id;	int res;	if (HFSPLUS_IS_RSRC(inode))		return -EPERM;	if (inode->i_ino == (u32)(unsigned long)src_dentry->d_fsdata) {		for (;;) {			get_random_bytes(&id, sizeof(cnid));			id &= 0x3fffffff;			str.name = name;			str.len = sprintf(name, "iNode%d", id);			res = hfsplus_rename_cat(inode->i_ino,						 src_dir, &src_dentry->d_name,						 HFSPLUS_SB(sb).hidden_dir, &str);			if (!res)				break;			if (res != -EEXIST)				return res;		}		HFSPLUS_I(inode).dev = id;		cnid = HFSPLUS_SB(sb).next_cnid++;		src_dentry->d_fsdata = (void *)(unsigned long)cnid;		res = hfsplus_create_cat(cnid, src_dir, &src_dentry->d_name, inode);		if (res)			/* panic? */			return res;		HFSPLUS_SB(sb).file_count++;	}	cnid = HFSPLUS_SB(sb).next_cnid++;	res = hfsplus_create_cat(cnid, dst_dir, &dst_dentry->d_name, inode);	if (res)		return res;	inc_nlink(inode);	hfsplus_instantiate(dst_dentry, inode, cnid);	atomic_inc(&inode->i_count);	inode->i_ctime = CURRENT_TIME_SEC;	mark_inode_dirty(inode);	HFSPLUS_SB(sb).file_count++;	sb->s_dirt = 1;	return 0;}

static int hfsplus_symlink(struct inode *dir, struct dentry *dentry,			   const char *symname){	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);	struct inode *inode;	int res = -ENOSPC;	mutex_lock(&sbi->vh_mutex);	inode = hfsplus_new_inode(dir->i_sb, S_IFLNK | S_IRWXUGO);	if (!inode)		goto out;	res = page_symlink(inode, symname, strlen(symname) + 1);	if (res)		goto out_err;	res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);	if (res)		goto out_err;	hfsplus_instantiate(dentry, inode, inode->i_ino);	mark_inode_dirty(inode);	goto out;out_err:	clear_nlink(inode);	hfsplus_delete_inode(inode);	iput(inode);out:	mutex_unlock(&sbi->vh_mutex);	return res;}

int hfsplus_asc2uni(struct super_block *sb,		    struct hfsplus_unistr *ustr, int max_unistr_len,		    const char *astr, int len){	int size, dsize, decompose;	u16 *dstr, outlen = 0;	wchar_t c;	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);	while (outlen < max_unistr_len && len > 0) {		size = asc2unichar(sb, astr, len, &c);		if (decompose)			dstr = decompose_unichar(c, &dsize);		else			dstr = NULL;		if (dstr) {			if (outlen + dsize > max_unistr_len)				break;			do {				ustr->unicode[outlen++] = cpu_to_be16(*dstr++);			} while (--dsize > 0);		} else			ustr->unicode[outlen++] = cpu_to_be16(c);		astr += size;		len -= size;	}	ustr->length = cpu_to_be16(outlen);	if (len > 0)		return -ENAMETOOLONG;	return 0;}

static int hfs_parse_new_pmap(struct super_block *sb, void *buf,		struct new_pmap *pm, sector_t *part_start, sector_t *part_size){	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);	int size = be32_to_cpu(pm->pmMapBlkCnt);	int buf_size = hfsplus_min_io_size(sb);	int res;	int i = 0;	do {		if (!memcmp(pm->pmPartType, "Apple_HFS", 9) &&		    (sbi->part < 0 || sbi->part == i)) {			*part_start += be32_to_cpu(pm->pmPyPartStart);			*part_size = be32_to_cpu(pm->pmPartBlkCnt);			return 0;		}		if (++i >= size)			return -ENOENT;		pm = (struct new_pmap *)((u8 *)pm + HFSPLUS_SECTOR_SIZE);		if ((u8 *)pm - (u8 *)buf >= buf_size) {			res = hfsplus_submit_bio(sb,						 *part_start + HFS_PMAP_BLK + i,						 buf, (void **)&pm, REQ_OP_READ,						 0);			if (res)				return res;		}	} while (pm->pmSig == cpu_to_be16(HFS_NEW_PMAP_MAGIC));	return -ENOENT;}

static int hfsplus_system_read_inode(struct inode *inode){	struct hfsplus_vh *vhdr = HFSPLUS_SB(inode->i_sb)->s_vhdr;	switch (inode->i_ino) {	case HFSPLUS_EXT_CNID:		hfsplus_inode_read_fork(inode, &vhdr->ext_file);		inode->i_mapping->a_ops = &hfsplus_btree_aops;		break;	case HFSPLUS_CAT_CNID:		hfsplus_inode_read_fork(inode, &vhdr->cat_file);		inode->i_mapping->a_ops = &hfsplus_btree_aops;		break;	case HFSPLUS_ALLOC_CNID:		hfsplus_inode_read_fork(inode, &vhdr->alloc_file);		inode->i_mapping->a_ops = &hfsplus_aops;		break;	case HFSPLUS_START_CNID:		hfsplus_inode_read_fork(inode, &vhdr->start_file);		break;	case HFSPLUS_ATTR_CNID:		hfsplus_inode_read_fork(inode, &vhdr->attr_file);		inode->i_mapping->a_ops = &hfsplus_btree_aops;		break;	default:		return -EIO;	}	return 0;}

int hfsplus_journaled_get_block(struct page *page){  struct inode * const inode = page->mapping->host;  struct super_block * const sb = inode->i_sb;  struct hfsplus_inode_info *hip = HFSPLUS_I(inode);  u32 ablock, res;  sector_t iblock;  s32 block_num = -1;    iblock = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);  ablock = iblock >> HFSPLUS_SB(sb)->fs_shift;  if (ablock < hip->first_blocks) {    block_num = hfsplus_ext_find_block(hip->first_extents, ablock);  }  else {    mutex_lock(&hip->extents_lock);    res = hfsplus_ext_read_extent(inode, ablock);    if (!res) {      mutex_lock(&hip->extents_lock);      block_num = hfsplus_ext_find_block(hip->cached_extents, ablock -      hip->cached_start);      mutex_unlock(&hip->extents_lock);    } else {      mutex_unlock(&hip->extents_lock);    }    mutex_unlock(&hip->extents_lock);  }    return block_num;}

static void hfsplus_put_super(struct super_block *sb){	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);	dprint(DBG_SUPER, "hfsplus_put_super/n");	if (!sb->s_fs_info)		return;	if (!(sb->s_flags & MS_RDONLY) && sbi->s_vhdr) {		struct hfsplus_vh *vhdr = sbi->s_vhdr;		vhdr->modify_date = hfsp_now2mt();		vhdr->attributes |= cpu_to_be32(HFSPLUS_VOL_UNMNT);		vhdr->attributes &= cpu_to_be32(~HFSPLUS_VOL_INCNSTNT);		hfsplus_sync_fs(sb, 1);	}	hfs_btree_close(sbi->cat_tree);	hfs_btree_close(sbi->ext_tree);	iput(sbi->alloc_file);	iput(sbi->hidden_dir);	kfree(sbi->s_vhdr);	kfree(sbi->s_backup_vhdr);	unload_nls(sbi->nls);	kfree(sb->s_fs_info);	sb->s_fs_info = NULL;}

/* * "Blessing" an HFS+ filesystem writes metadata to the superblock informing * the platform firmware which file to boot from */static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags){	struct dentry *dentry = file->f_path.dentry;	struct inode *inode = dentry->d_inode;	struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);	struct hfsplus_vh *vh = sbi->s_vhdr;	struct hfsplus_vh *bvh = sbi->s_backup_vhdr;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	mutex_lock(&sbi->vh_mutex);	/* Directory containing the bootable system */	vh->finder_info[0] = bvh->finder_info[0] =		cpu_to_be32(parent_ino(dentry));	/* Bootloader */	vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(inode->i_ino);	/* Per spec, the OS X system folder - same as finder_info[0] here */	vh->finder_info[5] = bvh->finder_info[5] =		cpu_to_be32(parent_ino(dentry));	mutex_unlock(&sbi->vh_mutex);	return 0;}

int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr,		    const char *astr, int len){	int size, dsize, decompose;	u16 *dstr, outlen = 0;	wchar_t c;	decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);	while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {		size = asc2unichar(sb, astr, len, &c);		if (decompose && (dstr = decompose_unichar(c, &dsize))) {			if (outlen + dsize > HFSPLUS_MAX_STRLEN)				break;			do {				ustr->unicode[outlen++] = cpu_to_be16(*dstr++);			} while (--dsize > 0);		} else			ustr->unicode[outlen++] = cpu_to_be16(c);		astr += size;		len -= size;	}	ustr->length = cpu_to_be16(outlen);	if (len > 0)		return -ENAMETOOLONG;	return 0;}

/* * "Blessing" an HFS+ filesystem writes metadata to the superblock informing * the platform firmware which file to boot from */static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags){	struct dentry *dentry = file->f_path.dentry;	struct inode *inode = dentry->d_inode;	struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);	struct hfsplus_vh *vh = sbi->s_vhdr;	struct hfsplus_vh *bvh = sbi->s_backup_vhdr;	u32 cnid = (unsigned long)dentry->d_fsdata;	if (!capable(CAP_SYS_ADMIN))		return -EPERM;	mutex_lock(&sbi->vh_mutex);	/* Directory containing the bootable system */	vh->finder_info[0] = bvh->finder_info[0] =		cpu_to_be32(parent_ino(dentry));	/*	 * Bootloader. Just using the inode here breaks in the case of	 * hard links - the firmware wants the ID of the hard link file,	 * but the inode points at the indirect inode	 */	vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(cnid);	/* Per spec, the OS X system folder - same as finder_info[0] here */	vh->finder_info[5] = bvh->finder_info[5] =		cpu_to_be32(parent_ino(dentry));	mutex_unlock(&sbi->vh_mutex);	return 0;}

static int hfsplus_mknod(struct inode *dir, struct dentry *dentry,			 umode_t mode, dev_t rdev){	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);	struct inode *inode;	int res = -ENOSPC;	mutex_lock(&sbi->vh_mutex);	inode = hfsplus_new_inode(dir->i_sb, mode);	if (!inode)		goto out;	if (S_ISBLK(mode) || S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode))		init_special_inode(inode, mode, rdev);	res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode);	if (res) {		clear_nlink(inode);		hfsplus_delete_inode(inode);		iput(inode);		goto out;	}	hfsplus_instantiate(dentry, inode, inode->i_ino);	mark_inode_dirty(inode);out:	mutex_unlock(&sbi->vh_mutex);	return res;}

/* * Hash a string to an integer as appropriate for the HFS+ filesystem. * Composed unicode characters are decomposed and case-folding is performed * if the appropriate bits are (un)set on the superblock. */int hfsplus_hash_dentry(const struct dentry *dentry, struct qstr *str){	struct super_block *sb = dentry->d_sb;	const char *astr;	const u16 *dstr;	int casefold, decompose, size, len;	unsigned long hash;	wchar_t c;	u16 c2;	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);	hash = init_name_hash(dentry);	astr = str->name;	len = str->len;	while (len > 0) {		int uninitialized_var(dsize);		size = asc2unichar(sb, astr, len, &c);		astr += size;		len -= size;		if (decompose)			dstr = decompose_unichar(c, &dsize);		else			dstr = NULL;		if (dstr) {			do {				c2 = *dstr++;				if (casefold)					c2 = case_fold(c2);				if (!casefold || c2)					hash = partial_name_hash(c2, hash);			} while (--dsize > 0);		} else {			c2 = c;			if (casefold)				c2 = case_fold(c2);			if (!casefold || c2)				hash = partial_name_hash(c2, hash);		}	}	str->hash = end_name_hash(hash);	return 0;}

static int hfsplus_unlink(struct inode *dir, struct dentry *dentry){	struct super_block *sb = dir->i_sb;	struct inode *inode = dentry->d_inode;	struct qstr str;	char name[32];	u32 cnid;	int res;	if (HFSPLUS_IS_RSRC(inode))		return -EPERM;	cnid = (u32)(unsigned long)dentry->d_fsdata;	if (inode->i_ino == cnid &&	    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,					 dir, &dentry->d_name,					 HFSPLUS_SB(sb).hidden_dir, &str);		if (!res)			inode->i_flags |= S_DEAD;		return res;	}	res = hfsplus_delete_cat(cnid, dir, &dentry->d_name);	if (res)		return res;	if (inode->i_nlink > 0)		drop_nlink(inode);	hfsplus_delete_inode(inode);	if (inode->i_ino != cnid && !inode->i_nlink) {		if (!atomic_read(&HFSPLUS_I(inode).opencnt)) {			res = hfsplus_delete_cat(inode->i_ino, HFSPLUS_SB(sb).hidden_dir, NULL);			if (!res)				hfsplus_delete_inode(inode);		} else			inode->i_flags |= S_DEAD;	} else		clear_nlink(inode);	inode->i_ctime = CURRENT_TIME_SEC;	mark_inode_dirty(inode);	return res;}

static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir,			struct dentry *dst_dentry){	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dst_dir->i_sb);	struct inode *inode = src_dentry->d_inode;	struct inode *src_dir = src_dentry->d_parent->d_inode;	struct qstr str;	char name[32];	u32 cnid, id;	int res;	if (HFSPLUS_IS_RSRC(inode))		return -EPERM;	if (!S_ISREG(inode->i_mode))		return -EPERM;	mutex_lock(&sbi->vh_mutex);	if (inode->i_ino == (u32)(unsigned long)src_dentry->d_fsdata) {		for (;;) {			get_random_bytes(&id, sizeof(cnid));			id &= 0x3fffffff;			str.name = name;			str.len = sprintf(name, "iNode%d", id);			res = hfsplus_rename_cat(inode->i_ino,						 src_dir, &src_dentry->d_name,						 sbi->hidden_dir, &str);			if (!res)				break;			if (res != -EEXIST)				goto out;		}		HFSPLUS_I(inode)->linkid = 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);		if (res)			/* panic? */			goto out;		sbi->file_count++;	}	cnid = sbi->next_cnid++;	res = hfsplus_create_cat(cnid, dst_dir, &dst_dentry->d_name, inode);	if (res)		goto out;	inc_nlink(inode);	hfsplus_instantiate(dst_dentry, inode, cnid);	ihold(inode);	inode->i_ctime = CURRENT_TIME_SEC;	mark_inode_dirty(inode);	sbi->file_count++;	hfsplus_mark_mdb_dirty(dst_dir->i_sb);out:	mutex_unlock(&sbi->vh_mutex);	return res;}

static int hfsplus_unlink(struct inode *dir, struct dentry *dentry){	struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb);	struct inode *inode = dentry->d_inode;	struct qstr str;	char name[32];	u32 cnid;	int res;	if (HFSPLUS_IS_RSRC(inode))		return -EPERM;	mutex_lock(&sbi->vh_mutex);	cnid = (u32)(unsigned long)dentry->d_fsdata;	if (inode->i_ino == cnid &&	    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,					 dir, &dentry->d_name,					 sbi->hidden_dir, &str);		if (!res) {			inode->i_flags |= S_DEAD;			drop_nlink(inode);		}		goto out;	}	res = hfsplus_delete_cat(cnid, dir, &dentry->d_name);	if (res)		goto out;	if (inode->i_nlink > 0)		drop_nlink(inode);	if (inode->i_ino == cnid)		clear_nlink(inode);	if (!inode->i_nlink) {		if (inode->i_ino != cnid) {			sbi->file_count--;			if (!atomic_read(&HFSPLUS_I(inode)->opencnt)) {				res = hfsplus_delete_cat(inode->i_ino,							 sbi->hidden_dir,							 NULL);				if (!res)					hfsplus_delete_inode(inode);			} else				inode->i_flags |= S_DEAD;		} else			hfsplus_delete_inode(inode);	} else		sbi->file_count--;	inode->i_ctime = CURRENT_TIME_SEC;	mark_inode_dirty(inode);out:	mutex_unlock(&sbi->vh_mutex);	return res;}

static void hfsplus_ext_write_extent_locked(struct inode *inode){	if (HFSPLUS_I(inode)->extent_state & HFSPLUS_EXT_DIRTY) {		struct hfs_find_data fd;		hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd);		__hfsplus_ext_write_extent(inode, &fd);		hfs_find_exit(&fd);	}}

void hfsplus_ext_write_extent(struct inode *inode){	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);		__hfsplus_ext_write_extent(inode, &fd);		hfs_find_exit(&fd);	}}

static int hfsplus_releasepage(struct page *page, gfp_t mask){	struct inode *inode = page->mapping->host;	struct super_block *sb = inode->i_sb;	struct hfs_btree *tree;	struct hfs_bnode *node;	u32 nidx;	int i, res = 1;	switch (inode->i_ino) {	case HFSPLUS_EXT_CNID:		tree = HFSPLUS_SB(sb)->ext_tree;		break;	case HFSPLUS_CAT_CNID:		tree = HFSPLUS_SB(sb)->cat_tree;		break;	case HFSPLUS_ATTR_CNID:		tree = HFSPLUS_SB(sb)->attr_tree;		break;	default:		BUG();		return 0;	}	if (!tree)		return 0;	if (tree->node_size >= PAGE_CACHE_SIZE) {		nidx = page->index >>			(tree->node_size_shift - PAGE_CACHE_SHIFT);		spin_lock(&tree->hash_lock);		node = hfs_bnode_findhash(tree, nidx);		if (!node)			;		else if (atomic_read(&node->refcnt))			res = 0;		if (res && node) {			hfs_bnode_unhash(node);			hfs_bnode_free(node);		}		spin_unlock(&tree->hash_lock);	} else {

int hfsplus_rmxattr(struct dentry *dentry, const char *name){	struct inode *inode = dentry->d_inode;	struct hfs_btree *btree = HFSPLUS_SB(inode->i_sb)->attr_tree;	struct hfs_find_data fd;	hfsplus_attr_entry entry;	char tmp[32] = {0};	int res = 0;	dprint(DBG_XATTR, "hfs: rmattr [%s][%s] [%lu]/n", dentry->d_name.name, name, dentry->d_inode->i_ino);	if (!strcmp(name, SZ_XATTR_NAME_TYPE) ||		!strcmp(name, SZ_XATTR_NAME_CREATOR)) {		return hfsplus_setxattr_buildin(dentry, name, tmp, 4, 0);	}	if (!strcmp(name, SZ_XATTR_NAME_FINDRINFO)) {		return hfsplus_setxattr_buildin(dentry, name, tmp, 32, 0);	} else if (!strcmp(name, SZ_XATTR_NAME_RFORK)) {		return -EOPNOTSUPP;	}	res = hfs_find_init(btree, &fd);	if (res) {		return res;	}	hfsplus_attr_build_key(inode->i_sb, fd.search_key, cpu_to_be32((u32)(unsigned long)dentry->d_fsdata), name, 0);	if ((res = hfs_brec_find(&fd))) {		hfs_find_exit(&fd);		goto out;	}	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, sizeof(hfsplus_attr_entry));	if (be32_to_cpu(entry.type) != kHFSPlusAttrData) {		res = -EOPNOTSUPP;		hfs_find_exit(&fd);		goto out;	}	res = hfs_brec_remove(&fd);	inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ATTR_DIRTY);	hfs_find_exit(&fd);	// check xattr after hfs_find_exit (unlock attr btree)	if (!hfsplus_has_xattr(dentry)) {		hfsplus_set_cat_flag(inode, HFS_HAS_ATTR_MASK, 0); // here would lock cat tree.	}	//if ((res = filemap_write_and_wait(inode->i_mapping))) {	//	goto out;	//}out:	return res;}

static int hfsplus_ext_read_extent(struct inode *inode, u32 block){	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)		return 0;	hfs_find_init(HFSPLUS_SB(inode->i_sb).ext_tree, &fd);	res = __hfsplus_ext_cache_extent(&fd, inode, block);	hfs_find_exit(&fd);	return res;}

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

// This function would lock the mutex of catalog tree.static ssize_t hfsplus_set_cat_flag(struct inode *inode, u16 flags, int add){	struct hfs_find_data fd;	hfsplus_cat_entry entry;	ssize_t res = 0;	int is_file = 0;	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);	if (res)		return res;	res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);	if (res) {		goto out;	}	hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, sizeof(hfsplus_cat_entry));	switch (be16_to_cpu(entry.type)) {		case HFSPLUS_FILE:			is_file = 1;			break;		case HFSPLUS_FOLDER:			is_file = 0;			break;		default:			res = EINVAL;			goto out;	}	if (is_file) {		if (add) 			entry.file.flags |= cpu_to_be16(flags);		else			entry.file.flags &= ~cpu_to_be16(flags);	} else {		if (add) 			entry.folder.flags |= cpu_to_be16(flags);		else			entry.folder.flags &= ~cpu_to_be16(flags);	}	res = 0;	hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,			is_file ? sizeof(struct hfsplus_cat_file) : sizeof(struct hfsplus_cat_folder));	inode->i_mtime = inode->i_ctime = CURRENT_TIME_SEC;	hfsplus_mark_inode_dirty(inode, HFSPLUS_I_CAT_DIRTY);	out:	hfs_find_exit(&fd);	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;}

/* * Convert one or more ASCII characters into a single unicode character. * Returns the number of ASCII characters corresponding to the unicode char. */static inline int asc2unichar(struct super_block *sb, const char *astr, int len,			      wchar_t *uc){	int size = HFSPLUS_SB(sb).nls->char2uni(astr, len, uc);	if (size <= 0) {		*uc = '?';		size = 1;	}	switch (*uc) {	case 0x2400:		*uc = 0;		break;	case ':':		*uc = '/';		break;	}	return size;}

static ssize_t hfsplus_get_cat_entry(struct inode *inode, hfsplus_cat_entry *entry){	struct hfs_find_data fd;	ssize_t res = 0;	res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd);	if (res)		return res;	res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd);	if (res) {		goto out;	}	hfs_bnode_read(fd.bnode, entry, fd.entryoffset,			sizeof(hfsplus_cat_entry));out:	hfs_find_exit(&fd);	return res;}