fs/hfs/mdb.c - linux - Git at Google

 /*
  *  linux/fs/hfs/mdb.c
  *
  * Copyright (C) 1995-1997  Paul H. Hargrove
  * (C) 2003 Ardis Technologies <roman@ardistech.com>
  * This file may be distributed under the terms of the GNU General Public License.
  *
  * This file contains functions for reading/writing the MDB.
  */

 #include <linux/cdrom.h>
 #include <linux/blkdev.h>
 #include <linux/nls.h>
 #include <linux/slab.h>

 #include "hfs_fs.h"
 #include "btree.h"

 /*================ File-local data types ================*/

 /*
  * The HFS Master Directory Block (MDB).
  *
  * Also known as the Volume Information Block (VIB), this structure is
  * the HFS equivalent of a superblock.
  *
  * Reference: _Inside Macintosh: Files_ pages 2-59 through 2-62
  *
  * modified for HFS Extended
  */

 static int hfs_get_last_session(struct super_block *sb,
 				sector_t *start, sector_t *size)
 {
 	struct cdrom_device_info *cdi = disk_to_cdi(sb->s_bdev->bd_disk);

 	/* default values */
 	*start = 0;
 	*size = bdev_nr_sectors(sb->s_bdev);

 	if (HFS_SB(sb)->session >= 0) {
 		struct cdrom_tocentry te;

 		if (!cdi)
 			return -EINVAL;

 		te.cdte_track = HFS_SB(sb)->session;
 		te.cdte_format = CDROM_LBA;
 		if (cdrom_read_tocentry(cdi, &te) ||
 		    (te.cdte_ctrl & CDROM_DATA_TRACK) != 4) {
 			pr_err("invalid session number or type of track\n");
 			return -EINVAL;
 		}

 		*start = (sector_t)te.cdte_addr.lba << 2;
 	} else if (cdi) {
 		struct cdrom_multisession ms_info;

 		ms_info.addr_format = CDROM_LBA;
 		if (cdrom_multisession(cdi, &ms_info) == 0 && ms_info.xa_flag)
 			*start = (sector_t)ms_info.addr.lba << 2;
 	}

 	return 0;
 }

 /*
  * hfs_mdb_get()
  *
  * Build the in-core MDB for a filesystem, including
  * the B-trees and the volume bitmap.
  */
 int hfs_mdb_get(struct super_block *sb)
 {
 	struct buffer_head *bh;
 	struct hfs_mdb *mdb, *mdb2;
 	unsigned int block;
 	char *ptr;
 	int off2, len, size, sect;
 	sector_t part_start, part_size;
 	loff_t off;
 	__be16 attrib;

 	/* set the device driver to 512-byte blocks */
 	size = sb_min_blocksize(sb, HFS_SECTOR_SIZE);
 	if (!size)
 		return -EINVAL;

 	if (hfs_get_last_session(sb, &part_start, &part_size))
 		return -EINVAL;
 	while (1) {
 		/* See if this is an HFS filesystem */
 		bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb);
 		if (!bh)
 			goto out;

 		if (mdb->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC))
 			break;
 		brelse(bh);

 		/* check for a partition block
 		 * (should do this only for cdrom/loop though)
 		 */
 		if (hfs_part_find(sb, &part_start, &part_size))
 			goto out;
 	}

 	HFS_SB(sb)->alloc_blksz = size = be32_to_cpu(mdb->drAlBlkSiz);
 	if (!size || (size & (HFS_SECTOR_SIZE - 1))) {
 		pr_err("bad allocation block size %d\n", size);
 		goto out_bh;
 	}

 	size = min(HFS_SB(sb)->alloc_blksz, (u32)PAGE_SIZE);
 	/* size must be a multiple of 512 */
 	while (size & (size - 1))
 		size -= HFS_SECTOR_SIZE;
 	sect = be16_to_cpu(mdb->drAlBlSt) + part_start;
 	/* align block size to first sector */
 	while (sect & ((size - 1) >> HFS_SECTOR_SIZE_BITS))
 		size >>= 1;
 	/* align block size to weird alloc size */
 	while (HFS_SB(sb)->alloc_blksz & (size - 1))
 		size >>= 1;
 	brelse(bh);
 	if (!sb_set_blocksize(sb, size)) {
 		pr_err("unable to set blocksize to %u\n", size);
 		goto out;
 	}

 	bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb);
 	if (!bh)
 		goto out;
 	if (mdb->drSigWord != cpu_to_be16(HFS_SUPER_MAGIC))
 		goto out_bh;

 	HFS_SB(sb)->mdb_bh = bh;
 	HFS_SB(sb)->mdb = mdb;

 	/* These parameters are read from the MDB, and never written */
 	HFS_SB(sb)->part_start = part_start;
 	HFS_SB(sb)->fs_ablocks = be16_to_cpu(mdb->drNmAlBlks);
 	HFS_SB(sb)->fs_div = HFS_SB(sb)->alloc_blksz >> sb->s_blocksize_bits;
 	HFS_SB(sb)->clumpablks = be32_to_cpu(mdb->drClpSiz) /
 				 HFS_SB(sb)->alloc_blksz;
 	if (!HFS_SB(sb)->clumpablks)
 		HFS_SB(sb)->clumpablks = 1;
 	HFS_SB(sb)->fs_start = (be16_to_cpu(mdb->drAlBlSt) + part_start) >>
 			       (sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS);

 	/* These parameters are read from and written to the MDB */
 	HFS_SB(sb)->free_ablocks = be16_to_cpu(mdb->drFreeBks);
 	HFS_SB(sb)->next_id = be32_to_cpu(mdb->drNxtCNID);
 	HFS_SB(sb)->root_files = be16_to_cpu(mdb->drNmFls);
 	HFS_SB(sb)->root_dirs = be16_to_cpu(mdb->drNmRtDirs);
 	HFS_SB(sb)->file_count = be32_to_cpu(mdb->drFilCnt);
 	HFS_SB(sb)->folder_count = be32_to_cpu(mdb->drDirCnt);

 	/* TRY to get the alternate (backup) MDB. */
 	sect = part_start + part_size - 2;
 	bh = sb_bread512(sb, sect, mdb2);
 	if (bh) {
 		if (mdb2->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC)) {
 			HFS_SB(sb)->alt_mdb_bh = bh;
 			HFS_SB(sb)->alt_mdb = mdb2;
 		} else
 			brelse(bh);
 	}

 	if (!HFS_SB(sb)->alt_mdb) {
 		pr_warn("unable to locate alternate MDB\n");
 		pr_warn("continuing without an alternate MDB\n");
 	}

 	HFS_SB(sb)->bitmap = kmalloc(8192, GFP_KERNEL);
 	if (!HFS_SB(sb)->bitmap)
 		goto out;

 	/* read in the bitmap */
 	block = be16_to_cpu(mdb->drVBMSt) + part_start;
 	off = (loff_t)block << HFS_SECTOR_SIZE_BITS;
 	size = (HFS_SB(sb)->fs_ablocks + 8) / 8;
 	ptr = (u8 *)HFS_SB(sb)->bitmap;
 	while (size) {
 		bh = sb_bread(sb, off >> sb->s_blocksize_bits);
 		if (!bh) {
 			pr_err("unable to read volume bitmap\n");
 			goto out;
 		}
 		off2 = off & (sb->s_blocksize - 1);
 		len = min((int)sb->s_blocksize - off2, size);
 		memcpy(ptr, bh->b_data + off2, len);
 		brelse(bh);
 		ptr += len;
 		off += len;
 		size -= len;
 	}

 	HFS_SB(sb)->ext_tree = hfs_btree_open(sb, HFS_EXT_CNID, hfs_ext_keycmp);
 	if (!HFS_SB(sb)->ext_tree) {
 		pr_err("unable to open extent tree\n");
 		goto out;
 	}
 	HFS_SB(sb)->cat_tree = hfs_btree_open(sb, HFS_CAT_CNID, hfs_cat_keycmp);
 	if (!HFS_SB(sb)->cat_tree) {
 		pr_err("unable to open catalog tree\n");
 		goto out;
 	}

 	attrib = mdb->drAtrb;
 	if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
 		pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended.  mounting read-only.\n");
 		sb->s_flags |= SB_RDONLY;
 	}
 	if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
 		pr_warn("filesystem is marked locked, mounting read-only.\n");
 		sb->s_flags |= SB_RDONLY;
 	}
 	if (!sb_rdonly(sb)) {
 		/* Mark the volume uncleanly unmounted in case we crash */
 		attrib &= cpu_to_be16(~HFS_SB_ATTRIB_UNMNT);
 		attrib |= cpu_to_be16(HFS_SB_ATTRIB_INCNSTNT);
 		mdb->drAtrb = attrib;
 		be32_add_cpu(&mdb->drWrCnt, 1);
 		mdb->drLsMod = hfs_mtime();

 		mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
 		sync_dirty_buffer(HFS_SB(sb)->mdb_bh);
 	}

 	return 0;

 out_bh:
 	brelse(bh);
 out:
 	hfs_mdb_put(sb);
 	return -EIO;
 }

 /*
  * hfs_mdb_commit()
  *
  * Description:
  *   This updates the MDB on disk.
  *   It does not check, if the superblock has been modified, or
  *   if the filesystem has been mounted read-only. It is mainly
  *   called by hfs_sync_fs() and flush_mdb().
  * Input Variable(s):
  *   struct hfs_mdb *mdb: Pointer to the hfs MDB
  *   int backup;
  * Output Variable(s):
  *   NONE
  * Returns:
  *   void
  * Preconditions:
  *   'mdb' points to a "valid" (struct hfs_mdb).
  * Postconditions:
  *   The HFS MDB and on disk will be updated, by copying the possibly
  *   modified fields from the in memory MDB (in native byte order) to
  *   the disk block buffer.
  *   If 'backup' is non-zero then the alternate MDB is also written
  *   and the function doesn't return until it is actually on disk.
  */
 void hfs_mdb_commit(struct super_block *sb)
 {
 	struct hfs_mdb *mdb = HFS_SB(sb)->mdb;

 	if (sb_rdonly(sb))
 		return;

 	lock_buffer(HFS_SB(sb)->mdb_bh);
 	if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) {
 		/* These parameters may have been modified, so write them back */
 		mdb->drLsMod = hfs_mtime();
 		mdb->drFreeBks = cpu_to_be16(HFS_SB(sb)->free_ablocks);
 		mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id);
 		mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files);
 		mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs);
 		mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count);
 		mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count);

 		/* write MDB to disk */
 		mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
 	}

 	/* write the backup MDB, not returning until it is written.
 	 * we only do this when either the catalog or extents overflow
 	 * files grow. */
 	if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags) &&
 	    HFS_SB(sb)->alt_mdb) {
 		hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec,
 				     &mdb->drXTFlSize, NULL);
 		hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,
 				     &mdb->drCTFlSize, NULL);

 		lock_buffer(HFS_SB(sb)->alt_mdb_bh);
 		memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);
 		HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
 		HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
 		unlock_buffer(HFS_SB(sb)->alt_mdb_bh);

 		mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
 		sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
 	}

 	if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags)) {
 		struct buffer_head *bh;
 		sector_t block;
 		char *ptr;
 		int off, size, len;

 		block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start;
 		off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1);
 		block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS;
 		size = (HFS_SB(sb)->fs_ablocks + 7) / 8;
 		ptr = (u8 *)HFS_SB(sb)->bitmap;
 		while (size) {
 			bh = sb_bread(sb, block);
 			if (!bh) {
 				pr_err("unable to read volume bitmap\n");
 				break;
 			}
 			len = min((int)sb->s_blocksize - off, size);

 			lock_buffer(bh);
 			memcpy(bh->b_data + off, ptr, len);
 			unlock_buffer(bh);

 			mark_buffer_dirty(bh);
 			brelse(bh);
 			block++;
 			off = 0;
 			ptr += len;
 			size -= len;
 		}
 	}
 	unlock_buffer(HFS_SB(sb)->mdb_bh);
 }

 void hfs_mdb_close(struct super_block *sb)
 {
 	/* update volume attributes */
 	if (sb_rdonly(sb))
 		return;
 	HFS_SB(sb)->mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
 	HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
 	mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
 }

 /*
  * hfs_mdb_put()
  *
  * Release the resources associated with the in-core MDB.  */
 void hfs_mdb_put(struct super_block *sb)
 {
 	if (!HFS_SB(sb))
 		return;
 	/* free the B-trees */
 	hfs_btree_close(HFS_SB(sb)->ext_tree);
 	hfs_btree_close(HFS_SB(sb)->cat_tree);

 	/* free the buffers holding the primary and alternate MDBs */
 	brelse(HFS_SB(sb)->mdb_bh);
 	brelse(HFS_SB(sb)->alt_mdb_bh);

 	unload_nls(HFS_SB(sb)->nls_io);
 	unload_nls(HFS_SB(sb)->nls_disk);

 	kfree(HFS_SB(sb)->bitmap);
 	kfree(HFS_SB(sb));
 	sb->s_fs_info = NULL;
 }
	/*
	* linux/fs/hfs/mdb.c
	*
	* Copyright (C) 1995-1997 Paul H. Hargrove
	* (C) 2003 Ardis Technologies <roman@ardistech.com>
	* This file may be distributed under the terms of the GNU General Public License.
	*
	* This file contains functions for reading/writing the MDB.
	*/

	#include <linux/cdrom.h>
	#include <linux/blkdev.h>
	#include <linux/nls.h>
	#include <linux/slab.h>

	#include "hfs_fs.h"
	#include "btree.h"

	/================ File-local data types ================/

	/*
	* The HFS Master Directory Block (MDB).
	*
	* Also known as the Volume Information Block (VIB), this structure is
	* the HFS equivalent of a superblock.
	*
	* Reference: _Inside Macintosh: Files_ pages 2-59 through 2-62
	*
	* modified for HFS Extended
	*/

	static int hfs_get_last_session(struct super_block *sb,
	sector_t start, sector_t size)
	{
	struct cdrom_device_info *cdi = disk_to_cdi(sb->s_bdev->bd_disk);

	/* default values */
	*start = 0;
	*size = bdev_nr_sectors(sb->s_bdev);

	if (HFS_SB(sb)->session >= 0) {
	struct cdrom_tocentry te;

	if (!cdi)
	return -EINVAL;

	te.cdte_track = HFS_SB(sb)->session;
	te.cdte_format = CDROM_LBA;
	if (cdrom_read_tocentry(cdi, &te) \|\|
	(te.cdte_ctrl & CDROM_DATA_TRACK) != 4) {
	pr_err("invalid session number or type of track\n");
	return -EINVAL;
	}

	*start = (sector_t)te.cdte_addr.lba << 2;
	} else if (cdi) {
	struct cdrom_multisession ms_info;

	ms_info.addr_format = CDROM_LBA;
	if (cdrom_multisession(cdi, &ms_info) == 0 && ms_info.xa_flag)
	*start = (sector_t)ms_info.addr.lba << 2;
	}

	return 0;
	}

	/*
	* hfs_mdb_get()
	*
	* Build the in-core MDB for a filesystem, including
	* the B-trees and the volume bitmap.
	*/
	int hfs_mdb_get(struct super_block *sb)
	{
	struct buffer_head *bh;
	struct hfs_mdb mdb, mdb2;
	unsigned int block;
	char *ptr;
	int off2, len, size, sect;
	sector_t part_start, part_size;
	loff_t off;
	__be16 attrib;

	/* set the device driver to 512-byte blocks */
	size = sb_min_blocksize(sb, HFS_SECTOR_SIZE);
	if (!size)
	return -EINVAL;

	if (hfs_get_last_session(sb, &part_start, &part_size))
	return -EINVAL;
	while (1) {
	/* See if this is an HFS filesystem */
	bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb);
	if (!bh)
	goto out;

	if (mdb->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC))
	break;
	brelse(bh);

	/* check for a partition block
	* (should do this only for cdrom/loop though)
	*/
	if (hfs_part_find(sb, &part_start, &part_size))
	goto out;
	}

	HFS_SB(sb)->alloc_blksz = size = be32_to_cpu(mdb->drAlBlkSiz);
	if (!size \|\| (size & (HFS_SECTOR_SIZE - 1))) {
	pr_err("bad allocation block size %d\n", size);
	goto out_bh;
	}

	size = min(HFS_SB(sb)->alloc_blksz, (u32)PAGE_SIZE);
	/* size must be a multiple of 512 */
	while (size & (size - 1))
	size -= HFS_SECTOR_SIZE;
	sect = be16_to_cpu(mdb->drAlBlSt) + part_start;
	/* align block size to first sector */
	while (sect & ((size - 1) >> HFS_SECTOR_SIZE_BITS))
	size >>= 1;
	/* align block size to weird alloc size */
	while (HFS_SB(sb)->alloc_blksz & (size - 1))
	size >>= 1;
	brelse(bh);
	if (!sb_set_blocksize(sb, size)) {
	pr_err("unable to set blocksize to %u\n", size);
	goto out;
	}

	bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb);
	if (!bh)
	goto out;
	if (mdb->drSigWord != cpu_to_be16(HFS_SUPER_MAGIC))
	goto out_bh;

	HFS_SB(sb)->mdb_bh = bh;
	HFS_SB(sb)->mdb = mdb;

	/* These parameters are read from the MDB, and never written */
	HFS_SB(sb)->part_start = part_start;
	HFS_SB(sb)->fs_ablocks = be16_to_cpu(mdb->drNmAlBlks);
	HFS_SB(sb)->fs_div = HFS_SB(sb)->alloc_blksz >> sb->s_blocksize_bits;
	HFS_SB(sb)->clumpablks = be32_to_cpu(mdb->drClpSiz) /
	HFS_SB(sb)->alloc_blksz;
	if (!HFS_SB(sb)->clumpablks)
	HFS_SB(sb)->clumpablks = 1;
	HFS_SB(sb)->fs_start = (be16_to_cpu(mdb->drAlBlSt) + part_start) >>
	(sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS);

	/* These parameters are read from and written to the MDB */
	HFS_SB(sb)->free_ablocks = be16_to_cpu(mdb->drFreeBks);
	HFS_SB(sb)->next_id = be32_to_cpu(mdb->drNxtCNID);
	HFS_SB(sb)->root_files = be16_to_cpu(mdb->drNmFls);
	HFS_SB(sb)->root_dirs = be16_to_cpu(mdb->drNmRtDirs);
	HFS_SB(sb)->file_count = be32_to_cpu(mdb->drFilCnt);
	HFS_SB(sb)->folder_count = be32_to_cpu(mdb->drDirCnt);

	/* TRY to get the alternate (backup) MDB. */
	sect = part_start + part_size - 2;
	bh = sb_bread512(sb, sect, mdb2);
	if (bh) {
	if (mdb2->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC)) {
	HFS_SB(sb)->alt_mdb_bh = bh;
	HFS_SB(sb)->alt_mdb = mdb2;
	} else
	brelse(bh);
	}

	if (!HFS_SB(sb)->alt_mdb) {
	pr_warn("unable to locate alternate MDB\n");
	pr_warn("continuing without an alternate MDB\n");
	}

	HFS_SB(sb)->bitmap = kmalloc(8192, GFP_KERNEL);
	if (!HFS_SB(sb)->bitmap)
	goto out;

	/* read in the bitmap */
	block = be16_to_cpu(mdb->drVBMSt) + part_start;
	off = (loff_t)block << HFS_SECTOR_SIZE_BITS;
	size = (HFS_SB(sb)->fs_ablocks + 8) / 8;
	ptr = (u8 *)HFS_SB(sb)->bitmap;
	while (size) {
	bh = sb_bread(sb, off >> sb->s_blocksize_bits);
	if (!bh) {
	pr_err("unable to read volume bitmap\n");
	goto out;
	}
	off2 = off & (sb->s_blocksize - 1);
	len = min((int)sb->s_blocksize - off2, size);
	memcpy(ptr, bh->b_data + off2, len);
	brelse(bh);
	ptr += len;
	off += len;
	size -= len;
	}

	HFS_SB(sb)->ext_tree = hfs_btree_open(sb, HFS_EXT_CNID, hfs_ext_keycmp);
	if (!HFS_SB(sb)->ext_tree) {
	pr_err("unable to open extent tree\n");
	goto out;
	}
	HFS_SB(sb)->cat_tree = hfs_btree_open(sb, HFS_CAT_CNID, hfs_cat_keycmp);
	if (!HFS_SB(sb)->cat_tree) {
	pr_err("unable to open catalog tree\n");
	goto out;
	}

	attrib = mdb->drAtrb;
	if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
	pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n");
	sb->s_flags \|= SB_RDONLY;
	}
	if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
	pr_warn("filesystem is marked locked, mounting read-only.\n");
	sb->s_flags \|= SB_RDONLY;
	}
	if (!sb_rdonly(sb)) {
	/* Mark the volume uncleanly unmounted in case we crash */
	attrib &= cpu_to_be16(~HFS_SB_ATTRIB_UNMNT);
	attrib \|= cpu_to_be16(HFS_SB_ATTRIB_INCNSTNT);
	mdb->drAtrb = attrib;
	be32_add_cpu(&mdb->drWrCnt, 1);
	mdb->drLsMod = hfs_mtime();

	mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
	sync_dirty_buffer(HFS_SB(sb)->mdb_bh);
	}

	return 0;

	out_bh:
	brelse(bh);
	out:
	hfs_mdb_put(sb);
	return -EIO;
	}

	/*
	* hfs_mdb_commit()
	*
	* Description:
	* This updates the MDB on disk.
	* It does not check, if the superblock has been modified, or
	* if the filesystem has been mounted read-only. It is mainly
	* called by hfs_sync_fs() and flush_mdb().
	* Input Variable(s):
	* struct hfs_mdb *mdb: Pointer to the hfs MDB
	* int backup;
	* Output Variable(s):
	* NONE
	* Returns:
	* void
	* Preconditions:
	* 'mdb' points to a "valid" (struct hfs_mdb).
	* Postconditions:
	* The HFS MDB and on disk will be updated, by copying the possibly
	* modified fields from the in memory MDB (in native byte order) to
	* the disk block buffer.
	* If 'backup' is non-zero then the alternate MDB is also written
	* and the function doesn't return until it is actually on disk.
	*/
	void hfs_mdb_commit(struct super_block *sb)
	{
	struct hfs_mdb *mdb = HFS_SB(sb)->mdb;

	if (sb_rdonly(sb))
	return;

	lock_buffer(HFS_SB(sb)->mdb_bh);
	if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) {
	/* These parameters may have been modified, so write them back */
	mdb->drLsMod = hfs_mtime();
	mdb->drFreeBks = cpu_to_be16(HFS_SB(sb)->free_ablocks);
	mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id);
	mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files);
	mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs);
	mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count);
	mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count);

	/* write MDB to disk */
	mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
	}

	/* write the backup MDB, not returning until it is written.
	* we only do this when either the catalog or extents overflow
	* files grow. */
	if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags) &&
	HFS_SB(sb)->alt_mdb) {
	hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec,
	&mdb->drXTFlSize, NULL);
	hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,
	&mdb->drCTFlSize, NULL);

	lock_buffer(HFS_SB(sb)->alt_mdb_bh);
	memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);
	HFS_SB(sb)->alt_mdb->drAtrb \|= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
	HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
	unlock_buffer(HFS_SB(sb)->alt_mdb_bh);

	mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
	sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
	}

	if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags)) {
	struct buffer_head *bh;
	sector_t block;
	char *ptr;
	int off, size, len;

	block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start;
	off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1);
	block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS;
	size = (HFS_SB(sb)->fs_ablocks + 7) / 8;
	ptr = (u8 *)HFS_SB(sb)->bitmap;
	while (size) {
	bh = sb_bread(sb, block);
	if (!bh) {
	pr_err("unable to read volume bitmap\n");
	break;
	}
	len = min((int)sb->s_blocksize - off, size);

	lock_buffer(bh);
	memcpy(bh->b_data + off, ptr, len);
	unlock_buffer(bh);

	mark_buffer_dirty(bh);
	brelse(bh);
	block++;
	off = 0;
	ptr += len;
	size -= len;
	}
	}
	unlock_buffer(HFS_SB(sb)->mdb_bh);
	}

	void hfs_mdb_close(struct super_block *sb)
	{
	/* update volume attributes */
	if (sb_rdonly(sb))
	return;
	HFS_SB(sb)->mdb->drAtrb \|= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
	HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
	mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
	}

	/*
	* hfs_mdb_put()
	*
	* Release the resources associated with the in-core MDB. */
	void hfs_mdb_put(struct super_block *sb)
	{
	if (!HFS_SB(sb))
	return;
	/* free the B-trees */
	hfs_btree_close(HFS_SB(sb)->ext_tree);
	hfs_btree_close(HFS_SB(sb)->cat_tree);

	/* free the buffers holding the primary and alternate MDBs */
	brelse(HFS_SB(sb)->mdb_bh);
	brelse(HFS_SB(sb)->alt_mdb_bh);

	unload_nls(HFS_SB(sb)->nls_io);
	unload_nls(HFS_SB(sb)->nls_disk);

	kfree(HFS_SB(sb)->bitmap);
	kfree(HFS_SB(sb));
	sb->s_fs_info = NULL;
	}