1 // SPDX-License-Identifier: GPL-2.0
3 * linux/fs/hfsplus/wrapper.c
6 * Brad Boyer (flar@allandria.com)
7 * (C) 2003 Ardis Technologies <roman@ardistech.com>
9 * Handling of HFS wrappers around HFS+ volumes
13 #include <linux/blkdev.h>
14 #include <linux/cdrom.h>
15 #include <asm/unaligned.h>
17 #include "hfsplus_fs.h"
18 #include "hfsplus_raw.h"
28 * hfsplus_submit_bio - Perform block I/O
29 * @sb: super block of volume for I/O
30 * @sector: block to read or write, for blocks of HFSPLUS_SECTOR_SIZE bytes
31 * @buf: buffer for I/O
32 * @data: output pointer for location of requested data
33 * @opf: I/O operation type and flags
35 * The unit of I/O is hfsplus_min_io_size(sb), which may be bigger than
36 * HFSPLUS_SECTOR_SIZE, and @buf must be sized accordingly. On reads
37 * @data will return a pointer to the start of the requested sector,
38 * which may not be the same location as @buf.
40 * If @sector is not aligned to the bdev logical block size it will
41 * be rounded down. For writes this means that @buf should contain data
42 * that starts at the rounded-down address. As long as the data was
43 * read using hfsplus_submit_bio() and the same buffer is used things
44 * will work correctly.
46 * Returns: %0 on success else -errno code
48 int hfsplus_submit_bio(struct super_block
*sb
, sector_t sector
,
49 void *buf
, void **data
, blk_opf_t opf
)
51 const enum req_op op
= opf
& REQ_OP_MASK
;
59 * Align sector to hardware sector size and find offset. We
60 * assume that io_size is a power of two, which _should_
63 io_size
= hfsplus_min_io_size(sb
);
64 start
= (loff_t
)sector
<< HFSPLUS_SECTOR_SHIFT
;
65 offset
= start
& (io_size
- 1);
66 sector
&= ~((io_size
>> HFSPLUS_SECTOR_SHIFT
) - 1);
68 bio
= bio_alloc(sb
->s_bdev
, 1, opf
, GFP_NOIO
);
69 bio
->bi_iter
.bi_sector
= sector
;
71 if (op
!= REQ_OP_WRITE
&& data
)
72 *data
= (u8
*)buf
+ offset
;
75 unsigned int page_offset
= offset_in_page(buf
);
76 unsigned int len
= min_t(unsigned int, PAGE_SIZE
- page_offset
,
79 ret
= bio_add_page(bio
, virt_to_page(buf
), len
, page_offset
);
85 buf
= (u8
*)buf
+ len
;
88 ret
= submit_bio_wait(bio
);
91 return ret
< 0 ? ret
: 0;
94 static int hfsplus_read_mdb(void *bufptr
, struct hfsplus_wd
*wd
)
100 sig
= *(__be16
*)(bufptr
+ HFSP_WRAPOFF_EMBEDSIG
);
101 if (sig
!= cpu_to_be16(HFSPLUS_VOLHEAD_SIG
) &&
102 sig
!= cpu_to_be16(HFSPLUS_VOLHEAD_SIGX
))
105 attrib
= be16_to_cpu(*(__be16
*)(bufptr
+ HFSP_WRAPOFF_ATTRIB
));
106 if (!(attrib
& HFSP_WRAP_ATTRIB_SLOCK
) ||
107 !(attrib
& HFSP_WRAP_ATTRIB_SPARED
))
111 be32_to_cpu(*(__be32
*)(bufptr
+ HFSP_WRAPOFF_ABLKSIZE
));
112 if (wd
->ablk_size
< HFSPLUS_SECTOR_SIZE
)
114 if (wd
->ablk_size
% HFSPLUS_SECTOR_SIZE
)
117 be16_to_cpu(*(__be16
*)(bufptr
+ HFSP_WRAPOFF_ABLKSTART
));
119 extent
= get_unaligned_be32(bufptr
+ HFSP_WRAPOFF_EMBEDEXT
);
120 wd
->embed_start
= (extent
>> 16) & 0xFFFF;
121 wd
->embed_count
= extent
& 0xFFFF;
126 static int hfsplus_get_last_session(struct super_block
*sb
,
127 sector_t
*start
, sector_t
*size
)
129 struct cdrom_device_info
*cdi
= disk_to_cdi(sb
->s_bdev
->bd_disk
);
133 *size
= bdev_nr_sectors(sb
->s_bdev
);
135 if (HFSPLUS_SB(sb
)->session
>= 0) {
136 struct cdrom_tocentry te
;
141 te
.cdte_track
= HFSPLUS_SB(sb
)->session
;
142 te
.cdte_format
= CDROM_LBA
;
143 if (cdrom_read_tocentry(cdi
, &te
) ||
144 (te
.cdte_ctrl
& CDROM_DATA_TRACK
) != 4) {
145 pr_err("invalid session number or type of track\n");
148 *start
= (sector_t
)te
.cdte_addr
.lba
<< 2;
150 struct cdrom_multisession ms_info
;
152 ms_info
.addr_format
= CDROM_LBA
;
153 if (cdrom_multisession(cdi
, &ms_info
) == 0 && ms_info
.xa_flag
)
154 *start
= (sector_t
)ms_info
.addr
.lba
<< 2;
160 /* Find the volume header and fill in some minimum bits in superblock */
161 /* Takes in super block, returns true if good data read */
162 int hfsplus_read_wrapper(struct super_block
*sb
)
164 struct hfsplus_sb_info
*sbi
= HFSPLUS_SB(sb
);
165 struct hfsplus_wd wd
;
166 sector_t part_start
, part_size
;
171 blocksize
= sb_min_blocksize(sb
, HFSPLUS_SECTOR_SIZE
);
175 if (hfsplus_get_last_session(sb
, &part_start
, &part_size
))
179 sbi
->s_vhdr_buf
= kmalloc(hfsplus_min_io_size(sb
), GFP_KERNEL
);
180 if (!sbi
->s_vhdr_buf
)
182 sbi
->s_backup_vhdr_buf
= kmalloc(hfsplus_min_io_size(sb
), GFP_KERNEL
);
183 if (!sbi
->s_backup_vhdr_buf
)
187 error
= hfsplus_submit_bio(sb
, part_start
+ HFSPLUS_VOLHEAD_SECTOR
,
188 sbi
->s_vhdr_buf
, (void **)&sbi
->s_vhdr
,
191 goto out_free_backup_vhdr
;
194 switch (sbi
->s_vhdr
->signature
) {
195 case cpu_to_be16(HFSPLUS_VOLHEAD_SIGX
):
196 set_bit(HFSPLUS_SB_HFSX
, &sbi
->flags
);
198 case cpu_to_be16(HFSPLUS_VOLHEAD_SIG
):
200 case cpu_to_be16(HFSP_WRAP_MAGIC
):
201 if (!hfsplus_read_mdb(sbi
->s_vhdr
, &wd
))
202 goto out_free_backup_vhdr
;
203 wd
.ablk_size
>>= HFSPLUS_SECTOR_SHIFT
;
204 part_start
+= (sector_t
)wd
.ablk_start
+
205 (sector_t
)wd
.embed_start
* wd
.ablk_size
;
206 part_size
= (sector_t
)wd
.embed_count
* wd
.ablk_size
;
210 * Check for a partition block.
212 * (should do this only for cdrom/loop though)
214 if (hfs_part_find(sb
, &part_start
, &part_size
))
215 goto out_free_backup_vhdr
;
219 error
= hfsplus_submit_bio(sb
, part_start
+ part_size
- 2,
220 sbi
->s_backup_vhdr_buf
,
221 (void **)&sbi
->s_backup_vhdr
, REQ_OP_READ
);
223 goto out_free_backup_vhdr
;
226 if (sbi
->s_backup_vhdr
->signature
!= sbi
->s_vhdr
->signature
) {
227 pr_warn("invalid secondary volume header\n");
228 goto out_free_backup_vhdr
;
231 blocksize
= be32_to_cpu(sbi
->s_vhdr
->blocksize
);
234 * Block size must be at least as large as a sector and a multiple of 2.
236 if (blocksize
< HFSPLUS_SECTOR_SIZE
|| ((blocksize
- 1) & blocksize
))
237 goto out_free_backup_vhdr
;
238 sbi
->alloc_blksz
= blocksize
;
239 sbi
->alloc_blksz_shift
= ilog2(blocksize
);
240 blocksize
= min_t(u32
, sbi
->alloc_blksz
, PAGE_SIZE
);
243 * Align block size to block offset.
245 while (part_start
& ((blocksize
>> HFSPLUS_SECTOR_SHIFT
) - 1))
248 if (sb_set_blocksize(sb
, blocksize
) != blocksize
) {
249 pr_err("unable to set blocksize to %u!\n", blocksize
);
250 goto out_free_backup_vhdr
;
254 part_start
>> (sb
->s_blocksize_bits
- HFSPLUS_SECTOR_SHIFT
);
255 sbi
->part_start
= part_start
;
256 sbi
->sect_count
= part_size
;
257 sbi
->fs_shift
= sbi
->alloc_blksz_shift
- sb
->s_blocksize_bits
;
260 out_free_backup_vhdr
:
261 kfree(sbi
->s_backup_vhdr_buf
);
263 kfree(sbi
->s_vhdr_buf
);