[linux.git] / fs / hfs / mdb.c

/*
 *  linux/fs/hfs/mdb.c
 *
 * Copyright (C) 1995-1997  Paul H. Hargrove
 * (C) 2003 Ardis Technologies <[email protected]>
 * 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;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/hfs/mdb.c
	3	*
	4	* Copyright (C) 1995-1997 Paul H. Hargrove
	5	* (C) 2003 Ardis Technologies <[email protected]>
	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>
322cbb50	12	#include <linux/blkdev.h>
328b9227	13	#include <linux/nls.h>
5a0e3ad6	14	#include <linux/slab.h>
1da177e4 LT	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	{
af00423a	35	struct cdrom_device_info *cdi = disk_to_cdi(sb->s_bdev->bd_disk);
1da177e4 LT	36
	37	/* default values */
	38	*start = 0;
beffd16e	39	*size = bdev_nr_sectors(sb->s_bdev);
1da177e4 LT	40
1da177e4 LT	41	if (HFS_SB(sb)->session >= 0) {
af00423a CH	42	struct cdrom_tocentry te;
	43
	44	if (!cdi)
	45	return -EINVAL;
	46
1da177e4 LT	47	te.cdte_track = HFS_SB(sb)->session;
1da177e4 LT	48	te.cdte_format = CDROM_LBA;
af00423a CH	49	if (cdrom_read_tocentry(cdi, &te) \|\|
	50	(te.cdte_ctrl & CDROM_DATA_TRACK) != 4) {
	51	pr_err("invalid session number or type of track\n");
	52	return -EINVAL;
1da177e4	53	}
af00423a CH	54
	55	*start = (sector_t)te.cdte_addr.lba << 2;
	56	} else if (cdi) {
	57	struct cdrom_multisession ms_info;
	58
	59	ms_info.addr_format = CDROM_LBA;
	60	if (cdrom_multisession(cdi, &ms_info) == 0 && ms_info.xa_flag)
	61	*start = (sector_t)ms_info.addr.lba << 2;
1da177e4	62	}
af00423a	63
1da177e4 LT	64	return 0;
	65	}
	66
	67	/*
	68	* hfs_mdb_get()
	69	*
	70	* Build the in-core MDB for a filesystem, including
	71	* the B-trees and the volume bitmap.
	72	*/
	73	int hfs_mdb_get(struct super_block *sb)
	74	{
	75	struct buffer_head *bh;
	76	struct hfs_mdb mdb, mdb2;
	77	unsigned int block;
	78	char *ptr;
	79	int off2, len, size, sect;
	80	sector_t part_start, part_size;
	81	loff_t off;
	82	__be16 attrib;
	83
	84	/* set the device driver to 512-byte blocks */
	85	size = sb_min_blocksize(sb, HFS_SECTOR_SIZE);
	86	if (!size)
	87	return -EINVAL;
	88
	89	if (hfs_get_last_session(sb, &part_start, &part_size))
	90	return -EINVAL;
	91	while (1) {
	92	/* See if this is an HFS filesystem */
	93	bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb);
	94	if (!bh)
	95	goto out;
	96
	97	if (mdb->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC))
	98	break;
	99	brelse(bh);
	100
	101	/* check for a partition block
	102	* (should do this only for cdrom/loop though)
	103	*/
	104	if (hfs_part_find(sb, &part_start, &part_size))
	105	goto out;
	106	}
	107
	108	HFS_SB(sb)->alloc_blksz = size = be32_to_cpu(mdb->drAlBlkSiz);
	109	if (!size \|\| (size & (HFS_SECTOR_SIZE - 1))) {
d6142673	110	pr_err("bad allocation block size %d\n", size);
1da177e4 LT	111	goto out_bh;
	112	}
	113
	114	size = min(HFS_SB(sb)->alloc_blksz, (u32)PAGE_SIZE);
	115	/* size must be a multiple of 512 */
	116	while (size & (size - 1))
	117	size -= HFS_SECTOR_SIZE;
	118	sect = be16_to_cpu(mdb->drAlBlSt) + part_start;
	119	/* align block size to first sector */
	120	while (sect & ((size - 1) >> HFS_SECTOR_SIZE_BITS))
	121	size >>= 1;
	122	/* align block size to weird alloc size */
	123	while (HFS_SB(sb)->alloc_blksz & (size - 1))
	124	size >>= 1;
	125	brelse(bh);
	126	if (!sb_set_blocksize(sb, size)) {
d6142673	127	pr_err("unable to set blocksize to %u\n", size);
1da177e4 LT	128	goto out;
	129	}
	130
	131	bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb);
	132	if (!bh)
	133	goto out;
	134	if (mdb->drSigWord != cpu_to_be16(HFS_SUPER_MAGIC))
	135	goto out_bh;
	136
	137	HFS_SB(sb)->mdb_bh = bh;
	138	HFS_SB(sb)->mdb = mdb;
	139
	140	/* These parameters are read from the MDB, and never written */
	141	HFS_SB(sb)->part_start = part_start;
	142	HFS_SB(sb)->fs_ablocks = be16_to_cpu(mdb->drNmAlBlks);
	143	HFS_SB(sb)->fs_div = HFS_SB(sb)->alloc_blksz >> sb->s_blocksize_bits;
	144	HFS_SB(sb)->clumpablks = be32_to_cpu(mdb->drClpSiz) /
	145	HFS_SB(sb)->alloc_blksz;
	146	if (!HFS_SB(sb)->clumpablks)
	147	HFS_SB(sb)->clumpablks = 1;
	148	HFS_SB(sb)->fs_start = (be16_to_cpu(mdb->drAlBlSt) + part_start) >>
	149	(sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS);
	150
	151	/* These parameters are read from and written to the MDB */
	152	HFS_SB(sb)->free_ablocks = be16_to_cpu(mdb->drFreeBks);
	153	HFS_SB(sb)->next_id = be32_to_cpu(mdb->drNxtCNID);
	154	HFS_SB(sb)->root_files = be16_to_cpu(mdb->drNmFls);
	155	HFS_SB(sb)->root_dirs = be16_to_cpu(mdb->drNmRtDirs);
	156	HFS_SB(sb)->file_count = be32_to_cpu(mdb->drFilCnt);
	157	HFS_SB(sb)->folder_count = be32_to_cpu(mdb->drDirCnt);
	158
	159	/* TRY to get the alternate (backup) MDB. */
	160	sect = part_start + part_size - 2;
	161	bh = sb_bread512(sb, sect, mdb2);
	162	if (bh) {
	163	if (mdb2->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC)) {
	164	HFS_SB(sb)->alt_mdb_bh = bh;
	165	HFS_SB(sb)->alt_mdb = mdb2;
	166	} else
	167	brelse(bh);
	168	}
	169
	170	if (!HFS_SB(sb)->alt_mdb) {
d6142673 JP	171	pr_warn("unable to locate alternate MDB\n");
d6142673 JP	172	pr_warn("continuing without an alternate MDB\n");
1da177e4 LT	173	}
1da177e4 LT	174
80f8dccf	175	HFS_SB(sb)->bitmap = kmalloc(8192, GFP_KERNEL);
1da177e4 LT	176	if (!HFS_SB(sb)->bitmap)
	177	goto out;
	178
	179	/* read in the bitmap */
	180	block = be16_to_cpu(mdb->drVBMSt) + part_start;
	181	off = (loff_t)block << HFS_SECTOR_SIZE_BITS;
	182	size = (HFS_SB(sb)->fs_ablocks + 8) / 8;
	183	ptr = (u8 *)HFS_SB(sb)->bitmap;
	184	while (size) {
	185	bh = sb_bread(sb, off >> sb->s_blocksize_bits);
	186	if (!bh) {
d6142673	187	pr_err("unable to read volume bitmap\n");
1da177e4 LT	188	goto out;
	189	}
	190	off2 = off & (sb->s_blocksize - 1);
	191	len = min((int)sb->s_blocksize - off2, size);
	192	memcpy(ptr, bh->b_data + off2, len);
	193	brelse(bh);
	194	ptr += len;
	195	off += len;
	196	size -= len;
	197	}
	198
	199	HFS_SB(sb)->ext_tree = hfs_btree_open(sb, HFS_EXT_CNID, hfs_ext_keycmp);
	200	if (!HFS_SB(sb)->ext_tree) {
d6142673	201	pr_err("unable to open extent tree\n");
1da177e4 LT	202	goto out;
	203	}
	204	HFS_SB(sb)->cat_tree = hfs_btree_open(sb, HFS_CAT_CNID, hfs_cat_keycmp);
	205	if (!HFS_SB(sb)->cat_tree) {
d6142673	206	pr_err("unable to open catalog tree\n");
1da177e4 LT	207	goto out;
	208	}
	209
	210	attrib = mdb->drAtrb;
	211	if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
d6142673	212	pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n");
1751e8a6	213	sb->s_flags \|= SB_RDONLY;
1da177e4 LT	214	}
1da177e4 LT	215	if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
d6142673	216	pr_warn("filesystem is marked locked, mounting read-only.\n");
1751e8a6	217	sb->s_flags \|= SB_RDONLY;
1da177e4	218	}
bc98a42c	219	if (!sb_rdonly(sb)) {
1da177e4 LT	220	/* Mark the volume uncleanly unmounted in case we crash */
	221	attrib &= cpu_to_be16(~HFS_SB_ATTRIB_UNMNT);
	222	attrib \|= cpu_to_be16(HFS_SB_ATTRIB_INCNSTNT);
	223	mdb->drAtrb = attrib;
20c79e78	224	be32_add_cpu(&mdb->drWrCnt, 1);
1da177e4 LT	225	mdb->drLsMod = hfs_mtime();
	226
	227	mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
3072b90c	228	sync_dirty_buffer(HFS_SB(sb)->mdb_bh);
1da177e4 LT	229	}
	230
	231	return 0;
	232
	233	out_bh:
	234	brelse(bh);
	235	out:
	236	hfs_mdb_put(sb);
	237	return -EIO;
	238	}
	239
	240	/*
	241	* hfs_mdb_commit()
	242	*
	243	* Description:
50640bcc	244	* This updates the MDB on disk.
1da177e4 LT	245	* It does not check, if the superblock has been modified, or
1da177e4 LT	246	* if the filesystem has been mounted read-only. It is mainly
50640bcc	247	* called by hfs_sync_fs() and flush_mdb().
1da177e4 LT	248	* Input Variable(s):
	249	* struct hfs_mdb *mdb: Pointer to the hfs MDB
	250	* int backup;
	251	* Output Variable(s):
	252	* NONE
	253	* Returns:
	254	* void
	255	* Preconditions:
	256	* 'mdb' points to a "valid" (struct hfs_mdb).
	257	* Postconditions:
	258	* The HFS MDB and on disk will be updated, by copying the possibly
	259	* modified fields from the in memory MDB (in native byte order) to
	260	* the disk block buffer.
	261	* If 'backup' is non-zero then the alternate MDB is also written
	262	* and the function doesn't return until it is actually on disk.
	263	*/
	264	void hfs_mdb_commit(struct super_block *sb)
	265	{
	266	struct hfs_mdb *mdb = HFS_SB(sb)->mdb;
	267
bc98a42c	268	if (sb_rdonly(sb))
4527440d AB	269	return;
4527440d AB	270
b5935235	271	lock_buffer(HFS_SB(sb)->mdb_bh);
1da177e4 LT	272	if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) {
	273	/* These parameters may have been modified, so write them back */
	274	mdb->drLsMod = hfs_mtime();
	275	mdb->drFreeBks = cpu_to_be16(HFS_SB(sb)->free_ablocks);
	276	mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id);
	277	mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files);
	278	mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs);
	279	mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count);
	280	mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count);
	281
	282	/* write MDB to disk */
	283	mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
	284	}
	285
	286	/* write the backup MDB, not returning until it is written.
	287	* we only do this when either the catalog or extents overflow
	288	* files grow. */
	289	if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags) &&
	290	HFS_SB(sb)->alt_mdb) {
	291	hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec,
	292	&mdb->drXTFlSize, NULL);
	293	hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,
	294	&mdb->drCTFlSize, NULL);
b5935235 AB	295
b5935235 AB	296	lock_buffer(HFS_SB(sb)->alt_mdb_bh);
1da177e4 LT	297	memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);
	298	HFS_SB(sb)->alt_mdb->drAtrb \|= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
	299	HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
b5935235 AB	300	unlock_buffer(HFS_SB(sb)->alt_mdb_bh);
b5935235 AB	301
1da177e4	302	mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
3072b90c	303	sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
1da177e4 LT	304	}
	305
	306	if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags)) {
	307	struct buffer_head *bh;
	308	sector_t block;
	309	char *ptr;
	310	int off, size, len;
	311
	312	block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start;
	313	off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1);
	314	block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS;
	315	size = (HFS_SB(sb)->fs_ablocks + 7) / 8;
	316	ptr = (u8 *)HFS_SB(sb)->bitmap;
	317	while (size) {
	318	bh = sb_bread(sb, block);
	319	if (!bh) {
d6142673	320	pr_err("unable to read volume bitmap\n");
1da177e4 LT	321	break;
	322	}
	323	len = min((int)sb->s_blocksize - off, size);
b5935235 AB	324
b5935235 AB	325	lock_buffer(bh);
1da177e4	326	memcpy(bh->b_data + off, ptr, len);
b5935235 AB	327	unlock_buffer(bh);
b5935235 AB	328
1da177e4 LT	329	mark_buffer_dirty(bh);
	330	brelse(bh);
	331	block++;
	332	off = 0;
	333	ptr += len;
	334	size -= len;
	335	}
	336	}
b5935235	337	unlock_buffer(HFS_SB(sb)->mdb_bh);
1da177e4 LT	338	}
	339
	340	void hfs_mdb_close(struct super_block *sb)
	341	{
	342	/* update volume attributes */
bc98a42c	343	if (sb_rdonly(sb))
1da177e4 LT	344	return;
	345	HFS_SB(sb)->mdb->drAtrb \|= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
	346	HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
	347	mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
	348	}
	349
	350	/*
	351	* hfs_mdb_put()
	352	*
	353	* Release the resources associated with the in-core MDB. */
	354	void hfs_mdb_put(struct super_block *sb)
	355	{
945b0920 CL	356	if (!HFS_SB(sb))
945b0920 CL	357	return;
1da177e4 LT	358	/* free the B-trees */
	359	hfs_btree_close(HFS_SB(sb)->ext_tree);
	360	hfs_btree_close(HFS_SB(sb)->cat_tree);
	361
	362	/* free the buffers holding the primary and alternate MDBs */
	363	brelse(HFS_SB(sb)->mdb_bh);
	364	brelse(HFS_SB(sb)->alt_mdb_bh);
945b0920	365
6d729e44 TG	366	unload_nls(HFS_SB(sb)->nls_io);
6d729e44 TG	367	unload_nls(HFS_SB(sb)->nls_disk);
328b9227	368
80f8dccf	369	kfree(HFS_SB(sb)->bitmap);
945b0920 CL	370	kfree(HFS_SB(sb));
945b0920 CL	371	sb->s_fs_info = NULL;
1da177e4	372	}