blob: 3031d81f5f0f585b17ecc3928da80b19b8a9eee3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <asm/unaligned.h>
16
17#include "hfsplus_fs.h"
18#include "hfsplus_raw.h"
19
20struct hfsplus_wd {
21 u32 ablk_size;
22 u16 ablk_start;
23 u16 embed_start;
24 u16 embed_count;
25};
26
Christoph Hellwig52399b12010-11-23 14:37:47 +010027static 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
34int 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070061static int hfsplus_read_mdb(void *bufptr, struct hfsplus_wd *wd)
62{
63 u32 extent;
64 u16 attrib;
David Elliott2179d372006-01-18 17:43:08 -080065 __be16 sig;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
David Elliott2179d372006-01-18 17:43:08 -080067 sig = *(__be16 *)(bufptr + HFSP_WRAPOFF_EMBEDSIG);
68 if (sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIG) &&
69 sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIGX))
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 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
Anton Salikhmetov2753cc22010-12-16 18:08:38 +020077 wd->ablk_size =
78 be32_to_cpu(*(__be32 *)(bufptr + HFSP_WRAPOFF_ABLKSIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 if (wd->ablk_size < HFSPLUS_SECTOR_SIZE)
80 return 0;
81 if (wd->ablk_size % HFSPLUS_SECTOR_SIZE)
82 return 0;
Anton Salikhmetov2753cc22010-12-16 18:08:38 +020083 wd->ablk_start =
84 be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ABLKSTART));
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Harvey Harrison8b3789e2008-04-29 01:03:44 -070086 extent = get_unaligned_be32(bufptr + HFSP_WRAPOFF_EMBEDEXT);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087 wd->embed_start = (extent >> 16) & 0xFFFF;
88 wd->embed_count = extent & 0xFFFF;
89
90 return 1;
91}
92
93static 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
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200104 if (HFSPLUS_SB(sb)->session >= 0) {
105 te.cdte_track = HFSPLUS_SB(sb)->session;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 te.cdte_format = CDROM_LBA;
Anton Salikhmetov2753cc22010-12-16 18:08:38 +0200107 res = ioctl_by_bdev(sb->s_bdev,
108 CDROMREADTOCENTRY, (unsigned long)&te);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 if (!res && (te.cdte_ctrl & CDROM_DATA_TRACK) == 4) {
110 *start = (sector_t)te.cdte_addr.lba << 2;
111 return 0;
112 }
Roman Zippel634725a2006-01-18 17:43:05 -0800113 printk(KERN_ERR "hfs: invalid session number or type of track\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 return -EINVAL;
115 }
116 ms_info.addr_format = CDROM_LBA;
Anton Salikhmetov2753cc22010-12-16 18:08:38 +0200117 res = ioctl_by_bdev(sb->s_bdev, CDROMMULTISESSION,
118 (unsigned long)&ms_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 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 */
126int hfsplus_read_wrapper(struct super_block *sb)
127{
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200128 struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 struct hfsplus_wd wd;
130 sector_t part_start, part_size;
131 u32 blocksize;
Christoph Hellwig52399b12010-11-23 14:37:47 +0100132 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Christoph Hellwig52399b12010-11-23 14:37:47 +0100134 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 blocksize = sb_min_blocksize(sb, HFSPLUS_SECTOR_SIZE);
136 if (!blocksize)
Christoph Hellwig52399b12010-11-23 14:37:47 +0100137 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
139 if (hfsplus_get_last_session(sb, &part_start, &part_size))
Christoph Hellwig52399b12010-11-23 14:37:47 +0100140 goto out;
Ben Hutchings5c36fe32009-10-26 16:49:51 -0700141 if ((u64)part_start + part_size > 0x100000000ULL) {
142 pr_err("hfs: volumes larger than 2TB are not supported yet\n");
Christoph Hellwig52399b12010-11-23 14:37:47 +0100143 goto out;
Ben Hutchings5c36fe32009-10-26 16:49:51 -0700144 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
Christoph Hellwig52399b12010-11-23 14:37:47 +0100146 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
Christoph Hellwig52399b12010-11-23 14:37:47 +0100154reread:
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))
Chuck Ebberta1dbcef2011-02-02 10:55:06 -0500170 goto out_free_backup_vhdr;
Christoph Hellwig52399b12010-11-23 14:37:47 +0100171 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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 * (should do this only for cdrom/loop though)
180 */
181 if (hfs_part_find(sb, &part_start, &part_size))
Chuck Ebberta1dbcef2011-02-02 10:55:06 -0500182 goto out_free_backup_vhdr;
Christoph Hellwig52399b12010-11-23 14:37:47 +0100183 goto reread;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 }
185
Christoph Hellwig52399b12010-11-23 14:37:47 +0100186 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Christoph Hellwig52399b12010-11-23 14:37:47 +0100192 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;
197 }
198
199 blocksize = be32_to_cpu(sbi->s_vhdr->blocksize);
200
201 /*
202 * Block size must be at least as large as a sector and a multiple of 2.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 */
Christoph Hellwig52399b12010-11-23 14:37:47 +0100204 if (blocksize < HFSPLUS_SECTOR_SIZE || ((blocksize - 1) & blocksize))
205 goto out_free_backup_vhdr;
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200206 sbi->alloc_blksz = blocksize;
207 sbi->alloc_blksz_shift = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 while ((blocksize >>= 1) != 0)
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200209 sbi->alloc_blksz_shift++;
210 blocksize = min(sbi->alloc_blksz, (u32)PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
Christoph Hellwig52399b12010-11-23 14:37:47 +0100212 /*
213 * Align block size to block offset.
214 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 while (part_start & ((blocksize >> HFSPLUS_SECTOR_SHIFT) - 1))
216 blocksize >>= 1;
217
218 if (sb_set_blocksize(sb, blocksize) != blocksize) {
Anton Salikhmetov2753cc22010-12-16 18:08:38 +0200219 printk(KERN_ERR "hfs: unable to set blocksize to %u!\n",
220 blocksize);
Christoph Hellwig52399b12010-11-23 14:37:47 +0100221 goto out_free_backup_vhdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 }
223
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200224 sbi->blockoffset =
225 part_start >> (sb->s_blocksize_bits - HFSPLUS_SECTOR_SHIFT);
Christoph Hellwig52399b12010-11-23 14:37:47 +0100226 sbi->part_start = part_start;
Christoph Hellwigdd73a012010-10-01 05:42:59 +0200227 sbi->sect_count = part_size;
228 sbi->fs_shift = sbi->alloc_blksz_shift - sb->s_blocksize_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 return 0;
Christoph Hellwig52399b12010-11-23 14:37:47 +0100230
231out_free_backup_vhdr:
232 kfree(sbi->s_backup_vhdr);
233out_free_vhdr:
234 kfree(sbi->s_vhdr);
235out:
236 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237}