[mirror_ubuntu-artful-kernel.git] / fs / hfs / mdb.c

/*
 *  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/genhd.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_multisession ms_info;
	struct cdrom_tocentry te;
	int res;

	/* default values */
	*start = 0;
	*size = i_size_read(sb->s_bdev->bd_inode) >> 9;

	if (HFS_SB(sb)->session >= 0) {
		te.cdte_track = HFS_SB(sb)->session;
		te.cdte_format = CDROM_LBA;
		res = ioctl_by_bdev(sb->s_bdev, CDROMREADTOCENTRY, (unsigned long)&te);
		if (!res && (te.cdte_ctrl & CDROM_DATA_TRACK) == 4) {
			*start = (sector_t)te.cdte_addr.lba << 2;
			return 0;
		}
		pr_err("invalid session number or type of track\n");
		return -EINVAL;
	}
	ms_info.addr_format = CDROM_LBA;
	res = ioctl_by_bdev(sb->s_bdev, CDROMMULTISESSION, (unsigned long)&ms_info);
	if (!res && 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 |= MS_RDONLY;
	}
	if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
		pr_warn("filesystem is marked locked, mounting read-only.\n");
		sb->s_flags |= MS_RDONLY;
	}
	if (!(sb->s_flags & MS_RDONLY)) {
		/* 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->s_flags & MS_RDONLY)
		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->s_flags & MS_RDONLY)
		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 <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>
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	{
	35	struct cdrom_multisession ms_info;
	36	struct cdrom_tocentry te;
	37	int res;
	38
	39	/* default values */
	40	*start = 0;
8d85063a	41	*size = i_size_read(sb->s_bdev->bd_inode) >> 9;
1da177e4 LT	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	}
d6142673	51	pr_err("invalid session number or type of track\n");
1da177e4 LT	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))) {
d6142673	104	pr_err("bad allocation block size %d\n", size);
1da177e4 LT	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)) {
d6142673	121	pr_err("unable to set blocksize to %u\n", size);
1da177e4 LT	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) {
d6142673 JP	165	pr_warn("unable to locate alternate MDB\n");
d6142673 JP	166	pr_warn("continuing without an alternate MDB\n");
1da177e4 LT	167	}
1da177e4 LT	168
80f8dccf	169	HFS_SB(sb)->bitmap = kmalloc(8192, GFP_KERNEL);
1da177e4 LT	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) {
d6142673	181	pr_err("unable to read volume bitmap\n");
1da177e4 LT	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) {
d6142673	195	pr_err("unable to open extent tree\n");
1da177e4 LT	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) {
d6142673	200	pr_err("unable to open catalog tree\n");
1da177e4 LT	201	goto out;
	202	}
	203
	204	attrib = mdb->drAtrb;
	205	if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
d6142673	206	pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n");
1da177e4 LT	207	sb->s_flags \|= MS_RDONLY;
	208	}
	209	if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
d6142673	210	pr_warn("filesystem is marked locked, mounting read-only.\n");
1da177e4 LT	211	sb->s_flags \|= MS_RDONLY;
	212	}
	213	if (!(sb->s_flags & MS_RDONLY)) {
	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;
20c79e78	218	be32_add_cpu(&mdb->drWrCnt, 1);
1da177e4 LT	219	mdb->drLsMod = hfs_mtime();
	220
	221	mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
3072b90c	222	sync_dirty_buffer(HFS_SB(sb)->mdb_bh);
1da177e4 LT	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:
50640bcc	238	* This updates the MDB on disk.
1da177e4 LT	239	* It does not check, if the superblock has been modified, or
1da177e4 LT	240	* if the filesystem has been mounted read-only. It is mainly
50640bcc	241	* called by hfs_sync_fs() and flush_mdb().
1da177e4 LT	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
4527440d AB	262	if (sb->s_flags & MS_RDONLY)
	263	return;
	264
b5935235	265	lock_buffer(HFS_SB(sb)->mdb_bh);
1da177e4 LT	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);
b5935235 AB	289
b5935235 AB	290	lock_buffer(HFS_SB(sb)->alt_mdb_bh);
1da177e4 LT	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);
b5935235 AB	294	unlock_buffer(HFS_SB(sb)->alt_mdb_bh);
b5935235 AB	295
1da177e4	296	mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
3072b90c	297	sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
1da177e4 LT	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) {
d6142673	314	pr_err("unable to read volume bitmap\n");
1da177e4 LT	315	break;
	316	}
	317	len = min((int)sb->s_blocksize - off, size);
b5935235 AB	318
b5935235 AB	319	lock_buffer(bh);
1da177e4	320	memcpy(bh->b_data + off, ptr, len);
b5935235 AB	321	unlock_buffer(bh);
b5935235 AB	322
1da177e4 LT	323	mark_buffer_dirty(bh);
	324	brelse(bh);
	325	block++;
	326	off = 0;
	327	ptr += len;
	328	size -= len;
	329	}
	330	}
b5935235	331	unlock_buffer(HFS_SB(sb)->mdb_bh);
1da177e4 LT	332	}
	333
	334	void hfs_mdb_close(struct super_block *sb)
	335	{
	336	/* update volume attributes */
	337	if (sb->s_flags & MS_RDONLY)
	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	{
945b0920 CL	350	if (!HFS_SB(sb))
945b0920 CL	351	return;
1da177e4 LT	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);
945b0920	359
6d729e44 TG	360	unload_nls(HFS_SB(sb)->nls_io);
6d729e44 TG	361	unload_nls(HFS_SB(sb)->nls_disk);
328b9227	362
80f8dccf	363	kfree(HFS_SB(sb)->bitmap);
945b0920 CL	364	kfree(HFS_SB(sb));
945b0920 CL	365	sb->s_fs_info = NULL;
1da177e4	366	}