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