[people/ms/linux.git] / fs / jfs / jfs_mount.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *   Copyright (C) International Business Machines Corp., 2000-2004
 */

/*
 * Module: jfs_mount.c
 *
 * note: file system in transition to aggregate/fileset:
 *
 * file system mount is interpreted as the mount of aggregate,
 * if not already mounted, and mount of the single/only fileset in
 * the aggregate;
 *
 * a file system/aggregate is represented by an internal inode
 * (aka mount inode) initialized with aggregate superblock;
 * each vfs represents a fileset, and points to its "fileset inode
 * allocation map inode" (aka fileset inode):
 * (an aggregate itself is structured recursively as a filset:
 * an internal vfs is constructed and points to its "fileset inode
 * allocation map inode" (aka aggregate inode) where each inode
 * represents a fileset inode) so that inode number is mapped to
 * on-disk inode in uniform way at both aggregate and fileset level;
 *
 * each vnode/inode of a fileset is linked to its vfs (to facilitate
 * per fileset inode operations, e.g., unmount of a fileset, etc.);
 * each inode points to the mount inode (to facilitate access to
 * per aggregate information, e.g., block size, etc.) as well as
 * its file set inode.
 *
 *   aggregate
 *   ipmnt
 *   mntvfs -> fileset ipimap+ -> aggregate ipbmap -> aggregate ipaimap;
 *             fileset vfs     -> vp(1) <-> ... <-> vp(n) <->vproot;
 */

#include <linux/fs.h>
#include <linux/buffer_head.h>
#include <linux/blkdev.h>
#include <linux/log2.h>

#include "jfs_incore.h"
#include "jfs_filsys.h"
#include "jfs_superblock.h"
#include "jfs_dmap.h"
#include "jfs_imap.h"
#include "jfs_metapage.h"
#include "jfs_debug.h"


/*
 * forward references
 */
static int chkSuper(struct super_block *);
static int logMOUNT(struct super_block *sb);

/*
 * NAME:	jfs_mount(sb)
 *
 * FUNCTION:	vfs_mount()
 *
 * PARAMETER:	sb	- super block
 *
 * RETURN:	-EBUSY	- device already mounted or open for write
 *		-EBUSY	- cvrdvp already mounted;
 *		-EBUSY	- mount table full
 *		-ENOTDIR- cvrdvp not directory on a device mount
 *		-ENXIO	- device open failure
 */
int jfs_mount(struct super_block *sb)
{
	int rc = 0;		/* Return code */
	struct jfs_sb_info *sbi = JFS_SBI(sb);
	struct inode *ipaimap = NULL;
	struct inode *ipaimap2 = NULL;
	struct inode *ipimap = NULL;
	struct inode *ipbmap = NULL;

	/*
	 * read/validate superblock
	 * (initialize mount inode from the superblock)
	 */
	if ((rc = chkSuper(sb))) {
		goto out;
	}

	ipaimap = diReadSpecial(sb, AGGREGATE_I, 0);
	if (ipaimap == NULL) {
		jfs_err("jfs_mount: Failed to read AGGREGATE_I");
		rc = -EIO;
		goto out;
	}
	sbi->ipaimap = ipaimap;

	jfs_info("jfs_mount: ipaimap:0x%p", ipaimap);

	/*
	 * initialize aggregate inode allocation map
	 */
	if ((rc = diMount(ipaimap))) {
		jfs_err("jfs_mount: diMount(ipaimap) failed w/rc = %d", rc);
		goto err_ipaimap;
	}

	/*
	 * open aggregate block allocation map
	 */
	ipbmap = diReadSpecial(sb, BMAP_I, 0);
	if (ipbmap == NULL) {
		rc = -EIO;
		goto err_umount_ipaimap;
	}

	jfs_info("jfs_mount: ipbmap:0x%p", ipbmap);

	sbi->ipbmap = ipbmap;

	/*
	 * initialize aggregate block allocation map
	 */
	if ((rc = dbMount(ipbmap))) {
		jfs_err("jfs_mount: dbMount failed w/rc = %d", rc);
		goto err_ipbmap;
	}

	/*
	 * open the secondary aggregate inode allocation map
	 *
	 * This is a duplicate of the aggregate inode allocation map.
	 *
	 * hand craft a vfs in the same fashion as we did to read ipaimap.
	 * By adding INOSPEREXT (32) to the inode number, we are telling
	 * diReadSpecial that we are reading from the secondary aggregate
	 * inode table.  This also creates a unique entry in the inode hash
	 * table.
	 */
	if ((sbi->mntflag & JFS_BAD_SAIT) == 0) {
		ipaimap2 = diReadSpecial(sb, AGGREGATE_I, 1);
		if (!ipaimap2) {
			jfs_err("jfs_mount: Failed to read AGGREGATE_I");
			rc = -EIO;
			goto err_umount_ipbmap;
		}
		sbi->ipaimap2 = ipaimap2;

		jfs_info("jfs_mount: ipaimap2:0x%p", ipaimap2);

		/*
		 * initialize secondary aggregate inode allocation map
		 */
		if ((rc = diMount(ipaimap2))) {
			jfs_err("jfs_mount: diMount(ipaimap2) failed, rc = %d",
				rc);
			goto err_ipaimap2;
		}
	} else
		/* Secondary aggregate inode table is not valid */
		sbi->ipaimap2 = NULL;

	/*
	 *	mount (the only/single) fileset
	 */
	/*
	 * open fileset inode allocation map (aka fileset inode)
	 */
	ipimap = diReadSpecial(sb, FILESYSTEM_I, 0);
	if (ipimap == NULL) {
		jfs_err("jfs_mount: Failed to read FILESYSTEM_I");
		/* open fileset secondary inode allocation map */
		rc = -EIO;
		goto err_umount_ipaimap2;
	}
	jfs_info("jfs_mount: ipimap:0x%p", ipimap);

	/* map further access of per fileset inodes by the fileset inode */
	sbi->ipimap = ipimap;

	/* initialize fileset inode allocation map */
	if ((rc = diMount(ipimap))) {
		jfs_err("jfs_mount: diMount failed w/rc = %d", rc);
		goto err_ipimap;
	}

	return rc;

	/*
	 *	unwind on error
	 */
err_ipimap:
	/* close fileset inode allocation map inode */
	diFreeSpecial(ipimap);
err_umount_ipaimap2:
	/* close secondary aggregate inode allocation map */
	if (ipaimap2)
		diUnmount(ipaimap2, 1);
err_ipaimap2:
	/* close aggregate inodes */
	if (ipaimap2)
		diFreeSpecial(ipaimap2);
err_umount_ipbmap:	/* close aggregate block allocation map */
	dbUnmount(ipbmap, 1);
err_ipbmap:		/* close aggregate inodes */
	diFreeSpecial(ipbmap);
err_umount_ipaimap:	/* close aggregate inode allocation map */
	diUnmount(ipaimap, 1);
err_ipaimap:		/* close aggregate inodes */
	diFreeSpecial(ipaimap);
out:
	if (rc)
		jfs_err("Mount JFS Failure: %d", rc);

	return rc;
}

/*
 * NAME:	jfs_mount_rw(sb, remount)
 *
 * FUNCTION:	Completes read-write mount, or remounts read-only volume
 *		as read-write
 */
int jfs_mount_rw(struct super_block *sb, int remount)
{
	struct jfs_sb_info *sbi = JFS_SBI(sb);
	int rc;

	/*
	 * If we are re-mounting a previously read-only volume, we want to
	 * re-read the inode and block maps, since fsck.jfs may have updated
	 * them.
	 */
	if (remount) {
		if (chkSuper(sb) || (sbi->state != FM_CLEAN))
			return -EINVAL;

		truncate_inode_pages(sbi->ipimap->i_mapping, 0);
		truncate_inode_pages(sbi->ipbmap->i_mapping, 0);
		diUnmount(sbi->ipimap, 1);
		if ((rc = diMount(sbi->ipimap))) {
			jfs_err("jfs_mount_rw: diMount failed!");
			return rc;
		}

		dbUnmount(sbi->ipbmap, 1);
		if ((rc = dbMount(sbi->ipbmap))) {
			jfs_err("jfs_mount_rw: dbMount failed!");
			return rc;
		}
	}

	/*
	 * open/initialize log
	 */
	if ((rc = lmLogOpen(sb)))
		return rc;

	/*
	 * update file system superblock;
	 */
	if ((rc = updateSuper(sb, FM_MOUNT))) {
		jfs_err("jfs_mount: updateSuper failed w/rc = %d", rc);
		lmLogClose(sb);
		return rc;
	}

	/*
	 * write MOUNT log record of the file system
	 */
	logMOUNT(sb);

	return rc;
}

/*
 *	chkSuper()
 *
 * validate the superblock of the file system to be mounted and
 * get the file system parameters.
 *
 * returns
 *	0 with fragsize set if check successful
 *	error code if not successful
 */
static int chkSuper(struct super_block *sb)
{
	int rc = 0;
	struct jfs_sb_info *sbi = JFS_SBI(sb);
	struct jfs_superblock *j_sb;
	struct buffer_head *bh;
	int AIM_bytesize, AIT_bytesize;
	int expected_AIM_bytesize, expected_AIT_bytesize;
	s64 AIM_byte_addr, AIT_byte_addr, fsckwsp_addr;
	s64 byte_addr_diff0, byte_addr_diff1;
	s32 bsize;

	if ((rc = readSuper(sb, &bh)))
		return rc;
	j_sb = (struct jfs_superblock *)bh->b_data;

	/*
	 * validate superblock
	 */
	/* validate fs signature */
	if (strncmp(j_sb->s_magic, JFS_MAGIC, 4) ||
	    le32_to_cpu(j_sb->s_version) > JFS_VERSION) {
		rc = -EINVAL;
		goto out;
	}

	bsize = le32_to_cpu(j_sb->s_bsize);
	if (bsize != PSIZE) {
		jfs_err("Only 4K block size supported!");
		rc = -EINVAL;
		goto out;
	}

	jfs_info("superblock: flag:0x%08x state:0x%08x size:0x%Lx",
		 le32_to_cpu(j_sb->s_flag), le32_to_cpu(j_sb->s_state),
		 (unsigned long long) le64_to_cpu(j_sb->s_size));

	/* validate the descriptors for Secondary AIM and AIT */
	if ((j_sb->s_flag & cpu_to_le32(JFS_BAD_SAIT)) !=
	    cpu_to_le32(JFS_BAD_SAIT)) {
		expected_AIM_bytesize = 2 * PSIZE;
		AIM_bytesize = lengthPXD(&(j_sb->s_aim2)) * bsize;
		expected_AIT_bytesize = 4 * PSIZE;
		AIT_bytesize = lengthPXD(&(j_sb->s_ait2)) * bsize;
		AIM_byte_addr = addressPXD(&(j_sb->s_aim2)) * bsize;
		AIT_byte_addr = addressPXD(&(j_sb->s_ait2)) * bsize;
		byte_addr_diff0 = AIT_byte_addr - AIM_byte_addr;
		fsckwsp_addr = addressPXD(&(j_sb->s_fsckpxd)) * bsize;
		byte_addr_diff1 = fsckwsp_addr - AIT_byte_addr;
		if ((AIM_bytesize != expected_AIM_bytesize) ||
		    (AIT_bytesize != expected_AIT_bytesize) ||
		    (byte_addr_diff0 != AIM_bytesize) ||
		    (byte_addr_diff1 <= AIT_bytesize))
			j_sb->s_flag |= cpu_to_le32(JFS_BAD_SAIT);
	}

	if ((j_sb->s_flag & cpu_to_le32(JFS_GROUPCOMMIT)) !=
	    cpu_to_le32(JFS_GROUPCOMMIT))
		j_sb->s_flag |= cpu_to_le32(JFS_GROUPCOMMIT);

	/* validate fs state */
	if (j_sb->s_state != cpu_to_le32(FM_CLEAN) &&
	    !sb_rdonly(sb)) {
		jfs_err("jfs_mount: Mount Failure: File System Dirty.");
		rc = -EINVAL;
		goto out;
	}

	sbi->state = le32_to_cpu(j_sb->s_state);
	sbi->mntflag = le32_to_cpu(j_sb->s_flag);

	/*
	 * JFS always does I/O by 4K pages.  Don't tell the buffer cache
	 * that we use anything else (leave s_blocksize alone).
	 */
	sbi->bsize = bsize;
	sbi->l2bsize = le16_to_cpu(j_sb->s_l2bsize);

	/* check some fields for possible corruption */
	if (sbi->l2bsize != ilog2((u32)bsize) ||
	    j_sb->pad != 0 ||
	    le32_to_cpu(j_sb->s_state) > FM_STATE_MAX) {
		rc = -EINVAL;
		jfs_err("jfs_mount: Mount Failure: superblock is corrupt!");
		goto out;
	}

	/*
	 * For now, ignore s_pbsize, l2bfactor.  All I/O going through buffer
	 * cache.
	 */
	sbi->nbperpage = PSIZE >> sbi->l2bsize;
	sbi->l2nbperpage = L2PSIZE - sbi->l2bsize;
	sbi->l2niperblk = sbi->l2bsize - L2DISIZE;
	if (sbi->mntflag & JFS_INLINELOG)
		sbi->logpxd = j_sb->s_logpxd;
	else {
		sbi->logdev = new_decode_dev(le32_to_cpu(j_sb->s_logdev));
		uuid_copy(&sbi->uuid, &j_sb->s_uuid);
		uuid_copy(&sbi->loguuid, &j_sb->s_loguuid);
	}
	sbi->fsckpxd = j_sb->s_fsckpxd;
	sbi->ait2 = j_sb->s_ait2;

      out:
	brelse(bh);
	return rc;
}


/*
 *	updateSuper()
 *
 * update synchronously superblock if it is mounted read-write.
 */
int updateSuper(struct super_block *sb, uint state)
{
	struct jfs_superblock *j_sb;
	struct jfs_sb_info *sbi = JFS_SBI(sb);
	struct buffer_head *bh;
	int rc;

	if (sbi->flag & JFS_NOINTEGRITY) {
		if (state == FM_DIRTY) {
			sbi->p_state = state;
			return 0;
		} else if (state == FM_MOUNT) {
			sbi->p_state = sbi->state;
			state = FM_DIRTY;
		} else if (state == FM_CLEAN) {
			state = sbi->p_state;
		} else
			jfs_err("updateSuper: bad state");
	} else if (sbi->state == FM_DIRTY)
		return 0;

	if ((rc = readSuper(sb, &bh)))
		return rc;

	j_sb = (struct jfs_superblock *)bh->b_data;

	j_sb->s_state = cpu_to_le32(state);
	sbi->state = state;

	if (state == FM_MOUNT) {
		/* record log's dev_t and mount serial number */
		j_sb->s_logdev = cpu_to_le32(new_encode_dev(sbi->log->bdev->bd_dev));
		j_sb->s_logserial = cpu_to_le32(sbi->log->serial);
	} else if (state == FM_CLEAN) {
		/*
		 * If this volume is shared with OS/2, OS/2 will need to
		 * recalculate DASD usage, since we don't deal with it.
		 */
		if (j_sb->s_flag & cpu_to_le32(JFS_DASD_ENABLED))
			j_sb->s_flag |= cpu_to_le32(JFS_DASD_PRIME);
	}

	mark_buffer_dirty(bh);
	sync_dirty_buffer(bh);
	brelse(bh);

	return 0;
}


/*
 *	readSuper()
 *
 * read superblock by raw sector address
 */
int readSuper(struct super_block *sb, struct buffer_head **bpp)
{
	/* read in primary superblock */
	*bpp = sb_bread(sb, SUPER1_OFF >> sb->s_blocksize_bits);
	if (*bpp)
		return 0;

	/* read in secondary/replicated superblock */
	*bpp = sb_bread(sb, SUPER2_OFF >> sb->s_blocksize_bits);
	if (*bpp)
		return 0;

	return -EIO;
}


/*
 *	logMOUNT()
 *
 * function: write a MOUNT log record for file system.
 *
 * MOUNT record keeps logredo() from processing log records
 * for this file system past this point in log.
 * it is harmless if mount fails.
 *
 * note: MOUNT record is at aggregate level, not at fileset level,
 * since log records of previous mounts of a fileset
 * (e.g., AFTER record of extent allocation) have to be processed
 * to update block allocation map at aggregate level.
 */
static int logMOUNT(struct super_block *sb)
{
	struct jfs_log *log = JFS_SBI(sb)->log;
	struct lrd lrd;

	lrd.logtid = 0;
	lrd.backchain = 0;
	lrd.type = cpu_to_le16(LOG_MOUNT);
	lrd.length = 0;
	lrd.aggregate = cpu_to_le32(new_encode_dev(sb->s_bdev->bd_dev));
	lmLog(log, NULL, &lrd, NULL);

	return 0;
}
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4 LT	2	/*
1da177e4 LT	3	* Copyright (C) International Business Machines Corp., 2000-2004
1da177e4 LT	4	*/
	5
	6	/*
	7	* Module: jfs_mount.c
	8	*
	9	* note: file system in transition to aggregate/fileset:
	10	*
63f83c9f DK	11	* file system mount is interpreted as the mount of aggregate,
63f83c9f DK	12	* if not already mounted, and mount of the single/only fileset in
1da177e4 LT	13	* the aggregate;
	14	*
	15	* a file system/aggregate is represented by an internal inode
	16	* (aka mount inode) initialized with aggregate superblock;
63f83c9f	17	* each vfs represents a fileset, and points to its "fileset inode
1da177e4	18	* allocation map inode" (aka fileset inode):
63f83c9f DK	19	* (an aggregate itself is structured recursively as a filset:
	20	* an internal vfs is constructed and points to its "fileset inode
	21	* allocation map inode" (aka aggregate inode) where each inode
	22	* represents a fileset inode) so that inode number is mapped to
1da177e4 LT	23	* on-disk inode in uniform way at both aggregate and fileset level;
	24	*
	25	* each vnode/inode of a fileset is linked to its vfs (to facilitate
	26	* per fileset inode operations, e.g., unmount of a fileset, etc.);
	27	* each inode points to the mount inode (to facilitate access to
	28	* per aggregate information, e.g., block size, etc.) as well as
	29	* its file set inode.
	30	*
63f83c9f	31	* aggregate
1da177e4 LT	32	* ipmnt
	33	* mntvfs -> fileset ipimap+ -> aggregate ipbmap -> aggregate ipaimap;
	34	* fileset vfs -> vp(1) <-> ... <-> vp(n) <->vproot;
	35	*/
	36
	37	#include <linux/fs.h>
	38	#include <linux/buffer_head.h>
621c1f42	39	#include <linux/blkdev.h>
3bef198f	40	#include <linux/log2.h>
1da177e4 LT	41
	42	#include "jfs_incore.h"
	43	#include "jfs_filsys.h"
	44	#include "jfs_superblock.h"
	45	#include "jfs_dmap.h"
	46	#include "jfs_imap.h"
	47	#include "jfs_metapage.h"
	48	#include "jfs_debug.h"
	49
	50
	51	/*
	52	* forward references
	53	*/
	54	static int chkSuper(struct super_block *);
	55	static int logMOUNT(struct super_block *sb);
	56
	57	/*
	58	* NAME: jfs_mount(sb)
	59	*
	60	* FUNCTION: vfs_mount()
	61	*
	62	* PARAMETER: sb - super block
	63	*
	64	* RETURN: -EBUSY - device already mounted or open for write
	65	* -EBUSY - cvrdvp already mounted;
	66	* -EBUSY - mount table full
	67	* -ENOTDIR- cvrdvp not directory on a device mount
	68	* -ENXIO - device open failure
	69	*/
	70	int jfs_mount(struct super_block *sb)
	71	{
f720e3ba	72	int rc = 0; /* Return code */
1da177e4 LT	73	struct jfs_sb_info *sbi = JFS_SBI(sb);
	74	struct inode *ipaimap = NULL;
	75	struct inode *ipaimap2 = NULL;
	76	struct inode *ipimap = NULL;
	77	struct inode *ipbmap = NULL;
	78
	79	/*
63f83c9f	80	* read/validate superblock
1da177e4 LT	81	* (initialize mount inode from the superblock)
	82	*/
	83	if ((rc = chkSuper(sb))) {
c48a14dc	84	goto out;
1da177e4 LT	85	}
	86
	87	ipaimap = diReadSpecial(sb, AGGREGATE_I, 0);
	88	if (ipaimap == NULL) {
426d3107	89	jfs_err("jfs_mount: Failed to read AGGREGATE_I");
1da177e4	90	rc = -EIO;
c48a14dc	91	goto out;
1da177e4 LT	92	}
	93	sbi->ipaimap = ipaimap;
	94
	95	jfs_info("jfs_mount: ipaimap:0x%p", ipaimap);
	96
	97	/*
	98	* initialize aggregate inode allocation map
	99	*/
	100	if ((rc = diMount(ipaimap))) {
	101	jfs_err("jfs_mount: diMount(ipaimap) failed w/rc = %d", rc);
c48a14dc	102	goto err_ipaimap;
1da177e4 LT	103	}
	104
	105	/*
	106	* open aggregate block allocation map
	107	*/
	108	ipbmap = diReadSpecial(sb, BMAP_I, 0);
	109	if (ipbmap == NULL) {
	110	rc = -EIO;
c48a14dc	111	goto err_umount_ipaimap;
1da177e4 LT	112	}
	113
	114	jfs_info("jfs_mount: ipbmap:0x%p", ipbmap);
	115
	116	sbi->ipbmap = ipbmap;
	117
	118	/*
	119	* initialize aggregate block allocation map
	120	*/
	121	if ((rc = dbMount(ipbmap))) {
	122	jfs_err("jfs_mount: dbMount failed w/rc = %d", rc);
c48a14dc	123	goto err_ipbmap;
1da177e4 LT	124	}
	125
	126	/*
	127	* open the secondary aggregate inode allocation map
	128	*
	129	* This is a duplicate of the aggregate inode allocation map.
	130	*
	131	* hand craft a vfs in the same fashion as we did to read ipaimap.
	132	* By adding INOSPEREXT (32) to the inode number, we are telling
	133	* diReadSpecial that we are reading from the secondary aggregate
	134	* inode table. This also creates a unique entry in the inode hash
	135	* table.
	136	*/
	137	if ((sbi->mntflag & JFS_BAD_SAIT) == 0) {
	138	ipaimap2 = diReadSpecial(sb, AGGREGATE_I, 1);
09aaa749	139	if (!ipaimap2) {
426d3107	140	jfs_err("jfs_mount: Failed to read AGGREGATE_I");
1da177e4	141	rc = -EIO;
c48a14dc	142	goto err_umount_ipbmap;
1da177e4 LT	143	}
	144	sbi->ipaimap2 = ipaimap2;
	145
	146	jfs_info("jfs_mount: ipaimap2:0x%p", ipaimap2);
	147
	148	/*
	149	* initialize secondary aggregate inode allocation map
	150	*/
	151	if ((rc = diMount(ipaimap2))) {
	152	jfs_err("jfs_mount: diMount(ipaimap2) failed, rc = %d",
	153	rc);
c48a14dc	154	goto err_ipaimap2;
1da177e4 LT	155	}
	156	} else
	157	/* Secondary aggregate inode table is not valid */
	158	sbi->ipaimap2 = NULL;
	159
	160	/*
f720e3ba	161	* mount (the only/single) fileset
1da177e4 LT	162	*/
	163	/*
	164	* open fileset inode allocation map (aka fileset inode)
	165	*/
	166	ipimap = diReadSpecial(sb, FILESYSTEM_I, 0);
	167	if (ipimap == NULL) {
	168	jfs_err("jfs_mount: Failed to read FILESYSTEM_I");
	169	/* open fileset secondary inode allocation map */
	170	rc = -EIO;
c48a14dc	171	goto err_umount_ipaimap2;
1da177e4 LT	172	}
	173	jfs_info("jfs_mount: ipimap:0x%p", ipimap);
	174
	175	/* map further access of per fileset inodes by the fileset inode */
	176	sbi->ipimap = ipimap;
	177
	178	/* initialize fileset inode allocation map */
	179	if ((rc = diMount(ipimap))) {
	180	jfs_err("jfs_mount: diMount failed w/rc = %d", rc);
c48a14dc	181	goto err_ipimap;
1da177e4 LT	182	}
1da177e4 LT	183
c48a14dc	184	return rc;
1da177e4 LT	185
1da177e4 LT	186	/*
f720e3ba	187	* unwind on error
1da177e4	188	*/
c48a14dc DM	189	err_ipimap:
c48a14dc DM	190	/* close fileset inode allocation map inode */
1da177e4	191	diFreeSpecial(ipimap);
c48a14dc	192	err_umount_ipaimap2:
1da177e4	193	/* close secondary aggregate inode allocation map */
c48a14dc	194	if (ipaimap2)
1da177e4	195	diUnmount(ipaimap2, 1);
c48a14dc DM	196	err_ipaimap2:
	197	/* close aggregate inodes */
	198	if (ipaimap2)
1da177e4	199	diFreeSpecial(ipaimap2);
c48a14dc	200	err_umount_ipbmap: /* close aggregate block allocation map */
1da177e4	201	dbUnmount(ipbmap, 1);
c48a14dc	202	err_ipbmap: /* close aggregate inodes */
1da177e4	203	diFreeSpecial(ipbmap);
c48a14dc	204	err_umount_ipaimap: /* close aggregate inode allocation map */
1da177e4	205	diUnmount(ipaimap, 1);
c48a14dc	206	err_ipaimap: /* close aggregate inodes */
1da177e4	207	diFreeSpecial(ipaimap);
c48a14dc	208	out:
1da177e4 LT	209	if (rc)
	210	jfs_err("Mount JFS Failure: %d", rc);
	211
	212	return rc;
	213	}
	214
	215	/*
	216	* NAME: jfs_mount_rw(sb, remount)
	217	*
	218	* FUNCTION: Completes read-write mount, or remounts read-only volume
	219	* as read-write
	220	*/
	221	int jfs_mount_rw(struct super_block *sb, int remount)
	222	{
63f83c9f	223	struct jfs_sb_info *sbi = JFS_SBI(sb);
1da177e4 LT	224	int rc;
	225
	226	/*
	227	* If we are re-mounting a previously read-only volume, we want to
	228	* re-read the inode and block maps, since fsck.jfs may have updated
	229	* them.
	230	*/
	231	if (remount) {
	232	if (chkSuper(sb) \|\| (sbi->state != FM_CLEAN))
	233	return -EINVAL;
	234
	235	truncate_inode_pages(sbi->ipimap->i_mapping, 0);
	236	truncate_inode_pages(sbi->ipbmap->i_mapping, 0);
	237	diUnmount(sbi->ipimap, 1);
	238	if ((rc = diMount(sbi->ipimap))) {
	239	jfs_err("jfs_mount_rw: diMount failed!");
	240	return rc;
	241	}
	242
	243	dbUnmount(sbi->ipbmap, 1);
	244	if ((rc = dbMount(sbi->ipbmap))) {
	245	jfs_err("jfs_mount_rw: dbMount failed!");
	246	return rc;
	247	}
	248	}
	249
	250	/*
	251	* open/initialize log
	252	*/
	253	if ((rc = lmLogOpen(sb)))
	254	return rc;
	255
	256	/*
	257	* update file system superblock;
	258	*/
	259	if ((rc = updateSuper(sb, FM_MOUNT))) {
	260	jfs_err("jfs_mount: updateSuper failed w/rc = %d", rc);
	261	lmLogClose(sb);
	262	return rc;
	263	}
	264
	265	/*
	266	* write MOUNT log record of the file system
	267	*/
	268	logMOUNT(sb);
	269
1da177e4 LT	270	return rc;
	271	}
	272
	273	/*
	274	* chkSuper()
	275	*
63f83c9f	276	* validate the superblock of the file system to be mounted and
1da177e4 LT	277	* get the file system parameters.
	278	*
	279	* returns
	280	* 0 with fragsize set if check successful
	281	* error code if not successful
	282	*/
	283	static int chkSuper(struct super_block *sb)
	284	{
	285	int rc = 0;
	286	struct jfs_sb_info *sbi = JFS_SBI(sb);
	287	struct jfs_superblock *j_sb;
	288	struct buffer_head *bh;
	289	int AIM_bytesize, AIT_bytesize;
	290	int expected_AIM_bytesize, expected_AIT_bytesize;
	291	s64 AIM_byte_addr, AIT_byte_addr, fsckwsp_addr;
	292	s64 byte_addr_diff0, byte_addr_diff1;
	293	s32 bsize;
	294
	295	if ((rc = readSuper(sb, &bh)))
	296	return rc;
	297	j_sb = (struct jfs_superblock *)bh->b_data;
	298
	299	/*
	300	* validate superblock
	301	*/
	302	/* validate fs signature */
	303	if (strncmp(j_sb->s_magic, JFS_MAGIC, 4) \|\|
	304	le32_to_cpu(j_sb->s_version) > JFS_VERSION) {
	305	rc = -EINVAL;
	306	goto out;
	307	}
	308
	309	bsize = le32_to_cpu(j_sb->s_bsize);
1da177e4	310	if (bsize != PSIZE) {
e471e594	311	jfs_err("Only 4K block size supported!");
1da177e4 LT	312	rc = -EINVAL;
	313	goto out;
	314	}
1da177e4 LT	315
	316	jfs_info("superblock: flag:0x%08x state:0x%08x size:0x%Lx",
	317	le32_to_cpu(j_sb->s_flag), le32_to_cpu(j_sb->s_state),
	318	(unsigned long long) le64_to_cpu(j_sb->s_size));
	319
	320	/* validate the descriptors for Secondary AIM and AIT */
	321	if ((j_sb->s_flag & cpu_to_le32(JFS_BAD_SAIT)) !=
	322	cpu_to_le32(JFS_BAD_SAIT)) {
	323	expected_AIM_bytesize = 2 * PSIZE;
	324	AIM_bytesize = lengthPXD(&(j_sb->s_aim2)) * bsize;
	325	expected_AIT_bytesize = 4 * PSIZE;
	326	AIT_bytesize = lengthPXD(&(j_sb->s_ait2)) * bsize;
	327	AIM_byte_addr = addressPXD(&(j_sb->s_aim2)) * bsize;
	328	AIT_byte_addr = addressPXD(&(j_sb->s_ait2)) * bsize;
	329	byte_addr_diff0 = AIT_byte_addr - AIM_byte_addr;
	330	fsckwsp_addr = addressPXD(&(j_sb->s_fsckpxd)) * bsize;
	331	byte_addr_diff1 = fsckwsp_addr - AIT_byte_addr;
	332	if ((AIM_bytesize != expected_AIM_bytesize) \|\|
	333	(AIT_bytesize != expected_AIT_bytesize) \|\|
	334	(byte_addr_diff0 != AIM_bytesize) \|\|
	335	(byte_addr_diff1 <= AIT_bytesize))
	336	j_sb->s_flag \|= cpu_to_le32(JFS_BAD_SAIT);
	337	}
	338
	339	if ((j_sb->s_flag & cpu_to_le32(JFS_GROUPCOMMIT)) !=
	340	cpu_to_le32(JFS_GROUPCOMMIT))
	341	j_sb->s_flag \|= cpu_to_le32(JFS_GROUPCOMMIT);
	342
	343	/* validate fs state */
	344	if (j_sb->s_state != cpu_to_le32(FM_CLEAN) &&
bc98a42c	345	!sb_rdonly(sb)) {
1da177e4 LT	346	jfs_err("jfs_mount: Mount Failure: File System Dirty.");
	347	rc = -EINVAL;
	348	goto out;
	349	}
	350
	351	sbi->state = le32_to_cpu(j_sb->s_state);
	352	sbi->mntflag = le32_to_cpu(j_sb->s_flag);
	353
	354	/*
	355	* JFS always does I/O by 4K pages. Don't tell the buffer cache
	356	* that we use anything else (leave s_blocksize alone).
	357	*/
	358	sbi->bsize = bsize;
	359	sbi->l2bsize = le16_to_cpu(j_sb->s_l2bsize);
	360
3bef198f RD	361	/* check some fields for possible corruption */
	362	if (sbi->l2bsize != ilog2((u32)bsize) \|\|
	363	j_sb->pad != 0 \|\|
	364	le32_to_cpu(j_sb->s_state) > FM_STATE_MAX) {
	365	rc = -EINVAL;
	366	jfs_err("jfs_mount: Mount Failure: superblock is corrupt!");
	367	goto out;
	368	}
	369
1da177e4 LT	370	/*
	371	* For now, ignore s_pbsize, l2bfactor. All I/O going through buffer
	372	* cache.
	373	*/
	374	sbi->nbperpage = PSIZE >> sbi->l2bsize;
	375	sbi->l2nbperpage = L2PSIZE - sbi->l2bsize;
	376	sbi->l2niperblk = sbi->l2bsize - L2DISIZE;
	377	if (sbi->mntflag & JFS_INLINELOG)
	378	sbi->logpxd = j_sb->s_logpxd;
	379	else {
	380	sbi->logdev = new_decode_dev(le32_to_cpu(j_sb->s_logdev));
2e3bc612 AS	381	uuid_copy(&sbi->uuid, &j_sb->s_uuid);
2e3bc612 AS	382	uuid_copy(&sbi->loguuid, &j_sb->s_loguuid);
1da177e4 LT	383	}
	384	sbi->fsckpxd = j_sb->s_fsckpxd;
	385	sbi->ait2 = j_sb->s_ait2;
	386
	387	out:
	388	brelse(bh);
	389	return rc;
	390	}
	391
	392
	393	/*
	394	* updateSuper()
	395	*
	396	* update synchronously superblock if it is mounted read-write.
	397	*/
	398	int updateSuper(struct super_block *sb, uint state)
	399	{
	400	struct jfs_superblock *j_sb;
	401	struct jfs_sb_info *sbi = JFS_SBI(sb);
	402	struct buffer_head *bh;
	403	int rc;
	404
	405	if (sbi->flag & JFS_NOINTEGRITY) {
	406	if (state == FM_DIRTY) {
	407	sbi->p_state = state;
	408	return 0;
	409	} else if (state == FM_MOUNT) {
	410	sbi->p_state = sbi->state;
	411	state = FM_DIRTY;
	412	} else if (state == FM_CLEAN) {
	413	state = sbi->p_state;
	414	} else
	415	jfs_err("updateSuper: bad state");
	416	} else if (sbi->state == FM_DIRTY)
	417	return 0;
63f83c9f	418
1da177e4 LT	419	if ((rc = readSuper(sb, &bh)))
	420	return rc;
	421
	422	j_sb = (struct jfs_superblock *)bh->b_data;
	423
	424	j_sb->s_state = cpu_to_le32(state);
	425	sbi->state = state;
	426
	427	if (state == FM_MOUNT) {
	428	/* record log's dev_t and mount serial number */
	429	j_sb->s_logdev = cpu_to_le32(new_encode_dev(sbi->log->bdev->bd_dev));
	430	j_sb->s_logserial = cpu_to_le32(sbi->log->serial);
	431	} else if (state == FM_CLEAN) {
	432	/*
	433	* If this volume is shared with OS/2, OS/2 will need to
	434	* recalculate DASD usage, since we don't deal with it.
	435	*/
	436	if (j_sb->s_flag & cpu_to_le32(JFS_DASD_ENABLED))
	437	j_sb->s_flag \|= cpu_to_le32(JFS_DASD_PRIME);
	438	}
	439
	440	mark_buffer_dirty(bh);
	441	sync_dirty_buffer(bh);
	442	brelse(bh);
	443
	444	return 0;
	445	}
	446
	447
	448	/*
	449	* readSuper()
	450	*
	451	* read superblock by raw sector address
	452	*/
	453	int readSuper(struct super_block sb, struct buffer_head *bpp)
	454	{
	455	/* read in primary superblock */
	456	*bpp = sb_bread(sb, SUPER1_OFF >> sb->s_blocksize_bits);
	457	if (*bpp)
	458	return 0;
	459
	460	/* read in secondary/replicated superblock */
	461	*bpp = sb_bread(sb, SUPER2_OFF >> sb->s_blocksize_bits);
	462	if (*bpp)
	463	return 0;
	464
	465	return -EIO;
	466	}
	467
	468
	469	/*
	470	* logMOUNT()
	471	*
	472	* function: write a MOUNT log record for file system.
	473	*
	474	* MOUNT record keeps logredo() from processing log records
	475	* for this file system past this point in log.
	476	* it is harmless if mount fails.
	477	*
63f83c9f	478	* note: MOUNT record is at aggregate level, not at fileset level,
1da177e4	479	* since log records of previous mounts of a fileset
63f83c9f	480	* (e.g., AFTER record of extent allocation) have to be processed
1da177e4 LT	481	* to update block allocation map at aggregate level.
	482	*/
	483	static int logMOUNT(struct super_block *sb)
	484	{
	485	struct jfs_log *log = JFS_SBI(sb)->log;
	486	struct lrd lrd;
	487
	488	lrd.logtid = 0;
	489	lrd.backchain = 0;
	490	lrd.type = cpu_to_le16(LOG_MOUNT);
	491	lrd.length = 0;
	492	lrd.aggregate = cpu_to_le32(new_encode_dev(sb->s_bdev->bd_dev));
	493	lmLog(log, NULL, &lrd, NULL);
	494
	495	return 0;
	496	}