1 | /* |
2 | * linux/fs/hfs/mdb.c |
3 | * |
4 | * Copyright (C) 1995-1997 Paul H. Hargrove |
5 | * (C) 2003 Ardis Technologies <roman@ardistech.com> |
6 | * This file may be distributed under the terms of the GNU General Public License. |
7 | * |
8 | * This file contains functions for reading/writing the MDB. |
9 | */ |
10 | |
11 | #include <linux/cdrom.h> |
12 | #include <linux/blkdev.h> |
13 | #include <linux/nls.h> |
14 | #include <linux/slab.h> |
15 | |
16 | #include "hfs_fs.h" |
17 | #include "btree.h" |
18 | |
19 | /*================ File-local data types ================*/ |
20 | |
21 | /* |
22 | * The HFS Master Directory Block (MDB). |
23 | * |
24 | * Also known as the Volume Information Block (VIB), this structure is |
25 | * the HFS equivalent of a superblock. |
26 | * |
27 | * Reference: _Inside Macintosh: Files_ pages 2-59 through 2-62 |
28 | * |
29 | * modified for HFS Extended |
30 | */ |
31 | |
32 | static int hfs_get_last_session(struct super_block *sb, |
33 | sector_t *start, sector_t *size) |
34 | { |
35 | struct cdrom_device_info *cdi = disk_to_cdi(sb->s_bdev->bd_disk); |
36 | |
37 | /* default values */ |
38 | *start = 0; |
39 | *size = bdev_nr_sectors(bdev: sb->s_bdev); |
40 | |
41 | if (HFS_SB(sb)->session >= 0) { |
42 | struct cdrom_tocentry te; |
43 | |
44 | if (!cdi) |
45 | return -EINVAL; |
46 | |
47 | te.cdte_track = HFS_SB(sb)->session; |
48 | te.cdte_format = CDROM_LBA; |
49 | if (cdrom_read_tocentry(cdi, entry: &te) || |
50 | (te.cdte_ctrl & CDROM_DATA_TRACK) != 4) { |
51 | pr_err("invalid session number or type of track\n" ); |
52 | return -EINVAL; |
53 | } |
54 | |
55 | *start = (sector_t)te.cdte_addr.lba << 2; |
56 | } else if (cdi) { |
57 | struct cdrom_multisession ms_info; |
58 | |
59 | ms_info.addr_format = CDROM_LBA; |
60 | if (cdrom_multisession(cdi, info: &ms_info) == 0 && ms_info.xa_flag) |
61 | *start = (sector_t)ms_info.addr.lba << 2; |
62 | } |
63 | |
64 | return 0; |
65 | } |
66 | |
67 | /* |
68 | * hfs_mdb_get() |
69 | * |
70 | * Build the in-core MDB for a filesystem, including |
71 | * the B-trees and the volume bitmap. |
72 | */ |
73 | int hfs_mdb_get(struct super_block *sb) |
74 | { |
75 | struct buffer_head *bh; |
76 | struct hfs_mdb *mdb, *mdb2; |
77 | unsigned int block; |
78 | char *ptr; |
79 | int off2, len, size, sect; |
80 | sector_t part_start, part_size; |
81 | loff_t off; |
82 | __be16 attrib; |
83 | |
84 | /* set the device driver to 512-byte blocks */ |
85 | size = sb_min_blocksize(sb, HFS_SECTOR_SIZE); |
86 | if (!size) |
87 | return -EINVAL; |
88 | |
89 | if (hfs_get_last_session(sb, start: &part_start, size: &part_size)) |
90 | return -EINVAL; |
91 | while (1) { |
92 | /* See if this is an HFS filesystem */ |
93 | bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb); |
94 | if (!bh) |
95 | goto out; |
96 | |
97 | if (mdb->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC)) |
98 | break; |
99 | brelse(bh); |
100 | |
101 | /* check for a partition block |
102 | * (should do this only for cdrom/loop though) |
103 | */ |
104 | if (hfs_part_find(sb, &part_start, &part_size)) |
105 | goto out; |
106 | } |
107 | |
108 | HFS_SB(sb)->alloc_blksz = size = be32_to_cpu(mdb->drAlBlkSiz); |
109 | if (!size || (size & (HFS_SECTOR_SIZE - 1))) { |
110 | pr_err("bad allocation block size %d\n" , size); |
111 | goto out_bh; |
112 | } |
113 | |
114 | size = min(HFS_SB(sb)->alloc_blksz, (u32)PAGE_SIZE); |
115 | /* size must be a multiple of 512 */ |
116 | while (size & (size - 1)) |
117 | size -= HFS_SECTOR_SIZE; |
118 | sect = be16_to_cpu(mdb->drAlBlSt) + part_start; |
119 | /* align block size to first sector */ |
120 | while (sect & ((size - 1) >> HFS_SECTOR_SIZE_BITS)) |
121 | size >>= 1; |
122 | /* align block size to weird alloc size */ |
123 | while (HFS_SB(sb)->alloc_blksz & (size - 1)) |
124 | size >>= 1; |
125 | brelse(bh); |
126 | if (!sb_set_blocksize(sb, size)) { |
127 | pr_err("unable to set blocksize to %u\n" , size); |
128 | goto out; |
129 | } |
130 | |
131 | bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb); |
132 | if (!bh) |
133 | goto out; |
134 | if (mdb->drSigWord != cpu_to_be16(HFS_SUPER_MAGIC)) |
135 | goto out_bh; |
136 | |
137 | HFS_SB(sb)->mdb_bh = bh; |
138 | HFS_SB(sb)->mdb = mdb; |
139 | |
140 | /* These parameters are read from the MDB, and never written */ |
141 | HFS_SB(sb)->part_start = part_start; |
142 | HFS_SB(sb)->fs_ablocks = be16_to_cpu(mdb->drNmAlBlks); |
143 | HFS_SB(sb)->fs_div = HFS_SB(sb)->alloc_blksz >> sb->s_blocksize_bits; |
144 | HFS_SB(sb)->clumpablks = be32_to_cpu(mdb->drClpSiz) / |
145 | HFS_SB(sb)->alloc_blksz; |
146 | if (!HFS_SB(sb)->clumpablks) |
147 | HFS_SB(sb)->clumpablks = 1; |
148 | HFS_SB(sb)->fs_start = (be16_to_cpu(mdb->drAlBlSt) + part_start) >> |
149 | (sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS); |
150 | |
151 | /* These parameters are read from and written to the MDB */ |
152 | HFS_SB(sb)->free_ablocks = be16_to_cpu(mdb->drFreeBks); |
153 | HFS_SB(sb)->next_id = be32_to_cpu(mdb->drNxtCNID); |
154 | HFS_SB(sb)->root_files = be16_to_cpu(mdb->drNmFls); |
155 | HFS_SB(sb)->root_dirs = be16_to_cpu(mdb->drNmRtDirs); |
156 | HFS_SB(sb)->file_count = be32_to_cpu(mdb->drFilCnt); |
157 | HFS_SB(sb)->folder_count = be32_to_cpu(mdb->drDirCnt); |
158 | |
159 | /* TRY to get the alternate (backup) MDB. */ |
160 | sect = part_start + part_size - 2; |
161 | bh = sb_bread512(sb, sect, mdb2); |
162 | if (bh) { |
163 | if (mdb2->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC)) { |
164 | HFS_SB(sb)->alt_mdb_bh = bh; |
165 | HFS_SB(sb)->alt_mdb = mdb2; |
166 | } else |
167 | brelse(bh); |
168 | } |
169 | |
170 | if (!HFS_SB(sb)->alt_mdb) { |
171 | pr_warn("unable to locate alternate MDB\n" ); |
172 | pr_warn("continuing without an alternate MDB\n" ); |
173 | } |
174 | |
175 | HFS_SB(sb)->bitmap = kmalloc(size: 8192, GFP_KERNEL); |
176 | if (!HFS_SB(sb)->bitmap) |
177 | goto out; |
178 | |
179 | /* read in the bitmap */ |
180 | block = be16_to_cpu(mdb->drVBMSt) + part_start; |
181 | off = (loff_t)block << HFS_SECTOR_SIZE_BITS; |
182 | size = (HFS_SB(sb)->fs_ablocks + 8) / 8; |
183 | ptr = (u8 *)HFS_SB(sb)->bitmap; |
184 | while (size) { |
185 | bh = sb_bread(sb, block: off >> sb->s_blocksize_bits); |
186 | if (!bh) { |
187 | pr_err("unable to read volume bitmap\n" ); |
188 | goto out; |
189 | } |
190 | off2 = off & (sb->s_blocksize - 1); |
191 | len = min((int)sb->s_blocksize - off2, size); |
192 | memcpy(ptr, bh->b_data + off2, len); |
193 | brelse(bh); |
194 | ptr += len; |
195 | off += len; |
196 | size -= len; |
197 | } |
198 | |
199 | HFS_SB(sb)->ext_tree = hfs_btree_open(sb, HFS_EXT_CNID, hfs_ext_keycmp); |
200 | if (!HFS_SB(sb)->ext_tree) { |
201 | pr_err("unable to open extent tree\n" ); |
202 | goto out; |
203 | } |
204 | HFS_SB(sb)->cat_tree = hfs_btree_open(sb, HFS_CAT_CNID, hfs_cat_keycmp); |
205 | if (!HFS_SB(sb)->cat_tree) { |
206 | pr_err("unable to open catalog tree\n" ); |
207 | goto out; |
208 | } |
209 | |
210 | attrib = mdb->drAtrb; |
211 | if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) { |
212 | pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n" ); |
213 | sb->s_flags |= SB_RDONLY; |
214 | } |
215 | if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) { |
216 | pr_warn("filesystem is marked locked, mounting read-only.\n" ); |
217 | sb->s_flags |= SB_RDONLY; |
218 | } |
219 | if (!sb_rdonly(sb)) { |
220 | /* Mark the volume uncleanly unmounted in case we crash */ |
221 | attrib &= cpu_to_be16(~HFS_SB_ATTRIB_UNMNT); |
222 | attrib |= cpu_to_be16(HFS_SB_ATTRIB_INCNSTNT); |
223 | mdb->drAtrb = attrib; |
224 | be32_add_cpu(var: &mdb->drWrCnt, val: 1); |
225 | mdb->drLsMod = hfs_mtime(); |
226 | |
227 | mark_buffer_dirty(HFS_SB(sb)->mdb_bh); |
228 | sync_dirty_buffer(HFS_SB(sb)->mdb_bh); |
229 | } |
230 | |
231 | return 0; |
232 | |
233 | out_bh: |
234 | brelse(bh); |
235 | out: |
236 | hfs_mdb_put(sb); |
237 | return -EIO; |
238 | } |
239 | |
240 | /* |
241 | * hfs_mdb_commit() |
242 | * |
243 | * Description: |
244 | * This updates the MDB on disk. |
245 | * It does not check, if the superblock has been modified, or |
246 | * if the filesystem has been mounted read-only. It is mainly |
247 | * called by hfs_sync_fs() and flush_mdb(). |
248 | * Input Variable(s): |
249 | * struct hfs_mdb *mdb: Pointer to the hfs MDB |
250 | * int backup; |
251 | * Output Variable(s): |
252 | * NONE |
253 | * Returns: |
254 | * void |
255 | * Preconditions: |
256 | * 'mdb' points to a "valid" (struct hfs_mdb). |
257 | * Postconditions: |
258 | * The HFS MDB and on disk will be updated, by copying the possibly |
259 | * modified fields from the in memory MDB (in native byte order) to |
260 | * the disk block buffer. |
261 | * If 'backup' is non-zero then the alternate MDB is also written |
262 | * and the function doesn't return until it is actually on disk. |
263 | */ |
264 | void hfs_mdb_commit(struct super_block *sb) |
265 | { |
266 | struct hfs_mdb *mdb = HFS_SB(sb)->mdb; |
267 | |
268 | if (sb_rdonly(sb)) |
269 | return; |
270 | |
271 | lock_buffer(HFS_SB(sb)->mdb_bh); |
272 | if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, addr: &HFS_SB(sb)->flags)) { |
273 | /* These parameters may have been modified, so write them back */ |
274 | mdb->drLsMod = hfs_mtime(); |
275 | mdb->drFreeBks = cpu_to_be16(HFS_SB(sb)->free_ablocks); |
276 | mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id); |
277 | mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files); |
278 | mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs); |
279 | mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count); |
280 | mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count); |
281 | |
282 | /* write MDB to disk */ |
283 | mark_buffer_dirty(HFS_SB(sb)->mdb_bh); |
284 | } |
285 | |
286 | /* write the backup MDB, not returning until it is written. |
287 | * we only do this when either the catalog or extents overflow |
288 | * files grow. */ |
289 | if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, addr: &HFS_SB(sb)->flags) && |
290 | HFS_SB(sb)->alt_mdb) { |
291 | hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec, |
292 | &mdb->drXTFlSize, NULL); |
293 | hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec, |
294 | &mdb->drCTFlSize, NULL); |
295 | |
296 | lock_buffer(HFS_SB(sb)->alt_mdb_bh); |
297 | memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE); |
298 | HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT); |
299 | HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT); |
300 | unlock_buffer(HFS_SB(sb)->alt_mdb_bh); |
301 | |
302 | mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh); |
303 | sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh); |
304 | } |
305 | |
306 | if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, addr: &HFS_SB(sb)->flags)) { |
307 | struct buffer_head *bh; |
308 | sector_t block; |
309 | char *ptr; |
310 | int off, size, len; |
311 | |
312 | block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start; |
313 | off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1); |
314 | block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS; |
315 | size = (HFS_SB(sb)->fs_ablocks + 7) / 8; |
316 | ptr = (u8 *)HFS_SB(sb)->bitmap; |
317 | while (size) { |
318 | bh = sb_bread(sb, block); |
319 | if (!bh) { |
320 | pr_err("unable to read volume bitmap\n" ); |
321 | break; |
322 | } |
323 | len = min((int)sb->s_blocksize - off, size); |
324 | |
325 | lock_buffer(bh); |
326 | memcpy(bh->b_data + off, ptr, len); |
327 | unlock_buffer(bh); |
328 | |
329 | mark_buffer_dirty(bh); |
330 | brelse(bh); |
331 | block++; |
332 | off = 0; |
333 | ptr += len; |
334 | size -= len; |
335 | } |
336 | } |
337 | unlock_buffer(HFS_SB(sb)->mdb_bh); |
338 | } |
339 | |
340 | void hfs_mdb_close(struct super_block *sb) |
341 | { |
342 | /* update volume attributes */ |
343 | if (sb_rdonly(sb)) |
344 | return; |
345 | HFS_SB(sb)->mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT); |
346 | HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT); |
347 | mark_buffer_dirty(HFS_SB(sb)->mdb_bh); |
348 | } |
349 | |
350 | /* |
351 | * hfs_mdb_put() |
352 | * |
353 | * Release the resources associated with the in-core MDB. */ |
354 | void hfs_mdb_put(struct super_block *sb) |
355 | { |
356 | if (!HFS_SB(sb)) |
357 | return; |
358 | /* free the B-trees */ |
359 | hfs_btree_close(HFS_SB(sb)->ext_tree); |
360 | hfs_btree_close(HFS_SB(sb)->cat_tree); |
361 | |
362 | /* free the buffers holding the primary and alternate MDBs */ |
363 | brelse(HFS_SB(sb)->mdb_bh); |
364 | brelse(HFS_SB(sb)->alt_mdb_bh); |
365 | |
366 | unload_nls(HFS_SB(sb)->nls_io); |
367 | unload_nls(HFS_SB(sb)->nls_disk); |
368 | |
369 | kfree(HFS_SB(sb)->bitmap); |
370 | kfree(HFS_SB(sb)); |
371 | sb->s_fs_info = NULL; |
372 | } |
373 | |