fs/hfs/mdb.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
hfs_get_last_session
hfs_mdb_get
hfs_mdb_commit
hfs_mdb_close
hfs_mdb_put
   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 |= SB_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 |= SB_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 }
/* [<][>][^][v][top][bottom][index][help] */
root/fs/hfs/mdb.c

DEFINITIONS
