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