1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * linux/fs/hfsplus/wrapper.c |
4 | * |
5 | * Copyright (C) 2001 |
6 | * Brad Boyer (flar@allandria.com) |
7 | * (C) 2003 Ardis Technologies <roman@ardistech.com> |
8 | * |
9 | * Handling of HFS wrappers around HFS+ volumes |
10 | */ |
11 | |
12 | #include <linux/fs.h> |
13 | #include <linux/blkdev.h> |
14 | #include <linux/cdrom.h> |
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 | |
27 | /** |
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 |
34 | * |
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. |
39 | * |
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. |
45 | * |
46 | * Returns: %0 on success else -errno code |
47 | */ |
48 | int hfsplus_submit_bio(struct super_block *sb, sector_t sector, |
49 | void *buf, void **data, blk_opf_t opf) |
50 | { |
51 | const enum req_op op = opf & REQ_OP_MASK; |
52 | struct bio *bio; |
53 | int ret = 0; |
54 | u64 io_size; |
55 | loff_t start; |
56 | int offset; |
57 | |
58 | /* |
59 | * Align sector to hardware sector size and find offset. We |
60 | * assume that io_size is a power of two, which _should_ |
61 | * be true. |
62 | */ |
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); |
67 | |
68 | bio = bio_alloc(bdev: sb->s_bdev, nr_vecs: 1, opf, GFP_NOIO); |
69 | bio->bi_iter.bi_sector = sector; |
70 | |
71 | if (op != REQ_OP_WRITE && data) |
72 | *data = (u8 *)buf + offset; |
73 | |
74 | while (io_size > 0) { |
75 | unsigned int page_offset = offset_in_page(buf); |
76 | unsigned int len = min_t(unsigned int, PAGE_SIZE - page_offset, |
77 | io_size); |
78 | |
79 | ret = bio_add_page(bio, virt_to_page(buf), len, off: page_offset); |
80 | if (ret != len) { |
81 | ret = -EIO; |
82 | goto out; |
83 | } |
84 | io_size -= len; |
85 | buf = (u8 *)buf + len; |
86 | } |
87 | |
88 | ret = submit_bio_wait(bio); |
89 | out: |
90 | bio_put(bio); |
91 | return ret < 0 ? ret : 0; |
92 | } |
93 | |
94 | static int hfsplus_read_mdb(void *bufptr, struct hfsplus_wd *wd) |
95 | { |
96 | u32 extent; |
97 | u16 attrib; |
98 | __be16 sig; |
99 | |
100 | sig = *(__be16 *)(bufptr + HFSP_WRAPOFF_EMBEDSIG); |
101 | if (sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIG) && |
102 | sig != cpu_to_be16(HFSPLUS_VOLHEAD_SIGX)) |
103 | return 0; |
104 | |
105 | attrib = be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ATTRIB)); |
106 | if (!(attrib & HFSP_WRAP_ATTRIB_SLOCK) || |
107 | !(attrib & HFSP_WRAP_ATTRIB_SPARED)) |
108 | return 0; |
109 | |
110 | wd->ablk_size = |
111 | be32_to_cpu(*(__be32 *)(bufptr + HFSP_WRAPOFF_ABLKSIZE)); |
112 | if (wd->ablk_size < HFSPLUS_SECTOR_SIZE) |
113 | return 0; |
114 | if (wd->ablk_size % HFSPLUS_SECTOR_SIZE) |
115 | return 0; |
116 | wd->ablk_start = |
117 | be16_to_cpu(*(__be16 *)(bufptr + HFSP_WRAPOFF_ABLKSTART)); |
118 | |
119 | extent = get_unaligned_be32(p: bufptr + HFSP_WRAPOFF_EMBEDEXT); |
120 | wd->embed_start = (extent >> 16) & 0xFFFF; |
121 | wd->embed_count = extent & 0xFFFF; |
122 | |
123 | return 1; |
124 | } |
125 | |
126 | static int hfsplus_get_last_session(struct super_block *sb, |
127 | sector_t *start, sector_t *size) |
128 | { |
129 | struct cdrom_device_info *cdi = disk_to_cdi(sb->s_bdev->bd_disk); |
130 | |
131 | /* default values */ |
132 | *start = 0; |
133 | *size = bdev_nr_sectors(bdev: sb->s_bdev); |
134 | |
135 | if (HFSPLUS_SB(sb)->session >= 0) { |
136 | struct cdrom_tocentry te; |
137 | |
138 | if (!cdi) |
139 | return -EINVAL; |
140 | |
141 | te.cdte_track = HFSPLUS_SB(sb)->session; |
142 | te.cdte_format = CDROM_LBA; |
143 | if (cdrom_read_tocentry(cdi, entry: &te) || |
144 | (te.cdte_ctrl & CDROM_DATA_TRACK) != 4) { |
145 | pr_err("invalid session number or type of track\n" ); |
146 | return -EINVAL; |
147 | } |
148 | *start = (sector_t)te.cdte_addr.lba << 2; |
149 | } else if (cdi) { |
150 | struct cdrom_multisession ms_info; |
151 | |
152 | ms_info.addr_format = CDROM_LBA; |
153 | if (cdrom_multisession(cdi, info: &ms_info) == 0 && ms_info.xa_flag) |
154 | *start = (sector_t)ms_info.addr.lba << 2; |
155 | } |
156 | |
157 | return 0; |
158 | } |
159 | |
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) |
163 | { |
164 | struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb); |
165 | struct hfsplus_wd wd; |
166 | sector_t part_start, part_size; |
167 | u32 blocksize; |
168 | int error = 0; |
169 | |
170 | error = -EINVAL; |
171 | blocksize = sb_min_blocksize(sb, HFSPLUS_SECTOR_SIZE); |
172 | if (!blocksize) |
173 | goto out; |
174 | |
175 | if (hfsplus_get_last_session(sb, start: &part_start, size: &part_size)) |
176 | goto out; |
177 | |
178 | error = -ENOMEM; |
179 | sbi->s_vhdr_buf = kmalloc(size: hfsplus_min_io_size(sb), GFP_KERNEL); |
180 | if (!sbi->s_vhdr_buf) |
181 | goto out; |
182 | sbi->s_backup_vhdr_buf = kmalloc(size: hfsplus_min_io_size(sb), GFP_KERNEL); |
183 | if (!sbi->s_backup_vhdr_buf) |
184 | goto out_free_vhdr; |
185 | |
186 | reread: |
187 | error = hfsplus_submit_bio(sb, sector: part_start + HFSPLUS_VOLHEAD_SECTOR, |
188 | buf: sbi->s_vhdr_buf, data: (void **)&sbi->s_vhdr, |
189 | opf: REQ_OP_READ); |
190 | if (error) |
191 | goto out_free_backup_vhdr; |
192 | |
193 | error = -EINVAL; |
194 | switch (sbi->s_vhdr->signature) { |
195 | case cpu_to_be16(HFSPLUS_VOLHEAD_SIGX): |
196 | set_bit(HFSPLUS_SB_HFSX, addr: &sbi->flags); |
197 | fallthrough; |
198 | case cpu_to_be16(HFSPLUS_VOLHEAD_SIG): |
199 | break; |
200 | case cpu_to_be16(HFSP_WRAP_MAGIC): |
201 | if (!hfsplus_read_mdb(bufptr: sbi->s_vhdr, wd: &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; |
207 | goto reread; |
208 | default: |
209 | /* |
210 | * Check for a partition block. |
211 | * |
212 | * (should do this only for cdrom/loop though) |
213 | */ |
214 | if (hfs_part_find(sb, part_start: &part_start, part_size: &part_size)) |
215 | goto out_free_backup_vhdr; |
216 | goto reread; |
217 | } |
218 | |
219 | error = hfsplus_submit_bio(sb, sector: part_start + part_size - 2, |
220 | buf: sbi->s_backup_vhdr_buf, |
221 | data: (void **)&sbi->s_backup_vhdr, opf: REQ_OP_READ); |
222 | if (error) |
223 | goto out_free_backup_vhdr; |
224 | |
225 | error = -EINVAL; |
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; |
229 | } |
230 | |
231 | blocksize = be32_to_cpu(sbi->s_vhdr->blocksize); |
232 | |
233 | /* |
234 | * Block size must be at least as large as a sector and a multiple of 2. |
235 | */ |
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); |
241 | |
242 | /* |
243 | * Align block size to block offset. |
244 | */ |
245 | while (part_start & ((blocksize >> HFSPLUS_SECTOR_SHIFT) - 1)) |
246 | blocksize >>= 1; |
247 | |
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; |
251 | } |
252 | |
253 | sbi->blockoffset = |
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; |
258 | return 0; |
259 | |
260 | out_free_backup_vhdr: |
261 | kfree(objp: sbi->s_backup_vhdr_buf); |
262 | out_free_vhdr: |
263 | kfree(objp: sbi->s_vhdr_buf); |
264 | out: |
265 | return error; |
266 | } |
267 | |