LXR linux/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#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
  32static 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 */
  67int 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
 228out_bh:
 229        brelse(bh);
 230out:
 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.
 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_sync_fs() and flush_mdb().
 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 */
 259void hfs_mdb_commit(struct super_block *sb)
 260{
 261        struct hfs_mdb *mdb = HFS_SB(sb)->mdb;
 262
 263        if (sb->s_flags & MS_RDONLY)
 264                return;
 265
 266        lock_buffer(HFS_SB(sb)->mdb_bh);
 267        if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) {
 268                /* These parameters may have been modified, so write them back */
 269                mdb->drLsMod = hfs_mtime();
 270                mdb->drFreeBks = cpu_to_be16(HFS_SB(sb)->free_ablocks);
 271                mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id);
 272                mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files);
 273                mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs);
 274                mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count);
 275                mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count);
 276
 277                /* write MDB to disk */
 278                mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
 279        }
 280
 281        /* write the backup MDB, not returning until it is written.
 282         * we only do this when either the catalog or extents overflow
 283         * files grow. */
 284        if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags) &&
 285            HFS_SB(sb)->alt_mdb) {
 286                hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec,
 287                                     &mdb->drXTFlSize, NULL);
 288                hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,
 289                                     &mdb->drCTFlSize, NULL);
 290
 291                lock_buffer(HFS_SB(sb)->alt_mdb_bh);
 292                memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);
 293                HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
 294                HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
 295                unlock_buffer(HFS_SB(sb)->alt_mdb_bh);
 296
 297                mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
 298                sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
 299        }
 300
 301        if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags)) {
 302                struct buffer_head *bh;
 303                sector_t block;
 304                char *ptr;
 305                int off, size, len;
 306
 307                block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start;
 308                off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1);
 309                block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS;
 310                size = (HFS_SB(sb)->fs_ablocks + 7) / 8;
 311                ptr = (u8 *)HFS_SB(sb)->bitmap;
 312                while (size) {
 313                        bh = sb_bread(sb, block);
 314                        if (!bh) {
 315                                printk(KERN_ERR "hfs: unable to read volume bitmap\n");
 316                                break;
 317                        }
 318                        len = min((int)sb->s_blocksize - off, size);
 319
 320                        lock_buffer(bh);
 321                        memcpy(bh->b_data + off, ptr, len);
 322                        unlock_buffer(bh);
 323
 324                        mark_buffer_dirty(bh);
 325                        brelse(bh);
 326                        block++;
 327                        off = 0;
 328                        ptr += len;
 329                        size -= len;
 330                }
 331        }
 332        unlock_buffer(HFS_SB(sb)->mdb_bh);
 333}
 334
 335void hfs_mdb_close(struct super_block *sb)
 336{
 337        /* update volume attributes */
 338        if (sb->s_flags & MS_RDONLY)
 339                return;
 340        HFS_SB(sb)->mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
 341        HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
 342        mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
 343}
 344
 345/*
 346 * hfs_mdb_put()
 347 *
 348 * Release the resources associated with the in-core MDB.  */
 349void hfs_mdb_put(struct super_block *sb)
 350{
 351        if (!HFS_SB(sb))
 352                return;
 353        /* free the B-trees */
 354        hfs_btree_close(HFS_SB(sb)->ext_tree);
 355        hfs_btree_close(HFS_SB(sb)->cat_tree);
 356
 357        /* free the buffers holding the primary and alternate MDBs */
 358        brelse(HFS_SB(sb)->mdb_bh);
 359        brelse(HFS_SB(sb)->alt_mdb_bh);
 360
 361        unload_nls(HFS_SB(sb)->nls_io);
 362        unload_nls(HFS_SB(sb)->nls_disk);
 363
 364        free_pages((unsigned long)HFS_SB(sb)->bitmap, PAGE_SIZE < 8192 ? 1 : 0);
 365        kfree(HFS_SB(sb));
 366        sb->s_fs_info = NULL;
 367}
 368