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
hfs_get_last_session(struct super_block * sb,sector_t * start,sector_t * size)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(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, &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, &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 */
hfs_mdb_get(struct super_block * sb)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, &part_start, &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 atomic64_set(&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 atomic64_set(&HFS_SB(sb)->file_count, be32_to_cpu(mdb->drFilCnt));
157 atomic64_set(&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 = kzalloc(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, 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(&mdb->drWrCnt, 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 */
hfs_mdb_commit(struct super_block * sb)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, &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 BUG_ON(atomic64_read(&HFS_SB(sb)->next_id) > U32_MAX);
277 mdb->drNxtCNID =
278 cpu_to_be32((u32)atomic64_read(&HFS_SB(sb)->next_id));
279 mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files);
280 mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs);
281 BUG_ON(atomic64_read(&HFS_SB(sb)->file_count) > U32_MAX);
282 mdb->drFilCnt =
283 cpu_to_be32((u32)atomic64_read(&HFS_SB(sb)->file_count));
284 BUG_ON(atomic64_read(&HFS_SB(sb)->folder_count) > U32_MAX);
285 mdb->drDirCnt =
286 cpu_to_be32((u32)atomic64_read(&HFS_SB(sb)->folder_count));
287
288 /* write MDB to disk */
289 mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
290 }
291
292 /* write the backup MDB, not returning until it is written.
293 * we only do this when either the catalog or extents overflow
294 * files grow. */
295 if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags) &&
296 HFS_SB(sb)->alt_mdb) {
297 hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec,
298 &mdb->drXTFlSize, NULL);
299 hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,
300 &mdb->drCTFlSize, NULL);
301
302 lock_buffer(HFS_SB(sb)->alt_mdb_bh);
303 memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);
304 HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
305 HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
306 unlock_buffer(HFS_SB(sb)->alt_mdb_bh);
307
308 mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
309 sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
310 }
311
312 if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags)) {
313 struct buffer_head *bh;
314 sector_t block;
315 char *ptr;
316 int off, size, len;
317
318 block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start;
319 off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1);
320 block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS;
321 size = (HFS_SB(sb)->fs_ablocks + 7) / 8;
322 ptr = (u8 *)HFS_SB(sb)->bitmap;
323 while (size) {
324 bh = sb_bread(sb, block);
325 if (!bh) {
326 pr_err("unable to read volume bitmap\n");
327 break;
328 }
329 len = min((int)sb->s_blocksize - off, size);
330
331 lock_buffer(bh);
332 memcpy(bh->b_data + off, ptr, len);
333 unlock_buffer(bh);
334
335 mark_buffer_dirty(bh);
336 brelse(bh);
337 block++;
338 off = 0;
339 ptr += len;
340 size -= len;
341 }
342 }
343 unlock_buffer(HFS_SB(sb)->mdb_bh);
344 }
345
hfs_mdb_close(struct super_block * sb)346 void hfs_mdb_close(struct super_block *sb)
347 {
348 /* update volume attributes */
349 if (sb_rdonly(sb))
350 return;
351 HFS_SB(sb)->mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
352 HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
353 mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
354 }
355
356 /*
357 * hfs_mdb_put()
358 *
359 * Release the resources associated with the in-core MDB. */
hfs_mdb_put(struct super_block * sb)360 void hfs_mdb_put(struct super_block *sb)
361 {
362 if (!HFS_SB(sb))
363 return;
364 /* free the B-trees */
365 hfs_btree_close(HFS_SB(sb)->ext_tree);
366 hfs_btree_close(HFS_SB(sb)->cat_tree);
367
368 /* free the buffers holding the primary and alternate MDBs */
369 brelse(HFS_SB(sb)->mdb_bh);
370 brelse(HFS_SB(sb)->alt_mdb_bh);
371
372 unload_nls(HFS_SB(sb)->nls_io);
373 unload_nls(HFS_SB(sb)->nls_disk);
374
375 kfree(HFS_SB(sb)->bitmap);
376 kfree(HFS_SB(sb));
377 sb->s_fs_info = NULL;
378 }
379