Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | { |
Colin Leroy | 945b092 | 2005-05-01 08:59:16 -0700 | [diff] [blame] | 336 | if (!HFS_SB(sb)) |
| 337 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | /* free the B-trees */ |
| 339 | hfs_btree_close(HFS_SB(sb)->ext_tree); |
| 340 | hfs_btree_close(HFS_SB(sb)->cat_tree); |
| 341 | |
| 342 | /* free the buffers holding the primary and alternate MDBs */ |
| 343 | brelse(HFS_SB(sb)->mdb_bh); |
| 344 | brelse(HFS_SB(sb)->alt_mdb_bh); |
Colin Leroy | 945b092 | 2005-05-01 08:59:16 -0700 | [diff] [blame] | 345 | |
| 346 | kfree(HFS_SB(sb)); |
| 347 | sb->s_fs_info = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | } |