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 = i_size_read(sb->s_bdev->bd_inode) >> 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 pr_err("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 pr_err("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 pr_err("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 pr_warn("unable to locate alternate MDB\n"); 166 pr_warn("continuing without an alternate MDB\n"); 167 } 168 169 HFS_SB(sb)->bitmap = kmalloc(8192, GFP_KERNEL); 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 pr_err("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 pr_err("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 pr_err("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 pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n"); 207 sb->s_flags |= MS_RDONLY; 208 } 209 if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) { 210 pr_warn("filesystem is marked locked, mounting read-only.\n"); 211 sb->s_flags |= MS_RDONLY; 212 } 213 if (!sb_rdonly(sb)) { 214 /* Mark the volume uncleanly unmounted in case we crash */ 215 attrib &= cpu_to_be16(~HFS_SB_ATTRIB_UNMNT); 216 attrib |= cpu_to_be16(HFS_SB_ATTRIB_INCNSTNT); 217 mdb->drAtrb = attrib; 218 be32_add_cpu(&mdb->drWrCnt, 1); 219 mdb->drLsMod = hfs_mtime(); 220 221 mark_buffer_dirty(HFS_SB(sb)->mdb_bh); 222 sync_dirty_buffer(HFS_SB(sb)->mdb_bh); 223 } 224 225 return 0; 226 227 out_bh: 228 brelse(bh); 229 out: 230 hfs_mdb_put(sb); 231 return -EIO; 232 } 233 234 /* 235 * hfs_mdb_commit() 236 * 237 * Description: 238 * This updates the MDB on disk. 239 * It does not check, if the superblock has been modified, or 240 * if the filesystem has been mounted read-only. It is mainly 241 * called by hfs_sync_fs() and flush_mdb(). 242 * Input Variable(s): 243 * struct hfs_mdb *mdb: Pointer to the hfs MDB 244 * int backup; 245 * Output Variable(s): 246 * NONE 247 * Returns: 248 * void 249 * Preconditions: 250 * 'mdb' points to a "valid" (struct hfs_mdb). 251 * Postconditions: 252 * The HFS MDB and on disk will be updated, by copying the possibly 253 * modified fields from the in memory MDB (in native byte order) to 254 * the disk block buffer. 255 * If 'backup' is non-zero then the alternate MDB is also written 256 * and the function doesn't return until it is actually on disk. 257 */ 258 void hfs_mdb_commit(struct super_block *sb) 259 { 260 struct hfs_mdb *mdb = HFS_SB(sb)->mdb; 261 262 if (sb_rdonly(sb)) 263 return; 264 265 lock_buffer(HFS_SB(sb)->mdb_bh); 266 if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) { 267 /* These parameters may have been modified, so write them back */ 268 mdb->drLsMod = hfs_mtime(); 269 mdb->drFreeBks = cpu_to_be16(HFS_SB(sb)->free_ablocks); 270 mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id); 271 mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files); 272 mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs); 273 mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count); 274 mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count); 275 276 /* write MDB to disk */ 277 mark_buffer_dirty(HFS_SB(sb)->mdb_bh); 278 } 279 280 /* write the backup MDB, not returning until it is written. 281 * we only do this when either the catalog or extents overflow 282 * files grow. */ 283 if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags) && 284 HFS_SB(sb)->alt_mdb) { 285 hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec, 286 &mdb->drXTFlSize, NULL); 287 hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec, 288 &mdb->drCTFlSize, NULL); 289 290 lock_buffer(HFS_SB(sb)->alt_mdb_bh); 291 memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE); 292 HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT); 293 HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT); 294 unlock_buffer(HFS_SB(sb)->alt_mdb_bh); 295 296 mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh); 297 sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh); 298 } 299 300 if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags)) { 301 struct buffer_head *bh; 302 sector_t block; 303 char *ptr; 304 int off, size, len; 305 306 block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start; 307 off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1); 308 block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS; 309 size = (HFS_SB(sb)->fs_ablocks + 7) / 8; 310 ptr = (u8 *)HFS_SB(sb)->bitmap; 311 while (size) { 312 bh = sb_bread(sb, block); 313 if (!bh) { 314 pr_err("unable to read volume bitmap\n"); 315 break; 316 } 317 len = min((int)sb->s_blocksize - off, size); 318 319 lock_buffer(bh); 320 memcpy(bh->b_data + off, ptr, len); 321 unlock_buffer(bh); 322 323 mark_buffer_dirty(bh); 324 brelse(bh); 325 block++; 326 off = 0; 327 ptr += len; 328 size -= len; 329 } 330 } 331 unlock_buffer(HFS_SB(sb)->mdb_bh); 332 } 333 334 void hfs_mdb_close(struct super_block *sb) 335 { 336 /* update volume attributes */ 337 if (sb_rdonly(sb)) 338 return; 339 HFS_SB(sb)->mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT); 340 HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT); 341 mark_buffer_dirty(HFS_SB(sb)->mdb_bh); 342 } 343 344 /* 345 * hfs_mdb_put() 346 * 347 * Release the resources associated with the in-core MDB. */ 348 void hfs_mdb_put(struct super_block *sb) 349 { 350 if (!HFS_SB(sb)) 351 return; 352 /* free the B-trees */ 353 hfs_btree_close(HFS_SB(sb)->ext_tree); 354 hfs_btree_close(HFS_SB(sb)->cat_tree); 355 356 /* free the buffers holding the primary and alternate MDBs */ 357 brelse(HFS_SB(sb)->mdb_bh); 358 brelse(HFS_SB(sb)->alt_mdb_bh); 359 360 unload_nls(HFS_SB(sb)->nls_io); 361 unload_nls(HFS_SB(sb)->nls_disk); 362 363 kfree(HFS_SB(sb)->bitmap); 364 kfree(HFS_SB(sb)); 365 sb->s_fs_info = NULL; 366 } 367