[people/ms/linux.git] / fs / hfsplus / wrapper.c

/*
 *  linux/fs/hfsplus/wrapper.c
 *
 * Copyright (C) 2001
 * Brad Boyer (flar@allandria.com)
 * (C) 2003 Ardis Technologies <roman@ardistech.com>
 *
 * Handling of HFS wrappers around HFS+ volumes
 */

#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/cdrom.h>
#include <linux/genhd.h>
#include <asm/unaligned.h>

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

struct hfsplus_wd {
	u32 ablk_size;
	u16 ablk_start;
	u16 embed_start;
	u16 embed_count;
};

static void hfsplus_end_io_sync(struct bio *bio, int err)
{
	if (err)
		clear_bit(BIO_UPTODATE, &bio->bi_flags);
	complete(bio->bi_private);
}

int hfsplus_submit_bio(struct block_device *bdev, sector_t sector,
		void *data, int rw)
{
	DECLARE_COMPLETION_ONSTACK(wait);
	struct bio *bio;

	bio = bio_alloc(GFP_NOIO, 1);
	bio->bi_sector = sector;
	bio->bi_bdev = bdev;
	bio->bi_end_io = hfsplus_end_io_sync;
	bio->bi_private = &wait;

	/*
	 * We always submit one sector at a time, so bio_add_page must not fail.
	 */
	if (bio_add_page(bio, virt_to_page(data), HFSPLUS_SECTOR_SIZE,
			 offset_in_page(data)) != HFSPLUS_SECTOR_SIZE)
		BUG();

	submit_bio(rw, bio);
	wait_for_completion(&wait);

	if (!bio_flagged(bio, BIO_UPTODATE))
		return -EIO;
	return 0;
}

static int hfsplus_read_mdb(void *bufptr, struct hfsplus_wd *wd)
{
	u32 extent;
	u16 attrib;
	__be16 sig;

	sig = *(__be16 *)(bufptr + HFSP_WRAPOFF_EMBEDSIG);
	if (sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIG) &&
	    sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIGX))
		return 0;

	attrib = be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ATTRIB));
	if (!(attrib & HFSP_WRAP_ATTRIB_SLOCK) ||
	   !(attrib & HFSP_WRAP_ATTRIB_SPARED))
		return 0;

	wd->ablk_size = be32_to_cpu(*(__be32 *)(bufptr + HFSP_WRAPOFF_ABLKSIZE));
	if (wd->ablk_size < HFSPLUS_SECTOR_SIZE)
		return 0;
	if (wd->ablk_size % HFSPLUS_SECTOR_SIZE)
		return 0;
	wd->ablk_start = be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ABLKSTART));

	extent = get_unaligned_be32(bufptr + HFSP_WRAPOFF_EMBEDEXT);
	wd->embed_start = (extent >> 16) & 0xFFFF;
	wd->embed_count = extent & 0xFFFF;

	return 1;
}

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;
		}
		printk(KERN_ERR "hfs: 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;
}

/* Find the volume header and fill in some minimum bits in superblock */
/* Takes in super block, returns true if good data read */
int hfsplus_read_wrapper(struct super_block *sb)
{
	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
	struct hfsplus_wd wd;
	sector_t part_start, part_size;
	u32 blocksize;
	int error = 0;

	error = -EINVAL;
	blocksize = sb_min_blocksize(sb, HFSPLUS_SECTOR_SIZE);
	if (!blocksize)
		goto out;

	if (hfsplus_get_last_session(sb, &part_start, &part_size))
		goto out;
	if ((u64)part_start + part_size > 0x100000000ULL) {
		pr_err("hfs: volumes larger than 2TB are not supported yet\n");
		goto out;
	}

	error = -ENOMEM;
	sbi->s_vhdr = kmalloc(HFSPLUS_SECTOR_SIZE, GFP_KERNEL);
	if (!sbi->s_vhdr)
		goto out;
	sbi->s_backup_vhdr = kmalloc(HFSPLUS_SECTOR_SIZE, GFP_KERNEL);
	if (!sbi->s_backup_vhdr)
		goto out_free_vhdr;

reread:
	error = hfsplus_submit_bio(sb->s_bdev,
				   part_start + HFSPLUS_VOLHEAD_SECTOR,
				   sbi->s_vhdr, READ);
	if (error)
		goto out_free_backup_vhdr;

	error = -EINVAL;
	switch (sbi->s_vhdr->signature) {
	case cpu_to_be16(HFSPLUS_VOLHEAD_SIGX):
		set_bit(HFSPLUS_SB_HFSX, &sbi->flags);
		/*FALLTHRU*/
	case cpu_to_be16(HFSPLUS_VOLHEAD_SIG):
		break;
	case cpu_to_be16(HFSP_WRAP_MAGIC):
		if (!hfsplus_read_mdb(sbi->s_vhdr, &wd))
			goto out;
		wd.ablk_size >>= HFSPLUS_SECTOR_SHIFT;
		part_start += wd.ablk_start + wd.embed_start * wd.ablk_size;
		part_size = wd.embed_count * wd.ablk_size;
		goto reread;
	default:
		/*
		 * Check for a partition block.
		 *
		 * (should do this only for cdrom/loop though)
		 */
		if (hfs_part_find(sb, &part_start, &part_size))
			goto out;
		goto reread;
	}

	error = hfsplus_submit_bio(sb->s_bdev,
				   part_start + part_size - 2,
				   sbi->s_backup_vhdr, READ);
	if (error)
		goto out_free_backup_vhdr;

	error = -EINVAL;
	if (sbi->s_backup_vhdr->signature != sbi->s_vhdr->signature) {
		printk(KERN_WARNING
			"hfs: invalid secondary volume header\n");
		goto out_free_backup_vhdr;
	}

	blocksize = be32_to_cpu(sbi->s_vhdr->blocksize);

	/*
	 * Block size must be at least as large as a sector and a multiple of 2.
	 */
	if (blocksize < HFSPLUS_SECTOR_SIZE || ((blocksize - 1) & blocksize))
		goto out_free_backup_vhdr;
	sbi->alloc_blksz = blocksize;
	sbi->alloc_blksz_shift = 0;
	while ((blocksize >>= 1) != 0)
		sbi->alloc_blksz_shift++;
	blocksize = min(sbi->alloc_blksz, (u32)PAGE_SIZE);

	/*
	 * Align block size to block offset.
	 */
	while (part_start & ((blocksize >> HFSPLUS_SECTOR_SHIFT) - 1))
		blocksize >>= 1;

	if (sb_set_blocksize(sb, blocksize) != blocksize) {
		printk(KERN_ERR "hfs: unable to set blocksize to %u!\n", blocksize);
		goto out_free_backup_vhdr;
	}

	sbi->blockoffset =
		part_start >> (sb->s_blocksize_bits - HFSPLUS_SECTOR_SHIFT);
	sbi->part_start = part_start;
	sbi->sect_count = part_size;
	sbi->fs_shift = sbi->alloc_blksz_shift - sb->s_blocksize_bits;
	return 0;

out_free_backup_vhdr:
	kfree(sbi->s_backup_vhdr);
out_free_vhdr:
	kfree(sbi->s_vhdr);
out:
	return error;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/hfsplus/wrapper.c
	3	*
	4	* Copyright (C) 2001
	5	* Brad Boyer (flar@allandria.com)
	6	* (C) 2003 Ardis Technologies <roman@ardistech.com>
	7	*
	8	* Handling of HFS wrappers around HFS+ volumes
	9	*/
	10
	11	#include <linux/fs.h>
	12	#include <linux/blkdev.h>
	13	#include <linux/cdrom.h>
	14	#include <linux/genhd.h>
1da177e4 LT	15	#include <asm/unaligned.h>
	16
	17	#include "hfsplus_fs.h"
	18	#include "hfsplus_raw.h"
	19
	20	struct hfsplus_wd {
	21	u32 ablk_size;
	22	u16 ablk_start;
	23	u16 embed_start;
	24	u16 embed_count;
	25	};
	26
52399b17 CH	27	static void hfsplus_end_io_sync(struct bio *bio, int err)
	28	{
	29	if (err)
	30	clear_bit(BIO_UPTODATE, &bio->bi_flags);
	31	complete(bio->bi_private);
	32	}
	33
	34	int hfsplus_submit_bio(struct block_device *bdev, sector_t sector,
	35	void *data, int rw)
	36	{
	37	DECLARE_COMPLETION_ONSTACK(wait);
	38	struct bio *bio;
	39
	40	bio = bio_alloc(GFP_NOIO, 1);
	41	bio->bi_sector = sector;
	42	bio->bi_bdev = bdev;
	43	bio->bi_end_io = hfsplus_end_io_sync;
	44	bio->bi_private = &wait;
	45
	46	/*
	47	* We always submit one sector at a time, so bio_add_page must not fail.
	48	*/
	49	if (bio_add_page(bio, virt_to_page(data), HFSPLUS_SECTOR_SIZE,
	50	offset_in_page(data)) != HFSPLUS_SECTOR_SIZE)
	51	BUG();
	52
	53	submit_bio(rw, bio);
	54	wait_for_completion(&wait);
	55
	56	if (!bio_flagged(bio, BIO_UPTODATE))
	57	return -EIO;
	58	return 0;
	59	}
	60
1da177e4 LT	61	static int hfsplus_read_mdb(void bufptr, struct hfsplus_wd wd)
	62	{
	63	u32 extent;
	64	u16 attrib;
2179d372	65	__be16 sig;
1da177e4	66
2179d372 DE	67	sig = (__be16 )(bufptr + HFSP_WRAPOFF_EMBEDSIG);
	68	if (sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIG) &&
	69	sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIGX))
1da177e4 LT	70	return 0;
	71
	72	attrib = be16_to_cpu((__be16 )(bufptr + HFSP_WRAPOFF_ATTRIB));
	73	if (!(attrib & HFSP_WRAP_ATTRIB_SLOCK) \|\|
	74	!(attrib & HFSP_WRAP_ATTRIB_SPARED))
	75	return 0;
	76
	77	wd->ablk_size = be32_to_cpu((__be32 )(bufptr + HFSP_WRAPOFF_ABLKSIZE));
	78	if (wd->ablk_size < HFSPLUS_SECTOR_SIZE)
	79	return 0;
	80	if (wd->ablk_size % HFSPLUS_SECTOR_SIZE)
	81	return 0;
	82	wd->ablk_start = be16_to_cpu((__be16 )(bufptr + HFSP_WRAPOFF_ABLKSTART));
	83
8b3789e5	84	extent = get_unaligned_be32(bufptr + HFSP_WRAPOFF_EMBEDEXT);
1da177e4 LT	85	wd->embed_start = (extent >> 16) & 0xFFFF;
	86	wd->embed_count = extent & 0xFFFF;
	87
	88	return 1;
	89	}
	90
	91	static int hfsplus_get_last_session(struct super_block *sb,
	92	sector_t start, sector_t size)
	93	{
	94	struct cdrom_multisession ms_info;
	95	struct cdrom_tocentry te;
	96	int res;
	97
	98	/* default values */
	99	*start = 0;
	100	*size = sb->s_bdev->bd_inode->i_size >> 9;
	101
dd73a01a CH	102	if (HFSPLUS_SB(sb)->session >= 0) {
dd73a01a CH	103	te.cdte_track = HFSPLUS_SB(sb)->session;
1da177e4 LT	104	te.cdte_format = CDROM_LBA;
	105	res = ioctl_by_bdev(sb->s_bdev, CDROMREADTOCENTRY, (unsigned long)&te);
	106	if (!res && (te.cdte_ctrl & CDROM_DATA_TRACK) == 4) {
	107	*start = (sector_t)te.cdte_addr.lba << 2;
	108	return 0;
	109	}
634725a9	110	printk(KERN_ERR "hfs: invalid session number or type of track\n");
1da177e4 LT	111	return -EINVAL;
	112	}
	113	ms_info.addr_format = CDROM_LBA;
	114	res = ioctl_by_bdev(sb->s_bdev, CDROMMULTISESSION, (unsigned long)&ms_info);
	115	if (!res && ms_info.xa_flag)
	116	*start = (sector_t)ms_info.addr.lba << 2;
	117	return 0;
	118	}
	119
	120	/* Find the volume header and fill in some minimum bits in superblock */
	121	/* Takes in super block, returns true if good data read */
	122	int hfsplus_read_wrapper(struct super_block *sb)
	123	{
dd73a01a	124	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
1da177e4 LT	125	struct hfsplus_wd wd;
	126	sector_t part_start, part_size;
	127	u32 blocksize;
52399b17	128	int error = 0;
1da177e4	129
52399b17	130	error = -EINVAL;
1da177e4 LT	131	blocksize = sb_min_blocksize(sb, HFSPLUS_SECTOR_SIZE);
1da177e4 LT	132	if (!blocksize)
52399b17	133	goto out;
1da177e4 LT	134
1da177e4 LT	135	if (hfsplus_get_last_session(sb, &part_start, &part_size))
52399b17	136	goto out;
5c36fe3d BH	137	if ((u64)part_start + part_size > 0x100000000ULL) {
5c36fe3d BH	138	pr_err("hfs: volumes larger than 2TB are not supported yet\n");
52399b17	139	goto out;
5c36fe3d	140	}
1da177e4	141
52399b17 CH	142	error = -ENOMEM;
	143	sbi->s_vhdr = kmalloc(HFSPLUS_SECTOR_SIZE, GFP_KERNEL);
	144	if (!sbi->s_vhdr)
	145	goto out;
	146	sbi->s_backup_vhdr = kmalloc(HFSPLUS_SECTOR_SIZE, GFP_KERNEL);
	147	if (!sbi->s_backup_vhdr)
	148	goto out_free_vhdr;
	149
	150	reread:
	151	error = hfsplus_submit_bio(sb->s_bdev,
	152	part_start + HFSPLUS_VOLHEAD_SECTOR,
	153	sbi->s_vhdr, READ);
	154	if (error)
	155	goto out_free_backup_vhdr;
	156
	157	error = -EINVAL;
	158	switch (sbi->s_vhdr->signature) {
	159	case cpu_to_be16(HFSPLUS_VOLHEAD_SIGX):
	160	set_bit(HFSPLUS_SB_HFSX, &sbi->flags);
	161	/FALLTHRU/
	162	case cpu_to_be16(HFSPLUS_VOLHEAD_SIG):
	163	break;
	164	case cpu_to_be16(HFSP_WRAP_MAGIC):
	165	if (!hfsplus_read_mdb(sbi->s_vhdr, &wd))
	166	goto out;
	167	wd.ablk_size >>= HFSPLUS_SECTOR_SHIFT;
	168	part_start += wd.ablk_start + wd.embed_start * wd.ablk_size;
	169	part_size = wd.embed_count * wd.ablk_size;
	170	goto reread;
	171	default:
	172	/*
	173	* Check for a partition block.
	174	*
1da177e4 LT	175	* (should do this only for cdrom/loop though)
	176	*/
	177	if (hfs_part_find(sb, &part_start, &part_size))
52399b17 CH	178	goto out;
	179	goto reread;
	180	}
	181
	182	error = hfsplus_submit_bio(sb->s_bdev,
	183	part_start + part_size - 2,
	184	sbi->s_backup_vhdr, READ);
	185	if (error)
	186	goto out_free_backup_vhdr;
	187
	188	error = -EINVAL;
	189	if (sbi->s_backup_vhdr->signature != sbi->s_vhdr->signature) {
	190	printk(KERN_WARNING
	191	"hfs: invalid secondary volume header\n");
	192	goto out_free_backup_vhdr;
1da177e4 LT	193	}
1da177e4 LT	194
52399b17	195	blocksize = be32_to_cpu(sbi->s_vhdr->blocksize);
1da177e4	196
52399b17 CH	197	/*
52399b17 CH	198	* Block size must be at least as large as a sector and a multiple of 2.
1da177e4	199	*/
52399b17 CH	200	if (blocksize < HFSPLUS_SECTOR_SIZE \|\| ((blocksize - 1) & blocksize))
52399b17 CH	201	goto out_free_backup_vhdr;
dd73a01a CH	202	sbi->alloc_blksz = blocksize;
dd73a01a CH	203	sbi->alloc_blksz_shift = 0;
1da177e4	204	while ((blocksize >>= 1) != 0)
dd73a01a CH	205	sbi->alloc_blksz_shift++;
dd73a01a CH	206	blocksize = min(sbi->alloc_blksz, (u32)PAGE_SIZE);
1da177e4	207
52399b17 CH	208	/*
	209	* Align block size to block offset.
	210	*/
1da177e4 LT	211	while (part_start & ((blocksize >> HFSPLUS_SECTOR_SHIFT) - 1))
	212	blocksize >>= 1;
	213
	214	if (sb_set_blocksize(sb, blocksize) != blocksize) {
634725a9	215	printk(KERN_ERR "hfs: unable to set blocksize to %u!\n", blocksize);
52399b17	216	goto out_free_backup_vhdr;
1da177e4 LT	217	}
1da177e4 LT	218
dd73a01a CH	219	sbi->blockoffset =
dd73a01a CH	220	part_start >> (sb->s_blocksize_bits - HFSPLUS_SECTOR_SHIFT);
52399b17	221	sbi->part_start = part_start;
dd73a01a CH	222	sbi->sect_count = part_size;
dd73a01a CH	223	sbi->fs_shift = sbi->alloc_blksz_shift - sb->s_blocksize_bits;
1da177e4	224	return 0;
52399b17 CH	225
	226	out_free_backup_vhdr:
	227	kfree(sbi->s_backup_vhdr);
	228	out_free_vhdr:
	229	kfree(sbi->s_vhdr);
	230	out:
	231	return error;
1da177e4	232	}