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 	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(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 		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, &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, &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 
hfs_mdb_close(struct super_block * sb)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.  */
hfs_mdb_put(struct super_block * sb)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