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

/*
 *  linux/fs/hfsplus/wrapper.c
 *
 * Copyright (C) 2001
 * Brad Boyer ([email protected])
 * (C) 2003 Ardis Technologies <[email protected]>
 *
 * 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_free_backup_vhdr;
		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_free_backup_vhdr;
		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 ([email protected])
	6	* (C) 2003 Ardis Technologies <[email protected]>
	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
2753cc28 AS	77	wd->ablk_size =
2753cc28 AS	78	be32_to_cpu((__be32 )(bufptr + HFSP_WRAPOFF_ABLKSIZE));
1da177e4 LT	79	if (wd->ablk_size < HFSPLUS_SECTOR_SIZE)
	80	return 0;
	81	if (wd->ablk_size % HFSPLUS_SECTOR_SIZE)
	82	return 0;
2753cc28 AS	83	wd->ablk_start =
2753cc28 AS	84	be16_to_cpu((__be16 )(bufptr + HFSP_WRAPOFF_ABLKSTART));
1da177e4	85
8b3789e5	86	extent = get_unaligned_be32(bufptr + HFSP_WRAPOFF_EMBEDEXT);
1da177e4 LT	87	wd->embed_start = (extent >> 16) & 0xFFFF;
	88	wd->embed_count = extent & 0xFFFF;
	89
	90	return 1;
	91	}
	92
	93	static int hfsplus_get_last_session(struct super_block *sb,
	94	sector_t start, sector_t size)
	95	{
	96	struct cdrom_multisession ms_info;
	97	struct cdrom_tocentry te;
	98	int res;
	99
	100	/* default values */
	101	*start = 0;
	102	*size = sb->s_bdev->bd_inode->i_size >> 9;
	103
dd73a01a CH	104	if (HFSPLUS_SB(sb)->session >= 0) {
dd73a01a CH	105	te.cdte_track = HFSPLUS_SB(sb)->session;
1da177e4	106	te.cdte_format = CDROM_LBA;
2753cc28 AS	107	res = ioctl_by_bdev(sb->s_bdev,
2753cc28 AS	108	CDROMREADTOCENTRY, (unsigned long)&te);
1da177e4 LT	109	if (!res && (te.cdte_ctrl & CDROM_DATA_TRACK) == 4) {
	110	*start = (sector_t)te.cdte_addr.lba << 2;
	111	return 0;
	112	}
634725a9	113	printk(KERN_ERR "hfs: invalid session number or type of track\n");
1da177e4 LT	114	return -EINVAL;
	115	}
	116	ms_info.addr_format = CDROM_LBA;
2753cc28 AS	117	res = ioctl_by_bdev(sb->s_bdev, CDROMMULTISESSION,
2753cc28 AS	118	(unsigned long)&ms_info);
1da177e4 LT	119	if (!res && ms_info.xa_flag)
	120	*start = (sector_t)ms_info.addr.lba << 2;
	121	return 0;
	122	}
	123
	124	/* Find the volume header and fill in some minimum bits in superblock */
	125	/* Takes in super block, returns true if good data read */
	126	int hfsplus_read_wrapper(struct super_block *sb)
	127	{
dd73a01a	128	struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
1da177e4 LT	129	struct hfsplus_wd wd;
	130	sector_t part_start, part_size;
	131	u32 blocksize;
52399b17	132	int error = 0;
1da177e4	133
52399b17	134	error = -EINVAL;
1da177e4 LT	135	blocksize = sb_min_blocksize(sb, HFSPLUS_SECTOR_SIZE);
1da177e4 LT	136	if (!blocksize)
52399b17	137	goto out;
1da177e4 LT	138
1da177e4 LT	139	if (hfsplus_get_last_session(sb, &part_start, &part_size))
52399b17	140	goto out;
5c36fe3d BH	141	if ((u64)part_start + part_size > 0x100000000ULL) {
5c36fe3d BH	142	pr_err("hfs: volumes larger than 2TB are not supported yet\n");
52399b17	143	goto out;
5c36fe3d	144	}
1da177e4	145
52399b17 CH	146	error = -ENOMEM;
	147	sbi->s_vhdr = kmalloc(HFSPLUS_SECTOR_SIZE, GFP_KERNEL);
	148	if (!sbi->s_vhdr)
	149	goto out;
	150	sbi->s_backup_vhdr = kmalloc(HFSPLUS_SECTOR_SIZE, GFP_KERNEL);
	151	if (!sbi->s_backup_vhdr)
	152	goto out_free_vhdr;
	153
	154	reread:
	155	error = hfsplus_submit_bio(sb->s_bdev,
	156	part_start + HFSPLUS_VOLHEAD_SECTOR,
	157	sbi->s_vhdr, READ);
	158	if (error)
	159	goto out_free_backup_vhdr;
	160
	161	error = -EINVAL;
	162	switch (sbi->s_vhdr->signature) {
	163	case cpu_to_be16(HFSPLUS_VOLHEAD_SIGX):
	164	set_bit(HFSPLUS_SB_HFSX, &sbi->flags);
	165	/FALLTHRU/
	166	case cpu_to_be16(HFSPLUS_VOLHEAD_SIG):
	167	break;
	168	case cpu_to_be16(HFSP_WRAP_MAGIC):
	169	if (!hfsplus_read_mdb(sbi->s_vhdr, &wd))
a1dbcef0	170	goto out_free_backup_vhdr;
52399b17 CH	171	wd.ablk_size >>= HFSPLUS_SECTOR_SHIFT;
	172	part_start += wd.ablk_start + wd.embed_start * wd.ablk_size;
	173	part_size = wd.embed_count * wd.ablk_size;
	174	goto reread;
	175	default:
	176	/*
	177	* Check for a partition block.
	178	*
1da177e4 LT	179	* (should do this only for cdrom/loop though)
	180	*/
	181	if (hfs_part_find(sb, &part_start, &part_size))
a1dbcef0	182	goto out_free_backup_vhdr;
52399b17 CH	183	goto reread;
	184	}
	185
	186	error = hfsplus_submit_bio(sb->s_bdev,
	187	part_start + part_size - 2,
	188	sbi->s_backup_vhdr, READ);
	189	if (error)
	190	goto out_free_backup_vhdr;
	191
	192	error = -EINVAL;
	193	if (sbi->s_backup_vhdr->signature != sbi->s_vhdr->signature) {
	194	printk(KERN_WARNING
	195	"hfs: invalid secondary volume header\n");
	196	goto out_free_backup_vhdr;
1da177e4 LT	197	}
1da177e4 LT	198
52399b17	199	blocksize = be32_to_cpu(sbi->s_vhdr->blocksize);
1da177e4	200
52399b17 CH	201	/*
52399b17 CH	202	* Block size must be at least as large as a sector and a multiple of 2.
1da177e4	203	*/
52399b17 CH	204	if (blocksize < HFSPLUS_SECTOR_SIZE \|\| ((blocksize - 1) & blocksize))
52399b17 CH	205	goto out_free_backup_vhdr;
dd73a01a CH	206	sbi->alloc_blksz = blocksize;
dd73a01a CH	207	sbi->alloc_blksz_shift = 0;
1da177e4	208	while ((blocksize >>= 1) != 0)
dd73a01a CH	209	sbi->alloc_blksz_shift++;
dd73a01a CH	210	blocksize = min(sbi->alloc_blksz, (u32)PAGE_SIZE);
1da177e4	211
52399b17 CH	212	/*
	213	* Align block size to block offset.
	214	*/
1da177e4 LT	215	while (part_start & ((blocksize >> HFSPLUS_SECTOR_SHIFT) - 1))
	216	blocksize >>= 1;
	217
	218	if (sb_set_blocksize(sb, blocksize) != blocksize) {
2753cc28 AS	219	printk(KERN_ERR "hfs: unable to set blocksize to %u!\n",
2753cc28 AS	220	blocksize);
52399b17	221	goto out_free_backup_vhdr;
1da177e4 LT	222	}
1da177e4 LT	223
dd73a01a CH	224	sbi->blockoffset =
dd73a01a CH	225	part_start >> (sb->s_blocksize_bits - HFSPLUS_SECTOR_SHIFT);
52399b17	226	sbi->part_start = part_start;
dd73a01a CH	227	sbi->sect_count = part_size;
dd73a01a CH	228	sbi->fs_shift = sbi->alloc_blksz_shift - sb->s_blocksize_bits;
1da177e4	229	return 0;
52399b17 CH	230
	231	out_free_backup_vhdr:
	232	kfree(sbi->s_backup_vhdr);
	233	out_free_vhdr:
	234	kfree(sbi->s_vhdr);
	235	out:
	236	return error;
1da177e4	237	}