fs/hfs/mdb.c

   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         if (!HFS_SB(sb))
 337                 return;
 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);
 345
 346         kfree(HFS_SB(sb));
 347         sb->s_fs_info = NULL;
 348 }